Annotation是从JDK1.5开始引入的新技术
Annotation的作用：
不是程序本身，可以对程序做出解释可以被其他程序读取Annotation的格式：
注解是以“@注释名”在代码中存在的，还可以添加一下参数值
如：@SuppressWarning（value=“unchecked”）
Annotation在哪里使用：
可以附加在包，类，方法，属性等上面，相当于给他们添加了额外的辅助信息，我们就可以通过反射机制编程实现对这些元数据的访问
@Override：定义在java.lang.Override中，此注解只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法
public class test extends Object{ @Override //重写的注解 public String toString(){ return super.toString(); } }@Deprecated：定义在java.lang.Deprecated中，此注解只适用于修辞方法、属性、类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择
@SuppressWarning：定义在java.lang.SuppressWarning中。用来抑制编译时的警告信息，与前两个注释不同，需要添加一个参数才能正常使用
@SuppressWarning（“all”） 抑制所有编译时的警告
@SuppressWarning（“unchecked”）
@SuppressWarning（value={“unchecked”，“deprecation”}）
作用：负责注解其他的注解
@Target：用于描述注解的使用范围
@Retention：表示需要在什么级别保存改注释信息，用于描述注解的生命周期（SOURCE>CLASS>RUNTIME）
@Document：说明该注解将被包含在javadoc中
@Inherited：说明子类可以继承父类的该注解
//测试元注解 @MyAnnotation public class Test1 { @MyAnnotation public void Test2(){} } //定义一个元注解 @Target(value = {ElementType.METHOD,ElementType.TYPE}) @Retention(value = RetentionPolicy.RUNTIME) @interface MyAnnotation{ }使用@interface自定义注解，自动继承java.lang.annotation.Annotation接口
格式：@interface 注解名{定义内容}
其中的每一个方法实际上是声明了一个配置参数方法的名称就是参数的名称返回值得类型就是参数类型（返回值只能是基本类型，class,String,enum）可以通过default来声明参数的默认值如果只有一个参数成员，一般参数名为value注解元素必须要有值，我们定义注解元素时，经常使用空字符串，0作为默认值注解可以显性赋值，如果没有默认值就必须给注解赋值 public class Test{ @MyAnnotation1(age=18) public void test{} } @interface MyAnnotation1{ //注解参数格式：参数类型+参数名（）； String name() default ""; int age(); int id() default -1;//如果默认为-1 表示不存在 String[] schools() default {"hyb","111"}; } 反射是java被视为动态语言的关键，反射机制允许程序在执行期间借助Reflection API取得任何类的内部信息，并能直接操作任何对象的内部属性及方法
Class c =Class.forName("java.lang.String") 加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了完整的类的结构信息，我们可以通过这个对象看到类的结构，这个对象就像一面镜子，所以我们称之为：反射
java反射机制提供的功能：
在运行时判断任意一个对象所属的类在运行时构造任意一个类的对象在运行时判断任意一个类所具有的成员变量和方法在运行时获取泛型在运行时调用任意一个对象的成员变量和方法在运行时处理注解生成动态代理优点：
可以实现动态创建对象和编译，体现出很大的灵活性
缺点：
对性能有影响，这类操作总是慢与直接执行相同的操作
public class Test2 { public static void main(String[] args) throws ClassNotFoundException { //通过反射获取类的Class对象 Class c1 = Class.forName("User"); System.out.println(c1); Class c2 = Class.forName("User"); Class c3= Class.forName("User"); Class c4 = Class.forName("User"); //一个类在内存中只有一个class对象 System.out.println(c2.hashCode()); System.out.println(c3.hashCode()); System.out.println(c4.hashCode()); } } //实体类 class User{ private String name; private int id; private int age; public User() { } public User(String name, int id, int age) { this.name = name; this.id = id; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getId() { return id; } public void setId(int id) { this.id = id; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "User{" + "name='" + name + '\'' + ", id=" + id + ", age=" + age + '}'; } }一个类在内存中只有一个Class对象，在被加载后，类的整个结构都会被封装在Class对象中
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KYYMhbra-1602063075492)(C:\Users\Administrator\Pictures\Camera Roll\14.png)]
在Object类中定义了getClass（）方法，此方法将被所有子类继承
Class本身也是一个类
Class对象只能由系统建立对象
一个加载的类在JVM中只会有一个Class实例
一个Class对象对应的是一个加载到JVM中的一个.class文件
每一个类的实例都会记得自己是由哪个Class实例所生成的
Class类是反射的根源，针对任何你想动态加载、运行的类，唯一先获得相应的Class对象
若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
Class clazz=Person.class; 已知某个类的实例，调用该实例的getClass（）方法获取Class对象 Class clazz=person.getClass(); 已知一个类的全类名，且该类在类的路径下，可通过Class类的静态方法forName（）获取，可能抛出异常 Class clazz=Class.forName("类的路径名") 内置基本数据类型可以直接用类名.Type还可以使用ClassLoader public class Test3 { public static void main(String[] args) throws ClassNotFoundException { Person person = new Student(); System.out.println("这个人是："+person.name); //方式一： 通过对象获得 Class c1=person.getClass(); System.out.println(c1.hashCode()); //方式二：通过forName获得 Class c2=Class.forName("Student"); System.out.println(c2.hashCode()); //方式三：通过类名.class获得 Class c3=Student.class; System.out.println(c3.hashCode()); //方法四：基本内置类型的包装类都有一个Type属性 Class c5=Integer.TYPE; System.out.println(c5); //获得父类类型 Class c6=c1.getSuperclass(); System.out.println(c6); } } class Person{ public String name; public Person(){ } public Person(String name){ this.name=name; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + '}'; } } class Student extends Person{ public Student(){ this.name="学生"; } } class Teacher extends Person{ public Teacher(){ this.name="老师"; } }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-khcMB4Pm-1602063075501)(C:\Users\Administrator\Pictures\Camera Roll\15.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VEqvM44I-1602063075503)(C:\Users\Administrator\Pictures\Camera Roll\16.png)]
只要元素类型与维度一样，就是同一个Class
int[] a=new int[10]; int[] b=new int[100]; System.out.println(a.getClass().hashCode()); System.out.println(b.getClass().hashCode());[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EUrndAlz-1602063075505)(C:\Users\Administrator\Pictures\Camera Roll\17.png)]
加载：将Class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个 代表这个类的java.lang.Class对象
链接：将java类的二进制代码合并到JVM的运行状态之中的过程
验证：确保加载的类信息符合JVM规范，没有安全方面问题
准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分
解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程
初始化：
执行构造器()方法的过程，类构造器()方法是由编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）当初始化一个类的时候，如果发现其父类还没有初始化，则需要先触发其父类的初始化虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步 public class Test5 { public static void main(String[] args) { A a = new A(); System.out.println(A.m); } } class A{ static { System.out.println("A类的静态代码初始化"); m=300; } static int m=100; public A(){ System.out.println("A类的无参构造初始化"); } }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6cFzRlxU-1602063075506)(C:\Users\Administrator\Pictures\Camera Roll\18.png)]
类加载器的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然 后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据访问入口
类缓存：标准的javaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载一段时间。 不过JVM垃圾回收机制可以回收这些Class对象
类的主动引用（一定会发生类的初始化）
当虚拟机启动，先初始化main方法所在的类new一个类的对象调用类的静态成员（除了final常量）和静态方法使用java.lang.reflect包的方法对类进行反射调用当初始化一个类，如果其父类没有被初始化，则会先初始化他的父类 public class Test6 { static { System.out.println("main被加载"); } public static void main(String[] args) throws ClassNotFoundException { Son son = new Son();//主动调用 Class.forName("Son");//反射产生主动引用 } } class Father{ static int a=2; static { System.out.println("父类被加载"); } } class Son extends Father{ static { System.out.println("子类被加载"); m=300; } static int m=100; static final int M=1; }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c2ANUNke-1602063075508)(C:\Users\Administrator\Pictures\Camera Roll\19.png)]
类的被动引用（不会发生类的初始化）
当访问一个静态域时，只有真正声明这个域的类才回被初始化，如：通过子类引用父类的静态变量，子类不会初始化 public static void main(String[] args) throws ClassNotFoundException { //Son son = new Son();//主动调用 //Class.forName("Son");//反射产生主动引用 System.out.println(Son.a); }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nQDvx4Jl-1602063075509)(C:\Users\Administrator\Pictures\Camera Roll\20.png)]
通过数组定义类引用，不会触发此类的初始化 public static void main(String[] args) throws ClassNotFoundException { //Son son = new Son();//主动调用 //Class.forName("Son");//反射产生主动引用 //不会产生类的引用的方法 //System.out.println(Son.a); Son[] array=new Son[5]; }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-StVSUzif-1602063075509)(C:\Users\Administrator\Pictures\Camera Roll\21.png)]
引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中） public static void main(String[] args) throws ClassNotFoundException { //Son son = new Son();//主动调用 //Class.forName("Son");//反射产生主动引用 //不会产生类的引用的方法 //System.out.println(Son.a); //Son[] array=new Son[5]; System.out.println(Son.M); }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iGDa5SOQ-1602063075510)(C:\Users\Administrator\Pictures\Camera Roll\22.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-97O3fBcl-1602063075511)(C:\Users\Administrator\Pictures\Camera Roll\23.png)]
创建类的对象：调用Class对象的newInstance()方法
类必须有一个无参数的构造器类的构造器的访问权限需要足够如果没有无参构造，要在操作的时候明确的调用类中的构造器，并将参数传递进去，才可以实例化操作
步骤如下：
通过Class类的getDeclaredConstructor(Class … parameterType)取得本类的指定形参类型的构造器向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数通过Constructor实例化对象 public class Test8 { public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException { Class c1 = Class.forName("User");//获得Class对象 User user=(User) c1.newInstance();//构造一个对象，实际是调用了类的无参构造器 System.out.println(user); //通过构造器创建对象 Constructor contructor=c1.getDeclaredConstructor(String.class,int.class,int.class); User user2 =(User) contructor.newInstance("hyb", 1, 18); System.out.println(user2); //通过反射调用普通方法 User user3=(User)c1.newInstance(); //通过反射获取一个方法 Method setName=c1.getDeclaredMethod("setName", String.class); setName.invoke(user3,"hyb");//invoke激活的意思 System.out.println(user3); //通过反射操作属性 User user4=(User)c1.newInstance(); Field name=c1.getDeclaredField("name"); //不能直接操作私有属性，需关闭程序的安全检测，属性或者方法的setAccessible(true) name.setAccessible(true); name.set(user4,"hyb2"); System.out.println(user4); } }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W6Dt4F6r-1602063075512)(C:\Users\Administrator\Pictures\Camera Roll\24.png)]
Object invoke(Object obj,Object … args)
Object对应原方法的返回值，若原方法没有返回值，此时返回null若原方法为静态方法，此时形参Object obj可为null若原方法形参列表为空，则Object[] args为null[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vOiPoqAG-1602063075513)(C:\Users\Administrator\Pictures\Camera Roll\25.png)]
