Java反射机制

Java反射机制

概要

概要

1、线程这块还有那些内容呢？列举一下

	1.1、守护线程

		java语言中线程分为两大类：
			一类是：用户线程
			一类是：守护线程（后台线程）
			其中具有代表性的就是：垃圾回收线程（守护线程）。

		守护线程的特点：
			一般守护线程是一个死循环，所有的用户线程只要结束，
			守护线程自动结束。
		
		注意：主线程main方法是一个用户线程。

		守护线程用在什么地方呢？
			每天00:00的时候系统数据自动备份。
			这个需要使用到定时器，并且我们可以将定时器设置为守护线程。
			一直在那里看着，没到00:00的时候就备份一次。所有的用户线程
			如果结束了，守护线程自动退出，没有必要进行数据备份了。

	1.2、定时器
		定时器的作用：
			间隔特定的时间，执行特定的程序。

			每周要进行银行账户的总账操作。
			每天要进行数据的备份操作。

			在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，
			那么在java中其实可以采用多种方式实现：
				
				可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行
				任务。这种方式是最原始的定时器。（比较low）

				在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。
				不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持
				定时任务的。

				在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，
				这个框架只要进行简单的配置，就可以完成定时器的任务。


	1.3、实现线程的第三种方式：实现Callable接口。（JDK8新特性。）
		这种方式实现的线程可以获取线程的返回值。
		之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。

		思考：
			系统委派一个线程去执行一个任务，该线程执行完任务之后，可能
			会有一个执行结果，我们怎么能拿到这个执行结果呢？
				使用第三种方式：实现Callable接口方式。


	1.4、关于Object类中的wait和notify方法。（生产者和消费者模式！）

		第一：wait和notify方法不是线程对象的方法，是java中任何一个java对象
		都有的方法，因为这两个方式是Object类中自带的。
			wait方法和notify方法不是通过线程对象调用，
			不是这样的：t.wait()，也不是这样的：t.notify()..不对。
		
		第二：wait()方法作用？
			Object o = new Object();
			o.wait();

			表示：
				让正在o对象上活动的线程进入等待状态，无期限等待，
				直到被唤醒为止。
				o.wait();方法的调用，会让“当前线程（正在o对象上
				活动的线程）”进入等待状态。

		第三：notify()方法作用？
			Object o = new Object();
			o.notify();

			表示：
				唤醒正在o对象上等待的线程。
			
			还有一个notifyAll()方法：
				这个方法是唤醒o对象上处于等待的所有线程。


2、反射机制（比较简单，因为只要会查帮助文档，就可以了。）
	
	2.1、反射机制有什么用？
		通过java语言中的反射机制可以操作字节码文件。
		优点类似于黑客。（可以读和修改字节码文件。）
		通过反射机制可以操作代码片段。（class文件。）
	
	2.2、反射机制的相关类在哪个包下？
		java.lang.reflect.*;
	
	2.3、反射机制相关的重要的类有哪些？

		java.lang.Class：代表整个字节码，代表一个类型，代表整个类。

		java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法。

		java.lang.reflect.Constructor：代表字节码中的构造方法字节码。代表类中的构造方法

		java.lang.reflect.Field：代表字节码中的属性字节码。代表类中的成员变量（静态变量+实例变量）。

		java.lang.Class：
			public class User{
				// Field
				int no;

				// Constructor
				public User(){
				
				}
				public User(int no){
					this.no = no;
				}

				// Method
				public void setNo(int no){
					this.no = no;
				}
				public int getNo(){
					return no;
				}
			}

3、关于JDK中自带的类加载器：（聊一聊，不需要掌握，知道当然最好！）
	3.1、什么是类加载器？
		专门负责加载类的命令/工具。
		ClassLoader
	
	3.2、JDK中自带了3个类加载器
		启动类加载器:rt.jar
		扩展类加载器:ext/*.jar
		应用类加载器:classpath
	
	3.3、假设有这样一段代码：
		String s = "abc";
		
		代码在开始执行之前，会将所需要类全部加载到JVM当中。
		通过类加载器加载，看到以上代码类加载器会找String.class
		文件，找到就加载，那么是怎么进行加载的呢？

			首先通过“启动类加载器”加载。
				注意：启动类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\rt.jar
				rt.jar中都是JDK最核心的类库。
			
			如果通过“启动类加载器”加载不到的时候，
			会通过"扩展类加载器"加载。
				注意：扩展类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\*.jar

	
			如果“扩展类加载器”没有加载到，那么
			会通过“应用类加载器”加载。
				注意：应用类加载器专门加载：classpath中的类。
	
	3.4、java中为了保证类加载的安全，使用了双亲委派机制。
		优先从启动类加载器中加载，这个称为“父”
		“父”无法加载到，再从扩展类加载器中加载，
		这个称为“母”。双亲委派。如果都加载不到，
		才会考虑从应用类加载器中加载。直到加载
		到为止。

总结:

1、回顾反射机制

	1.1、什么是反射机制？反射机制有什么用？
		反射机制：可以操作字节码文件
		作用：可以让程序更加灵活。

	1.2、反射机制相关的类在哪个包下？
		java.lang.reflect.*;

	1.3、反射机制相关的主要的类？
		java.lang.Class
		java.lang.reflect.Method;
		java.lang.reflect.Constructor;
		java.lang.reflect.Field;

	1.4、在java中获取Class的三种方式？
		第一种：	 
			Class c = Class.forName("完整类名");
		第二种：
			Class c = 对象.getClass();
		第三种：
			Class c = int.class;
			Class c = String.class;

	1.5、获取了Class之后，可以调用无参数构造方法来实例化对象

		//c代表的就是日期Date类型
		Class c = Class.forName("java.util.Date");

		//实例化一个Date日期类型的对象
		Object obj = c.newInstance();

		一定要注意：
			newInstance()底层调用的是该类型的无参数构造方法。
			如果没有这个无参数构造方法会出现"实例化"异常。
	
	1.6、如果你只想让一个类的“静态代码块”执行的话，你可以怎么做？
		Class.forName("该类的类名");
		这样类就加载，类加载的时候，静态代码块执行！！！！
		在这里，对该方法的返回值不感兴趣，主要是为了使用“类加载”这个动作。
	
	1.7、关于路径问题？

		String path = Thread.currentThread().getContextClassLoader()
						  .getResource("写相对路径，但是这个相对路径从src出发开始找").getPath();	

		String path = Thread.currentThread().getContextClassLoader()
						  .getResource("abc").getPath();	//必须保证src下有abc文件。

		String path = Thread.currentThread().getContextClassLoader()
						  .getResource("a/db").getPath();	//必须保证src下有a目录，a目录下有db文件。
		
		String path = Thread.currentThread().getContextClassLoader()
						  .getResource("com/example/test.properties").getPath();	
						  //必须保证src下有com目录，com目录下有example目录。
						  //example目录下有test.properties文件。

		这种方式是为了获取一个文件的绝对路径。（通用方式，不会受到环境移植的影响。）
		但是该文件要求放在类路径下，换句话说：也就是放到src下面。
		src下是类的根路径。

		直接以流的形式返回：
		InputStream in = Thread.currentThread().getContextClassLoader()
								.getResourceAsStream("com/example/test.properties");

	1.8、IO + Properties，怎么快速绑定属性资源文件？

		//要求：第一这个文件必须在类路径下
		//第二这个文件必须是以.properties结尾。
		ResourceBundle bundle = ResourceBundle.getBundle("com/example/test");
		String value = bundle.getString(key);
	

2、今日反射机制的重点内容
	2.1、通过反射机制访问对象的某个属性。
	2.2、通过反射机制调用对象的某个方法。
	2.3、通过反射机制调用某个构造方法实例化对象。
	2.4、通过反射机制获取父类以及父类型接口。

ReflectTest01——获取类的字节码文件的三种方式

怎么获取一个类的字节码文件？有三种方式：

Class c = Class.forName("完整类名带包名");

是一个静态方法。
方法的参数是一个字符串。
字符串需要的是一个完整类名。
完整类名必须带有包名。java.lang包也不能省略。如：com.example.bean.Student或java.lang.String
Class c = 对象.getClass();

Class c1 = Class.forName("java.lang.String"); // c1代表String.class文件，或者说c1代表String类型。

String s = "abc";

Class x = s.getClass(); // x代表String.class字节码文件，x代表String类型。

System.out.println(c1 == x); // true（==判断的是对象的内存地址。）

字节码内存图：
Class c = 任何类型.class;

Class z = String.class; // z代表String类型
Class k = Date.class; // k代表Date类型
Class f = int.class; // f代表int类型
Class e = double.class; // e代表double类型

import java.util.Date;

/*
要操作一个类的字节码，需要首先获取到这个类的字节码，怎么获取java.lang.Class实例？
    三种方式
        第一种：Class c = Class.forName("完整类名带包名");
        第二种：Class c = 对象.getClass();
        第三种：Class c = 任何类型.class;

 */
public class ReflectTest01 {
    public static void main(String[] args) {
        /*
        Class.forName()
            1、静态方法
            2、方法的参数是一个字符串。
            3、字符串需要的是一个完整类名。
            4、完整类名必须带有包名。java.lang包也不能省略。
         */
        Class c1 = null;
        Class c2 = null;
        try {
            c1 = Class.forName("java.lang.String"); // c1代表String.class文件，或者说c1代表String类型。
            c2 = Class.forName("java.util.Date"); // c2代表Date类型
            Class c3 = Class.forName("java.lang.Integer"); // c3代表Integer类型
            Class c4 = Class.forName("java.lang.System"); // c4代表System类型
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        // java中任何一个对象都有一个方法：getClass()
        String s = "abc";
        Class x = s.getClass(); // x代表String.class字节码文件，x代表String类型。
        System.out.println(c1 == x); // true（==判断的是对象的内存地址。）

        Date time = new Date();
        Class y = time.getClass();
        System.out.println(c2 == y); // true (c2和y两个变量中保存的内存地址都是一样的，都指向方法区中的字节码文件。)

        // 第三种方式，java语言中任何一种类型，包括基本数据类型，它都有.class属性。
        Class z = String.class; // z代表String类型
        Class k = Date.class; // k代表Date类型
        Class f = int.class; // f代表int类型
        Class e = double.class; // e代表double类型

        System.out.println(x == z); // true

    }
}

ReflectTest02——通过Class的newInstance()方法来实例化对象

获取到Class字节码文件，可以通过此字节码文件的newInstance()方法实例化对象

例如：

Class c = Class.forName("com.example.java.bean.User"); // c代表User类型。

Object obj = c.newInstance();

注意：newInstance()方法内部实际上调用了无参数构造方法，如果类中有有参数的构造，那么必须保证无参构造也存在才可以。

注意:

class Person{

}

默认情况下是有无参构造的，如果你要生成一个有参构造，那么无参构造必须声明。

class Person{

//此处必须声明无参构造

public Person(){}

public Person(String name){}

}

public class ReflectTest02 {
    public static void main(String[] args) {

        // 这是不使用反射机制，创建对象
        User user = new User();
        System.out.println(user);

        // 下面这段代码是以反射机制的方式创建对象。
        try {
            // 通过反射机制，获取Class，通过Class来实例化对象
            Class c = Class.forName("com.example.java.bean.User"); // c代表User类型。

            // newInstance() 这个方法会调用User这个类的无参数构造方法，完成对象的创建。
            // 重点是：newInstance()调用的是无参构造，必须保证无参构造是存在的！
            Object obj = c.newInstance();

            System.out.println(obj); // com.example.java.bean.User@10f87f48
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

public class User {
    public User(){
        System.out.println("无参数构造方法！");
    }

    // 定义了有参数的构造方法，无参数构造方法就没了。
    public User(String s){

    }
}

ReflectTest03——验证反射机制的灵活性

为什么说反射机制灵活？

Java代码写一遍，再不改变java源代码的基础之上，可以做到不同对象的实例化。
非常之灵活。（符合OCP开闭原则：对扩展开放，对修改关闭。）

反射机制的用途是什么？

高级框架底层使用反射机制比较多，反射机制很重要。

学会了反射机制有利于你理解剖析框架底层的源代码。

示例：

以下例子是通过修改 classinfo2.properties 配置文件属性的方式，java代码不需要改动，通过修改配置文件就可以动态的实例化不同的对象。

public class ReflectTest03 {
    public static void main(String[] args) throws Exception{

        // 这种方式代码就写死了。只能创建一个User类型的对象
        //User user = new User();

        // 以下代码是灵活的，代码不需要改动，可以修改配置文件，配置文件修改之后，可以创建出不同的实例对象。
        // 通过IO流读取classinfo.properties文件
        FileReader reader = new FileReader("chapter25/classinfo2.properties");
        // 创建属性类对象Map
        Properties pro = new Properties(); // key value都是String
        // 加载
        pro.load(reader);
        // 关闭流
        reader.close();

        // 通过key获取value
        String className = pro.getProperty("className");
        //System.out.println(className);

        // 通过反射机制实例化对象
        Class c = Class.forName(className);
        Object obj = c.newInstance();
        System.out.println(obj);
    }
}

ReflectTest04——Class.forName()只是让一个类的静态代码块执行，其它代码一律不执行

如果你只是希望一个类的静态代码块执行，其它代码一律不执行，你可以使用：

Class.forName("完整类名");
这个方法的执行会导致类加载，类加载时，静态代码块执行。

用到的地方：

JDBC技术。

如：Class.forName(com.mysql.jdbc.Driver);

public class ReflectTest04 {
    public static void main(String[] args) {
        try {
            // Class.forName()这个方法的执行会导致：类加载。
            Class.forName("com.example.reflect.MyClass");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

public class MyClass {

    // 静态代码块在类加载时执行，并且只执行一次。
    static {
        System.out.println("MyClass类的静态代码块执行了！");
    }
}

AboutPath——获取一个文件的绝对路径

为什么不使用FileReader reader = new FileReader("chapter25/classinfo2.properties");来读取配置文件，这种方式获取文件路径的缺点?

这种方式的路径缺点是：可移植性差，在IDEA中默认的当前路径是project的根。

这个代码假设离开了IDEA，换到了其它位置，可能当前路径就不是project的根了，这时这个路径就无效了。

怎么获取一个文件的绝对路径?

String path = Thread.currentThread().getContextClassLoader().getResource("classinfo2.properties").getPath();

// 这种方式获取文件绝对路径是通用的。

解释：

Thread.currentThread() 当前线程对象
getContextClassLoader() 是线程对象的方法，可以获取到当前线程的类加载器对象。
getResource() 【获取资源】这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源。

前提是：文件需要在类路径下。才能用这种方式。

什么类路径下？在src下的都是类路径下。

public class AboutPath {
    public static void main(String[] args) throws Exception{
        String path = Thread.currentThread().getContextClassLoader()
                .getResource("classinfo2.properties").getPath(); // 这种方式获取文件绝对路径是通用的。

        // 采用以上的代码可以拿到一个文件的绝对路径。
        // /C:/Users/Administrator/IdeaProjects/javase/out/production/chapter25/classinfo2.properties
        System.out.println(path);

        // 获取db.properties文件的绝对路径（从类的根路径下作为起点开始）
        String path2 = Thread.currentThread().getContextClassLoader()
                .getResource("com/example/java/bean/db.properties").getPath();
        System.out.println(path2);

    }
}

IoPropertiesTest——以流的形式返回读取的文件

直接以流的形式返回 InputStream 对象：

InputStream reader = Thread.currentThread().getContextClassLoader()
.getResourceAsStream("classinfo2.properties");

使用Properties的load方法加载流中的数据：

Properties pro = new Properties();
pro.load(reader);

public class IoPropertiesTest {
    public static void main(String[] args) throws Exception{

        // 获取一个文件的绝对路径了！！！！！
        /*String path = Thread.currentThread().getContextClassLoader()
                .getResource("classinfo2.properties").getPath();
        FileReader reader = new FileReader(path);*/

        // 直接以流的形式返回。
        InputStream reader = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("classinfo2.properties");

        Properties pro = new Properties();
        pro.load(reader);
        reader.close();
        // 通过key获取value
        String className = pro.getProperty("className");
        System.out.println(className);
    }
}

ResourceBundleTest——资源绑定器

ResourceBundle的常用方法：

#test.properties配置文件
className=com.example.bean.User

public static final ResourceBundle getBundle(String baseName)：获得资源绑定器。参数baseName是资源的全限定名称(不能包含后缀)。

ResourceBundle bundle = ResourceBundle.getBundle("test");

//注意：baseName不能带有后缀。
public final String getString(String key)：获取给定key的value字符串。

String string = bundle.getString("className");
System.out.println(string); //com.example.bean.User
public boolean containsKey(String key)：确定读取的配置文件是否包含某个key。

boolean containsKey1 = bundle.containsKey("className");
boolean containsKey2 = bundle.containsKey("className1");
System.out.println(containsKey1); //true
System.out.println(containsKey2); //false
public abstract Enumeration<String> getKeys()：返回所有key的枚举。

Enumeration keys = bundle.getKeys();
while (keys.hasMoreElements()) {
System.out.println(keys.nextElement());
}
public Set<String> keySet()：返回所有key的set集合。

Set keySet = bundle.keySet();
for (String s : keySet) {
System.out.println(s);
}

import java.util.ResourceBundle;
/*
java.util包下提供了一个资源绑定器，便于获取属性配置文件中的内容。
使用以下这种方式的时候，属性配置文件xxx.properties必须放到类路径下。
 */
public class ResourceBundleTest {
    public static void main(String[] args) {

        // 资源绑定器，只能绑定xxx.properties文件。并且这个文件必须在类路径下。文件扩展名也必须是properties
        // 并且在写路径的时候，路径后面的扩展名不能写。
        //ResourceBundle bundle = ResourceBundle.getBundle("classinfo2");

        ResourceBundle bundle = ResourceBundle.getBundle("com/example/java/bean/db");

        String className = bundle.getString("className");
        System.out.println(className);
    }
}

ReflectTest05——Class、Field、Constructor、Methods类的常用方法

Class对象的常用方法：

student类：

public class Student {
    private String name; 
    protected int age; 
    boolean sex;
    public int no;
    public static final double MATH_PI = 3.1415926;
    //无参构造
    public Student() {
        
    }
	//有参构造
    public Student(String name) {
        
    }
    //普通方法m1
    public void m1() {

    }
    //普通方法m2
    public void m2() {

    }
}

static Class<?> forName(String className)：返回指定的字符串名的类或接口的 Class 对象。参数是类的全限定名称。

Class studentClass = Class.forName("com.example.java.bean.Student");
public T newInstance()：创建此 Class 对象所表示的类的一个新实例。

Object o = studentClass.newInstance();
String getName()：以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称【返回的是全类名】。

String name = clazz.getName();
System.out.println(name); //com.example.bean.Student
public String getSimpleName()：返回当前对象的简单。

String simpleName = clazz.getSimpleName();
System.out.println(simpleName); //Student
public Field[] getDeclaredFields()：返回 Field 对象的一个数组，这些对象是此 Class 对象所表示的类或接口所声明的所有字段。包括公共、保护、默认（包）访问和私有字段，但不包括继承的字段。

Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
System.out.println(field.getName());
}
// name
// age
// sex
// no
// MATH_PI
public Field getDeclaredField(String name)：返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。name 参数是一个 String，它指定所需字段的简称。

Field name = clazz.getDeclaredField("name");
public Method[] getDeclaredMethods()：返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法，不包括构造方法。

Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method.getName());
}
//m2
//m1
public Method getDeclaredMethod(String name,Class<?>... parameterTypes)：返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。name 参数是一个 String，它指定所需方法的简称，parameterTypes 参数是 Class 对象的一个数组，它按声明顺序标识该方法的形参类型。

Method method = clazz.getDeclaredMethod("m1");
System.out.println(method); //public void com.example.bean.Student.m1()

问题：知道了方法名称，为什么还需要指定参数的类型？

因为有方法的重载。
public Constructor<?>[] getDeclaredConstructors()：返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。

Constructor[] constructors = clazz.getDeclaredConstructors(); for (Constructor constructor : constructors) {
System.out.println(constructor);
}
// public com.example.bean.Student()
// public com.example.bean.Student(java.lang.String)
public Constructor<T> getConstructor(Class<?>... parameterTypes)：返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。

Constructor<?> constructor = clazz.getDeclaredConstructor(String.class);
System.out.println(constructor); //public com.example.bean.Student(java.lang.String)
public Package getPackage()：获取此类的包。

Package classPackage = clazz.getPackage();
System.out.println(classPackage.getName()); //com.example.bean
public Class<? super T> getSuperclass()：返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的父类的 Class。

Class<?> superclass = clazz.getSuperclass();
System.out.println(superclass); //class java.lang.Object
public Class<?>[] getInterfaces()：返回此对象所实现的所有接口。

Class clazz1 = Class.forName("java.lang.String"); Class[] interfaces = clazz1.getInterfaces();
for (Class<?> anInterface : interfaces) {
System.out.println(anInterface.getName());
}
// java.io.Serializable
// java.lang.Comparable
// java.lang.CharSequence
public int getModifiers()：返回此类或接口以整数编码的 Java 语言修饰符。修饰符由 Java 虚拟机的 public、protected、private、final、static、abstract 和 interface 对应的常量组成；它们应当使用 Modifier 类的 toString() 方法来解码。

int modifiers = clazz.getModifiers();
System.out.println(modifiers); //1

//返回值是int型数据，应当使用 Modifier 类的方法来解码。

String string = Modifier.toString(modifiers); //public
public Annotation[] getAnnotations()：返回此元素上存在的所有注释。（如果此元素没有注释，则返回长度为零的数组。）该方法的调用者可以随意修改返回的数组；这不会对其他调用者返回的数组产生任何影响。

//获取一个类/接口/注解上的所有注解
Class<?> clazz = Class.forName("com.example.annotation7.MustHaveIdPropertyAnnotation");
Annotation[] annotations = clazz.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
// @java.lang.annotation.Target(value=[TYPE])
// @java.lang.annotation.Retention(value=RUNTIME)
}
public <A extends Annotation> A getAnnotation(Class<A> annotationClass)：返回该元素的指定类型的注释，不存在则返回 null。

Class<?> clazz = Class.forName("com.example.annotation7.MustHaveIdPropertyAnnotation");
Retention annotation = clazz.getAnnotation(Retention.class);
System.out.println(annotation.value()); //RUNTIME
public boolean isAnnotation()：如果此 Class 对象表示一个注释类型则返回 true。注意，如果此方法返回 true，则 isInterface() 也返回 true，因为所有的注释类型同时也是接口。

Class<?> clazz1 = Class.forName("com.example.annotation6.MyAnnotation");
System.out.println(clazz1.isAnnotation()); //true
public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)：判断指定注解是否出现在此元素上。

//判断此元素上是否存在 Retention.class 类型的注解
Class<?> clazz = Class.forName("com.example.annotation6.MyAnnotationTest");
boolean present = clazz.isAnnotationPresent(Retention.class);
System.out.println(present); //true

Field对象的常用方法：

Student.java

public class Student {
    private String name; 
    protected int age; 
    boolean sex;
    public int no;
    public static final double MATH_PI = 3.1415926;
}

public String getName()：返回此 Field 对象表示的字段的名称。

Field field = clazz.getDeclaredField("MATH_PI");
//获得字段名称
String fieldName = field.getName();
System.out.println(fieldName); //MATH_PI
public void set(Object obj,Object value)：将指定对象变量上此 Field 对象表示的字段设置为指定的新值。

注意：当给 private 类型的属性赋值时，需要先打破其封装性。

//获得该类的字节码文件
Class<?> clazz = Class.forName("com.example.test01.Person");
//获得该类的实例对象
Object o = clazz.newInstance();
//获得该类的指定属性，返回Field对象
Field field = clazz.getDeclaredField("no");
System.out.println(field); //private int com.example.test01.Person.no
//因为该字段是 private 修饰，因从调用赋值方法之前，需要打破该字段的封装性
//注意：只打破了该字段的封装性，对于其他 private 属性，仍需打破其他字段的封装，才可赋值。
field.setAccessible(true);
//调用该属性的赋值方法
field.set(o, 122);
//获得该属性的值
Object o1 = field.get(o);
System.out.println(o1); //122
public Object get(Object obj)：返回指定对象上此 Field 表示的字段的值。

Field field = clazz.getDeclaredField("MATH_PI");
//获得字段的值
Object o = field.get("MATH_PI");
System.out.println(o); //3.1415926
public String toString()：回一个描述此 Field 的字符串。格式是：该字段（如果存在的话）的访问修饰符，后面跟着字段类型和一个空格，再后面是声明该字段的类的完全限定名，后面跟着一个句点，最后是字段的名称。

Field field = clazz.getDeclaredField("MATH_PI");
String fieldString = field.toString();
System.out.println(fieldString);
// public static final double com.example.bean.Student.MATH_PI
public int getModifiers()：以整数形式返回由此 Field 对象表示的字段的 Java 语言修饰符。应该使用 Modifier 类对这些修饰符进行解码。

Field field = clazz.getDeclaredField("MATH_PI");
//获得字段的修饰符
int modifiers = field.getModifiers();
System.out.println(Modifier.toString(modifiers)); //public static final
public Class<?> getType()：返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。

Field field = clazz.getDeclaredField("MATH_PI");
String simpleName = field.getType().getSimpleName();
System.out.println(simpleName); //double

Constructor对象的常用方法：

public Class<?>[] getParameterTypes()：返回一组 Class 对象，这些对象表示此 Constructor 对象所表示构造方法的形参类型。

Class clazz = Class.forName("com.example.bean.Student"); Constructor constructor = clazz.getDeclaredConstructor(String.class);
Class[] parameterTypes = constructor.getParameterTypes(); for (Class parameterType : parameterTypes) {
System.out.println(parameterType.getName());
}

//java.lang.String
public T newInstance(Object... initargs)：使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。

//获得该类的字节码文件
Class clazz = Class.forName("com.example.test03.Person"); //获得该类的无参构造 Constructor constructor = clazz.getDeclaredConstructor();
//获得该无参构造的实例对象
Object o = constructor.newInstance();
//输出该无参构造
System.out.println(o); //Person{age=null, name='null'}

//使用有参构造创建对象。

Constructor<?> constructor1 = clazz.getDeclaredConstructor(Integer.class, String.class);
Object o1 = constructor1.newInstance(100, "zhangsan");
System.out.println(o1); //Person

Method对象的常用方法：

public <T extends Annotation> T getAnnotation(Class<T> annotationClass)：如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。
public Annotation[] getDeclaredAnnotations()：返回直接存在于此元素上的所有注释。
public Object invoke(Object obj,Object... args)：对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。

/*
反射Student类当中所有的Field（了解一下）
 */
public class ReflectTest05 {
    public static void main(String[] args) throws Exception{

        // 获取整个类
        Class studentClass = Class.forName("com.example.java.bean.Student");

        //com.example.java.bean.Student
        String className = studentClass.getName();
        System.out.println("完整类名：" + className);

        String simpleName = studentClass.getSimpleName();
        System.out.println("简类名：" + simpleName);

        // 获取类中所有的public修饰的Field
        Field[] fields = studentClass.getFields();
        System.out.println(fields.length); // 测试数组中只有1个元素
        // 取出这个Field
        Field f = fields[0];
        // 取出这个Field它的名字
        String fieldName = f.getName();
        System.out.println(fieldName);

        // 获取所有的Field
        Field[] fs = studentClass.getDeclaredFields();
        System.out.println(fs.length); // 4

        System.out.println("==================================");
        // 遍历
        for(Field field : fs){
            // 获取属性的修饰符列表
            int i = field.getModifiers(); // 返回的修饰符是一个数字，每个数字是修饰符的代号！！！
            System.out.println(i);
            // 可以将这个“代号”数字转换成“字符串”吗？
            String modifierString = Modifier.toString(i);
            System.out.println(modifierString);
            // 获取属性的类型
            Class fieldType = field.getType();
            //String fName = fieldType.getName();
            String fName = fieldType.getSimpleName();
            System.out.println(fName);
            // 获取属性的名字
            System.out.println(field.getName());
        }
    }
}

Student实体类：

package com.example.java.bean;

// 反射属性Field
public class Student {

    // Field翻译为字段，其实就是属性/成员
    // 4个Field，分别采用了不同的访问控制权限修饰符
    private String name; // Field对象
    protected int age; // Field对象
    boolean sex;
    public int no;
    public static final double MATH_PI = 3.1415926;
}

ReflectTest06——通过反射机制，反编译一个类的属性Field

package com.example.java.reflect;

//通过反射机制，反编译一个类的属性Field（了解一下）

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class ReflectTest06 {
    public static void main(String[] args) throws Exception{

        // 创建这个是为了拼接字符串。
        StringBuilder s = new StringBuilder();

        //Class studentClass = Class.forName("com.example.java.bean.Student");
        Class studentClass = Class.forName("java.lang.Thread");

        s.append(Modifier.toString(studentClass.getModifiers()) + " class " + studentClass.getSimpleName() + " {\n");

        Field[] fields = studentClass.getDeclaredFields();
        for(Field field : fields){
            s.append("\t");
            s.append(Modifier.toString(field.getModifiers()));
            s.append(" ");
            s.append(field.getType().getSimpleName());
            s.append(" ");
            s.append(field.getName());
            s.append(";\n");
        }

        s.append("}");
        System.out.println(s);

    }
}

ReflectTest07——通过反射机制设置和访问一个java对象的属性

步骤如下：

通过反射机制获得该类的字节码文件。

Class<?> clazz = Class.forName("com.example.test01.Person");
获得该类的实例对象。

Object o = clazz.newInstance();
获得该类的指定属性，返回Field对象。

Field field = clazz.getDeclaredField("no");
因为该字段是 private 修饰，因从调用赋值方法之前，需要打破该字段的封装性。

field.setAccessible(true);
调用该属性的赋值方法.

field.set(o, 122);
获取该属性的值。

Object o1 = field.get(o); //122

/*
必须掌握：
    怎么通过反射机制访问一个java对象的属性？
        给属性赋值set
        获取属性的值get
 */
public class ReflectTest07 {
    public static void main(String[] args) throws Exception{

        // 我们不使用反射机制，怎么去访问一个对象的属性呢？
        Student s = new Student();

        // 给属性赋值
        s.no = 1111; //三要素：给s对象的no属性赋值1111
                    //要素1：对象s
                    //要素2：no属性
                    //要素3：1111

        // 读属性值
        // 两个要素：获取s对象的no属性的值。
        System.out.println(s.no);

        // 使用反射机制，怎么去访问一个对象的属性。（set get）
        Class studentClass = Class.forName("com.example.java.bean.Student");
        Object obj = studentClass.newInstance(); // obj就是Student对象。（底层调用无参数构造方法）

        // 获取no属性（根据属性的名称来获取Field）
        Field noFiled = studentClass.getDeclaredField("no");

        // 给obj对象(Student对象)的no属性赋值
        /*
        虽然使用了反射机制，但是三要素还是缺一不可：
            要素1：obj对象
            要素2：no属性
            要素3：2222值
        注意：反射机制让代码复杂了，但是为了一个“灵活”，这也是值得的。
         */
        noFiled.set(obj, 22222); // 给obj对象的no属性赋值2222

        // 读取属性的值
        // 两个要素：获取obj对象的no属性的值。
        System.out.println(noFiled.get(obj));

        // 可以访问私有的属性吗？
        Field nameField = studentClass.getDeclaredField("name");

        // 打破封装（反射机制的缺点：打破封装，可能会给不法分子留下机会！！！）
        // 这样设置完之后，在外部也是可以访问private的。
        nameField.setAccessible(true);

        // 给name属性赋值
        nameField.set(obj, "jackson");
        // 获取name属性的值
        System.out.println(nameField.get(obj));
    }
}

ArgsTest——可变长度参数

可变长度参数：
int... args 这就是可变长度参数
语法是：类型... （注意：一定是3个点。）

1、可变长度参数要求的参数个数是：0~N个。
2、可变长度参数在参数列表中必须在最后一个位置上，而且可变长度参数只能有1个。
3、可变长度参数可以当做一个数组来看待

语法格式：

修饰符返回值类型方法名 (参数类型...形参名 )

如：public static void m2(int a, String... args1) { }

注意：这种可变长参数的一个方法中只能有一个，且必须放在最后位置。

/*
可变长度参数
    int... args 这就是可变长度参数
    语法是：类型...  （注意：一定是3个点。）

    1、可变长度参数要求的参数个数是：0~N个。
    2、可变长度参数在参数列表中必须在最后一个位置上，而且可变长度参数只能有1个。
    3、可变长度参数可以当做一个数组来看待
 */
public class ArgsTest {
    public static void main(String[] args) {
        m();
        m(10);
        m(10, 20);

        // 编译报错
        //m("abc");

        m2(100);
        m2(200, "abc");
        m2(200, "abc", "def");
        m2(200, "abc", "def", "xyz");

        m3("ab", "de", "kk", "ff");

        String[] strs = {"a","b","c"};
        // 也可以传1个数组
        m3(strs);

        // 直接传1个数组
        m3(new String[]{"我","是","中","国", "人"}); //没必要

        m3("我","是","中","国", "人");
    }

    public static void m(int... args){
        System.out.println("m方法执行了！");
    }

    //public static void m2(int... args2, String... args1){}

    // 必须在最后，只能有1个。
    public static void m2(int a, String... args1){

    }

    public static void m3(String... args){
        //args有length属性，说明args是一个数组！
        // 可以将可变长度参数当做一个数组来看。
        for(int i = 0; i < args.length; i++){
            System.out.println(args[i]);
        }
    }
}

ReflectTest08——反射Method

//反射Method
public class ReflectTest08 {
    public static void main(String[] args) throws Exception{

        // 获取类了
        Class userServiceClass = Class.forName("com.example.java.service.UserService");

        // 获取所有的Method（包括私有的！）
        Method[] methods = userServiceClass.getDeclaredMethods();
        //System.out.println(methods.length); // 2

        // 遍历Method
        for(Method method : methods){
            // 获取修饰符列表
            System.out.println(Modifier.toString(method.getModifiers()));
            // 获取方法的返回值类型
            System.out.println(method.getReturnType().getSimpleName());
            // 获取方法名
            System.out.println(method.getName());
            // 方法的修饰符列表（一个方法的参数可能会有多个。）
            Class[] parameterTypes = method.getParameterTypes();
            for(Class parameterType : parameterTypes){
                System.out.println(parameterType.getSimpleName());
            }
        }
    }
}

UserService

package com.bjpowernode.java.service;

/**
 * 用户业务类
 */
public class UserService {

    /**
     * 登录方法
     * @param name 用户名
     * @param password 密码
     * @return true表示登录成功，false表示登录失败！
     */
    public boolean login(String name,String password){
        if("admin".equals(name) && "123".equals(password)){
            return true;
        }
        return false;
    }

    // 可能还有一个同名login方法
    // java中怎么区分一个方法，依靠方法名和参数列表。
    public void login(int i){

    }

    /**
     * 退出系统的方法
     */
    public void logout(){
        System.out.println("系统已经安全退出！");
    }
}

ReflectTest09——反编译一个类的方法

/*
反编译一个类的方法
 */
public class ReflectTest09 {
    public static void main(String[] args) throws Exception{
        StringBuilder s = new StringBuilder();
        //Class userServiceClass = Class.forName("com.bjpowernode.java.service.UserService");
        Class userServiceClass = Class.forName("java.lang.String");
        s.append(Modifier.toString(userServiceClass.getModifiers()) + " class "+userServiceClass.getSimpleName()+" {\n");

        Method[] methods = userServiceClass.getDeclaredMethods();
        for(Method method : methods){
            //public boolean login(String name,String password){}
            s.append("\t");
            s.append(Modifier.toString(method.getModifiers()));
            s.append(" ");
            s.append(method.getReturnType().getSimpleName());
            s.append(" ");
            s.append(method.getName());
            s.append("(");
            // 参数列表
            Class[] parameterTypes = method.getParameterTypes();
            for(Class parameterType : parameterTypes){
                s.append(parameterType.getSimpleName());
                s.append(",");
            }
            // 删除指定下标位置上的字符
            s.deleteCharAt(s.length() - 1);
            s.append("){}\n");
        }

        s.append("}");
        System.out.println(s);
    }
}

ReflectTest10——通过反射机制怎么调用一个对象的方法

步骤：

使用到的UserService对象：

public class UserService {
    private String username;
    private String password;

    public boolean login(String username, String password) {
        if ("zhangsan".equals(username) && "123456".equals(password)) {
            return true;
        } else {
            return false;
        }
    }
}

获得该类的字节码文件。

Class<?> clazz = Class.forName("com.example.test02.UserService");
获得该类的实例对象。

Object o = clazz.newInstance();
获得该类的login方法。

Method login = clazz.getDeclaredMethod("login", String.class, String.class);
调用该类的login方法。

Object retValue = login.invoke(o, "zhangsan", "123456");
System.out.println((Boolean) retValue?"登录成功":"登录失败"); //登录成功

Object retValue = login.invoke(o, "zhangsan", "1234560");
System.out.println((Boolean) retValue?"登录成功":"登录失败"); //登录失败

/*
重点：必须掌握，通过反射机制怎么调用一个对象的方法？
    五颗星*****

    反射机制，让代码很具有通用性，可变化的内容都是写到配置文件当中，
    将来修改配置文件之后，创建的对象不一样了，调用的方法也不同了，
    但是java代码不需要做任何改动。这就是反射机制的魅力。
 */
public class ReflectTest10 {
    public static void main(String[] args) throws Exception{
        // 不使用反射机制，怎么调用方法
        // 创建对象
        UserService userService = new UserService();
        // 调用方法
        /*
        要素分析：
            要素1：对象userService
            要素2：login方法名
            要素3：实参列表
            要素4：返回值
         */
        boolean loginSuccess = userService.login("admin","123");
        //System.out.println(loginSuccess);
        System.out.println(loginSuccess ? "登录成功" : "登录失败");

        // 使用反射机制来调用一个对象的方法该怎么做？
        Class userServiceClass = Class.forName("com.example.java.service.UserService");
        // 创建对象
        Object obj = userServiceClass.newInstance();
        // 获取Method
        Method loginMethod = userServiceClass.getDeclaredMethod("login", String.class, String.class);
        //Method loginMethod = userServiceClass.getDeclaredMethod("login", int.class);
        // 调用方法
        // 调用方法有几个要素？ 也需要4要素。
        // 反射机制中最最最最最重要的一个方法，必须记住。
        /*
        四要素：
        loginMethod方法
        obj对象
        "admin","123" 实参
        retValue 返回值
         */
        Object retValue = loginMethod.invoke(obj, "admin","123123");
        System.out.println(retValue);
    }
}

ReflectTest11——反编译一个类的Constructor构造方法

/*
反编译一个类的Constructor构造方法。
 */
public class ReflectTest11 {
    public static void main(String[] args) throws Exception{
        StringBuilder s = new StringBuilder();
        Class vipClass = Class.forName("java.lang.String");
        s.append(Modifier.toString(vipClass.getModifiers()));
        s.append(" class ");
        s.append(vipClass.getSimpleName());
        s.append("{\n");

        // 拼接构造方法
        Constructor[] constructors = vipClass.getDeclaredConstructors();
        for(Constructor constructor : constructors){
            //public Vip(int no, String name, String birth, boolean sex) {
            s.append("\t");
            s.append(Modifier.toString(constructor.getModifiers()));
            s.append(" ");
            s.append(vipClass.getSimpleName());
            s.append("(");
            // 拼接参数
            Class[] parameterTypes = constructor.getParameterTypes();
            for(Class parameterType : parameterTypes){
                s.append(parameterType.getSimpleName());
                s.append(",");
            }
            // 删除最后下标位置上的字符
            if(parameterTypes.length > 0){
                s.deleteCharAt(s.length() - 1);
            }
            s.append("){}\n");
        }

        s.append("}");
        System.out.println(s);
    }
}

ReflectTest12——通过反射机制调用构造方法实例化java对象

用到的实体类：

public class Person {
    private Integer age;
    private String name;

    public Person() {
    }

    public Person(Integer age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
            "age=" + age +
            ", name='" + name + '\'' +
            '}';
    }
}

使用无参构造创建对象：

获得该类的字节码文件。

Class<?> clazz = Class.forName("com.example.test03.Person");
使用该类的无参构造创建对象。

Constructor<?> constructor = clazz.getDeclaredConstructor();
获得该无参构造的实例对象。

Object o = constructor.newInstance();
输出该无参构造。

System.out.println(o); //Person

使用有参构造创建对象：

获得该类的字节码文件。

Class<?> clazz = Class.forName("com.example.test03.Person");
使用该类的有参构造创建对象。

Constructor<?> constructor1 = clazz.getDeclaredConstructor(Integer.class, String.class);
获得该无参构造的实例对象。

Object o1 = constructor1.newInstance(100, "zhangsan");
输出该无参构造。

System.out.println(o1); //Person

完整代码：

/*
比上一个例子(ReflectTest11)重要一些！！！

通过反射机制调用构造方法实例化java对象。（这个不是重点）
 */
public class ReflectTest12 {
    public static void main(String[] args) throws Exception{
        // 不使用反射机制怎么创建对象
        Vip v1 = new Vip();
        Vip v2 = new Vip(110, "zhangsan", "2001-10-11", true);

        // 使用反射机制怎么创建对象呢？
        Class c = Class.forName("com.bjpowernode.java.bean.Vip");
        // 调用无参数构造方法
        Object obj = c.newInstance();
        System.out.println(obj);

        // 调用有参数的构造方法怎么办？
        // 第一步：先获取到这个有参数的构造方法
        Constructor con = c.getDeclaredConstructor(int.class, String.class, String.class,boolean.class);
        // 第二步：调用构造方法new对象
        Object newObj = con.newInstance(110, "jackson", "1990-10-11", true);
        System.out.println(newObj);

        // 获取无参数构造方法
        Constructor con2 = c.getDeclaredConstructor();
        Object newObj2 = con2.newInstance();
        System.out.println(newObj2);
    }
}

ReflectTest13——给你一个类，怎么获取这个类的父类，已经实现了哪些接口？

/*
重点：给你一个类，怎么获取这个类的父类，已经实现了哪些接口？
 */
public class ReflectTest13 {
    public static void main(String[] args) throws Exception{

        // String举例
        Class stringClass = Class.forName("java.lang.String");

        // 获取String的父类
        Class superClass = stringClass.getSuperclass();
        System.out.println(superClass.getName());

        // 获取String类实现的所有接口（一个类可以实现多个接口。）
        Class[] interfaces = stringClass.getInterfaces();
        for(Class in : interfaces){
            System.out.println(in.getName());
        }
    }
}

posted @ 2020-09-17 22:30 笑到不能自已阅读(168) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

笑到不能自已

Java反射机制

Java反射机制

概要

总结:

ReflectTest01——获取类的字节码文件的三种方式

ReflectTest02——通过Class的newInstance()方法来实例化对象

ReflectTest03——验证反射机制的灵活性

ReflectTest04——Class.forName()只是让一个类的静态代码块执行，其它代码一律不执行

AboutPath——获取一个文件的绝对路径

IoPropertiesTest——以流的形式返回读取的文件

ResourceBundleTest——资源绑定器

ReflectTest05——Class、Field、Constructor、Methods类的常用方法

Class对象的常用方法：

Field对象的常用方法：

Constructor对象的常用方法：

Method对象的常用方法：

ReflectTest06——通过反射机制，反编译一个类的属性Field

ReflectTest07——通过反射机制设置和访问一个java对象的属性

ArgsTest——可变长度参数

ReflectTest08——反射Method

ReflectTest09——反编译一个类的方法

ReflectTest10——通过反射机制怎么调用一个对象的方法

ReflectTest11——反编译一个类的Constructor构造方法

ReflectTest12——通过反射机制调用构造方法实例化java对象

ReflectTest13——给你一个类，怎么获取这个类的父类，已经实现了哪些接口？

公告