java第二十六天之学到辽~

1.1 反射(类的加载概述和加载时机)

*     类的加载概述
    当程序要使用某个类时，如果该类还未被加载到内存中，
    则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
    * 加载 
        就是指将class文件读入内存，并为之创建一个Class对象。
        任何类被使用时系统都会建立一个Class对象。
    * 连接
        验证 :    是否有正确的内部结构，并和其他类协调一致
        准备 :    负责为类的静态成员分配内存，并设置默认初始化值
        解析： 把类中的符号引用转换为直接引用
    * 初始化       就是我们初始化步骤（三步）

*  类的加载时机
    创建类的实例
    访问类的静态变量，或者为静态变量赋值
    调用类的静态方法 
    使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
    初始化某个类的子类
    直接使用java.exe命令来运行某个主类

1.2 反射(类加载器的概述和分类)

*  类加载器的概述
    负责将.class文件加载到内在中，并为之生成对应的Class对象。
*  类加载器的分类
    Bootstrap ClassLoader 根类加载器
    Extension ClassLoader 扩展类加载器
    Sysetm ClassLoader 系统类加载器
*  类加载器的作用
    Bootstrap ClassLoader 根类加载器
        也被称为引导类加载器，负责Java核心类的加载
        比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
    Extension ClassLoader 扩展类加载器
        负责JRE的扩展目录中jar包的加载。
        在JDK中JRE的lib目录下ext目录
    Sysetm ClassLoader 系统类加载器
        负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径

1.3 反射(反射概述以及获取class文件对象的三种方式)

*  反射概述
    JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
    对于任意一个对象，都能够调用它的任意一个方法和属性；
    这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
    要想解剖一个类,必须先要获取到该类的字节码文件对象。
    而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象
*  获取class文件对象的三种方式
    a:Object类的getClass()方法
    b:静态属性class
    c:Class类中静态方法forName()
*  获取class文件对象的三种方式
        反射: 就是在运行状态中的一种动态调用方法或者属性的一种机制.
        就是获取字节码文件对象,然后剖析改类中存在哪些构造方法,哪些成员变量,哪些成员方法

- 类的成员
- 成员变量        Field
- 构造方法        Constructor
- 成员方法        Method

*  如何获取一个类对应的字节码文件对象:

- a: 第一种通过Object类中的getClass方法
- b:　通过静态属性(class属性)
- c: 通过Class类中的一个静态方法:
- public static Class forName(String className): 
- className: 这个表示的是一个类对应的全类名(就是需要加上包名)

1.4 反射(通过反射获取构造方法并使用)

*  获取所有构造方法
    public Constructor<?>[] getConstructors() 获取所有的构造方法不包含私有的
    public Constructor<?>[] getDeclaredConstructors() 获取所有的构造方法 包括私有的
*  获取单个构造方法
    public Constructor<T> getConstructor(Class<?>... parameterTypes) 获取单个的构造方法 不包含私有的
    public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 获取单个的构造方法包含私有的


public class MyTest2 {
    public static void main(String[] args) throws Exception{

        Class<?> clazz = Class.forName("org.westos.demo2.Student");
        //获取空参的构造方法对象
        Constructor<?> constructor = clazz.getConstructor();
        //通过构造方法对象中的newInstance()方法，创建该类对象
        Student o = (Student) constructor.newInstance();
        //通过反射的方式
        Constructor<?> constructor1 = clazz.getConstructor(String.class, int.class);
        Object obj = constructor1.newInstance("lisi", 24);
        System.out.println(obj);
    }
}


public class MyTest3 {
    public static void main(String[] args) throws Exception{
        //创建Teacher对象
        //new Thacher();
        //通过反射来创建该类的对象
        Class<?> aClass = Class.forName("org.westos.demo2.Teacher");
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);//取消权限检查
        Object o = declaredConstructor.newInstance();
        System.out.println(o);
        System.out.println("----------------------------");
        //获取两个参数的构造方法对象
        Constructor<?> declaredConstructor1 = aClass.getDeclaredConstructor(String.class, int.class);
        declaredConstructor1.setAccessible(true);//取消权限检查
        //new Theacher("wangwu",23);
        Object teacher = declaredConstructor1.newInstance("wangwu", 23);
        System.out.println(teacher);

    }
}

1.5 反射(通过反射获取成员变量并使用)

*  获取所有成员变量
    public Field[] getFields() 获取所有的成员变量包含从父类继承过来的
    public Field[] getDeclaredFields() 获取所有的成员变量 包含私有的 也包含从父类继承过来的成员变量
*  获取单个成员变量


public class MyTest {
    public static void main(String[] args) throws NoSuchFieldException {
        //Field 字段类型
        Class<Student> studentClass = Student.class;
        //获取所有的公共字段对象
        Field[] fields = studentClass.getFields();
        for (Field field : fields) {
            System.out.println(field.toString());
        }
        System.out.println("----------------------");
        //获取所有的字段对象，包括私有的
        Field[] declaredFields = studentClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField.getName());
        }

        //获取单个公共字段对象
        Field name = studentClass.getField("name");
        System.out.println(name);

        //获取单个的私有字段对象
        Field money = studentClass.getDeclaredField("money");
        System.out.println(money);


    }
}


        public Field getField(String name)
        public Field getDeclaredField(String name)
public class MyTest2 {
    public static void main(String[] args) throws Exception {
        Class<?> aClass = Class.forName("org.westos.demo4.Student");
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        Object object= declaredConstructor.newInstance();


        Field name = aClass.getField("name");
        name.set(object,"张三");
        Object o = name.get(object);
        System.out.println(o);



    }
}

1.6 反射(通过反射获取成员方法并使用)

*  获取所有成员方法
    public Method[] getMethods() //获取所有的公共的成员方法不包含私有的 包含从父类继承过来的过来的公共方法
    public Method[] getDeclaredMethods()//获取自己的所有成员方法 包含私有的
*  获取单个成员方法
    //参数1: 方法名称  参数2:方法行参的class 对象
    public Method getMethod(String name,Class<?>... parameterTypes) //获取单个的方法 不包含私有的
    public Method getDeclaredMethod(String name,Class<?>... parameterTypes) 获取单个方法包括私有的


public class MyTest2 {
    public static void main(String[] args) throws Exception{
        Class<?> aClass = Class.forName("org.westos.demo5.Student");
        Constructor<?> constructor = aClass.getDeclaredConstructor();
        constructor.setAccessible(true);
        Student obj = (Student) constructor.newInstance();
       // obj.show();

        //获取方法对象
        Method show = aClass.getMethod("show");
        //通过反射的反射，来让方法执行了invoke()让方法执行
        show.invoke(obj);
        System.out.println("---------------------");
        Method test = aClass.getMethod("test", String.class, int.class);
        //参1：该类的对象，参数2：传给方法的形参要的值
        test.invoke(obj,"zhangsan",23);

        Method hehe = aClass.getMethod("hehe", double.class);
        Object invoke = hehe.invoke(obj, 3.2);
        System.out.println(invoke);

        System.out.println("-----------------------------");
        //通过反射，掉私有的方法
        Method haha = aClass.getDeclaredMethod("haha");
        haha.setAccessible(true);//调用私有方法，取消权限检查
        Object invoke1 = haha.invoke(obj);
        System.out.println(invoke1);
    }
}



public class MyTest {
    public static void main(String[] args) throws Exception{
        //Student student = new Student();
        //student.hehe(3.2);
        //student.show();
        //student.test("abc",32);
        //student.haha();
        //通过反射的反射，来剖析方法对象 Method 方法对象

        Class<?> aClass = Class.forName("org.westos.demo5.Student");
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        Student student = (Student) declaredConstructor .newInstance();

        //获取所有的公共的方法对象,包括他父类的公共方法 对象也获取到了
        Method[] methods = aClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("---------------------------");
        //获取所有的公共的方法对象包括私有的
        Method[] declaredMethods = aClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
        System.out.println("------------------------");
        //获取单个的公共方法对象
        Method show = aClass.getMethod("show");
        System.out.println(show);
        //参1：方法名 参数2：该方法形参类型的class类型
        Method test = aClass.getMethod("test", String.class, int.class);
        System.out.println(test);
        //获取私有的方法
        Method haha = aClass.getDeclaredMethod("haha");
        System.out.println(haha);


    }
}

​

1.7 反射(通过反射运行配置文件内容)

public class MyTest {
    public static void main(String[] args) throws Exception {
        //反射机制：
        //基于狗类做开发
        //Dog dog = new Dog();
        //dog.eat();
        //dog.sleep();

        //Cat cat = new Cat();
        //cat.eat();
        //cat.sleep();
        //采用反射
        //读取配置文件
        Properties properties = new Properties();
        properties.load(new FileReader("peizhi.properties"));

        Class<?> classname = Class.forName(properties.getProperty("classname"));
        Object o = classname.getDeclaredConstructor().newInstance();

        Method eat = classname.getMethod(properties.getProperty("methodname"));
        eat.invoke(o);


    }
}

1.8 反射(通过反射越过泛型检查)

* 案例演示:    我给你ArrayList<Integer>的一个对象，我想在这个集合中添加一个字符串数据，如何实现呢？


public class MyTest {
    public static void main(String[] args) throws Exception {
       // 我给你ArrayList<Integer> 的一个对象，我想在这个集合中添加一个字符串数据，如何实现呢？
        ArrayList<Integer> list = new ArrayList<>();
        list.add(100);
        //list.add("abc");
        //泛型：泛型只在编译期有效，运行期就擦除了。
        Class<? extends ArrayList> aClass = list.getClass();
        //获取add方法对象
        Method add = aClass.getDeclaredMethod("add", Object.class);
        //让add方法执行
        add.invoke(list,"abc");
        System.out.println(list);
    }
}

1.9 反射(动态代理的概述和实现)(理解)

*  动态代理概述
    代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。
    举例：春季回家买票让人代买
    动态代理：在程序运行过程中产生的这个对象
    而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理

    在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，
    通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。
    我们有更强大的代理cglib，Proxy类中的方法创建动态代理类对象
        public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
    最终会调用InvocationHandler的方法
        InvocationHandler Object invoke(Object proxy,Method method,Object[] args)

    我们可以通过Proxy类中的静态方法获取一个代理对象:

 public static Object newProxyInstance(ClassLoader loader,  Class<?>[] interfaces,  InvocationHandler h)


loader:             类加载器
interfaces:            接口对应的一个Class数组
InvocationHandler:    这个其实就是要代理对象所做的事情的一个类的封装

注意：JDK给我们提供的动态代理,只能对接口进行代理.


public interface UserDao {
    void insert();
    void delete();
    void update();
    void query();
}

public class UserDaoImpl implements UserDao {
    @Override
    public void insert() {
        System.out.println("添加了一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

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



    @Override
    public void query() {
        System.out.println("查询用户");
    }
}

 public static UserDao getPrxoy(UserDao userDao){
        //创建一个代理对象
        //static Object newProxyInstance (ClassLoader loader, Class < ?>[]interfaces, InvocationHandler h)
        //返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
        /**
         *1. loader 类加载器，负责加载代理对象的字节码文件，跟被代理对象使用的是同一个类加载器 ,固定写法
         *2. 接口对应的一个Class数组 固定写法
         * 3.InvocationHandler：用于提供增强的代码
         */

        UserDao obj = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(), userDao.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            /**proxy 代理对象
             * method 方法对象
             * args 方法上的参数数组
             */
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //System.out.println("权限校验");
                //Object invoke = method.invoke(userDao);
                //System.out.println("记录日志");
                Object invoke=null;
                if(method.getName().equals("update")){
                    System.out.println("权限校验");
                    invoke= method.invoke(userDao);
                    System.out.println("记录日志");
                }

               return invoke;
            }
        });

       return obj;
    }
}

public class MyTest {
    public static void main(String[] args) {
        //动态代理：目的：在不修改某个类的情况下，对该类中的方法进行增强的一种手段
        //UserDao 被代理对象（目标对象）
        //代理对象（运行期生成代理对象）
        //Proxy 提供用于创建动态代理类和实例的静态方法
        //static Object newProxyInstance (ClassLoader loader, Class < ?>[]interfaces, InvocationHandler h)
       // 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。

        //JDK的动态代理，要求要有接口
        //如果没有接口 使用cglib 可以代理
        UserDao userDao = new UserDaoImpl();

        UserDao prxoy = ProxyUtils.getPrxoy(userDao);
        prxoy.insert();
        System.out.println("----------------------");
        prxoy.delete();
        System.out.println("----------------------");
        prxoy.query();
        System.out.println("----------------------");
        prxoy.update();


    }
}

2.1 JDK5新特性(JDK1.5的新特性回归以及自己实现枚举类)

*  JDK1.5的新特性: 自动拆装箱 , 泛型 , 增强for , 静态导入 , 可变参数 , 枚举
*  枚举概述:    就是一个类只能存在几个固定的对象,那么这个就是枚举.我们就可以使用这些对象可以表示一些固定的值.
            举例：一周只有7天，一年只有12个月等。

2.2 JDK5新特性(通过enum实现枚举类)

public enum Direction { //枚举enum
    //0                  1               2                3
    FRONT("前"),AFTER("后"),LEFT("左"),RIGHT("右");
    private Direction(String name){}
}


/*public class Direction { //方向
    //提供该类的四个对象
    public static final org.westos.demo7.Direction FRONT = new org.westos.demo7.Direction("前");
    public static final org.westos.demo7.Direction AFTER = new org.westos.demo7.Direction("后");
    public static final org.westos.demo7.Direction LEFT = new org.westos.demo7.Direction("左");
    public static final org.westos.demo7.Direction RIGHT = new org.westos.demo7.Direction("右");
    public String name;

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

    //private Direction() {
    //}
}*/

2.3 JDK5新特性(枚举的注意事项)

    定义枚举类要用关键字enum
    所有枚举类都是Enum的子类
    枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略
    枚举类可以有构造器，但必须是private的，它默认的也是private的。枚举项的用法比较特殊：枚举(“”);
    枚举类也可以有抽象方法，但是枚举项必须重写该方法
    枚举在switch语句中的使用

2.4 JDK5新特性(枚举类的常见方法)

*  枚举类的常见方法
    int ordinal()  返回枚举项的序号
    int compareTo(E o) 比较两个枚举项的 返回的是两个枚举项序号的 差值
    String name() 获取枚举项的名称
    String toString()获取枚举项的名称
    <T> T valueOf(Class<T> type,String name) 用来获取指定的枚举项  参数1:枚举类对应的字节码对象 参数2 枚举项的名称
    values()  获取所有的枚举项

public static void main(String[] args) {

    // 测试
    Direction front = Direction.FRONT ;
    Direction behind = Direction.BEHIND;
    Direction left = Direction.LEFT ;
    Direction right = Direction.RIGHT ;

    System.out.println(front.ordinal());
    System.out.println(behind.ordinal());
    System.out.println(left.ordinal());
    System.out.println(right.ordinal());

    System.out.println("----------------------------------");

    System.out.println(front.compareTo(right));

    System.out.println("----------------------------------");

    System.out.println(front.name());

    System.out.println("----------------------------------");

    System.out.println(front.toString());
    System.out.println(front);

    System.out.println("----------------------------------");

    // <T> T valueOf(Class<T> type,String name):    用来获取指定的枚举项
    // type: 表示的是对应的枚举的字节码文件对象
    // name: 就是枚举项的名称
    Direction direction = Direction.valueOf(Direction.class, "RIGHT") ;
    System.out.println(direction);

    System.out.println("----------------------------------");

    Direction[] directions = Direction.values() ;

    for(Direction d : directions){
        System.out.println(d);
    }

}

2.5 JDK7新特性(JDK7的六个新特性回顾和讲解)

*  二进制字面量
    JDK7开始，终于可以用二进制来表示整数（byte,short,int和long）。
    使用二进制字面量的好处是，可以使代码更容易被理解。语法非常简单，只要在二进制数值前面加 0b或者0B
    int x = 0b110110
*  数字字面量可以出现下划线
    为了增强对数值的阅读性，如我们经常把数据用逗号分隔一样。JDK7提供了_对数据分隔。
    举例：
        int x = 100_1000;
    注意事项：
        不能出现在进制标识和数值之间
        不能出现在数值开头和结尾
        不能出现在小数点旁边
*  switch 语句可以用字符串
*  泛型简化
*  异常的多个catch合并