java基础知识（反射 动态代理 类加载器 一些JDK的新特性）

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合并