廖雪峰Java4反射与泛型-1反射-1Class类

1.Class类与反射定义

Class类本身是一种数据类型（Type），class/interface的数据类型是Class，JVM为每个加载的class创建了唯一的Class实例。
Class实例包含该class的所有信息，通过Class实例获取class的信息的方法称为反射（Reflection）

Java除基本类型外，其他都是class（包括interface）。如String、Object、Runnable、Exception...

• class（包括interface）的本质是数据类型。我们把一个对象实例赋值给一种数据类型变量时，必须严格按照数据类型赋值。
• 没有继承关系的数据类型是无法赋值的。Java定义了一种强数据类型关系，并且编译器会检查数据类型，不符合数据类型要求的，在赋值时，编译器就会报错。

        String s = new String("Hello");
        Object o = new Double(123.456);
        Runnable r = new Thread();
        Exception e = new RuntimeException();       

class/interface的数据类型是Class。
每加载一个class，JVM就为其创建一个Class类型的实例，并关联起来。Class实例是JVM内部创建的。

JVM持有的每个Class实例都指向一个数据类型（class或interface）

	Class实例
name	java.lang.String --> String
name	java.util.Randome --> Random
name	java.lang.Runnable --> Runnable

一个Class实例包含了该class的完整信息。如String的Class实例持有name，package，super，interface，field，method

	Class实例
name	java.lang.String
package	java.lang
super	java.lang.Object
interface	CharSequence, ...
field	value[], hash, ...
method	indexOf, valueOf, ...

所以Java定义的Class类是：

• JVM为每个加载的class创建对应的Class实例，并在实例中保存该class的所有信息
• 如果获取了某个Class实例，则可以获取到该实例对应的class的所有信息。
• 通过Class实例获取class信息的方法成为反射（Reflection ）

2.获取一个class的Class实例

方法1：通过Type.class

        Class cls = String.class;

方法2：通过实例getClass()

        String s = "Hello";
        Class cls1 = s.getClass();
        Class cls2 = "Hello".getClass();

方法3：Class.forName(完整类名)

        try{
            Class cls = Class.forName("java.lang.String");
        }catch (Exception e){
            System.out.println(e);
        }

Class实例在JVM中是唯一的：

• 因此可以用 == 来比较两个Class实例

public class Main {
    public static void main(String[] args){
        Class cls1 = String.class;

        String s = "Hello";
        Class cls2 = s.getClass();
        System.out.println("cls1 == cls2: " + (cls1 == cls2));

        Class cls3;
        try{
            cls3 = Class.forName("java.lang.String");
            System.out.println("cls2 == cls3: " + (cls2 == cls3));
        }catch (ClassNotFoundException e){
            System.out.println(e);
        }
    }
}

2.1Class实例比较和instanceof的差别

public class Main {
    public static void main(String[] args){
        Integer n = new Integer(2);
        boolean b1 = n.getClass()==Integer.class;
        System.out.println("n.getClass()==Integer.class: " + b1);
        boolean b2 = n.getClass()==Number.class;
        //System.out.println("n.getClass() == Number.class: "+ b2);//Error:(10, 34) java: 不可比较的类型: java.lang.Class<capture#1, 共 ? extends java.lang.Integer>和java.lang.Class<java.lang.Number>

        boolean b3 = n instanceof Integer;
        System.out.println("n instanceof Integer: " + b3);
        boolean b4 = n instanceof Number;
        System.out.println("n instanceof Number: " + b4);
    }

通常情况下，使用instanceof判断数据类型，因为面向抽象编程的时候，我们不关心具体的子类型；只有在需要精确判断某个类型的时候，才需要获取其Class进行判断。

2.2反射的目的

反射的目的是当获得某个Object实例时，我们可以获取该Object的class信息。
从Class实例获取class信息：

• getName() 获取完整的类名
• getSimpleName() 获取简单的类名
• getPackage() 获取包名

public class Main {
    public static void main(String[] args){
        Integer n = new Integer(2);
        Class cls = n.getClass();
        
        String fullName = cls.getName();
        System.out.println(fullName);
        
        String simpleName = cls.getSimpleName();
        System.out.println(simpleName);
        
        String packageName = cls.getPackage().getName();
        System.out.println(packageName);
    }
}

从Class实例判断class类型

• isInterface() 是否是接口
• isEnum() 是否是枚举类
• isArray() 是否是数组
• isPrimitive() 是否是基本类型

public class Main {
    public static void main(String[] args){
        Boolean b1 = Runnable.class.isInterface();
        Boolean b2 = java.time.Month.class.isEnum();
        Boolean b3 = String[].class.isArray();
        Boolean b4 = int.class.isPrimitive();
        Boolean b5 = String.class.isPrimitive();

        System.out.println("Runnable.class是接口:"+b1);
        System.out.println("java.time.Month.class是枚举累:"+b2);
        System.out.println("String[].class是数组:"+b3);
        System.out.println("int.class是基本类型:"+b4);
        System.out.println("String.class是基本类型:"+b5);
    }
}

2.3通过newInstance创建新的实例。

public class Main {
    public static void main(String[] args) throws InstantiationException,IllegalAccessException{
        Class cls = String.class;
        /*通过newInstance可以创建一个新的String实例。
        局限：只能调用public的没有参数的构造方法，带参数的构造方法是不能调用的。*/
        String s = (String) cls.newInstance();
    }
}

3.动态加载

利用JVM动态加载class的特性：

• 可以在运行期根据条件加载不同的实现类

public class Main {
    //如Commons Logging优先使用Log4j，没有再使用jdk自带的Logging
    public static void main(String[] args) {
        /*
        代码仅供演示。createLog4j()和createJdkLog()未定义
         */
        LogFactory factory;
        if (isClassPresent("com.apache.Logging.log4j.Logger")){
            factory = createLog4j();
        }else {
            factory = createJdkLog();
        }
    }
    static boolean isClassPresent(String name){
        try{
            Class.forName(name);//判断一个类是否存在
            return true;
        }catch (Exception e){
            return false;
        }
    }
}

Hello.java

package com.reflection;

public interface Hello {
    public void hello();
}

Student.java

package com.reflection;

public class Student implements Hello{
    private String name;
    public Student(){
        this("unNamed");
    }
    public Student(String name){
        this.name=name;
    }
    public void hello(){
        System.out.println(name+" is Student");
    }
}

Teacher.java

package com.reflection;

public class Teacher implements Hello{
    private String name;
    public Teacher(){
        this("unNamed");
    }
    public Teacher(String name){
        this.name=name;
    }
    public void hello(){
        System.out.println(name+" is Teacher");
    }
}

Main.java

package com.reflection;

public class Main {
    public static void main(String[] args) throws InstantiationException,IllegalAccessException{
        Class cls = Student.class;
        System.out.println("class name:"+cls.getName());
        System.out.println("class simple name:"+cls.getSimpleName());
        System.out.println("class package name:"+cls.getPackage().getName());
        Student s = (Student) cls.newInstance();
        s.hello();
    }
}

改写Main.java，使用动态加载实现

package com.reflection;

public class Main {
    public static void main(String[] args) throws InstantiationException,IllegalAccessException,ClassNotFoundException{
        Class cls ;
        if (clsClassPresent("com.reflection.President")){
            cls = Class.forName("com.reflection.President");
        }else{
            cls = Class.forName("com.reflection.Student");
        }
        System.out.println("class name:"+cls.getName());
        System.out.println("class simple name:"+cls.getSimpleName());
        System.out.println("class package name:"+cls.getPackage().getName());
        Hello s = (Hello) cls.newInstance();
        s.hello();
    }
    static boolean clsClassPresent(String name){
        try{
            Class.forName(name);
            return true;
        }catch (Exception e){
            return false;
        }
    }
}

4.总结

• JVM为每个加载的class创建对应的Class实例来保存class的所有的信息
• 获取一个class的Class实例后，就可以获取该class的所有信息
• 通过Class实例获取class信息的方法成为反射Reflection
• JVM总是动态加载class，可以在运行期根据条件控制加载class

转载于:https://www.cnblogs.com/csj2018/p/10345863.html