类加载

类加载概述

概念：

• 当程序要使用某个类时，如果该类未被加载到内存（JVM内存）中，则系统会通过类的加载、类的连接、类的初始化三个步骤对类进行初始化。
• JVM会将类加载、连接、初始化连续完成，这三个步骤被称为类加载或类初始化。

类的加载

• 指将.class文件读入内存，并为之创建一个java.lang.Class对象类加载器的作用
• 任何类被使用的时候，系统都会为之创建一个java.lang.Class对象

类的连接

• 验证阶段：用于检验被加载的类是否有正确的内部结构，并与其他类协调一致
• 准备阶段：负责为类的类变量分配内存，并设置默认初始化值
• 解析阶段：将类的二进制数据中的符号引用替换为直接引用

类的初始化

• 主要对类变量进行初始化

类的初始化步骤：

• 假如类还未被加载和连接，则程序先加载并连接该类
• 假如该类的直接父类还未被初始化，则先初始化被直接父类
• 假如类中有初始化语句，则系统依次执行这些初始化语句

注意：
在执行第二个步骤的时候，系统对直接父类的初始化步骤也遵循初始化步骤1-3
一个类被载入java虚拟机的时候，同一个类就不会再次被载入了。

类的初始化时机： 强调首次

• 创建类的实例
• 调用类的类方法（静态方法）
• 访问类或者接口的类变量（静态变量），或者为该类变量赋值
• 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
• 初始化某个类的子类（初始化子类首先就会初始化父类）
• 直接使用java.exe命令来运行某个主类

JVM的类加载机制

JVM的类加载机制有三种：全盘负责、父类委托、缓存机制。

• 全盘负责：当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也由该类加载器负责载入，除非显示使用另外一个类加载器载入；
• 父类委托：当一个类加载器负责加载某个Class时，先让父类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类；
• 缓存机制：保证所有被加载的Class都会被缓存，当程序需要使用某个Class对象时，类加载器先从缓存区中搜索该Class，只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存储在缓存区。

ClassLoader： 负责加载类的对象
java运行时具有以下内置类加载器：

类名	说明
Bootstrap class loader	它是虚拟机的内置类加载器，通常表示null，并且没有父null 也就是这个类是类加载器的祖宗
Platform class loader	平台类加载器可以看到所有平台类，平台类包括由平台类加载器或其祖先定义的java SE平台API，其实现类和JDK特定的运行时类
System class loader AppClassLoader	它也被称为应用程序类加载器，与平台类加载器不同。系统类加载器通常用于定义应用程序类路径、模块路径和JDK特定工具上的类

类加载器的继承关系：System的父加载器为Platform（java9）Ext（java8），Platform的父加载器为Bootstrap。

ClassLoader中的两个方法：

方法名	说明
static ClassLoader getSystemClassLoader()	返回用于委派的系统类加载器 ClassLoader.getSystemClassLoader()
ClassLoader getParent()	返回父类加载器进行委派

案例：

package itiheima315.test1;
public class ClassLoaderDemo {
    public static void main(String[] args) {
        // 系统类加载器 查看当前类的类加载器
        ClassLoader c = ClassLoader.getSystemClassLoader();
        System.out.println(c);//AppClassLoader（应用程序类加载器）

        // 父类加载器
        ClassLoader c2 = c.getParent();
        System.out.println(c2);//ExtClassLoader(扩展类加载器) 视频中是 PlatformClassLoader 
        // java8 的ExtClassLoader = java9 的 PlatformClassLoader 
        
        ClassLoader c3 = c2.getParent();
        System.out.println(c3);// null
    }
}

反射

概念：

• java反射机制：运行时去获取一个类的变量和方法信息，通过获取到的信息创建对象，调用方法的一种机制；
• 动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展；

理解xhj：

• 自己定义类要想使用–》类加载器加载对应的.class文件–》每一个.class文件都会包含成员变量、构造方法、成员方法…信息
• Class类就是所有.class文件对应的类型、躯体。
• 不再通过自己定义类的去使用成员变量、构造方法、成员方法，而是用Class类去使用成员变量、构造方法、成员方法，这就是反射。
• 反射就是把java类中的各种成分映射成相应的java类。

获取Class类的对象 Class.forName(常用)

原因： 通过反射去使用一个类。首先获取该类的 字节码文件对象=类型为Class类型的对象。
获取Class类型对象的方法：

方法	说明
使用类的class属性来获取该类对应的Class对象	Student.class将会返回Student类对应的Class对象
调用对象的getClass()方法，返回该对象所属类对应的Class对象	该方法是Object类中的方法，所有的Java对象都可以调用该方法
使用Class类中的静态方法forName（String className）	该方法需要出入 字符串参数 = 某个类的全路径=完整包名的路径

案例：

package itiheima315.test2;
public class ReflectDemo {
    public static void main(String[] args) {
    1 使用《类的class属性》来获取该类对应的Class对象
        Class<Student> c1 = Student.class;
        System.out.println(c1);
        // 输出内容是：class itiheima315.test2.Student
        
        // 一个类在内存中只有一个字节码文件
        Class<Student> c2 = Student.class;
        System.out.println(c1 == c2);
        // 输出：true
        System.out.println("------");
        
    2 调用《对象的getClass()方法》
        Student s = new Student();
        Class<? extends Student> c3 = s.getClass();
        System.out.println(c1 == c3);
        
    3 使用《Class类中的静态方法forName（String className）》
        Class<?> c4 = null;
        try {
            c4 = Class.forName("itiheima315.test2.Student");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(c1 == c4);
    }
}

反射获取构造方法并使用 Constructor

Class类

• 在java.lang包下，使用需要导包；Class Class< T >
• public final class Class< T > extends Object implements …是最终类，说明不能被继承
• Class类的实例表示正在运行的java应用程序的类和接口
• 通过Class对象获取Constructor对象的数据

所属类	方法名	说明
Class类	Constructor< ? >[] getConstructors()	返回所有公共构造方法对象的数组
Class类	Constructor<?>[] getDeclaredConstructors()	返回所有构造方法对象的数组
Class类	Constructor< T> getConstructor(Class<?>…parameterType)	返回单个公共构造方法对象 要获取的构造方法的参数的个数和数据类型对应的字节码文件对象 使用的是：String类型，则用String.class；int类型，则用的是int.class
Class类	Constructor< T> getDeclaredConstructor(Class<?>…parameterType)	返回单个构造方法对象 要获取的构造方法的参数的个数和数据类型对应的字节码文件对象

Constructor类

• 在java.lang.reflect包下，使用需要导包
• public final class Constructor< T> extends Executable 是最终类
• 提供了一个类的单个构造函数的信息和访问权限
• 通过Constructor类中的newInstance方法创建对象：

方法名	说明
T newInstance(Object…initargs)	使用由此Constructor对象表示的构造函数创建对象， 使用指定的初始化参数创建和初始化构造函数的声明类的新实例

理解xhj：

• 在反射中，实际上是将类中的成员变量、构造方法、成员方法，看成一个个对象；
• 通过反射创建类的对象：

1 通过Class.forName方法得到 类的字节码文件对象
	Class<?> c = Class.forName("类的路径")
	抛出异常 ClassNotFoundException
2 通过字节码文件对象的getConstructor方法得到单个构造函数
	Constructor<?> con = c.getConstructor();
	抛出异常 NoSuchMethodException
3 通过Constructor对象的newInstance方法创建对象
	Object obj = con.newInstance();
	抛出异常 IllegalAccessException, InvocationTargetException, InstantiationException

案例：

package itiheima315.test2;
public class ReflectDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 获取Class对象，也就是类的字节码对象
        Class<?> c = Class.forName("itiheima315.test2.Student");
        // 得到Student类的字节码文件对象

        // 要想获取构造方法，要在Class类中找方法获取构造方法。
        // 即getConstructors、getDeclaredConstructors、getConstructor、getDeclaredConstructor

        Constructor< ? >[] getConstructors() ：返回一个包含Constructor对象的数组
//        Constructor<?>[] arrayC = c.getConstructors();
//        for(Constructor con:arrayC){
//            System.out.println(con);
//        }
        // 结果：
        // public itiheima315.test2.Student(java.lang.String,int,java.lang.String)
        //public itiheima315.test2.Student() 

        Constructor<?>[] getDeclaredConstructors() ：返回反映该Class对象的类声明的所有构造函数的Constructor对象的数组
//        Constructor<?>[] conS = c.getDeclaredConstructors();
//        for (Constructor con : conS) {
//            System.out.println(con);
//        }
        // 结果
        /*
        public itiheima315.test2.Student(java.lang.String,int,java.lang.String) 公共构造方法
        itiheima315.test2.Student(java.lang.String,int)  默认构造方法
        private itiheima315.test2.Student(java.lang.String) 私有构造方法
        public itiheima315.test2.Student()*/ 公共无参构造方法

        Constructor< T> getConstructor(Class<?>.....parameterType)：返回一个Constructor对象，该对象反映该Class对象表示的类的指定公共构造函数|
        Constructor<?> c0 = c.getConstructor();//拿public的无参构造方法
//        System.out.println(c0);

        // 使用Constructor对象来实现通过类创建对象。
        Object obj = c0.newInstance();
        System.out.println(obj);
// 输出Student{name='null', age=0, address='null'}

        // Constructor< T> getDeclaredConstructor(Class<?>...parameterType)|返回一个Constructor对象，该对象反映由此Class对象表示的类或接口的指定构造函数|
    }
}

Student类

package itiheima315.test2;

public class Student {
    private String name;//私有成员变量
    int age;//默认
    public String address;//公共

    // 构造方法
    // 公共
    public Student(){}
    // 私有
    private Student(String name){
        this.name = name;
    }
    // 默认
    Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    // 公共
    public Student(String name,int age,String address){
        this.name = name;
        this.age = age;
        this.address = address;
    }

    // 成员方法
    private void function(){
        System.out.println("function");
    }
    public void method1(){
        System.out.println("method");
    }
    public void method2(String s){
        System.out.println("method:" + s);
    }
    public String method3(String s,int i){
        return s + ", " + i;
    }

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

案例：反射

案例1

需求：
通过反射实现以下操作：
Student s = new Student(“林俊杰”,30,“西安”); System.out.println(s);
思路

2022/5/19
1 获得class对象 
	类.class属性
2 获得constructor对象
	class对象.getConstructor(String.class,int.class,String.class);
3 使用newInstance方法创建对象
	constructor对象.newInstance("参数1","参数2","参数3");

基本数据类型可以通过.class得到对应的Class类型

package itiheima315.test2;

public class ReflectTest1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    /*    Student s = new Student("林俊杰",30,"西安");
        System.out.println(s);*/

        Class<?> c = Class.forName("itiheima315.test2.Student");
        // 获取Class对象
        Constructor<?> con = c.getDeclaredConstructor(String.class,int.class,String.class);
        Object obj = con.newInstance("林俊杰", 30, "西安");
        System.out.println(obj);
    }
}

案例2

需求：
通过反射实现以下操作：
Student s = new Student(“林俊杰”); System.out.println(s);

public void setAccessible（boolean flag）：值为true，取消访问检查 被称为暴力反射
作用：
当通过getDeclaredConstructor方法获得私有构造方法 并 创建对象的时候，会报错，IllegalAccessException
解决：对通过getDeclaredConstructor方法获得的私有构造方法使用setAccessible方法可以取消访问检查，即可实现利用私有构造方法创建对象。

package itiheima315.test2;

public class ReflectTest2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        /*Student s = new Student("林俊杰");
        System.out.println(s);*/
        Class<?> c = Class.forName("itiheima315.test2.Student");

        Constructor<?> con = c.getDeclaredConstructor(String.class);

        // 暴力反射
        // public void setAccessible(boolean flag):值为true，取消访问检查
        con.setAccessible(true);

        Object obj = con.newInstance("林俊杰");
        System.out.println(obj)
       
        //获取到的私有构造方法不能创建对象 会报错 IllegalAccessException
        //加了setAccessible方法 可以实现私有方法创建对象

        // 输出：Student{name='林俊杰', age=0, address='null'}
    }
}

反射获取成员变量并使用 Field

获取成员变量的方法

方法名	说明
Field[] getFields()	返回类或接口的所有可访问的公共字段组成的数组
Field[] getDeclaredFields()	返回类或接口声明的所有字段组成的数组
Field getField(String name)	返回类或接口的指定公共字段
Field getDeclaredField(String name)	返回类或接口的指定字段

Field类

• Field提供有关类或接口的单个字段的信息和动态访问
• 所给成员变量赋值的方法：

方法名	说明
void set(Object obj,Object value)	将指定的对象参数，设置为由Field对象表示的字段 成员变量名.set(对象,“具体值”) # 给对象的成员变量赋值为具体值

反射获取成员变量具体的代码过程：

1 获取Class对象
	Class<?> c = Class.forName("类的路径");
2 获取Class对象的无参构造方法
	Constructor<?> con = c.getConstructor();
3 获取Class对象的成员变量
	Field fName = c.getField("成员变量名");
4 通过无参构造方法创建对象
	Object obj = con.newInstance();
5 给对象的成员变量赋值
	fName.set(obj,"设置的值");

需求：反射获取成员变量并使用

package itiheima315.test2;
public class ReflectDemo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException
            , IllegalAccessException, InvocationTargetException, InstantiationException {
        // 获取类的Class对象
        Class<?> c = Class.forName("itiheima315.test2.Student");

//        Field[] fields = c.getFields();//获取公共的成员变量
        Field[] fields = c.getDeclaredFields();//获取所有成员变量组成的数组
        for(Field f:fields){
            System.out.println(f);
        }
        System.out.println("-------");

		// 获取成员变量
        Field addressField = c.getField("address");
        
        //获取无参构造方法创建对象
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

        addressField.set(obj,"西安");
        System.out.println(obj);
    }
}

练习：

需求：
通过反射实现：
Student s = new Student();
s.name = “汪苏泷”;
s.age = 30;
s.address = “阳泉”;
System.out.println(s);

package itiheima315.test2;
public class ReflectTest3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        // 通过反射实现
  /*      Student s = new Student();
        s.name = "汪苏泷";
        s.age = 30;
        s.address = "阳泉";
        System.out.println(s);*/

  		// 获取Class对象
        Class<?> c = Class.forName("itiheima315.test2.Student");
        // 获取无参构造方法
        Constructor<?> con = c.getConstructor();
        // 创建对象
        Object obj = con.newInstance();
        // 获取成员变量
//        Field fname = c.getField("name");
        Field fname = c.getDeclaredField("name");
        // 暴力反射
        fname.setAccessible(true);
        Field fage = c.getDeclaredField("age");
        fage.setAccessible(true);
        Field faddress = c.getField("address");
        // 给对象的成员变量赋值
        fname.set(obj, "汪苏泷");
        fage.set(obj, 30);
        faddress.set(obj,"北京");

        System.out.println(obj);

    }
}

注意：
当想使用私有的成员变量的时候，需要进行如下操作：

 Field f = class类对象.getDeclaredField("成员变量名");
 f.setAccessible(ture)；
 // 取消访问检查

当想使用私有成员方法的时候，需要进行如下操作：

Method method= class类对象.getDeclaredMethod("成员方法名",参数的.class对象);
method.setAccessible(ture)；
 // 取消访问检查

反射获取成员方法并使用 Method

获取成员方法的方法：

方法名	说明
Method[] getMethods()	返回类或接口的所有公共方法 包括类或接口声明的对象以及从超类和超级接口继承的类
Method[] getDeclaredMethods()	返回类或接口声明的所有方法 包括public、protected、default和private，不包括继承方法
Method[] getMethod(String name,Class<?> … parametreTyoes)	返回类或接口的指定公共成员方法
Method[] getDeclaredMethod(String name,Class<?> … parametreTyoes)	返回类或接口的指定成员方法

Method方法

• 在类或接口上提供有关单一方法的信息和访问权限
• 实现对象调用方法

方法名	说明
Object invoke(Object obj,Object …args)	在具有指定参数的指定对象上调用此方法表示的基础方法 Object返回值类型；obj调用方法的对象；args方法需要的参数

反射获取成员方法的具体代码实现：

1 获取Class对象
	Class<?> c = Class.forName("类的路径");
2 获取无参构造方法
	Constructor con = c.getConstructor();
3 无参构造方法创建对象
	Object obj = con.newInstance();
4 获取成员方法
	Method m = c.getMethod("成员方法名");
5 对象使用成员方法对象
	m.invoke(obj,"成员方法所需参数");

代码：

package itiheima315.test2;
public class ReflectDemo4 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException,
            IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<?> c = Class.forName("itiheima315.test2.Student");

//        Method[] methods = c.getMethods();//本类的 以及 继承的公共方法
//        Method[] methods = c.getDeclaredMethods();// 本类所有的方法
//        for(Method method:methods){
//            System.out.println(method);
//        }
//    }
        Method m1 = c.getMethod("method1");

        // 获取无参构造方法
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        m1.invoke(obj);
    }
}

练习

练习1

需求

2022/5/19
// Student s = new Student();
Class stuclass = Student.class

// 创建类的对象
Constructor stucon = stuclass.getConstructor();
Object obj = stucon.newInstance();

// s.method1();
Method method1 = stuclass.getMethod("method1");
method1.invoke(obj);

// s.method2("汪苏泷");
Method method2 = stuclass.getMethod("method2",String.class);
method2.invoke(obj,"汪苏泷");

// String ss = s.method3("许嵩",32);
Method method3 = stuclass.getMethod("method3",String.class,int.class);
Object obj1 = method3.invoke(obj,"许嵩",32);

// System.out.println(ss);
String ss = (String)obj1;
System.out.println(ss);

//s.function(); 私有方法
Method function = stuclass.getDeclaredMethod("function");
function.setAccessible(true);
function.invoke(obj);

代码：

package itiheima315.test2;
public class ReflectTest4 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//         //使用反射实现如下操作：
//        Student s = new Student();
//        s.method1();
//        s.method2("汪苏泷");
//        String ss = s.method3("许嵩",32);
//        System.out.println(ss);
//        s.function();

        Class<?> c = Class.forName("itiheima315.test2.Student");

        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

// s.method1();
        Method method1 = c.getDeclaredMethod("method1");
        method1.invoke(obj );
// s.method2("汪苏泷");
        Method method2 = c.getDeclaredMethod("method2", String.class);
        method2.invoke(obj,"汪苏泷");
//String ss = s.method3("许嵩",32);
        Method method3 = c.getDeclaredMethod("method3", String.class, int.class);
        Object ss = method3.invoke(obj, "许嵩", 30);
//  System.out.println(ss);
        String st = (String)ss;
        System.out.println(ss);
// s.function();
        Method function1 = c.getDeclaredMethod("function");
        // 由于function是私有成员，所以需要暴力反射
        function1.setAccessible(true);
        function1.invoke(obj);
    }
}

Student类

package itiheima315.test2;

public class Student {
    private String name;//私有成员变量
    int age;//默认
    public String address;//公共

    // 构造方法
    // 公共
    public Student(){}
    // 私有
    private Student(String name){
        this.name = name;
    }
    // 默认
    Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    // 公共
    public Student(String name,int age,String address){
        this.name = name;
        this.age = age;
        this.address = address;
    }

    // 成员方法
    private void function(){
        System.out.println("function");
    }
    public void method1(){
        System.out.println("method");
    }
    public void method2(String s){
        System.out.println("method:" + s);
    }
    public String method3(String s,int i){
        return s + ", " + i;
    }

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

练习2

有一个ArrayList< Integer>集合，在这个集合中添加一个字符串数据，如何实现？
反射可以完成一些正常情况下无法完成的事情
反射可以越过泛型检查的，获取到原始的方法所需要的参数类型
代码：

package itiheima315.test2;
public class ReflectTes5 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException,
            IllegalAccessException {
        ArrayList<Integer> array = new ArrayList<Integer>();

//        array.add(10);
//        array.add(20);
        // 获取Class对象，使用对象.getClass方法实现。
        Class<? extends ArrayList> c = array.getClass();
        Method madd = c.getMethod("add",Object.class);

        madd.invoke(array, "pretty");
        madd.invoke(array,"sunshine");

        System.out.println(array);

    }
}

练习3 : 通过配置文件运行类中的方法

代码：

package itiheima315.test3;
public class ReflectDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException,
            IllegalAccessException, InvocationTargetException, InstantiationException {
//        Student s = new Student();
//        s.study();
//
//        Teacher t = new Teacher();
//        t.teach();
        // 为了方便使用Student和Teacher两个类，可以使用配置文件完成 而不用每次修改main方法

        // 加载数据
        Properties prop = new Properties(); // 创建持久属性集 properties
        FileReader fr = new FileReader(".\\class.txt"); // 读取字符流
//        char[] chs = new char[1024];
//        int len;
//        while((len = fr.read(chs)) != -1){
//            System.out.println(new String(chs,0,len));
//        }
        // 输出结果是：
        // className=itiheima315.test3.Student
        //MethodName=study
        // 说明 内容已被读入
        
        prop.load(fr);
        fr.close(); // 字符流关闭

        // 数据文件加载成功
        String className = prop.getProperty("className"); // 使用指定键索引属性
        String methodName = prop.getProperty("MethodName");
        // 使用不使用 类以及其成员方法 在class.txt文件中修改

        // 通过反射来使用
        Class<?> c = Class.forName(className);//得到的是itiheima315.test3.Student
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();


        Method m = c.getMethod(methodName);
        // System.out.println(m);
        m.invoke(obj);
        
    }
}

案例涉及Properties方法

方法名	说明
String getProperty（String key）	使用此属性列表中指定的键搜索属性
void load(InputStream instream)	从输入字节流读取属性列表 （键值对）

注意

2022/5/19
properties内容在java25中。

模块化

概念

• 随着java语言的发展，逐渐成为一个“臃肿”的语言，无论是大系统还是小软件，JVM都需要加载整个JRE环境；
• java9实现了模块化，成功给java实现了瘦身，允许java程序可以根据需求选择要加载的模块；
• 整体的项目project，下面依次是：模块、包、类或者接口；
• 模块与模块之间是独立的，也可以作为访问权限的界定边界，可以通过模块的描述文件设置包是否被暴露处理、隐藏处理，对于隐藏的包即使它所包含的java类型使用了public修饰，别的模块仍旧不能访问这些类型。

模块基本使用

基本使用步骤：

• 创建模块 …包、类、定义方法
  定义两个模块，myOne和MyTwo
• 在模块的src目录下新建一个名为module-info.java的描述性文件，该文件专门定义模块名、访问权限、模块依赖等信息，描述性文件中使用模块导出和模块依赖进行配置并使用。
  所要使用的和被使用的两个模块都创建module-info.java文件
• 模块中所有未导出的包都是模块私有的，他们不能在模块之外被访问
  模块导出格式：exports 包名；
• 一个模块要访问其他模块，必须明确指定依赖那些模块，未明确指定依赖的模块不能访问
  模块依赖格式：requires 模块名；
  注意：写模块名报错，需要按下Alt+enter，选择模块依赖。

代码：
MyOne模块

package itiheima1;
public class Student {
    public void study(){
        System.out.println("你的自律，给你自信");
    }
}

package itiheima2;
public class Teacher {
    public void teach(){
        System.out.println("全心付出只为金榜题名");
    }
}

module MyOne {
    exports itiheima1;
}

MyTwo模块：

package itiheima315;
import itiheima1.Student;
public class Test1 {
    public static void main(String[] args) {
        Student s = new Student();
        s.study();
    }
}

// module-info.java文件
module MyTwo {
    requires MyOne;
}

模块服务的使用

概述：

• java6开始，提供了服务机制 = 允许服务提供者和服务使用者之间完成解耦 = 服务使用者只面向接口编程，不清楚服务提供者的实现类
• java9的模块化编程系统进一步简化了java的服务机制
• java9允许 = 》服务接口定义在模块中 =》使用uses语句声明该服务接口=》针对服务接口提供不同的服务实现类=》服务实现模块使用provides语句为服务接口指定实现类。 同样是服务使用者面向接口编程

模块服务的使用步骤

• 在模块a下创建包a，创建接口a定义抽象方法a
• 在包a下创建包b，创建接口a的两个实现类 类a和类b
• 模块a中的描述文件module-info.java文件中写如下配置：
  模块导出：exports 包a
  服务提供：provides 接口a with 类a/类b
• 在模块b的描述文件module-info.java中添加如下配置：
  声明服务接口：uses 接口a；
• 在模块b的类中使用接口a提供的服务

图示：

ServiceLoader

• 在java.util包下 使用需要导包
• public final class ServiceLoader< S > extends Object implements Iterable< S>说明是最终类，且可以使用增强for循环遍历
• 一种加载服务实现的工具
• 获取服务装载程序 =》 通过 ServiceLoader的静态方法load

例子：ServiceLoader.load（服务名.class）参数是服务的class对象

代码：
测试类：

package itiheima315;
import itiheima3.MyService;
import java.util.ServiceLoader;
public class Test2 {
    public static void main(String[] args) {
        // 加载服务
        ServiceLoader<MyService> myService = ServiceLoader.load(MyService.class);
        // 遍历服务
        for(MyService my:myService){
            my.service();
        }
    }
}

接口：

package itiheima3;
public interface MyService {
    void service();
}

实现类：

package itiheima3.impl;

import itiheima3.MyService;

public class Czxy implements MyService {
    @Override
    public void service() {
        System.out.println("you are my pretty sunshine");
    }
}

public class itiheima implements MyService {
    @Override
    public void service() {
        System.out.println("唯有不断学习，才能缓解焦虑不安");
    }
}

module-info.java配置文件：

// 导入接口、实现类
import itiheima3.MyService;
import itiheima3.impl.itiheima;
import itiheima3.impl.Czxy;
// 模块MyOne配置
module MyOne {
    // 导出包
    exports itiheima1;
    exports itiheima3;

    // 服务实现：通过provides为服务接口指定实现类
//    provides MyService with itiheima;
    provides MyService with Czxy;
}

1 java的反射

1.1 类的加载

• 程序在运行的时候如果需要使用某个类，该类如果还没有被加载到内存中。
  系统会通过加载，链接，初始化 三个步骤来实现对这个类的初始化。

• 加载：
  把class文件读入到内存中， 对应的就创建了 Class 的对象。
  任何类使用的时候都会创建一个Class对象。

• 链接：
  验证：内部结构是否正确，和其他类协调一致。
  准备：给类的静态成员分配内存，设置默认值
  解析：把类中的二进制数据中的符号编程直接引用

• 初始化：就是我们之前说过的初始化步骤

• 类的初始化时机
  创建对象
  访问类的静态变量，给静态变量赋值
  调用静态方法
  初始化某个类的子类
  使用java命令运行某个类的时候
  使用反射来创建某个类对象

1.2 类加载器

• 把class文件加载到内存中，创建 Class 的对象。
  我们不需要关系它到底是如何加载的，了解一下能帮助我们更好的理解程序的运行。

• 组成：
  根类加载器Bootstrap ClassLoader
  　　也叫做引导类加载器，主要负责java核心类的加载
  　　比如 System， String 等。 jdk中lib目录下 rt.jar
  扩展类加载器Extensions ClassLoader
  　　主要负责扩展类的加载。
  　　jdk中lib目录下 ext 下面
  系统类加载器System ClassLoader
  　　主要负责jvm启动的时候加载来自 java命令的class文件。

• 以后只要知道这些东西都是怎么来的。

• 你要明白一点，执行某个代码的时候，这个代码以及在这个代码中用到class 文件都会被加载到内存中。
  假如我们现在在内存中站着，面前是一堆字节码文件。如何使用这些字节码文件呢？
  字节码文件也是根据类编译得到的二进制文件。 类中有 成员变量，成员方法，构造方法。我们能看懂
  也就是说字节码文件中有 成员变量，成员方法，构造方法。但是这些东西在字节码文件中我们看不懂。
  反射研究的就是 我们在内存中如何使用字节码文件。

---

2 反射

2.1 java的反射机制

• java的反射机制是在运行状态中，对于任意一个对象，都可以获取这个类的多有属性和方法。
  对于任意一个对象，都能够调用它的任意一个方法和属性。这种动态获取信息以及动态调用对象
  方法的功能称为 java的反射机制。

• 我们想要在内存使用字节码文件，先要获取这个类的字节码文件对象。然后使用
  Class类中的方法了。获取字节码文件对象，其实就是获取一个Class类的对象。

• 反射就是通过class 字节码文件对象，使用文件中的成员变量，成员方法，构造方法。

2.2 Class

• Class类的对象表示正在运行的Java应用程序中的类和接口的字节码文件对象
• 字节码文件是有jvm执行的，所以字节码文件对象也是由jvm构建的。

package com.momo.demo;

import com.momo.domain.Stu;

/*
*  Stu s = new Stu();
*   s.show();
*
* 反射的使用方式
*   先要获取class字节码文件对象，其实也就是获取到了Class类的对象
*   Class类：
    *   成员变量：Field
    *   构造方法：Constructor
    *   成员方法：Method
    *
   如何获取class对象？  获取方式：
   *   1, Object类中有Class getClass() 方法
   *   2, 数据类型的静态属性  class
   *   3, Class类的静态方法：static Class forName(String className)
   *
   开发应该用那种？
   *    自己玩随意用。
   *   开发用第三种。 为什么？
   *      因为第三种要的是一个字符串，不是具体的类名。
   *      可以把字符串将来配置到配置文件中。
* */
public class Demo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //方式一
        Stu s1 = new Stu();
        Class c1 = s1.getClass();

        Stu s2 = new Stu();
        Class c2 = s2.getClass();

        System.out.println(s1==s2);//false
        System.out.println(c1==c2);//true
        System.out.println("-------------");

        //方式二
        Class c3 = Stu.class;
        /*int.class;
        String.class;*/
        System.out.println(c1==c3);
        System.out.println("-------------");

        //方式三
        //包名+类名
        Class c4 = Class.forName("com.momo.domain.Stu");
        System.out.println(c1==c4);
    }
}

---

package com.momo.domain;

public class Stu {
    private String name;
    int age;
    public String address;

    public Stu(){}
    Stu(String name,int age){
        this.name = name;
        this.age = age;
    }
    private Stu(String name){
        this.name = name;
    }
    public Stu(String name,int age,String address){
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public void show(){
        System.out.println("public show");
    }

    public void method(String s){
        System.out.println("public:"+s);
    }

    public String getString(String s,int i){
        return s+"---"+i;
    }

    private void fun(){
        System.out.println("private fun");
    }

    private void fun2(String s){
        System.out.println("private fun:"+s);
    }

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

2.3 使用反射获取构造方法并使用

• 获取构造方法对象的方法
  Constructor getConstructor(类<?>… parameterTypes)
  获取指定参数的公共的构造方法对象
  Constructor<?>[] getConstructors()
  获取所有公共构造 方法对象的数组
  Constructor getDeclaredConstructor(类<?>… parameterTypes)
  可以获取任意一个指定的构造方法，包括私有
  Constructor<?>[] getDeclaredConstructors()
  获取所有构造 方法对象的数组，包括私有

• 使用构造方法对象创建对象
  T newInstance(Object… initargs)
  使用此 Constructor对象表示的构造函数，使用指定的初始化参数来创建和初始化构造函数的声明类的新实例。

package com.momo.demo;

import com.momo.domain.Stu;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/*
* 反射获取构造方法对象并使用
* */
public class Demo4 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取字节码文件对象
        Class<?> c = Class.forName("com.momo.domain.Stu");
        //getConstructors() 获取所有公共构造方法对象
      /*  Constructor<?>[] cons = c.getConstructors();
        for(Constructor con:cons){
            System.out.println(con);
        }
        System.out.println("-------------------");
        //getDeclaredConstructors() 获取所有构造方法对象
        Constructor<?>[] cons2 = c.getDeclaredConstructors();
        for(Constructor con:cons2){
            System.out.println(con);
        }
        System.out.println("---------------------");*/

        //获取指定参数的公共的构造方法对象
        //getConstructor(...) 参数表示要获取的构造方法对象的参数个数，以及参数类型的class
        Constructor<?> con = c.getConstructor();
        //NoSuchMethodException
       // Constructor<?> con = c.getConstructor(String.class,int.class);
        System.out.println(con);
        Object o = con.newInstance();
       /* Stu s = (Stu)o;
        s.show();
*/
        System.out.println("-----------------------");
        //getDeclaredConstructor(...)  可以获取任意一个指定的构造方法，包括私有
       /* Constructor<?> con2 = c.getDeclaredConstructor();
        System.out.println(con2);
        Object o1 = con2.newInstance();
        System.out.println(o1);*/

       //获取的是私有构造，不能直接使用创建对象。  一会有办法。
        Constructor<?> con2 = c.getDeclaredConstructor(String.class);
        System.out.println(con2);
        Object o1 = con2.newInstance("aaa");
        System.out.println(o1);
    }
}

---

package com.momo.demo;

import com.momo.domain.Stu;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/*
* 反射获取不同的构造方法，创建对象
* */
public class Demo5 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取字节码文件对象
        Class c = Class.forName("com.momo.domain.Stu");
        //public Stu(String name,int age,String address)
       /* Constructor con = c.getConstructor(String.class, int.class, String.class);
        Object o = con.newInstance("默默", 18, "长安");
        System.out.println(o);*/
        System.out.println("---------------");

        //private Stu(String name)
        Constructor con = c.getDeclaredConstructor(String.class);
        //System.out.println(con);
        //IllegalAccessException 非法的访问异常
        //因为获取的是私有的，编译器会进行语法检查。
        //我们可以取消编译期检查
        con.setAccessible(true);//true 表示取消检查
        Object o = con.newInstance("默默");
        System.out.println(o);
    }
}

---

2.4 使用反射获取成员变量并使用

Field getField(String name)
返回一个 Field对象，它反映此表示的类或接口的指定公共成员字段 类对象。
Field[] getFields()
返回包含一个数组 Field对象反射由此表示的类或接口的所有可访问的公共字段 类对象
Field getDeclaredField(String name)
返回一个 Field对象，它反映此表示的类或接口的指定已声明字段 类对象。
Field[] getDeclaredFields()
返回的数组 Field对象反映此表示的类或接口声明的所有字段 类对象。

• 使用的方法
  Object get(Object obj)
  返回该所表示的字段的值 Field ，指定的对象上。
  void set(Object obj, Object value)
  将指定对象参数上的此 Field对象表示的字段设置为指定的新值。

package com.momo.demo;

import java.lang.reflect.Field;

/*
* 使用反射获取成员变量对象
* */
public class Demo6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c = Class.forName("com.momo.domain.Stu");
        //Field[] getFields() 获取所有公共的成员变量
        Field[] fields = c.getFields();
        for(Field f:fields){
            System.out.println(f);
        }
        System.out.println("------------");

        //getDeclaredFields() 获取所有的成员变量,包括私有
        Field[] fields1 = c.getDeclaredFields();
        for(Field f:fields1){
            System.out.println(f);
        }
        System.out.println("------------");

        //Field getField(String name) 获取指定名字的成员变量对象（公共）
       //NoSuchFieldException
       // Field f = c.getField("age");
       /* Field f = c.getField("address");
        System.out.println(f);*/
        //可以获取任意成员变量，包括私有
        //Field getDeclaredField(String name)
        Field f = c.getDeclaredField("name");
        System.out.println(f);
    }
}

---

package com.momo.demo;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/*
* 反射获取成员变量对象 并使用
* Stu s = new Stu();
* s.address = "地址"
* */
public class Demo7 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class c = Class.forName("com.momo.domain.Stu");

        //获取公共的address
        Field f = c.getField("address");
        //赋值的时候给指定对象的成员变量赋值，需要一个对象

        //获取构造方法对象
        Constructor con = c.getConstructor();
        Object o = con.newInstance();
        System.out.println(o);
        //赋值 set(Object obj, Object value)
        //是Field对象的方法，参数一表示对象，参数二表示要赋的值
        //给那个对象的这个成员变量赋值
        f.set(o,"北京");//表示要给o对对象的f成员变量赋值 北京
        System.out.println(o);
        System.out.println("-----------------");

        //获取name并赋值
        //IllegalAccessException
        Field fname = c.getDeclaredField("name");
        //取消访问检查
        fname.setAccessible(true);
        fname.set(o,"默默");
        System.out.println(o);

        System.out.println("-----------");
        Field fage = c.getDeclaredField("age");
        //取消访问检查
        fage.setAccessible(true);
        fage.set(o,18);
        System.out.println(o);
        System.out.println("-----------------");

        //Object get(Object obj)
        System.out.println(f.get(o));
        System.out.println(fname.get(o));
        System.out.println(fage.get(o));
    }
}

---

2.5 使用反射获取成员方法并使用

• Method getMethod(String name, 类<?>… parameterTypes)获取指定名称的公有的方法，第二个参数表示要获取的方法的参数的个数，以及参数类型的class
• Method[] getMethods()获取所有公共的方法，包括父类的
• Method getDeclaredMethod(String name, 类<?>… parameterTypes)获取指定名称的方法对象，第二个参数表示要获取的方法的参数的个数，以及参数类型的class
• Method[] getDeclaredMethods()获取所有的成员方法，不包括父类

---

• 使用成员方法对象的方法
  Object invoke(Object obj, Object… args)
  第一个参数表示要使用那个对象调用当前这个方法，第二个参数表示，调用这个方法的时候需要传递的实际参数

package com.momo.demo;

import java.lang.reflect.Method;

/*
* 获取成员方法对象
* */
public class Demo8 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class c = Class.forName("com.momo.domain.Stu");

        //Method[] getMethods() 获取所有公共的方法，包括父类的
        Method[] methods = c.getMethods();
        for(Method m:methods){
            System.out.println(m);
        }
        System.out.println("----------------");

        //Method[] getDeclaredMethods() 获取所有的成员方法，不包括父类
        Method[] methods = c.getDeclaredMethods();
        for(Method m:methods){
            System.out.println(m);
        }
        System.out.println("----------------");

        //方法 getMethod(String name, 类<?>... parameterTypes)
        //获取指定名称的公有的方法，第二个参数表示要获取的方法的参数的个数，以及参数类型的class
       /* Method mshow = c.getMethod("show");
        System.out.println(mshow);*/
        Method method = c.getMethod("method", String.class);
        System.out.println(method);

        System.out.println("----------------");
        //方法 getDeclaredMethod(String name, 类<?>... parameterTypes)
        //获取指定名称的方法对象，第二个参数表示要获取的方法的参数的个数，以及参数类型的class
        Method mfun = c.getDeclaredMethod("fun");
        System.out.println(mfun);
    }
}

---

package com.momo.demo;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/*
* 反射获取成员方法对象  并使用
* */
public class Demo9 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class c = Class.forName("com.momo.domain.Stu");

        Constructor con = c.getConstructor();
        Object o = con.newInstance();

        //public void show();
        Method mshow = c.getMethod("show");

        //Object invoke(Object obj, Object... args)
        //第一个参数表示要使用那个对象调用当前这个方法
        //第二个参数表示，调用这个方法的时候需要传递的实际参数
        //Object  表示方法的返回值
        Object invoke = mshow.invoke(o);
        System.out.println(invoke);
        System.out.println("---------------");

        //public void method(String s)
        Method method = c.getMethod("method", String.class);
        Object abad = method.invoke(o, "abad");
        System.out.println(abad);
        System.out.println("---------------");

        // public String getString(String s,int i)
        Method getmethod = c.getMethod("getString", String.class, int.class);
        Object asdf = getmethod.invoke(o, "asdf", 111);
        System.out.println(asdf);

        System.out.println("---------------");
        //private void fun()
        Method fun = c.getDeclaredMethod("fun");
        fun.setAccessible(true);

        Object invoke1 = fun.invoke(o);
        System.out.println(invoke1);
    }
}

---

3 junit单元测试

3.1 测试

• 分类：
  黑盒测试： 不需要写代码，给定输入值，看程序是否输出了期望值。
  白盒测试： 需要写代码，需要关注代码的执行流程。

3.2 使用

• 有一个类需要测试 MyMath — sum(int a,int b)
• 步骤：
  创建一个测试包，定义一个测试类 MyMathTest
  定义测试方法 sumTest() 返回值 void 空参
  需要让这个方法可以独立运行 需要给方法上加上 @Test
  如果报错了， 需要导入juint 的 jar包
  执行方法，对结果进行判断 。 红色表示失败。 绿色表示成功
  一般我们会使用 断言

package com.momo.test;

import com.momo.domain.MyMath;
import org.junit.Assert;
import org.junit.Test;

public class MyMathTest {

    @Test
    public void sumTest(){
        System.out.println("我执行了。。。。");

        //创建对象
        MyMath mm = new MyMath();
        //调用方法
        int result = mm.sum(2, 3);
        //System.out.println(result);

        //断言  我认为结果应该是什么
        Assert.assertEquals(5,result);
    }
}

3.3 @Before 和 @After

package com.momo.test;

import com.momo.domain.MyMath;
import org.junit.*;

public class MyMathTest {
    @BeforeClass
    public static void aaa(){
        System.out.println("aaa");
    }

    @AfterClass
    public static void bbb(){
        System.out.println("bbb");
    }

    /*
    * 初始化方法： 申请一些资源。。。。
    *   希望这个方法每次都可以在测试方法执行之前自动执行
    * */
    @Before
    public void init(){
        System.out.println("进行了一些初始化。。。。");
    }

    /*
    * 释放资源的方法：
    *   希望这个方法每次都可以在测试方法执行完成之后自动执行
    * */
    @After
    public void close(){
        System.out.println("释放了一些资源。。。。");
    }

    @Test
    public void divTest(){
        //创建对象
        MyMath mm = new MyMath();
        int result = mm.div(10,2);
        Assert.assertEquals(5,result);
    }

    @Test
    public void sumTest(){
        System.out.println("我执行了。。。。");

        //创建对象
        MyMath mm = new MyMath();
        //调用方法
        int result = mm.sum(2, 3);
        //System.out.println(result);

        //断言  我认为结果应该是什么
        Assert.assertEquals(5,result);
    }
}

---

4 注解

4.1 说明程序的，给计算机看的。

• 注解 Annotation， 也叫做元数据。一种代码级别的说明。
  是jdk5之后出现的。 和 类，接口 是同一个级别的。
• 它可以声明在 包 类 方法 字段 等前面。用来对这些东西进行说明。
• 注解的使用 @注解名称

4.2 作用分类：

• 代码分析：用到反射
• 编译检查：@override
• 编写文档：@return @param
• 替代配置文件: xml 框架部分
• 定义注解：元注解，注解上的注解

4.3 java中的几个注解

• @Override:表示方法是从类类继承过来的。执行编译检查。
• @SuppressWarnings()： 抑制警告 值比较多 all
• @Deprecated：表示方法不建议使用。

package com.momo.domain;

import java.util.List;
@SuppressWarnings("all")
public class Student {
    private String name;
    private int age;

    @SuppressWarnings("all")
    private int tele;

    /*@SuppressWarnings("all")*/
    private List list;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Deprecated
    public void show(){
        System.out.println("show");
    }

    public void show(String s){
        System.out.println("show"+s);
    }
}

package com.momo.demo;

import com.momo.domain.Student;

public class Demo11 {
    public static void main(String[] args) {
        Student s = new Student();
        s.show();
        s.show("aaa");
    }
}

---

4.4 自定义注解

• 格式：
  public @interface MyAnnotation {}

• 注解属性
  注解本身相当于就是一个接口，接口中有常量和抽象方法。
  抽象方法在注解中就叫做 注解属性

• 注解属性的类型：
  基本类型
  String
  Class
  Annotation
  Enum 枚举
  这几个类型的数组

• 注意事项：
  注解中一旦有了注解属性，使用注解的时候必须赋值。除非这个属性有默认值。

package com.momo.demo;

import com.momo.domain.Stu;

import java.util.Date;

public @interface MyAnnotation {
    //注解属性
    int i();
    short s();
    boolean boo();
    char c();

   // Stu stru();
    //Date date();
    String str();
    Class cc();
    aaaa abc();

    String[] strs();
}

---

package com.momo.domain;

public @interface MyAnntation2 {
    String s();
    int i();
}

package com.momo.demo;

import com.momo.domain.MyAnntation2;
@MyAnntation2(s="aaa",i=12)
public class Demo12 {
    public static void main(String[] args) {

      /*  @MyAnntation2(s="aaa")*/
        int i = 5;
    }

   /* @MyAnntation2(s="aaa")*/
    public void show(){

    }
}

---

• 给注解属性赋值的格式：
  @注解名(属性名=属性值)
  如果注解属性的类型是数组，如何赋值
  属性名={属性值}
  如果只有一个值
  属性名=属性值

package com.momo.domain;

public @interface MyAnntation2 {
   /* String s();
    int i();*/

   int[] arr();
}

package com.momo.demo;

import com.momo.domain.MyAnntation2;
/*@MyAnntation2(s="aaa",i=12)*/

//@MyAnntation2(arr={12,34,56,555})
@MyAnntation2(arr=12)
public class Demo12 {
    public static void main(String[] args) {

      /*  @MyAnntation2(s="aaa")*/
        int i = 5;
    }

   /* @MyAnntation2(s="aaa")*/
    public void show(){

    }
}

• 特殊情况
  如果属性名是value，并且只需要给value赋值的时候。
  这个时候value 这个属性名可以省略不写。

package com.momo.demo;

import com.momo.domain.MyAnnotation3;

/*@MyAnnotation3(i=1)*/
/*@MyAnnotation3(1)*/
@MyAnnotation3(value=12)
public class Demo13 {
}
package com.momo.domain;

public @interface MyAnnotation3 {
   /* int i();*/
    int value();
}

---

4.5 元注解

• 定义在注解上的注解
  @Retention 作用是规定注解保留到什么阶段
  值是 RetentionPolicy中的
  CLASS 在代码中的字节码文件中保留
  RUNTIME 所有阶段都保留
  SOURCE 只在源码中保留

@Target 规定注解可以用在什么上面
值是 ElementType 中的
TYPE: 用在类，接口等
METHOD：用在方法
FIELD：用在字段
…

package com.momo.demo;

        import com.momo.domain.MyAnnotation3;

/*@MyAnnotation3(i=1)*/
@MyAnnotation3(1)
/*@MyAnnotation3(value=12)*/
public class Demo13 {
   /* @MyAnnotation3(value=12)*/
    public static void main(String[] args) {
       /* @MyAnnotation3(value=12)*/
        int i = 5;
        System.out.println(i);
    }
}

package com.momo.domain;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
/*@Target(ElementType.LOCAL_VARIABLE)*/
/*@Retention(RetentionPolicy.SOURCE)*/
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation3 {
   /* int i();*/
    int value();
}

---

• 练习：模拟junit测试 @Test功能
  自定义一个注解@MyAnnotation 在另一个类中可以执行执行带有@MyAnnotation
  注解的方法

  分析：
  定义一个注解
  在注解上添加对应的元注解
  在另一个类中给方法上添加注解
  当执行这个类main的时候 可以自动执行带有@MyAnnotation的方法

  提示要使用反射

package com.momo.demo;

import java.lang.reflect.Method;

public class Demo14 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> c = Class.forName("com.momo.domain.MyMath");
        //获取所有方法
        Method[] methods = c.getMethods();
        //遍历
        for(Method m:methods){
            //判断方法是否带有指定的注解
            boolean boo = m.isAnnotationPresent(MyAnnotation.class);
            if(boo){
                m.invoke(对象,参数);
            }
        }
    }
}