java基础学习_反射、装饰模式、JDK新特性_day27总结

java基础学习_反射、装饰模式、JDK新特性_day27总结

=============================================================================
=============================================================================
涉及到的知识点有:
    1:反射(理解)
        (1)类的加载
        (2)类的初始化时机
        (3)类加载器
        (4)类加载器的组成
        (5)反射的概述
        (6)反射的使用
        (7)反射的案例
        (8)动态代理(中介)
        (9)Java中的代理类Proxy和调用处理接口InvocationHandler
        (10)代理类Proxy中的方法创建动态代理类对象
        (11)调用处理接口InvocationHandler的方法
        (12)动态代理案例
    2:设计模式
        A:模版设计模式(抽象类中用的多)
        B:装饰设计模式(IO流中用的多)
        C:适配器模式(GUI中用的多)
    3:JDK新特性
        (1)JDK5(掌握)
        (2)JDK6(很少见,了解)
        (3)JDK7(理解)
        (4)JDK8(了解)
=============================================================================
=============================================================================
1:反射(理解)
    (1)类的加载
        当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载、连接、初始化三步来实现对这个类进行初始化。
        
        加载 
            就是指将class文件读入内存，并为之创建一个Class对象。
            任何类被使用时系统都会建立一个Class对象。
        连接
            验证：是否有正确的内部结构，并和其他类协调一致。
            准备：负责为类的静态成员分配内存，并设置默认初始化值。
            解析：将类的二进制数据中的符号引用替换为直接引用。
        初始化 
            就是我们以前讲过的初始化步骤。
        
        注意：Object类的方法：
                public final Class getClass()    返回对象的字节码文件对象
             Class类的方法：
                public String getName()    以 String 的形式返回此 Class 对象所表示的实体名称。(实体包括：类、接口、数组名、基本类型或 void)
                    即：可以通过Class类中的一个方法，获取对象的真实类的全名称。
--------------------------------------
    (2)类的初始化时机
        1.创建类的实例时。
        2.访问类的静态变量，或者为静态变量赋值时。
        3.调用类的静态方法时。
        4.使用反射方式来强制创建某个类或接口对应的java.lang.Class对象时。
        5.初始化某个类的子类时。
        6.直接使用java.exe命令来运行某个主类时。
--------------------------------------
    (3)类加载器
        负责将.class文件加载到内在中，并为之生成对应的Class对象。
        虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。
    (4)类加载器的组成
            Bootstrap ClassLoader     根类加载器
            Extension ClassLoader     扩展类加载器
            Sysetm ClassLoader        系统类加载器
        
        Bootstrap ClassLoader     根类加载器
            也被称为引导类加载器，负责Java核心类的加载。
            比如System类,String类等。在JDK中JRE的lib目录下rt.jar文件中(JDK8以前版本中的位置,JDK9/10位置变化了)。
            
        Extension ClassLoader     扩展类加载器
            负责JRE的扩展目录中jar包的加载。
            在JDK中JRE的lib目录下ext目录。
            
        Sysetm ClassLoader        系统类加载器
            负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径。
            一般我们自己写的类通过系统类加载器来加载的。
            
        如果我们仅仅站在这些class文件的角度，我们如何来使用这些class文件中的内容呢?
--------------------------------------
    (5)反射的概述
        JAVA反射机制是在运行状态中，
        对于任意一个类，都能够知道这个类的所有属性和方法(动态获取信息)；
        对于任意一个对象，都能够调用它的任意一个方法和属性(动态调用对象的方法)；
        这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
        简言之：通过字节码文件对象，去使用该文件中的成员变量、构造方法、成员方法。
        
        要想解剖一个类，必须先要获取到该类的字节码文件对象。
        而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象。

        获取class文件对象的方式：
            A:Object类的getClass()方法
            B:数据类型的静态属性class(任意数据类型都具备一个class静态属性)
            C:Class类中的静态方法(将类名作为字符串传递给Class类中的静态方法forName)
            　　public static Class forName(String className)

            1:Person p = new Person();
              Class c = p.getClass();

            2:Class c2 = Person.class;
              任意数据类型都具备一个class静态属性，看上去要比第一种方式简单。

            3:将类名作为字符串传递给Class类中的静态方法forName()即可。
              注意：需要类的全路径(带包名的路径)
              Class c3 = Class.forName("Person");
                
            4:第三种和前两种的区别        
                前两种你必须明确Person类型。
                第三种需要这种类型的字符串就行(开发中用)。
                这种扩展更强，不需要知道具体的类，只提供字符串，按照配置文件加载就可以了。
示例代码如下：

package cn.itcast_01;

public class Person {
    private String name;
    int age;
    public String address;

    public Person() {
    }

    private Person(String name) {
        this.name = name;
    }

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public void show() {
        System.out.println("show");
    }

    public void method(String s) {
        System.out.println("method " + s);
    }

    public String getString(String s, int i) {
        return s + "---" + i;
    }

    private void function() {
        System.out.println("function");
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", address=" + address + "]";
    }

}

package cn.itcast_01;

/*
 * 反射：就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。
 * 
 *         Person p = new Person();
 *         p.使用;
 * 
 * 要想这样使用，首先你必须得到class文件对象，其实也就是得到Class类的对象。
 *         .class文件    -->    Class类
 *             成员变量        -->    Field类
 *             构造方法        -->    Constructor类
 *             成员方法        -->    Method类
 * 
 * 获取class文件对象的方式：
 *         A:Object类的getClass()方法
 *         B:数据类型的静态属性class(任意数据类型都具备一个class静态属性)
 *         C:Class类中的静态方法(将类名作为字符串传递给Class类中的静态方法forName)
 *             public static Class forName(String className)
 * 
 * 一般我们到底使用谁呢?
 *         A:自己玩        任选一种，第二种比较方便
 *         B:开发时        第三种
 *             为什么呢?因为第三种是一个字符串，而不是一个具体的类名。这样我们就可以把这样的字符串配置到配置文件中。
 */
public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        // 方式A
        Person p = new Person();
        Class c = p.getClass();

        Person p2 = new Person();
        Class c2 = p2.getClass();

        System.out.println(p == p2); // false
        System.out.println(c == c2); // true

        // 方式B
        Class c3 = Person.class;
        // int.class;
        // String.class;
        System.out.println(c == c3); // true

        // 方式C
        // ClassNotFoundException 需要类的全路径(带包名的路径)
        Class c4 = Class.forName("cn.itcast_01.Person");
        System.out.println(c == c4); // true
    }
}

--------------------------------------                
    (6)反射的使用
        // 获取字节码文件对象
        Class c = Class.forName("cn.itcast_01.Person");
        A:通过反射获取构造方法并使用
            Constructor con = c.getConstructor(String.class, ...);     // 获取单个的公共构造方法
            Constructor[] cons = c.getConstructors();                  // 获取所有的公共构造方法
            
            Constructor con = c.getDeclaredConstructor(String.class, ...);     // 获取单个的构造方法
            Constructor[] cons = c.getDeclaredConstructors();                  // 获取所有的构造方法

package cn.itcast_02;

import java.lang.reflect.Constructor;

//import cn.itcast_01.Person;

/*
 * 需求：通过反射去获取该公共无参构造方法并使用：
 *         public Person() {
 *         }
 * 
 * 以前的做法：
 *         Person p = new Person();
 *         System.out.println(p);
 * 
 * 现在的做法如下：
 * 
 * 反射的特点：
 *         1.Class类中的静态方法forName()传入的字符串将来会做成配置信息文件，所以以后你不知道程序运行的是谁(是哪个类)。
 *         2.反射是不会看到类的任何信息的。即通过构造方法对象Constructor、成员方法对象Method，调用他们的方法返回值都是Object类型。
 *             (因为任何类型都可以用Object类型接收，基本数据类型会自动装箱为引用数据类型)。
 *         3.反射可以访问私有的东西(前提是class文件未被加密)。
 */
public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 获取字节码文件对象
        // Class类的静态方法：public static Class forName(String className)
        Class c = Class.forName("cn.itcast_01.Person");

        // 获取构造方法
        // Class类的成员方法：public Constructor[] getConstructors() 获取所有的公共构造方法
        // Class类的成员方法：public Constructor[] getDeclaredConstructors() 获取所有的构造方法
        // Constructor[] cons = c.getDeclaredConstructors();
        // for (Constructor con : cons) {
        // System.out.println(con);
        // }

        // Class类的成员方法：public Constructor<T> getConstructor(Class<?>... parameterTypes) 获取单个的公共构造方法
        // Class类的成员方法：public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 获取单个的构造方法
        // 参数表示的是：要获取的构造方法的构造参数个数和数据类型的字节码文件对象
        // 通过字节码对象获取公共无参构造方法对象
        Constructor con = c.getConstructor(); // 返回的是构造方法的对象

        // Person p = new Person();
        // System.out.println(p);
        // Constructor类的成员方法：public T newInstance(Object... initargs) 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例
        // 通过公共无参构造方法对象创建一个实例对象
        Object obj = con.newInstance();
        System.out.println(obj); // Person [name=null, age=0, address=null]
        
        // Person p = (Person)obj;
        // p.show();
    }
}

package cn.itcast_02;

import java.lang.reflect.Constructor;

/*
 * 需求：通过反射去获取该公共带参构造方法并使用：
 *         public Person(String name, int age, String address) {
 *             this.name = name;
 *             this.age = age;
 *             this.address = address;    
 *         }
 * 
 * 以前的做法：
 *         Person p = new Person("林青霞", 27, "北京");
 *         System.out.println(p);
 * 
 * 现在的做法如下：
 */
public class ReflectDemo2 {
    public static void main(String[] args) throws Exception {
        // 获取字节码文件对象
        // Class类的静态方法：public static Class forName(String className)
        Class c = Class.forName("cn.itcast_01.Person");

        // 通过字节码对象获取公共带参构造方法对象
        // Class类的成员方法：public Constructor<T> getConstructor(Class<?>... parameterTypes)
        Constructor con = c.getConstructor(String.class, int.class, String.class);

        // 通过公共带参构造方法对象创建一个实例对象
        // Constructor类的成员方法：public T newInstance(Object... initargs)
        Object obj = con.newInstance("林青霞", 27, "北京");
        
        System.out.println(obj);
    }
}

package cn.itcast_02;

import java.lang.reflect.Constructor;

/*
 * 需求：通过反射获取私有带参构造方法并使用
 *         private Person(String name) {
 *             this.name = name;
 *         }
 * 
 * 以前的做法：
 *         Person p = new Person("风清扬");
 *         System.out.println(p);
 * 
 * 现在的做法如下：
 * 
 *         可以访问私有构造方法了，但是呢?是不是就不安全了。
 *         不用担心，我们可以有以下两种方式解决：
 *             1.将class文件加密，这样就还原不出来了。
 *             2.对某个数据或者字符使用位异或，这样也就还原不出来了。
 */
public class ReflectDemo3 {
    public static void main(String[] args) throws Exception {
        // 获取字节码文件对象
        // Class类的静态方法：public static Class forName(String className)
        Class c = Class.forName("cn.itcast_01.Person");

        // 通过字节码对象获取私有带参构造方法对象
        // NoSuchMethodException 没有这个方法异常
        // 原因是：一开始我们使用的方法只能获取公有的构造方法，下面这种方式就可以了。即获取所有的构造方法。
        Constructor con = c.getDeclaredConstructor(String.class);

        // 通过私有带参构造方法对象创建一个实例对象
        // IllegalAccessException 非法的访问异常
        // 肿么办? 暴力访问
        con.setAccessible(true); // 值为true，则指示反射的对象在使用时应该取消Java语言的访问检查
        Object obj = con.newInstance("风清扬");

        System.out.println(obj);
    }
}

        B:通过反射获取成员变量并使用
            Field field = c.getField("address");    // 获取单个的公共成员变量
            Field[] fields = c.getFields();         // 获取所有的公共成员变量
            
            Field field = c.getDeclaredField("name");   // 获取单个的成员变量
            Field[] fields = c.getDeclaredFields();     // 获取所有的成员变量

package cn.itcast_03;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/*
 * 需求：通过反射获取成员变量并使用
 * 
 */
public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 获取字节码文件对象
        Class c = Class.forName("cn.itcast_01.Person");
         
        // Field field = c.getField("address"); // 获取单个的公共成员变量
        // Field field = c.getDeclaredField("name"); // 获取单个的成员变量
        // Field[] fields = c.getFields(); // 获取所有的公共成员变量
        // Field[] fields = c.getDeclaredFields(); // 获取所有的成员变量
        
        // for (Field field : fields) {
        // System.out.println(field);
        // }

        /*
         * Person p = new Person(); 
         * p.address = "北京"; 
         * System.out.println(p);
         */

        // 通过字节码对象获取公共无参构造方法对象
        Constructor con = c.getConstructor();
        
        // 通过公共无参构造方法对象创建一个实例对象
        Object obj = con.newInstance();
        System.out.println(obj);
        
        // 通过字节码对象获取成员变量对象
        
        // 获取单个的公共成员变量address，并对其赋值
        Field addressField = c.getField("address");
        // Field类的成员方法：public void set(Object obj, Object value) 将指定对象变量上此 Field对象表示的字段设置为指定的新值
        addressField.set(obj, "北京"); // 给obj对象的addressField字段设置值为"北京"
        System.out.println(obj);

        // 获取成员变量name，并对其赋值
        // NoSuchFieldException 没有这个方法异常
        Field nameField = c.getDeclaredField("name");
        // IllegalAccessException 非法的访问异常
        // 肿么办? 暴力访问
        nameField.setAccessible(true);
        nameField.set(obj, "林青霞");
        System.out.println(obj);

        // 获取成员变量age，并对其赋值
        Field ageField = c.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.set(obj, 27);
        System.out.println(obj);
    }
}

        C:通过反射获取成员方法并使用
            Method method = c.getMethod("show", String.class, ...); // 获取自己单个的公共方法
            Method[] methods = c.getMethods();                      // 获取自己和父类所有的公共方法
            
            Method method = c.getDeclaredMethod("function", String.class, ...); // 获取单个的方法
            Method[] methods = c.getDeclaredMethods();                          // 获取自己所有的方法

package cn.itcast_04;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

/*
 * 需求：通过反射获取成员方法并使用
 * 
 */
public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 获取字节码文件对象
        Class c = Class.forName("cn.itcast_01.Person");
        
        // Method method = c.getMethod("show", String.class, ...); // 获取自己单个的公共方法
        // Method method = c.getDeclaredMethod("function", String.class, ...); // 获取单个的方法
        // Method[] methods = c.getMethods(); // 获取自己和父类所有的公共方法
        // Method[] methods = c.getDeclaredMethods(); // 获取自己所有的方法
        
        // for (Method method : methods) {
        // System.out.println(method);
        // }

        Constructor con = c.getConstructor();
        Object obj = con.newInstance();

        /*
         * Person p = new Person(); 
         * p.show();
         */

        // Class类的成员方法：public Method getMethod(String name, Class<?>... parameterTypes) 第一个参数表示的方法名，第二个参数表示的是方法的参数的class类型
        // Method类的方法：public Object invoke(Object obj, Object... args) 返回值是Object类型接收，第一个参数表示对象是谁，第二参数表示调用该方法的实际参数
        
        // 获取单个方法并使用
        // 获取Person类的成员方法：public void show()        
        Method m1 = c.getMethod("show");
        m1.invoke(obj); // 本质是：调用obj对象的m1方法，而obj对象是由Person对象得来的

        // 获取Person类的成员方法：public void method(String s)
        Method m2 = c.getMethod("method", String.class);
        m2.invoke(obj, "hello");

        // 获取Person类的成员方法：public String getString(String s, int i)
        Method m3 = c.getMethod("getString", String.class, int.class);
        Object objString = m3.invoke(obj, "hello", 100);
        System.out.println(objString);
        // String s = (String) m3.invoke(obj, "hello",100);
        // System.out.println(s);

        // 获取Person类的成员方法：private void function()
        Method m4 = c.getDeclaredMethod("function");
        m4.setAccessible(true);
        m4.invoke(obj);
    }
}

　　　　　　反射的特点：
　　　　　　　　1.Class类中的静态方法forName()传入的字符串将来会做成配置信息文件，所以以后你不知道程序运行的是谁(是哪个类)。
　　　　　　　　2.反射是不会看到类的任何信息的。即通过构造方法对象Constructor、成员方法对象Method，调用他们的方法返回值都是Object类型。
　　　　　　　　　　(因为任何类型都可以用Object类型接收，基本数据类型会自动装箱为引用数据类型)。
　　　　　　　　3.反射可以访问私有的东西(前提是class文件未被加密)。

--------------------------------------
    (7)反射的案例
        A:通过反射运行配置文件中的内容
            (即通过配置文件运行类中的方法)

package cn.itcast.test;

public class Student {
    public void love() {
        System.out.println("爱生活,爱Java");
    }
}

package cn.itcast.test;

public class Teacher {
    public void love() {
        System.out.println("爱生活,爱青霞");
    }
}

package cn.itcast.test;

public class Worker {
    public void love() {
        System.out.println("爱生活,爱老婆");
    }
}

className=cn.itcast.test.Worker
methodName=love

package cn.itcast.test;

import java.io.FileReader;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties;

/*
 * 通过反射运行配置文件中的内容
 *         (通过配置文件运行类中的方法)
 * 
 * 反射的做法：
 *         需要有配置文件配合使用。
 *             假如我们用class.txt代替。
 *             并且你要知道有两个键(即你得知道键:因为键相同,值覆盖)。
 *                 className
 *                 methodName
 * 
 * 反射的作用：
 *         一旦反射的代码写定后，就不修改它了。
 *         将来只需要提供配置文件，根据配置文件就可以动态的知道执行的是谁。即反射的动态执行效果。
 * 
 *         因为只要反射的代码不执行，我就不知道执行的是谁。
 *         只有在代码的执行中，去动态的加载配置文件里面的东西。
 *         所以通过反射写的代码，代码的灵活性高很多。
 * 
 *         将来就业班学框架，用的都是反射的原理。
 */
public class Test {
    public static void main(String[] args) throws Exception {
        // 反射前的做法(硬编码:代码写死了,写固定了,修改麻烦)
        // Student s = new Student();
        // s.love();
        // Teacher t = new Teacher();
        // t.love();
        // Worker w = new Worker();
        // w.love();
        
        // 反射后的做法(软编码:代码写活了,灵活度高)
        // 把文件中的数据加载到集合Properties中(即加载键值对数据)
        Properties prop = new Properties();
        FileReader fr = new FileReader("src//cn//itcast//test//class.txt");
        prop.load(fr);
        fr.close();

        // 从集合Properties中获取数据，根据键获取值
        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");

        // 反射
        // 获取字节码文件对象
        Class c = Class.forName(className);

        Constructor con = c.getConstructor();
        Object obj = con.newInstance();

        // 调用方法
        Method m = c.getMethod(methodName);
        m.invoke(obj);
    }
}

        B:通过反射越过泛型检查
            (即我给你ArrayList<Integer>的一个对象，我想在这个集合中添加一个字符串数据，如何实现呢?)

package cn.itcast.test;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

/*
 * 通过反射越过泛型检查
 *         (我给你ArrayList<Integer>的一个对象，我想在这个集合中添加一个字符串数据，如何实现呢?)
 */
public class ArrayListDemo {
    public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException,
            IllegalArgumentException, InvocationTargetException {

        // 创建集合对象
        ArrayList<Integer> array = new ArrayList<Integer>();

        // 反射前的做法
        // array.add("hello"); // 报错
        // array.add(10); // 自动装箱，没问题

        // 其实在集合的源码里面，ArrayList集合的add(E e)方法默认的数据类型是Object类型
        // 只不过在JDK5以后，为了数据的安全，加入了泛型的机制，
        // 而该泛型机制仅仅是给编译器看的(可以通过反编译工具查看哦)，真正运行加载的class文件里面放的依旧是Object类型

        // 反射后的做法
        Class c = array.getClass(); // 集合ArrayList的class文件对象
        Method m = c.getMethod("add", Object.class);

        m.invoke(array, "hello"); // 调用array的add方法，传入的值是hello
        m.invoke(array, "world");
        m.invoke(array, "java");

        System.out.println(array);
    }
}

        C:通过反射给任意的一个对象的任意的属性赋值为指定的值
            (即写一个方法，public void setProperty(Object obj, String propertyName, Object value) {}，此方法可将obj对象中名为propertyName的属性的值设置为value)

package cn.itcast.test;

import java.lang.reflect.Field;

/*
 * 通过反射给任意的一个对象的任意的属性赋值为指定的值
 *         写一个方法，public void setProperty(Object obj, String propertyName, Object value) {}，
 *         此方法可将obj对象中名为propertyName的属性的值设置为value。
 */
public class Tool {
    public void setProperty(Object obj, String propertyName, Object value)
            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
        
        // 根据对象获取字节码文件对象
        Class c = obj.getClass();
        // 获取该对象的propertyName成员变量
        Field field = c.getDeclaredField(propertyName);
        // 取消访问检查
        field.setAccessible(true);
        // 给对象的成员变量赋值为指定的值
        field.set(obj, value);
    }
    
}

package cn.itcast.test;

/*
 * 通过反射给任意的一个对象的任意的属性赋值为指定的值
 *         写一个方法，public void setProperty(Object obj, String propertyName, Object value) {}，
 *         此方法可将obj对象中名为propertyName的属性的值设置为value。
 */
public class ToolDemo {
    public static void main(String[] args)
            throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
        
        Person p = new Person();
        // p.name = "林青霞"; // 错误，因为name是私有成员变量
        // p.age = 27;    // 没问题，因为age是公共成员变量
        
        Tool t = new Tool();
        t.setProperty(p, "name", "林青霞");
        t.setProperty(p, "age", 27);
        System.out.println(p);
        System.out.println("-----------");

        Dog d = new Dog();
        t.setProperty(d, "sex", '男');
        t.setProperty(d, "price", 12.34f);
        System.out.println(d);
    }
}

class Person {
    private String name;
    public int age;

    @Override
    public String toString() {
        return name + "---" + age;
    }
}

class Dog {
    char sex;
    float price;

    @Override
    public String toString() {
        return sex + "---" + price;
    }
}

    (8)动态代理(中介)
        代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。
            举例：春季回家买票让人代买
        动态代理：在程序运行过程中产生的这个代理对象。
            而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理。
    (9)Java中的代理类Proxy和调用处理接口InvocationHandler
        在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。
        JDK提供的代理只能针对接口做代理。
        我们有更强大的代理cglib(在学框架的时候用到)。
    (10)代理类Proxy中的方法创建动态代理类对象
        public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
            最终会调用InvocationHandler的方法。
    (11)调用处理接口InvocationHandler的方法
            Object invoke(Object proxy, Method method, Object[] args)
            
        Proxy类中创建动态代理对象的方法的三个参数；
            ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载。
            Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了。
            InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上。

            每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，
            当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的invoke方法来进行调用。

        InvocationHandler接口中invoke方法的三个参数：
            proxy:代表动态代理对象。
            method:代表正在执行的方法。
            args:代表调用目标方法时传入的实参。
    (12)动态代理案例
        A:模拟给方法加权限校验和日志记录。

package cn.itcast_06;

/*
 * 用户操作接口
 */
public interface UserDao {
    public abstract void add();

    public abstract void delete();

    public abstract void update();

    public abstract void find();
}

package cn.itcast_06;

public class UserDaoImpl implements UserDao {

    @Override
    public void add() {
        System.out.println("添加功能");
    }

    @Override
    public void delete() {
        System.out.println("删除功能");
    }

    @Override
    public void update() {
        System.out.println("修改功能");
    }

    @Override
    public void find() {
        System.out.println("查找功能");
    }

}

package cn.itcast_06;

public interface StudentDao {
    public abstract void login();

    public abstract void regist();
}

package cn.itcast_06;

public class StudentDaoImpl implements StudentDao {

    @Override
    public void login() {
        System.out.println("登录功能");
    }

    @Override
    public void regist() {
        System.out.println("注册功能");
    }

}

package cn.itcast_06;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInvocationHandler implements InvocationHandler {
    private Object target; // 目标对象

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("权限校验");
        Object result = method.invoke(target, args);
        System.out.println("日志记录");
        return result; // 返回的是代理对象
    }
    
}

package cn.itcast_06;

import java.lang.reflect.Proxy;

public class Test {
    public static void main(String[] args) {
        // 基本的用户操作
        UserDao ud = new UserDaoImpl();
        ud.add();
        ud.delete();
        ud.update();
        ud.find();
        System.out.println("-----------");
        
        // 我们要创建一个动态代理对象
        // Proxy类中有一个静态方法可以创建动态代理对象
        // public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
        // 给目标对象ud创建一个代理对象
        MyInvocationHandler handler = new MyInvocationHandler(ud);
        UserDao proxy = (UserDao) Proxy.newProxyInstance(ud.getClass().getClassLoader(), ud.getClass().getInterfaces(), handler);
        proxy.add();
        proxy.delete();
        proxy.update();
        proxy.find();
        System.out.println("-----------");

        StudentDao sd = new StudentDaoImpl();
        MyInvocationHandler handler2 = new MyInvocationHandler(sd);
        StudentDao proxy2 = (StudentDao) Proxy.newProxyInstance(sd.getClass().getClassLoader(), sd.getClass().getInterfaces(), handler2);
        proxy2.login();
        proxy2.regist();
    }
    
}

        B:用动态代理实现：计算集合ArrayList的add()方法的运行时间。
-----------------------------------------------------------------------------    
2:设计模式
    A:模版设计模式(抽象类中用的多)
        模版设计模式的概述
            模版方法模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现。
        优点
            使用模版方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求。
        缺点
            如果算法骨架有修改的话，则需要修改抽象类。
        示例代码如下：

package cn.itcast_01;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 需求：请给计算出一段代码的运行时间
        // for循环的运行时间
        for (int x = 0; x < 10000; x++) {
            System.out.println(x);
        }

        // 复制视频的运行时间
        try {
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("src//cn//itcast_01//a.avi"));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("src//cn//itcast_01//b.avi"));
            byte[] bys = new byte[1024];
            int len = 0;
            while ((len = bis.read(bys)) != -1) {
                bos.write(bys, 0, len);
            }
            bos.close();
            bis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 再给我测试一个代码运行时间：集合操作的、多线程操作的、常用API操作的等等...
        // 所以说每次都要修改这个类，是不行的。肿么办?
 */

/*
 * 功能抽象类
 */
public abstract class GetTime {
    
    public abstract void code();
    
    public long getTime() {
        long start = System.currentTimeMillis();
        code();
        long end = System.currentTimeMillis();
        return end - start;
    }

}

package cn.itcast_01;

/*
 * 具体实现类
 *         for循环程序
 */
public class ForDemo extends GetTime {

    @Override
    public void code() {
        for (int x = 0; x < 100000; x++) {
            System.out.println(x);
        }
    }

}

package cn.itcast_01;

/*
 * 测试类
 */
public class GetTimeTest {
    public static void main(String[] args) {
        // GetTime gt = new GetTime();
        // System.out.println(gt.getTime() + "毫秒");

        GetTime gt = new ForDemo(); // 多态
        System.out.println(gt.getTime() + "毫秒");

        gt = new IODemo(); // 多态
        System.out.println(gt.getTime() + "毫秒");
    }
}

package cn.itcast_01;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 具体实现类
 *         IO程序
 */
public class IODemo extends GetTime{

    @Override
    public void code() {
        try {
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("src//cn//itcast_01//a.avi"));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("src//cn//itcast_01//b.avi"));
            byte[] bys = new byte[1024];
            int len = 0;
            while ((len = bis.read(bys)) != -1) {
                bos.write(bys, 0, len);
            }
            bos.close();
            bis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
}

        
    B:装饰设计模式(IO流中用的多)
        装饰设计模式的概述
            装饰模式就是使用被装饰类的一个子类的实例，在客户端将这个子类的实例交给装饰类。是继承的替代方案。
        优点
            使用装饰模式，可以提供比继承更灵活的扩展对象的功能，它可以动态的添加对象的功能，并且可以随意的组合这些功能。
        缺点
            正因为可以随意组合，所以就可能出现一些不合理的逻辑。
        示例代码如下：
            // 复杂的装饰(多重装饰)
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            BufferedWriter bw = new BufferedWriter((new OutputStreamWriter(System.out)));

            // 简单的装饰
            Scanner sc = new Scanner(System.in);

package cn.itcast_02;

/*
 * 手机接口
 */
public interface Phone {
    public abstract void call();
}

package cn.itcast_02;

/*
 * 手机实现类
 */
public class IPhone implements Phone {

    @Override
    public void call() {
        System.out.println("手机可以打电话了");
    }

}

package cn.itcast_02;

/*
 * 手机装饰抽象类
 */
public abstract class PhoneDecorate implements Phone {

    private Phone p;

    public PhoneDecorate(Phone p) {
        this.p = p;
    }

    @Override
    public void call() {
        this.p.call();
    }
}

package cn.itcast_02;

/*
 * 彩铃手机装饰具体类
 */
public class RingPhoneDecorate extends PhoneDecorate {

    public RingPhoneDecorate(Phone p) {
        super(p);
    }

    @Override
    public void call() {
        System.out.println("手机可以听彩铃");
        super.call();
    }
}

package cn.itcast_02;

/*
 * 听音乐手机装饰具体类
 */
public class MusicPhoneDecorate extends PhoneDecorate {

    public MusicPhoneDecorate(Phone p) {
        super(p);
    }

    @Override
    public void call() {
        super.call();
        System.out.println("手机可以听音乐");
    }
}

package cn.itcast_02;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Scanner;

/*
 * 手机测试类
 */
public class PhoneDemo {
    public static void main(String[] args) {
        Phone p = new IPhone(); // 多态
        p.call();
        System.out.println("------------");

        // 需求：我想在接电话前，听彩铃
        PhoneDecorate pd = new RingPhoneDecorate(p); // 多态
        pd.call();
        System.out.println("------------");

        // 需求：我想在接电话后，听音乐
        pd = new MusicPhoneDecorate(p);
        pd.call();
        System.out.println("------------");

        // 需求：我要想手机在接电话前听彩铃，接电话后听音乐
        // 自己提供听彩铃和听音乐的装饰类，在接电话前听彩铃，在接电话后听音乐，这样做的话，不好，太麻烦了。
        // 下面这种方式可以解决问题，这就是装饰的优点：可以任意组合功能。
        pd = new RingPhoneDecorate(new MusicPhoneDecorate(p));
        pd.call();
        System.out.println("----------");
        
        // 想想我们在IO流中的使用
        // InputStream is = System.in; // 字节流
        // InputStreamReader isr = new InputStreamReader(is); // 把字节流转为字符流
        // BufferedReader br = new BufferedReader(isr); // 把基本字符流转为高效字符流
        // 复杂的装饰
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter((new OutputStreamWriter(System.out)));

        // 简单的装饰
        Scanner sc = new Scanner(System.in);
    }
}

            
    C:适配器模式(GUI中用的多)
        适配器设计模式的概述
            将一个类的接口转换成另外一个客户希望的接口。从而使原来不能直接调用的接口变的可以调用。
        优点
            让本来不适合使用的接口变得适合使用。
        缺点
            一次只能适配一个类，使用有一定的局限性。

-----------------------------------------------------------------------------        
3:JDK新特性
    (1)JDK5(掌握)
        自动装箱和拆箱(day13)
        泛型(day16)
        增强for循环(day16)
        静态导入(day16)
        可变参数(day16)
--------------------------------------
        枚举(day27)
            A:枚举的概述
                是指将变量的值一一列出来，变量的值只限于列举出来的值的范围内。
                举例：一周只有7天，一年只有12个月等。
                回想单例设计模式：单例类是一个类只有一个实例。
                那么多例类就是一个类有多个实例，但不是无限个数的实例，而是有限个数的实例。这才能是枚举类。
--------------------------------------                
            B:通过自己定义一个枚举类来演示案例
                第一版
                第二版
                第三版
            发现自己定义一个枚举类，比较麻烦，所以，java就提供了枚举类供我们使用。
            格式是：只有枚举项的枚举类
                public enum 枚举类名 {
                    枚举项1, 枚举项2, 枚举项3, ...;
                }
--------------------------------------                
            C:注意事项
                1.定义枚举类要用关键字enum。
                2.所有枚举类都是Enum类的子类。
                3.枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议永远不要省略。
                4.枚举类中可以有构造方法，但必须是private的，它默认也是private的。枚举项的用法比较特殊：枚举("XXX")。
                5.枚举类中也可以有抽象方法，但枚举项必须重写该方法。
                6.枚举在switch语句中的使用。
            D:枚举类中的常见方法
                public final int compareTo(E o)
                public final String name()
                public final int ordinal()
                public String toString()
                public static <T> T valueOf(Class<T> enumType, String name)
                public static values() 此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便。
--------------------------------------
    (2)JDK6(很少见,了解)
    (3)JDK7(理解)
        二进制字面量(二进制的表现形式)
            JDK7开始，终于可以用二进制来表示整数(byte,short,int和long)。
            使用二进制字面量的好处是，可以使代码更容易被理解。语法非常简单，只要在二进制数值前面加0b或者0B即可。
                举例：
                    int x = ob110110;
--------------------------------------                    
        数字字面量可以出现下划线(用_分隔数据)
            为了增强对数值的阅读性，如我们经常把数据用逗号分隔一样。
            JDK7提供了_对数据分隔。
                举例：
                    int x = 100_1000;
                注意事项：
                    不能出现在进制标识和数值之间。
                    不能出现在数值开头和结尾。
                    不能出现在小数点旁边。
--------------------------------------
        switch语句的表达式可是用字符串(day04)
        泛型简化(泛型推断(也叫菱形泛型))
        异常的多个catch合并(多catch的使用)(day19)
        
        try-with-resources 语句(自动释放资源的用法)
            try (必须是java.lang.AutoCloseable的子类对象) {...}
            
            好处：
                资源自动释放，不需要close()了。
                把需要关闭资源的部分都定义在这里就ok了。
                主要是流体系的对象是这个接口的子类(看JDK7的API)。
--------------------------------------
    (4)JDK8(了解)
        可以去网上了解资料。
        1.接口中也可以有方法了（有默认方法、静态方法、私有方法(JDK9)）。

/*
JDK8新特性之
    接口中也可以有方法了
*/
interface Inter {
    // 抽象方法
    public abstract void show();
    
    // default方法(默认方法)
    public default void defaultPrint() {
        System.out.println("defaultPrint 我爱林青霞");
    }

    // static方法(静态方法)
    public static void staticPrint() {
        System.out.println("staticPrint 我爱林青霞");
    }
}

// 实现类
class InterImpl implements Inter {
    public void show() {
        System.out.println("重写接口中的方法");
    }
}

// 测试类
public class Demo01 {
    public static void main(String[] args) {
        // Inter.defaultPrint(); // 非静态方法不能直接调用 
        Inter.staticPrint();
        
        Inter i = new InterImpl();
        i.defaultPrint();
        i.show();
    }
}

=============================================================================