1、什么是注解

可以被其他程序读取

注解（Annotation）在哪使用？

• 可以附加在 package，class，method，field等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问。

2、内置注解

• @Override：只适用于修饰方法，表示一个方法声明打算重写超累中的另一个方法声明。、

• @Deprecated：此注释可用于修饰方法、属性、类，表示不鼓励程序员使用这样的元素，通常是存在危险或有更好的选择。

• @SuppressWarnings：用来抑制编译时的警告信息。比如修饰类，那么类下面的一些警告信息就会忽略。

  • 与前面两个注释不同，这个需要添加一个参数才能正常使用，这些参数也是已经定义好的。
  • @SuppressWarnings("all")
  • @SuppressWarnings("unchecked")
  • @SuppressWarnings(value={"unchecked","deprecation"})
  • 等等。。。

3、元注解

元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型，它们被用来提供对其他annotation类型作说明。

这些类型和它们所支持的类在java.lang.annotation包中可以找到，（@Target,@Retention,@Documented,@Inherited）

• @Target：用于描述注解的使用范围
• @Retention：表示需要在什么级别保存该注释信息，用于描述注解的声明周期 > (SOURCE < CLASS < RUNTIME)，一般自定义的注解写RUNTIME。运行中被读取。
• @Document：说明该注解将被包含在javadoc中
• @Inherited：说明子类可以继承父类中的该注解

4、自定义注解

使用 @interface 自定义注解，自动继承了java.lang.annotation.Annotation接口

• @interface用来声明一个注解，格式：public @interface 注解名{定义内容}
• 其中的每一个方法实际上是声明了一个配置参数
• 方法的名称就是参数的名称
• 返回值类型就是参数的类型(返回值只能是基本类型，class,String,enum)
• 可以通过default来声明参数的默认值
• 如果只有一个参数成员，一般参数名为 value
• 注解元素必须要有值，我们定义注解元素时，经常使用空字符串，0作为默认值。

package Demos_zhujie;
​
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
​
public class Test02 {
    @MyAnnotation2(name = "asdf",food = {"xigua","xiangjiao"})
    public void play(){
        
    }
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    // 注解参数：类型 + 参数名(); 这个不是方法
    // 如果有默认值，就可以不给注解传值
    String name() default "";
    int age() default 0;
​
    // 如果默认值为-1，代表不存在。
    int id() default -1;
  
    String[] food();
}

5、反射

动态语言：Object-C、C#、JavaScript、PHP、Python

静态语言：Java、C、C++

• Java不是动态语言，但java可以称之为“准动态语言“。即Java有一定的动态性，可以利用反射机制获得类似动态语言的特性。

Reflection

• Reflection 反射，是Java语言被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API 取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

  • Class c = Class.forName("java.lang.String")

  加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。

  • 正常方式：引入需要的包类名称 > 通过new实例化 > 取得实例化对象
  • 反射方式：实例化对象 > getClass() 方法 > 得到完整的包类名称

反射机制提供的功能：

在运行时 判断任意一个对象所属的类、构造任意一个类的对象、判断任意一个类所具有的成员变量和方法、获取泛型信息、调用任意一个对象的成员变量和方法、处理注解、生成动态代理.....

反射的缺点：

• 对性能有影响，使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于 直接执行相同的操作。

反射相关的API：

• java.lang.Class：代表一个类
• java.lang.reflect.Method：代表类的方法
• java.lang.relect.Field：代表类的成员变量
• java.lang.reflect.Constructor：代表类的构造器
• ...

6、Class类

对于每个类而言，JRE都会为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息

• Class 本身也是一个类
• Class 对象只能有系统建立对象
• 一个加载的类在JVM中只会有一个Class实例
• 一个Class对象对应的是一个加载到JVM中的.class文件
• 每个类的实例都会记得自己是由哪个Class实例所生成
• 通过Class可以完整的得到一个类中的所有被加载的结构
• Class 类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象。

class类的常会用方法：

• static ClassforName(String name) 返回指定类名name的Class对象
• Object newInstance() 调用缺省构造函数，返回Class对象的一个实例
• getName() 返回此Class对象所有表示的实体（类，接口，数组类或void）的名称
• Class getSuperClass() 返回当前Class对象的父类的Class对象
• Class[] getinterfaces() 获取当前Class对象的接口
• ClassLoader getClassLoader() 返回该类的类加载器
• Constructor[] getConstructros() 返回一个包含某些Constructor对象的数组
• Method getMothed(String name,Class.. T) 返回一个Method对象，此对象的形参类型为paramType
• Field[] getDeclaredFields() 返回Field对象的一个数组

获取Class类的实例：

• 若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高。

  • Class claz = Person.class;

• 已知某个类的实例，调用该实例的getClass() 方法获取Class对象

  • Class claz = person.getClass();

• 已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException

  • Class claz = Class.forName("Demo01.Person");

• 内置基本数据类型可以直接用类名.Type

• 还可以利用ClassLoader

• 只要元素类型和维度一样，那就是同一个Class

7、Java内存分析

类的加载与ClassLoader的理解： 栈保存变量，堆保存类，属性，方法等

加载 > 链接 > 初始化

• 加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象。

• 链接：将Java类的二进制代码合并到JVM的运行状态之中的过程。

  • 验证：确保加载的类信息符合JVM规范，没有安全方面的问题
  • 准备：正式为类变量(static) 分配内存并设置类变量默认初始值的阶段，这写内存都将在方法区中进行分配。
  • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

• 初始化：

  • 执行类构造器<clinit()>方法的过程。类构造器<clinit()>方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器。）
  • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先出发其父类的初始化。
  • 虚拟机会保证一个类的<clinit()>方法在多线程环境中被正确加锁和同步。

package Demos_fanshe;
​
public class Test03 {
    public static void main(String[] args) {
        A a = new A();
    }
}
class A{
    /**
     * 1、这个类会加载到内存中，生成一个 java.lang.Class 对象
     * 2、链接，链接结束后 name = null
     * 3、初始化：这个时候会把当前类的所有静态方法和并成一个方法 <clinit>(){
     *     System.out.println(A.name);
     *         name = "dd";
     *         name = "cc";
     * }
     * 4、最后这个name 就是cc，我们会看到先打印null;
     */
    static{
        System.out.println(A.name);
        name = "dd";
    }
    static String name = "cc";
    public A(){
        System.out.println("无参构造器");
        System.out.println(name);
    }
}
​

8、什么时候会发生类初始化？

• 类的主动引用（一定会发生类的初始化）

  • 当虚拟机启动，先初始化main方法所在的类
  • new一个类的对象
  • 调用类的静态成员（除了final常量）和静态方法
  • 使用java.lang.,reflect包的方法对类进行反射调用
  • 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类。

• 类的被动引用（不会发生类的初始化）

  • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化。
  • 通过数组定义类引用，不会触发此类的初始化
  • 引用常量不会触发此类的初始化（常量再链接阶段就存入调用类的常量池中了）

9、类加载器

类加载器作用是用来把类装载进内存的。JVM规范定义了如下类型的类的加载器

• 引导类加载器：用C++编写的，是JVM自带的类加载器，负责Java平台核心库。该加载器无法直接获取。
• 扩展类加载器：负责 jre/lib/ext 目录下的jar包或 -D java.ext.dirs 指定目录下的jar包装入工作库
• 系统类加载器：负责 java -classpath 或 -D java.class.path 所指的目录下的类与jar包装入工作库，是最常用的加载器

用户类加载器 < 扩展类加载器 < 根加载器

扩展：双亲委派机制：我们写一个类和rt.jar或者扩展包里相同，它会使用自己的，保证安全性

10、获取运行时类的完整结构

通过反射获取运行时类的完整结构

Field、Method、Constructor、Superclass、Interface、Annotation

package Demos_fanshe;
​
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
​
//  获取类的信息
public class Test04 {
    public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Food food = new Food();
        food.name = "xigua";
        Class c1 = food.getClass();
        System.out.println(c1.getName());  // 获取报名+ 类名
        System.out.println(c1.getSimpleName()); // 获取类名
​
        Field[] fields = c1.getFields();  // 只能找到 public 属性
        System.out.println(Arrays.toString(fields));
​
        fields = c1.getDeclaredFields();
        System.out.println(Arrays.toString(fields)); // 能找到所有属性
​
        Field name = c1.getDeclaredField("name"); // 单独找某个属性
​
        // 获得方法
        Method[] med = c1.getMethods(); // 获得本类和父类的所有方法
        System.out.println(Arrays.toString(med));
        Method[] methods = c1.getDeclaredMethods(); // 获取本类的方法
        System.out.println(Arrays.toString(methods));
​
        // 获取指定方法
        // 获取单独方法时，除了传方法名，因为重载关系，也要传具体要找的方法参数类型
        Method mt = c1.getMethod("eat",null);
        Method mt2 = c1.getMethod("eat",String.class);
        System.out.println(mt + " "+ mt2);
​
        // 获得指定的构造器
        Constructor[] constructors = c1.getConstructors(); // 获取所有的构造器 只能返回public修饰的
        System.out.println(Arrays.toString(constructors));
        Constructor constructor = c1.getConstructor(String.class); // 获取指定的构造器 只能返回public修饰的
        System.out.println(constructor);
        Constructor c = c1.getDeclaredConstructor(String.class); // 获取指定的构造器 包括public 非public 甚至private
        System.out.println(c);
        Food xiangjiao = (Food)c.newInstance( "香蕉");
        System.out.println(xiangjiao.name);
    }
}
​
​
class Food{
    String name;
​
    public Food() {
    }
​
    public Food(String name) {
        this.name = name;
    }
​
    public void eat(){
        System.out.println("chisha ?");
    }
    public void eat(String name){
        System.out.println("chi"+name);
    }
}

11、动态创建对象执行方法

• 创建类的对象：调用Class对象的newInstance() 方法

  • 1、类必须有一个无参数的构造器
  • 2、类的构造器的访问权限需要足够

• 没有无参数构造器的情况下创建对象：

  • 1、通过Class类的getDeclaredConstructor(Class... parameterTypes) 取得本类的指定形参类型的构造器
  • 2、向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数
  • 3、通过Constructor实例化对象。

package Demos_fanshe;

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

// 动态创建对象，通过反射
public class Test05 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {

        // 获取class对象
        Class c1 = Class.forName("Demos_fanshe.User");
        System.out.println(c1.getSimpleName());

        // 构造一个对象
        User user = (User) c1.newInstance();
        System.out.println(user);

        // 获取一个类的构造器，并使用构造器创建方法
        Constructor constructor = c1.getConstructor(String.class,int.class,int.class);
        User user2 = (User)constructor.newInstance("chen",15,1);
        System.out.println(user2);

        // 通过反射调用普通方法
        User user3 = (User)c1.newInstance();
        Method setName = c1.getDeclaredMethod("setName", String.class);
         // invoke : 激活的意思，参数：（对象，“方法的参数”）
        setName.invoke(user3,"chennn");
        System.out.println(user3.getName());

        // 通过反射操作属性
        User user4 = (User)c1.newInstance();
        Field name = c1.getDeclaredField("name");
        name.setAccessible(true); // 不能直接操作私有属性，需要通过方法关闭程序的安全检测。
        name.set(user4,"呵呵");;
        System.out.println(user4.getName());
    }
}

调用指定方法：

• 通过Class类的getMethod(String name,Class... parameterTypes) 方法取得一个Method对象，并设置此方法操作时所需要的参数类型。

• 之后使用Object invoke(Object obj,Objectp[] args)进行调用，并向方法中传递要设置的obj对象的参数信息

  • Object invoke(Object obj,Object... args)
  • Object 对应原方法的返回值，若原方法无返回值，此时返回null
  • 若原方法为静态方法，此时形参Object obj 可以为null
  • 若原方法形参列表出参数为空，则Object[] args 为 null
  • 若原方法声明为 private，则需要在调用此invoke() 方法前，显示调用方法对象的setAccessible(true)方法，将可访问private的方法。

setAccessible

• Method和Field、Constructor对象都有setAccessible()方法

• setAccessible作用是启动和禁用访问安全检查的开关

• 参数值为 true 则指示反射的对象在使用时应该取消Java语言访问检查

  • 提高反射的效率。如果代码中必须使用反射，而该句代码需要频繁的被调用，那么请设置为true
  • 使得原本无法访问的私有成员也可以访问

• 参数值为 false 则指示反射的对象应该实施Java语言访问检查

12、获取泛型信息

Map<Stirng,String> 这里面的 <> 里的String , String 就是指泛型

• Java采用泛型擦除机制来引入泛型，Java中的泛型仅仅时给编译器javac使用的，确保数据的安全性和免去强制类型转换的问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除
• 为了通过反射操作这些类型，Java新增了 ParameterizedType，GenericArrayType，TypeVariable 和 WildcardType 几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型
• ParameterizedType：表示一种参数化类型，比如 Collection<String>
• GenericArrayType：表示一种元素类型时参数化类型或者类型变量的数组类型
• TypeVariable：是各种类型变量的公共父接口
• WildcardType：代表一种通配符类型表达式

13、获取注解信息

• 1、先获取Class对象
• 2、通过反射获取注解 class.getAnnotations()
• 3、获取注解的value值：class.getAnnotation("要获取的注解的对象.class").value()
• 4、获取类中属性的注解，要先获取到类的指定属性字段，再重复第三步