Java高级特性 - 反射 - 《KarenChia技术架构师》

前言
反射
类
Class
获取 Class 对象
类的实例
创建实例
- newInstance
- 构造器
获取构造器Constructor
获取属性Field
获取方法Method

前言

一般情况下，我们在使用某个类或者对象时，通过关键字 new 或者其它的可访问的对象的实例化方式，得到被使用对象的实例，然后再使用这个类的实例进行相关的操作。

当我们需要访问的对象私有，或者说压根就不知道访问的类对象时，只能通过 JDK 提供的反射 API 对对象进行反射调用。

反射

在运行状态下，对于任意一个类，都能够知道它的属性和方法，都能够调用它的属性和方法，并且可改变它的属性和方法。

由此可以看出，反射提供了以下功能：

在运行时，构造任意一个类的实例引用。
在运行时，获取并调用任意一个类的属性和方法。
在运行时，获取并修改任意一个类的属性和方法。

在运行时，通过反射，修改任意一个类的功能执行逻辑。

类

什么是类？

对象在机器语言中的抽象定义。

什么是对象？

万物皆可看成是对象。

一个类，包含了类名、属性、方法、构造器等。

Class

源码直观的定义：

public final class Class<T> implements java.io.Serializable,
                              GenericDeclaration,
                              Type,
                              AnnotatedElement {
}

Class 的定义使用了泛型，关于泛型，可以查看这边文章 Java开发中的泛型

Class 就是一个类，它封装了当前对象所对应的类的信息，Class 就是用来描述类的。

对于每个类而言，JRE 都为其保留了一个不变的 Class 类型的对象。一个 Class 对象包含了特定的某个类的有关信息。对象只能由系统建立对象，一个类（而不是一个对象）在 JVM 中只会有一个Class实例。

反射操作的就是 Class。通过 Class，获取类的相关属性和方法。

获取 Class 对象

类名获取

通过类名.class 获取：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    public static void main(String[] args) {
        Class<MainActivity> mainActivityClass = MainActivity.class;
    }
}

对象获取

通过对象.getClass() 获取：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    public static void main(String[] args) {
        MainActivity mainActivity = new MainActivity();
        Class<? extends MainActivity> aClass = mainActivity.getClass();
    }
}

全类名获取

静态方法获取

使用 Class 类的静态方法 public static Class<?> forName(String className) 获取，该方法抛出了 ClassNotFoundException 异常，因为所给出的全类名参数可能不能获取到其 Class 对象：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    public static void main(String[] args) {
        try {
            Class<?> aClass = Class.forName("net.csdn.blog.myapplication.MainActivity");
            System.out.println(aClass);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

输出结果为：

class net.csdn.blog.myapplication.MainActivity
Process finished with exit code 0

类加载器获取

使用类加载器 ClassLoader 获取：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    public static void main(String[] args) {
        try {
            Class<?> aClass = ClassLoader.getSystemClassLoader().loadClass("net.csdn.blog.myapplication.MainActivity");
            System.out.println(aClass);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

输出结果为：

class net.csdn.blog.myapplication.MainActivity
Process finished with exit code 0

类的实例

一般情况下，我们通过 instanceof 判断是否为某个类的实例。

在反射中，可通过如下方法判断是否为某个类的实例：

public boolean isInstance(Object obj)

public boolean isAssignableFrom(Class<?> cls)

例子：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    public static void main(String[] args) {
        try {
            Class<?> aClass = ClassLoader.getSystemClassLoader().loadClass("net.csdn.blog.myapplication.MainActivity");
            boolean assignableFrom = aClass.isAssignableFrom(MainActivity.class);
            System.out.println(assignableFrom);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

结果输出：

true
Process finished with exit code 0

创建实例

newInstance

使用 Class 对象的 public native T newInstance() 方法来创建 Class 对象的实例：

public class Test {
    public static void main(String[] args) {
        try {
            Class<?> aClass = Test.class;
            Object o = aClass.newInstance();
            System.out.println(o);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

newInstance 方法默认调用的是被反射对象中的无参构造器。

构造器

通过 Class 对象获取相关的构造器，在通过构造器的 newInstance 方法创建类的实例。

使用这种方法的好处是：

可以根据需要，选择合适的构造器，相较于前一种方式，显得更加灵活。

public class Test {
    public static void main(String[] args) {
        try {
            Class<?> aClass = Test.class;
            Constructor<?> constructor = aClass.getConstructor();
            Object o = constructor.newInstance();
            System.out.println(o);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

获取构造器Constructor

Constructor getConstructor(Class[] params) 获得使用特殊的参数类型的public构造函数(包括父类）
Constructor[] getConstructors() 获得类的所有公共构造函数
Constructor getDeclaredConstructor(Class[] params) 获得使用特定参数类型的构造函数(包括私有)
Constructor[] getDeclaredConstructors() 获得类的所有构造函数(与接入级别无关)

获取属性Field
Field getField(String name) 获得命名的公共字段
Field[] getFields() 获得类的所有公共字段
Field getDeclaredField(String name) 获得类声明的命名的公共字段
Field[] getDeclaredFields() 获得类声明的所有字段

获取方法Method
Method getMethod(String name, Class[] params) 使用特定的参数类型，获得命名的公共方法
Method[] getMethods() 获得类的所有公共方法
Method getDeclaredMethod(String name, Class[] params) 使用特写的参数类型，获得类声明的命名的方法
Method[] getDeclaredMethods() 获得类声明的所有方法

反射

前言

反射

类