反射
web 框架 底层 全都都是使用反射来做。

反射的概念： 把字节文件  映射到 内存中 成为 class文件对象，  根据class文件对象 创建 类的对象 使用类中的各种内容（成员变量 构造方法 成员方法）
	class文件  用 Class 对象表示
	class文件中 成员变量  Field 对象表示
	class文件中 构造方法  Constructor 对象表示
	class文件中 成员方法  Method 对象表示。

	// idea
     /*
     自动提示 你对象里面具备什么方法。
     底层怎么知道 这个对象中具备什么方法啊？
     获取 对象 所属的 class文件对象。
     根据class文件对象 拿到所有的method对象。
     获取每个method对象的名字
     展示出来。
      */

获取class文件对象：
	反射研究生的是 通过class文件对象 创建 类的对象。 所以首先你得先获取 class文件对象

	三种方式：
		1：对象.getClass();

			Student s = new Student();
			Class c = s.getClass();

			class Student {
				@Override
				public boolean equals(Object obj){
					if (obj == this){
						return true;
					}
					if (obj ==null){
						return false;
					}
					if (obj.getClass() != this.getClass()){
						return false;
					}
					Student s = (Student)obj;
					return s.name.equals(this.name)&& s.age ==this.age;
				}
			}
		
		2: 类名.class
			
			Class c = Student.class;

			class Student {
				public static synchronized void show(){
				
				}

				public static void show1(){
					synchronized(Student.class){
					
					}
				}
			}
		
		3: Class.forName("类的全路径名（带包的）");  // 框架中用的很多。
			
			Class c  = Class.forName("com.itheima.domain.Student");
利用class文件对象
	创建 类 对象

	使用 成员变量
		
		Class c  = Class.forName("com.itheima.domain.Student");
		Field[] fs = c.getFields(); // fs 包含了Student里面所有的 public的属性
		
		Field f = c.getField("age"); // f 是Student里面的age属性
		//f = 18; // 错误
		Student s = new Student();
		f.set(s, 18); // age属性 是Student的 成员变量 ，成员变量的生命周期 随着对象的创建而存在，随着对象的消失而消失。
		System.out.println(s); // Student[name=null,age = 18]

		Field[] fs1 = c.getDeclaredFields();// fs1 包含了Student里面所有的属性

		Field f1 = c.getDeclaredField("name"); // f 是Student里面的私有的name属性
		Student s1 = new Student();
		f1.setAccessible(true);
		f.set(s1, "张三"); 

	使用 构造方法

		Class c  = Class.forName("com.itheima.domain.Student");
		//c.getConstructor(可变参数)  此处之所以设计为可变参数  是因为 你的构造方法 不知道有多少参数把。
		Constructor con = c.getConstructor(); //可变参数
		Object obj = con.newInstance(); //可变参数
		Student s = (Student)obj;

	使用 成员方法
		class Student {
			private void show(int a){
				System.out.println(this.a); //this指的是 谁来调用 包含this的这个方法 this就指的是谁。
			}
		}

		Class c  = Class.forName("com.itheima.domain.Student");
		Method[] ms = c.getMethods();  //ms 包含了Student里面所有的 public的方法
		Method[] ms1 = c.getDeclaredMethods();  //ms 包含了Student里面所有的方法
		
		Method ms2 = c.getDeclaredMethod("show", int.class)
		ms2.setAccessible(true);
		Constructor con = c.getConstructor();
		Object obj = con.newInstance();
		ms2.invoke(obj,20); //   20   必须要传一个 对象进去，  非静态方法 是需要对象调用的，否则里面的this不知道是谁，


案例：已知 配置文件a.properties 和 Student类， 请读取配置文件中的类名className 和方法名methodName ，通过反射 运行该方法。
	
	class Student {
		public void show(){
			System.out.println("abc");
		}
	}

	配置文件a.properties
		className=advance.day15.Student
		methodName=show
	
	代码：
		Properties pro = new Properties();
		//1.2加载配置文件，转换为一个集合
		//1.2.1获取class目录下的配置文件
		ClassLoader classLoader = ReflectTest.class.getClassLoader();
		InputStream is = classLoader.getResourceAsStream("pro.properties");
		pro.load(is);

		//2.获取配置文件中定义的数据
		String className = pro.getProperty("className");
		String methodName = pro.getProperty("methodName");


		//3.加载该类进内存
		Class cls = Class.forName(className);
		//4.创建对象
		Object obj = cls.newInstance();
		//5.获取方法对象
		Method method = cls.getMethod(methodName);
		//6.执行方法
		method.invoke(obj);

作业：模拟 idea的提示功能// 键盘录入一个 类的名字。   你立刻给我打印出 他有哪些方法 哪些成员变量
		
	Scanner sc = new Scanner(System.in);
	String s = sc.nextLine();

	Class<?> c = Class.forName(s);
	Field[] declaredFields = c.getDeclaredFields();
	for (Field declaredField : declaredFields) {
		System.out.println(declaredField);
	}
	Method[] declaredMethods = c.getDeclaredMethods();
	for (Method declaredMethod : declaredMethods) {
		System.out.println(declaredMethod);
	}

注解

框架 web  注解开发。

java的数据类型：
	基本类型：byte short int long float double boolean char
	引用类型：
		数组 []
		类 class
			lambda   jdk1.8的时候出现的
			枚举 enum  jdk1.5的时候出现的
		接口 interface
			注解 @interface jdk1.5的时候出现的

注解的概念：
	1：也叫做 代码的元数据。
		元数据：用来修饰其他数据的 数据 叫做元数据。	
	2：和类 接口 数组 并列为 引用类型。
	3：注解往往写在 类 接口 方法 成员变量的前面。
	
注解功能来分：
	文档注释的注解：对生成 程序的说明文档 的时候 起作用。
		@author  Joseph D. Darcy 作者
		@since 1.0 版本
		@param 参数说明
		@return 返回值说明
		@see  方法中涉及到的其他类的内容

	编译期的注解： 编译期起作用
		@Override		重写
		@Deprecated   过时
		@FunctionalInterface  函数式接口
		@SuppressWarnings("all")  压制警告
	
	运行时注解： 运行时期起作用
		框架中给我们提供：
		jdk给我们也提供了：
		自定义注解。


自定义注解：
	格式:
		元注解
		public @interface 名字{
			属性列表;
		}

		元注解： 
			元数据：就是修饰数据的数据
			元注解：就是修饰注解的注解。
	本质：
		public interface 名字 extends java.lang.annotation.Annotation {
			public abstract void show();
		}

	属性:
		属性类型：
			基本类型
			String类型
			枚举类型
			注解类型
			以上类型数组
			enum En{
				e1,e2,e3;
			}
			public @interface MyAnno{
				int a();
				String str();
				En en();

			}
					
			public @interface MyAnno1{
				int a();
				String str();
				En en();
				MyAnno ma();
				int[] as();
				//Student sts();  //编译报错
				// 为什么 属性类型里面 是不能有 类 和接口啊。
				// 我们的定义的注解 以后加在哪上面？  类 或者 接口上面。  那么你在 注解里面有定义 类属性和接口  就会 递归下去了。
			}
			@MyAnno1(a=10,str="abc",en=En.e2,ma=@MyAnno(a=20,str="bcd",en=En.e1),as={10,20})
			class Student{
				
			}
		
		注意事项：
			案例1：
				public @interface MyAnno{
					int[] as();
				}
				@MyAnno(as=10)
				class Student{
					
				}				
			案例2：
				public @interface MyAnno{
					int[] as();
				}
				@MyAnno()  //编译报错  因为 有as属性 你没赋值就比编译报错
				class Student{
					
				}
			案例3：
				public @interface MyAnno{
					int[] as() default {10,20};
				}
				@MyAnno()  //编译正确
				class Student{
					
				}
			案例4：
				public @interface MyAnno{
					int[] as();
				}
				@MyAnno({10,20})  //编译报错  因为 没有 as =
				class Student{
					
				}
			案例5：
				public @interface MyAnno{
					int[] value();
				}
				@MyAnno({10,20})  //编译正确  
				class Student{
					
				}
			案例6：
				public @interface MyAnno{
					int[] value();
					String str();
				}
				@MyAnno({10,20},str="abc")  //编译报错  因为 没有 value =  value不是单独的
				class Student{
					
				}
	
	元注解：用于描述注解的注解
		@Target： 描述注解能够作用的位置
			ElementType取值：
				TYPE：可以作用于类上
				METHOD：可以作用于方法上
				FIELD：可以作用于成员变量上
		@Retention： 描述注解被保留的阶段
			@Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
		@Documented： 描述注解是否被抽取到api文档中
		@Inherited： 描述注解是否被子类继承
	
	自定义注解的使用：
		（框架底层）反射+配置文件 案例：已知 配置文件a.properties 和 Student类， 请读取配置文件中的类名className 和方法名methodName ，通过反射 运行该方法。
			已知：
				class Student {
					public void show(){
						System.out.println("abc");
					}
				}

				配置文件a.properties
					className=advance.day15.Student
					methodName=show
			
			程序：
				Properties p = new Properties();
				p.load("a.properties");
				p.getProperty("className");
				p.getProperty("methodName");
				// 反射创建Student对象 反射执行show方法
		
		（框架底层）反射+注解
			已知：
				public @interface MyAnno{
					String className();
					String methodName();
				}
				
				class Student {
					public void show(){
						System.out.println("abc");
					}
				}

				@Pro(className = "cn.itcast.annotation.Demo1",methodName = "show")

			程序：
				/*
				 反射获取注解
				 获取 className  methodName

				 反射 创建Student对象 反射执行 show方法。
				*/
				@Pro(className = "cn.itcast.annotation.Demo1",methodName = "show")
				public class ReflectTest {
					public static void main(String[] args) throws Exception {
						//1.解析注解
						//1.1获取该类的字节码文件对象
						Class<ReflectTest> reflectTestClass = ReflectTest.class;
						//2.获取上边的注解对象
						//其实就是在内存中生成了一个该注解接口的子类实现对象
						/*

							public class ProImpl implements Pro{
								public String className(){
									return "cn.itcast.annotation.Demo1";
								}
								public String methodName(){
									return "show";
								}

							}
						*/
						Pro an = reflectTestClass.getAnnotation(Pro.class);
						//3.调用注解对象中定义的抽象方法，获取返回值
						String className = an.className();
						String methodName = an.methodName();
						System.out.println(className);
						System.out.println(methodName);

						//3.加载该类进内存
						Class cls = Class.forName(className);
						//4.创建对象
						Object obj = cls.newInstance();
						//5.获取方法对象
						Method method = cls.getMethod(methodName);
						//6.执行方法
						method.invoke(obj);
					}
				}