JAVA注解与反射(简单整理）

注解：

特点:可以被其他程序读取

格式:

“@注释名”,还可以添加一些参数

内置注解：

@Override ：表示一个方法声明打算重写另一个方法声明：典型的就是toString

@Deprecated:表示不鼓励使用这样的元素(但是可以使用)

@SuppressWarnings:用来抑制编译时的警告信息(需要添加参数）

元注解:

负责注解其他注解

@Target：描述注解的使用范围

@Runtime:表示在什么级别保存该注释信息

@Document:说明该注解被包含在javadoc中

@inherited:说明子类可以继承父类中的该注解

自定义注解：

格式：public @ interface 注解名

反射（java.Reflection)

动态语言：在运行时可以改变其结构的语言

例如。c#,JavaScript,PHP,python

静态语言：运行时结构不可改变的语言就是静态语言，JAVA不是动态语言，但java可以称为准动态语言，就是利用了反射机制。

反射机制：

允许在程序运行期间借用Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

加载完类之后，在堆内存的方法区会产生一个Class类型的对象（一个类只有一个Class对象），包含了完整的类的结构信息。我们可以通过这个对象看到类的结构，类似镜子，所以我们称之为反射。

反射方式：实例化对象->getClass()方法->获得完整的”包类“名称

优点：实现动态创建对象和编译，灵活性强

缺点：对性能有影响，慢于直接执行相同的操作

简单例子

package OOP.re;

public class student {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c1 = Class.forName("OOP.re.user");
        System.out.println(c1);
        System.out.println(c1.hashCode());
    }
}
class user {
    private String name;
    private int age;
    public user() {
    }
    public user(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 "user{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

得到Class类的几种方式：

1.若已知具体的类，通过类的class属性获取，该方法最安全

Class c1 = Person.class;

2.若知道某个类的实例，调用getClass(0方法获取Class对象

Class c1 = person.getClass();

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

Class c1 = Class.forName("demo1.Student");

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

哪些类型可以有Class对象

class:外部类，成员，局部内部类，匿名内部类

interface:接口

[]：数组

enum:枚举

annotation:注解

primitive type：基本数据类型

viod

类加载内存分析

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象(不能主动创建，只能被动的获取）

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

初始化：执行类构造器，把所有类变量的赋值动作和静态代码中的语句合并产生，当初始化一个类的时候，如果发现其父类还没有进行初始化，则先触发其父类的初始化

整体步骤：

1.加载到内存，产生一个类对应的Class对象

2.链接结束后赋值默认为0

3.初始化

分析类的初始化：

什么时候发生：类的主动引用（一定会发生类的初始化）/类的被动引用（不会发生类的初始化）

类的被动引用：

1.当通过子类引用父类静态变量不会导致子类初始化

2.通过数组定义类引用，不会触发此类的初始化

3.引用常量不会触发类的初始化

类加载器的作用

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

类缓存：某个类被加载到类加载器中，它将维持加载（缓存）一段时间

package OOP.jiazai;
public class test01 {
    public static void main(String[] args) throws ClassNotFoundException{
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);//获得系统类的加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);//获得扩展类加载器
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);//根加载器、、无法直接获取
        //获得当前类是什莫加载器
        ClassLoader classLoader = Class.forName("OOP.jiazai.test01").getClassLoader();
        System.out.println(classLoader);
    }
}

获取类运行时的完整结构

通过反射获取运行时类的完整结构
Field,Method,Constructor,Superclass,lnterface,Annotation

package OOP.re;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class qu {
    public static void main(String[] args) throws ClassNotFoundException,NoSuchFieldException {
        Class c1 = Class.forName("OOP.re.user");
        System.out.println(c1.getName());//获得包名+类名
        System.out.println(c1.getSimpleName());//获得类名
        //user user = new user()
        //c1 = user.getClass
        //这表明也可以通过对象获取
        Field[] fields = c1.getFields();//只能找到public 属性
        fields = c1.getDeclaredFields();//找到全部的属性
        for (Field field : fields) {
            System.out.println(field);
        }
        //获得指定属性
        Field name = c1.getDeclaredField("name");
        System.out.println(name);
        //获得类的方法
        Method[] methods = c1.getMethods();//公共的
        for (Method method : methods) {
            System.out.println(method);
        }
        Method[] declaredMethods = c1.getDeclaredMethods();//全部的
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);//获得构造器
        }
    }
}

动态创建对象执行方法

有了Class对象，能做什么？
创建类的对象，调用newinstance()方法
注意：1.类必须有一个无参数的构造器
2.类的构造器访问权限需要足够

package OOP.re;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class xin {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class c1 = Class.forName("OOP.re.user");
//        user user =(user) c1.newInstance();//本质调用了类的无参构造器
//        System.out.println(user);
//        //通过构造器创造对象
//        Constructor constructor = c1.getConstructor(String.class, int.class);
//        user xino = (user)constructor.newInstance("XINO", 18);
//        System.out.println(xino);
        //通过反射调用普通方法
        //invoke:激活
        //(对象，“方法的值”）
        user user1 = (user) c1.newInstance();
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.invoke(user1,"xxx");
        System.out.println(user1);
        //通过反射调用属性
        user user2 = (user) c1.newInstance();
        Field name = c1.getDeclaredField("name");
        name.setAccessible(true);//关闭程序的安全检测，可以利用private属性
        name.set(user2,"xxxxxxxxxxx");
        System.out.println(user2.getName());
    }
}

性能对比分析

setAccessible：Method,Field,Constructor对象都有该方法
该方法作用：启用和禁用访问安全检测的开关

获取泛型信息

先了解一下泛型是什么
Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
我们通过代码看看其作用

 List x = new ArrayList();
  x.add("xino"); // 加入string
  x.add(66666); // 加入int
  //此时我们传入多个类型都可以通过，但获取的时候极有可能错报
  //泛型起约束作用约束我们传入的类型
  //例如：list<String> x = new ArrayList();

优点：
提高了代码的可读性，一眼就能看出集合（其它泛型类）的类型
可在编译期检查类型安全
省心不需要强转（内部做了强转）
提高代码的复用率，定义好泛型，一个方法（类）可以适配所有类型
反射操作泛型
Java采用泛型擦除机制来引入泛型，一旦编译完成，所有和泛型有关的类型全部擦除
为了通过反射获取这些类型，java新增以下类型代表不能被归一到Class类中的类型但又和原始类型齐名的类型