(二十三)java 反射、JDK新特性

1. 反射概述

加载完类之后， 在堆内存的方法区中就产生了一个Class类型的对象（ 一个类只有一个Class对象） ， 这个对象就包含了完整的类的结构信息。 我们可以通过这个对象看到类的结构。 这个对象就像一面镜子， 透过这个镜子看到类的结构， 所以， 我们形象的称之为： 反射。

1.1 反射作用

○ 在运行时判断任意一个对象所属的类
○ 在运行时构造任意一个类的对象
○ 在运行时判断任意一个类所具有的成员变量和方法
○ 在运行时获取泛型信息
○ 在运行时调用任意一个对象的成员变量和方法
○ 在运行时处理注解
○ 生成动态代理

1.2 反射主要的API

○ java.lang.Class:代表一个类
○ java.lang.reflect.Method:代表类的方法
○ java.lang.reflect.Field:代表类的成员变量
○ java.lang.reflect.Constructor:代表类的构造器

2. Class类和实例

在Object类中定义了以下的方法，此方法将被所有子类继承
public final Class getClass()以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。

2.1 Class类

• 对象照镜子后可以得到的信息有：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言， JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。

  • Class本身也是一个类
  • Class 对象只能由系统建立对象
  • 一个加载的类在 JVM 中只会有一个Class实例
  • 一个Class对象对应的是一个加载到JVM中的一个.class文件
  • 每个类的实例都会记得自己是由哪个 Class 实例所生成
  • 通过Class可以完整地得到一个类中的所有被加载的结构
  • Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

• 常用的方法

static Class forName(String name)	返回指定类名 name 的 Class 对象
Object newInstance()	            调用缺省构造函数，返回该Class对象的一个实例
Method getMethod(String name,paramTypes)      返回一个Method对象，此对象的形参类型为paramType
getName()	                        返回此Class对象所表示的实体（类、接口、数组类、基本类型 或void）名称
Class getSuperClass()	            返回当前Class对象的父类的Class对象
Class [] getInterfaces()	        获取当前Class对象的接口
ClassLoader getClassLoader()	    返回该类的类加载器
Class getSuperclass()	            返回表示此Class所表示的实体的超类的Class
Constructor[] getConstructors()	    返回一个包含某些Constructor对象的数组
Field[] getDeclaredFields()	        返回Field对象的一个数组

类对象

public class User {
    private String name;
    private int age;
    public String adress = "河北";
    public String school = "家里蹲大学";
    public User() {
    }
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    private User(String name) {
        this.name = name;
    }
    public void show() {
        System.out.println("show");
    }
    public void show(String ll,int i2) {
        System.out.println("show");
        System.out.println(ll);
        System.out.println(i2);
    }
    private void display(String msg) {
        System.out.println(msg);
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", adress='" + adress + '\'' +
                ", school='" + school + '\'' +
                '}';
    }
}

案例：通过反射获取类和实例

public static void main(String[] args) throws Exception{
        Class clazz = Class.forName("user_demo.User");//获取指定的类
        Constructor constructor = clazz.getConstructor(String.class, int.class);//获取一个两参构造器
        Object obj = constructor.newInstance("雷利", 45);//获取实例对象并传数值
        Method method = clazz.getMethod("show");//获取show方法
        method.invoke(obj);//调用该实例的方法
        System.out.println(obj);//toString输出
    }

3. 反射动态获取类的结构

• 构造函数
• 成员变量
• 方法
• 注解

3.1 构造函数

● getConstructor(String.class,int.class.)：获取指定的一个构造函数
● getDeclaredConstructors()：获得构造函数，包括private的构造函数，返回数组
● newInstance(String str,int n)：执行构造函数产生对象

Class clazz = Class.forName("user_demo.User");
Object bean = clazz.newInstance(); //调用无参构造函数产生对象
等价于
Constructor con = clazz.getConstructor();
Object obj1 = con.newInstance(); //调用无参构造函数产生对象

案例演示：

public static void main(String[] args) throws Exception {
        Class clazz = Class.forName("user_demo.User");
        Constructor[] constructors = clazz.getDeclaredConstructors();//获取所有的构造函数
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + " " + Arrays.toString(constructor.getParameterTypes()));
        }
        Constructor con1 = clazz.getConstructor();//无参构造器
        Object obj = con1.newInstance();//调用默认的构造函数

        Constructor con2 = clazz.getConstructor(String.class, int.class);//获取一个两参构造函数
        Object obj1 = con2.newInstance("jack", 33);
        System.out.println(obj1);

        Constructor con3 = clazz.getDeclaredConstructor(String.class);//获取私有构造器
        con3.setAccessible(true);//能够使用私有的搞糟函数产生对象
        Object o = con3.newInstance("john");
        System.out.println(o);
    }
}

3.2 成员变量

● getDeclaredFields()：获得所有变量（包括private）
● getDeclaredField(String name)：获得具体的变量（包括private）
● getName()：获得变量的名字
● get(实例)：得到变量值
●set(实例，变量值)：设置该实例的变量的值

public static void main(String[] args) throws Exception{
        Class clazz = Class.forName("user_demo.User");//获取类
        Constructor con = clazz.getConstructor();//调用无参构造函数产生对象
        Object obj1 = con.newInstance(); 
        Field[] fields = clazz.getDeclaredFields();//得到所有的变量
        for (Field field : fields) {//打印输出变量
            field.setAccessible(true);
            System.out.println(field.getName() + " " + field.get(obj1));//变量名 + 变量值
        }
        Field field = clazz.getDeclaredField("name");//获取指定的属性
        field.setAccessible(true);//关闭安全检查
        field.set(obj1, "mickey");//修改obj1实例的名字为mickey
        System.out.println(obj1);

3.3 成员方法

● getDeclaredMethods()：得到当前类的所有方法，包括private
● getDeclaredMethod(方法名，方法参数列表...)：得到指定的所有方法
● method.invoke（对象实例，方法的参数值列表）：调用方法

public static void main(String[] args) throws Exception {
        Class clazz = Class.forName("user_demo.User");
        Object bean = clazz.newInstance(); //调用无参构造函数产生对象

        Method[] methods = clazz.getDeclaredMethods();//得到所有方法（包括private)
        for (Method method : methods) {
//            System.out.println(method.getName());
        }

        Method show = clazz.getMethod("show"); //得到具体方法
        show.invoke(bean);
        
        Method show2 = clazz.getMethod("show", String.class, int.class); //得到具体方法
        show2.invoke(bean, "hello show", 24);
        
        Method display = clazz.getDeclaredMethod("display", String.class); //得到私有方法
        display.setAccessible(true);
        display.invoke(bean, "hello display");
    }

3.4 类结构调用的安全检查

setAccessible()：默认是false，表示进行安全检查，不能访问private
设置为true，表示不进行安全检查。

4. 一道面试题

如何在不改变String内存地址的情况下，改变String的内容
思路：获取String类的成员属性Value[] --> 将其设置为允许改变 -->修改value[]的值。

public static void main(String[] args) throws Exception {
        String s = new String("123");
        String s1 = s;
        Field value = String.class.getDeclaredField("value");//获取String类型中的final value[]属性
        value.setAccessible(true);
        char[] chars = new char[]{97, 98, 99};
//        value.set(s,chars);
        value.set(s, chars);
        String s2 = s;
        System.out.println(s1.hashCode() + " " + s2.hashCode());
        System.out.println(s1 == s2);
    }
}
96354 96354
true

5. Java8新特性

5.1 Lambda表达式

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升

语法：
● 匿名内部类实现的接口一定是函数接口（只有一个抽象方法的接口）
● 左侧： 指定了 Lambda 表达式需要的参数列表
● 右侧： 指定了 Lambda 体， 是抽象方法的实现逻辑，也即Lambda 表达式要执行的功能。

5.2 类型判断

Lambda 表达式中的参数类型都是由编译器推断得出的。 Lambda表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。 Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”

5.3 案例分析

匿名内部类–> lambda表达式

interface A {
    void f1(String s);
}

interface B {
    void f2();
}
interface C{
    void f1(int x, int y);
}

public class Test1 {
	public static void test1(A a){
        a.f1("你好");
    }
    public static void show(C c) {
        c.f1(10, 20);
    }
    public static void main(String[] args) {
    	test1((str) ->{
           System.out.println(str);
       });
       show((n1,n2) ->{
           System.out.println(n1 -n2);
       });
    }

案例二

@Test
    public void test4() {
        List list = new ArrayList();
        list.add("555");
        list.add("zzz");
        list.add("xxx");
        list.add("444");
        Comparator<String> com = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return -o1.compareTo(o2);
            }
        };
//        定制排序器
//        Comparator<String> com = (s1, s2) -> {
//            return -s1.compareTo(s2);
//        };
        Collections.sort(list, com); //定制排序
        System.out.println(list);
    }