第1集：什么是注解

(注意：点我看视频)

一、注解概念

• Annotation是从JDK5.0开始引入的新技术
• Annotation的作用：
  • 可以对程序作出解释，这一点和注释comment类似
  • 对程序进行检查和约束，例如@Override
  • 可以被其他程序（比如：编译器等）读取
• Annotation的格式：
  • 注解是以“@注释名”在代码中存在的，还可以添加一些参数值，例如：@SuppressWarning(value=”unchecked”)
• Annotation在哪里使用？
  • 可以附加在package、class、method、field等上面，相等于给他们添加了额外的辅助信息，然后结合反射机制实现对这些元数据的访问

第2集：内置注解

一、内置注解

• @Override：定义在java.lang包中，此注解只适用于修饰方法，表示该方法打算重写父类中的同名方法，并且具有检查作用

• @Deprecated：定义在java.lang包中，此注释可以修饰方法、属性、类，注释@Deprecated的程序元素是程序员不鼓励使用的程序元素，通常是因为它是危险的，或者因为它已经过时了，然后存在更好的替代方法，但是你使用也没有任何影响，使用案例如下：

• @SupressWarnings：定义在java.lang包中，用来抑制编译时产生的黄色警告信息，虽然这些警告信息不会影响编译结果，但是看着不舒服，然后该注释和前两个注释有所不同，你需要添加一个参数才能正确使用，这些参数都是已经定义好了的，具体参数信息如下所示：
  @SuppressWarnings(“all”) // 压制所有警告，下面有例子：
  @SuppressWarnings(“unchecked”) // 压制"unchecked"警告
  @SuppressWarnings(value={“unchecked”, “deprecation”}) // 压制"unchecked", "deprecation"警告
  注意：public @interface SuppressWarnings {String[] value();}，其中value是参数名，而String[]是参数是类型，当注解只使用value这一个参数的时候，value可以省略，例如上面的@SuppressWarnings("all")和@SuppressWarnings("unchecked")就是省略了前面的value，但是仅限参数名是value，并且注解中只使用value这一个参数的情况才可以 省略value
  

第3集：什么是元注解

一、元注解

• 元注解作用：负责注解其他注解，Java中定义了4个标准的元注解（）类型，他们被用来对其他注解类型进行解释说明限制

• 元注解位置：在java.lang.annotation包中

• 元注解四大类型

  • @Target：用于描述注解的使用范围，也就是描述注解可以使用在什么地方，public @interface Target {ElementType[] value();}可以看出可以它是一个数组，可以有多个值，里面的值设置的都是定义的注解MyAnnotation的使用范围，比如在类上、方法上等等，你可以通过@Target，然后点击里面的ElementType去查看

  

  • @Retention：表示需要在什么级别保存该注释信息，用于描述注解的生命周期（SOURCE < CLASS < RUNTIME），SOURCE是源码级别，CLASS 是源码级别和编译之后的字节码文件中有效，RUNTIME是在源码级别、编译之后的字节码文件、JVM中运行都有效，最常用的就是RUNTIME

  

  • @Documented：说明该注解将被包含在javadoc文档中

  

  • @Inherited：说明子类可以继承父类中的该注解

  

第4集：自定义注解

一、自定义注解

• 使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口
• @interface 用来声明一个注解，格式是：修饰符 @interface 注解名{定义内容}
  • 内容中的每一个方法实际上是声明了一个配置参数，方法的名称就是参数的名称，方法的返回值类型就是参数的类型
  • 返回值类型只能是基本类型、Class、String、enum，如果返回值是String[]的时候，赋值的时候要用{“X1”, “X2”}这种形式；
  • 可以通过default来声明参数的默认值，声明默认值的可以不在自定义注解中赋值，反之必须赋值
  • 如果只有一个参数成员，一般参数名使用value字段，这是因为当参数名称是value并且自定义注解中只需要写一个参数的时候，可以省略参数名称，只有value可以这样，其他的都不行
  • 注解元素必须有值，我们定义注解元素时，经常使用空字符串、0、-1等作为默认值，当默认值为-1，代表不存在
    

第5集：反射概述

一、反射概念

• Reflection(反射)是Java被视为动态语言的关键，反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息，并且能直接操作任意对象的内部属性以及方法
• 加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构，这个对象就像一面镜子，透过这个镜子可以看到类的结构，这就是反射

第6集：获取反射对象

一、反射机制提供的功能

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

二、反射相关的主要API

• java.lang.Class：代表一个类，它就是Object类getClass()方法的返回值，它是唯一的所以类都指向它
• java.lang.reflect.Method：代表类的方法
• java.lang.reflect.Field：代表类的成员变量
• java.lang.reflect.Constructor：代表类的构造器
• ……

三、反射初体验

public class Test {
    public static void main(String[] args) throws ClassNotFoundException {
        // 通过反射返回类的Class对象，这里的Class就是Object类中getClass()方法的返回值Class是一样的，获取的c1是Class类的对象
        Class c1 =  Class.forName("com.atguigu.demo.User");
        System.out.println(c1);

        // 一个类在方法区中只有一个Class对象
        // 一个类被加载之后，类的整个结构(构造器、方法、属性等等)都会被封装在Class对象中
        Class c2 =  Class.forName("com.atguigu.demo.User");
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
    }
}

@Data
class User{
    private Integer id;
    private String name;
    private Integer age;
}

结果：

class com.atguigu.demo.User
1066516207
1066516207

四、Class类详解

第7集：得到Class类的几种方式

一、Class类

• Class本身也是一个类，不过这个类只有一个，所有的类都执行它，例如User类、Person类等
• Class对象是Class类的对象，一个加载的类(例如User.java)在JVM中只会有一个Class对象
• 一个Class对象对应的是一个加载到JVM中的对应的XXX.class文件
• 每个类(例如User.java)的实例(例如User u = new User()中的u)都会记着自己是由哪个Class对象所生成
• 通过CLass对象可以完整地得到一个类(例如User.java)中所有被加载的信息
• Class类(只有一个，和Object类中getClass()方法中返回的Class是同一个)是Reflection的根源，针对任何你想动态加载、运行的类、唯有先获得类(例如User.java)对应的Class对象
• 以上说了三个部分：Class类、Class对象、类、类的实例，通过类可以创建类的实例，通过Class类可以获取某类的Class对象，通过Class对象可以获取类中的所有信息(方法、属性等等)，当然也可以创建类的实例，另外Class对象是类具有的，类可以做的它也能做

二、Class类的常用方法

三、获取Class类的实例

1. 通过类的class属性获取，该方法最为安全可靠，程序性能最高

Class c1 = User.class;

2. 通过类的实例中的getClass()方法获取

Class c2 = user.getClass();

3. 通过类的全限定类名获取

Class c3 = Class.forName("com.atguigu.demo.User");

4.通过基本内置类型的包装类的Type属性（了解）

Class c4 = Integer.TYPE;

5. 通过ClassLoader类加载器获取

Constructor constructor = c1.getDeclaredConstructor(String.class);
Class c5 = constructor.getDeclaringClass();
System.out.println(c5.hashCode());

四、测试+提升

代码：

public class Test {
    public static void main(String[] args) throws Exception {
        // 普通new创建对象
        User student = new Student("mingming");
        System.out.println("这个人是：" + student.name);

        // 方式1：通过类的class属性获取，该方法最为安全可靠，程序性能最高（获取Student的Class对象）
        Class c1 = Student.class;
        System.out.println(c1.hashCode());

        // 方式2：通过类的实例中的getClass()方法获取（获取Student的Class对象）
        Class c2 = student.getClass();
        System.out.println(c2.hashCode());

        // 方式3：通过类的全限定类名获取（获取Student的Class对象）
        Class c3 = Class.forName("com.atguigu.demo.Student");
        System.out.println(c3.hashCode());

        // 方式4：通过基本内置类型的包装类的Type属性（了解）
        Class c4 = Integer.TYPE;


        // 方法5：通过ClassLoader类加载器获取
        Constructor constructor = c1.getDeclaredConstructor(String.class);
        Class c5 = constructor.getDeclaringClass();
        System.out.println(c5.hashCode());

        // 获取父类类型
        Class c6 = c1.getSuperclass();
        System.out.println(c6);

        // 获取Student对象
        Student s1 = (Student) c1.newInstance(); // 本质调用了类的无参构造器
        System.out.println(s1);

        // 使用构造器创建Student对象
        Student s2 = (Student) constructor.newInstance("mingming");
        System.out.println(s2);

        // 通过反射调用普通方法
        // 其中hello是方法名称，String.class代表方法需要的参数的Class对象，c1是Student类对应的Class对象，s1代表Student类的实例对象，“tiantian”代表具体的参数值
        Method method = c1.getDeclaredMethod("hello", String.class);
        method.invoke(s1, "tiantian");

        // 通过反射给属性赋值
        Field age = c1.getDeclaredField("age");
        // 无论是调用私有方法还是给私有属性赋值，都需要关闭程序的安全监测，才能调用方法或者设置属性
        age.setAccessible(true);
        age.set(s1,12);
        System.out.println(s1.getAge());

    }
}

class User {
    public String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Student extends User {
    private Integer age;
    public Student() {
    }

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

    public void hello(String str) {
        System.out.println("Hello!!! " + str);
    }

    public Integer getAge(){
        return this.age;
    }
}

结果：

这个人是：mingming
1066516207
1066516207
1066516207
1066516207
class com.atguigu.demo.User
com.atguigu.demo.Student@1a6c5a9e
com.atguigu.demo.Student@37bba400
Hello!!! tiantian
12

第8集：所有类型的Class对象

一、具有CLass对象的类型

• class：外部类、成员内部类和静态内部类、局部内部类、匿名内部类

Class c1 = Object.class;

• interface：接口

Class c2 = Comparable.class;

• []：数组

Class c3 = String[].class;

• enum：枚举

Class c5 = ElementType.class;

• annotation：注解

Class c4 = Override.class;

• 基本内置类型的包装类，例如Integer等

Class c6 =Integer.class;

• void

Class c7 = void.class;

• Class类

Class c8 =Class.class;

二、元素类型、维度和Class对象的关系

例子：

public class Test {
    public static void main(String[] args) {
        Class c1 = int[].class; // 一维整型数组
        Class c2 = int[][].class; // 二维整型数组
        Class c3 = String[].class; // 一维字符串数组
        int[] i1 = new int[10]; // 初值容量为10的一维整型数组
        int[] i2 = new int[100]; // 初始容量为100的一维整型数组

        System.out.println("一维整型数组：" + c1.hashCode());
        System.out.println("二维整型数组：" + i1.getClass().hashCode());
        System.out.println("一维字符串数组：" + i2.getClass().hashCode());
        System.out.println("初值容量为10的一维整型数组：" + c2.hashCode());
        System.out.println("初始容量为100的一维整型数组：" + c3.hashCode());
    }
}

结果：

一维整型数组：1066516207
二维整型数组：1066516207
一维字符串数组：1066516207
初值容量为10的一维整型数组：443308702
初始容量为100的一维整型数组：935044096

结论：

1. 元素类型不同，Class对象不同，例如int[ ]、String[ ]
2. 元素类型相同，但是维度不同，Class对象不同，例如int[ ]和int[ ][ ]
3. 元素类型相同，维度相同，但是具体内容不同，Class对象相同，例如：int[10]和int[100]

第14集：性能对比分析

例子：

public class Test {
    public static void main(String[] args) throws Exception {
        long start1 = System.currentTimeMillis();
        User user = new User();
        for (int i = 0; i < 1000000; i++) {
            user.getName();
        }
        long end1 = System.currentTimeMillis();
        System.out.println("普通方式执行：" + (end1 - start1) + "ms");

        long start2 = System.currentTimeMillis();
        Class userClass = user.getClass();
        Method getName = userClass.getDeclaredMethod("getName", null);
        for (int i = 0; i < 10000000; i++) {
            getName.invoke(user, null);
        }
        long end2 = System.currentTimeMillis();
        System.out.println("反射方式执行：" + (end2 - start2) + "ms");

        long start3 = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            getName.invoke(user, null);
        }
        long end3 = System.currentTimeMillis();
        System.out.println("反射方式关闭检测执行：" + (end3 - start3) + "ms");
    }
}

class User {
    private String name;

    public void getName() {

    }
}

结果：

普通方式执行：11ms
反射方式执行：164ms
反射方式关闭检测执行：96ms

最后

以上就是神勇小懒猪为你收集整理的【狂神说Java】注解和反射---文档第1集：什么是注解第2集：内置注解第3集：什么是元注解第4集：自定义注解第5集：反射概述第6集：获取反射对象第7集：得到Class类的几种方式第8集：所有类型的Class对象第14集：性能对比分析的全部内容，希望文章能够帮你解决【狂神说Java】注解和反射---文档第1集：什么是注解第2集：内置注解第3集：什么是元注解第4集：自定义注解第5集：反射概述第6集：获取反射对象第7集：得到Class类的几种方式第8集：所有类型的Class对象第14集：性能对比分析所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。