Java-类加载器、反射、动态代理、JDK1.5以及1.7的新特性

最新推荐文章于 2023-07-24 20:03:50 发布

Better Me

最新推荐文章于 2023-07-24 20:03:50 发布

阅读量230

点赞数 1

分类专栏： Java-SE

本文链接：https://blog.csdn.net/Despicable_Me/article/details/98447428

版权

Java-SE 专栏收录该内容

31 篇文章 0 订阅

订阅专栏

在这里插入图片描述

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

类的加载概述
当程序要使用某个类时，如果该类还未被加载到内存中，
则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
第一步：加载
就是指将class文件读入内存，并为之创建一个Class对象。
任何类被使用时系统都会建立一个Class对象。
第二步：连接
验证 : 是否有正确的内部结构，并和其他类协调一致
准备 : 负责为类的静态成员分配内存，并设置默认初始化值
解析：把类中的符号引用转换为直接引用
第三步：初始化
就是我们以前讲过的初始化步骤
类的加载时机
创建类的实例
访问类的静态变量，或者为静态变量赋值
调用类的静态方法
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
初始化某个类的子类
直接使用java.exe命令来运行某个主类

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

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

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

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

public class MyTest {
    public static void main(String[] args) throws ClassNotFoundException {
        //如果获取一个类的字节码文件对象。
        //方式1. 通过Object类中的getClass方法
        Student student = new Student();
        Class clazz = student.getClass();
        //方式2. 任何一个类，都有一个 class属性，通过这个属性就可以获取到该类的字节码文件对象
        Class<Student> studentClass = Student.class;
        //方式3. 用Class类的静态方法forName()来获取该类的字节码文件对象(参数传该类对应的文件路径)
        Class<?> aClass = Class.forName("org.westos.demo.Student");
        //每个类的字节码文件对象是唯一的，所以底下的结果全为True
        System.out.println(studentClass==clazz);
        System.out.println(aClass==studentClass);
        System.out.println(aClass==clazz);
    }
}
-----------------------------------------------------------------------------------
public class Student {
}

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

获取所有构造方法：
public Constructor<?>[] getConstructors() 获取所有的构造方法不包含私有的
public Constructor<?>[] getDeclaredConstructors() 获取所有的构造方法包括私有的
获取单个构造方法：
public Constructor getConstructor(Class<?>… parameterTypes) 获取单个的构造方法不包含私有的
public Constructor getDeclaredConstructor(Class<?>… parameterTypes) 获取单个的构造方法包含私有的
案例演示: 通过反射获取无参构造方法并使用

public class MyTest2 {
    public static void main(String[] args) throws Exception{
        //以前我们创建对象的方式
       // Student student = new Student();
        //通过反射的方式，来创建该类的对象
        Class<?> clazz = Class.forName("org.westos.demo2.Student");
        //获取空参的构造方法对象
        Constructor<?> constructor = clazz.getConstructor();
        //通过构造方法对象中的newInstance()方法，创建该类对象
        Student o = (Student) constructor.newInstance();
        System.out.println(o);
    }
}
------------------------------------------------------------------------------
public class Student {
}

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

案例演示: 通过反射获取带参构造方法并使用

public class MyTest2 {
    public static void main(String[] args) throws Exception {
        //通过有参构造来创建该类的对象
        //Student zhangsan = new Student("zhangsan", 23);
        //通过反射的方式
        Class<?> clazz = Class.forName("org.westos.demo2.Student");
        //有参构造的参一是String类型，所以这块传String类对应的字节码文件对象，参二是int类型，所以传int对应的字节码文件对象（可以不用Integer来调方法，基本数据类型就可以调）
        Constructor<?> constructor1 = clazz.getConstructor(String.class, int.class);
        Object obj = constructor1.newInstance("lisi", 24);
        System.out.println(obj);
    }
}
----------------------------------------------------------------------------------
public class Student {
    public Student() {
        System.out.println("空参构造执行 了");
    }
    public Student(String name) {
        System.out.println("一个参数的构造执行了");
    }
    public Student(String name,int age) {
        System.out.println("两个个参数的构造执行了"+name+"=="+age);
    }
    private Student(String name,char ch) {
        System.out.println("私有构造执行了");
    }
}

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

案例演示: 通过反射获取私有构造方法并使用
// 获取字节码文件对象
Class clazz = Class.forName(“com.click369.Student”) ;
Constructor con = clazz.getDeclaredConstructor(String.class , int.class) ;
// 值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。
con.setAccessible(true) ; 取消语法检查不然会报错因为私有的外界不能直接访问
Object obj = con.newInstance(“张三” , 23) ;
System.out.println(obj);

public class MyTest3 {
    public static void main(String[] args) throws Exception{
        //获取两个参数的私有构造方法对象
        Class<?> aClass = Class.forName("org.westos.demo2.Teacher");
        Constructor<?> declaredConstructor1 = aClass.getDeclaredConstructor(String.class, int.class);
        declaredConstructor1.setAccessible(true);//取消权限检查
        Object teacher = declaredConstructor1.newInstance("wangwu", 23);
        System.out.println(teacher);
    }
}
----------------------------------------------------------------------------------
public class Teacher {
    private Teacher(String name, int age) {
        System.out.println("这是两个参数私有的构造" + name + "===" + age);
    }
}

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

获取所有成员变量：
public Field[] getFields() 获取所有的成员变量包含从父类继承过来的
public Field[] getDeclaredFields() 获取所有的成员变量包含私有的也包含从父类继承过来的成员变量
获取单个成员变量：
public Field getField(String name)
public Field getDeclaredField(String name)
案例演示: 通过反射获取成员变量并使用

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 Method[] getMethods() //获取所有的公共的成员方法不包含私有的包含从父类继承过来的过来的公共方法
public Method[] getDeclaredMethods()//获取自己的所有成员方法包含私有的
获取单个成员方法
//参数1: 方法名称参数2:方法行参的class 对象
public Method getMethod(String name,Class<?>… parameterTypes) //获取单个的方法不包含私有的
public Method getDeclaredMethod(String name,Class<?>… parameterTypes) 获取单个方法包括私有的
案例演示: 通过反射获取无参无返回值成员方法并使用

public class MyTest {
    public static void main(String[] args) throws Exception{
        通过反射的反射，来剖析方法对象 Method 方法对象
        Class<?> aClass = Class.forName("org.westos.demo5.Student");
        Constructor<?> constructor = aClass.getDeclaredConstructor();
        constructor.setAccessible(true);
        Student stu = (Student) constructor.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");
        //执行该方法，参数传该类对象
        show.invoke(stu);
    }
}

反射(通过反射获取带参带返回值成员方法并使用)

案例演示: 通过反射获取带参带返回值成员方法并使用

public class MyTest {
    public static void main(String[] args) throws Exception{
        通过反射的反射，来剖析方法对象 Method 方法对象
        Class<?> aClass = Class.forName("org.westos.demo5.Student");
        Constructor<?> constructor = aClass.getDeclaredConstructor();
        constructor.setAccessible(true);
        Student stu = (Student) constructor.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");
        show.invoke(stu);
        //参1：方法名 参数2：该方法形参类型的class类型
        Method test = aClass.getMethod("test", String.class, int.class);
        test.invoke(stu,"张三",23);
        //获取私有的方法
        Method haha = aClass.getDeclaredMethod("haha");
        haha.setAccessible(true);//取消权限校验
        haha.invoke(stu);
    }
}

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

案例演示: 通过反射运行配置文件内容

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.txt"));

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

        Method eat = classname.getMethod(properties.getProperty("methodname"));
        eat.invoke(o);
    }
}
-----------------------------------------------------------------------------------
配置文件的内容：
classname=org.westos.demo.Dog
methodname=sleep
----------------------------------------------------------------------------------
配置文件中的Dog类：
public class Dog {
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void sleep() {
        System.out.println("狗睡觉");
    }
}

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

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

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);
    }
}

反射(通过反射写一个通用的设置某个对象的某个属性为指定的值)

案例演示
public void setProperty(Object obj, String propertyName, Object value){}，
此方法可将obj对象中名为propertyName的属性的值设置为value。

public class Student {
    private String name;
    private int age;
    private double money;
}
-----------------------------------------------------------------------------
public class MyUtils {
    private MyUtils() {

    }

    /**
     *
     * @param obj 对象
     * @param propertyName 成员变量名
     * @param value 值
     */
    public static void setProperty(Object obj, String propertyName, Object value) throws Exception {
        Class<?> aClass = obj.getClass();
        Field field = aClass.getDeclaredField(propertyName);
        field.setAccessible(true);
        field.set(obj,value);
    }
    //获取字段（即成员变量）的值
    public static Object getProperty(Object obj, String propertyName) throws Exception {
        Class<?> aClass = obj.getClass();
        Field field = aClass.getDeclaredField(propertyName);
        field.setAccessible(true);
        Object objField = field.get(obj);
        return objField;
    }
}
----------------------------------------------------------------------------------
public class MyTest {
    public static void main(String[] args) throws Exception {
        Student student = new Student();
        MyUtils.setProperty(student,"name","李四");
        MyUtils.setProperty(student, "age", 20);
        MyUtils.setProperty(student, "money", 3.6);

        Object name = MyUtils.getProperty(student, "name");
        System.out.println(name);
    }
}

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

动态代理概述
代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。
举例：春季回家买票让人代买
动态代理：在程序运行过程中产生的这个对象
而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理
在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给我们提供的动态代理,只能对接口进行代理.

动态代理：
         *  特点：字节码随用随创建，随用随加载
         *  作用：不修改源码的基础上对方法增强
         *  分类：
         *      基于接口的动态代理
         *      基于子类的动态代理
         *  基于接口的动态代理：
         *      涉及的类：Proxy
         *      提供者：JDK官方
         *  如何创建代理对象：
         *      使用Proxy类中的newProxyInstance方法
         *  创建代理对象的要求：
         *      被代理类最少实现一个接口，如果没有则不能使用
         *  newProxyInstance方法的参数：
         *      ClassLoader：类加载器
         *          它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
         *      Class[]：字节码数组
         *          它是用于让代理对象和被代理对象有相同方法。固定写法。
         *      InvocationHandler：用于提供增强的代码
         *          它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
         *          此接口的实现类都是谁用谁写。

new InvocationHandler() {
                    /**
                     * 作用：执行被代理对象的任何接口方法都会经过该方法
                     * 方法参数的含义
                     * @param proxy   代理对象的引用
                     * @param method  当前执行的方法
                     * @param args    当前执行方法所需的参数
                     * @return        和被代理对象方法有相同的返回值
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    }
                }

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

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

public enum Direction{ //枚举enum
    FRONT,AFTER,LEFT,RIGHT;//枚举项，必须位于第一行 最后一个枚举项的分号，如果下面没代码，就不用写，有就必须写上
    int num = 100;

    private Direction() { //枚举的构造方法必须私有
    }
}
-----------------------------------------------------------------------------------------
public class MyTest {
    public static void main(String[] args) {
        Direction front = Direction.FRONT;
        switch (front){
            case LEFT:
                System.out.println("左");
                break;
            case AFTER:
                System.out.println("后");
                break;
            case FRONT:
                System.out.println("前");
                break;
            case RIGHT:
                System.out.println("右");
                break;
        }
    }
}

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

案例演示: 通过enum实现枚举类

public enum Direction { //枚举enum
    FRONT("前"),AFTER("后"),LEFT("左"),RIGHT("右");
    private Direction(String name){}
}
--------------------------------------------------------------------------
public class MyTest {
    public static void main(String[] args) {
        Direction front = Direction.FRONT;
        Direction after = Direction.AFTER;
        Direction left = Direction.LEFT;
        Direction right = Direction.RIGHT;
        System.out.println(front);
    }
}

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

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

public  enum Direction { //枚举enum
    FRONT(){
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    },AFTER {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    },LEFT {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    },RIGHT {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    };
    public abstract void show(String name);
    private Direction(){}
}
-----------------------------------------------------------------------------
public class MyTest {
    public static void main(String[] args) {
        Direction front = Direction.FRONT;
        Direction after = Direction.AFTER;
        Direction left = Direction.LEFT;
        Direction right = Direction.RIGHT;
        System.out.println(front);
        //可以调用枚举里的方法
        after.show("你好！世界");
    }
}

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

枚举类的常见方法
int ordinal() 返回枚举项的序号
int compareTo(E o) 比较两个枚举项的返回的是两个枚举项序号的差值
String name() 获取枚举项的名称
String toString()获取枚举项的名称
T valueOf(Class type,String name) 用来获取指定的枚举项参数1:枚举类对应的字节码对象参数2 枚举项的名称
values() 获取所有的枚举项
此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便

案例演示: 枚举类的常见方法

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);
  }	
}

JDK7新特性(JDK7的新特性)

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