Java--注解与反射--自定义注解与元注解、初识反射、 所有类型的class对象、类的内存初始化、类何时初始化

Java–注解与反射–自定义注解与元注解、初识反射、 所有类型的class对象、类的内存初始化、类何时初始化

自定义注解与元注解

package com.zy.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 *description: Java--注解与反射--元注解
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-30 21:03
 */
@MyAnnotation(name = "zy")
public class StudyMetaAnnotation {
    // 注解可以显示赋值，如果没有默认值，就必须显示赋值
    @MyAnnotation(name = "zz")
    @MyAnnotation2("默认不写参数名")
    public void studyOne(){

    }
}

// Target：说明注解可以作用在哪些地方，类似于注解的作用域
@Target(value = {ElementType.METHOD,ElementType.TYPE})
// Retention：说明注解在什么时候还有效：runtime>class>sources
@Retention(value = RetentionPolicy.RUNTIME)
// 说明是否将注解生成在Javadoc中
@Documented
// 说明子类可以继承父类的注解
@Inherited
@interface MyAnnotation{
    // 注解的参数：参数类型+参数名();
    String name();
    int age() default 18;
    // 如果默认值为-1，代表不存在
    int id() default -1;
    String[] schools() default {"清华大学","北京大学"};
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    String value();
}

初识反射

package com.zy.reflection;

/**
 *description: Java--注解与反射--初识反射
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-30 21:34
 */
public class Study01 {

    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> c1 = Class.forName("com.zy.reflection.User");
        Class<User> c2 = User.class;
        Class<?> c3 = new User().getClass();

        // 基本内置类型的包装类都有一个type属性
        Class c4 = Integer.TYPE;

        // 一个类被加载后，类的整个结构都会被封装在class对象中
        System.out.println(c1);
        // 一个类在内存中只有一个class对象
        System.out.println(c2.hashCode());// 2125039532
        System.out.println(c3.hashCode());// 2125039532
        // int
        System.out.println(c4);

        // 获得父类类型
        Class<?> c5 = c1.getSuperclass();
        System.out.println(c5);

    }
}

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 super.toString();
    }
}

所有类型的class对象

package com.zy.reflection;

import java.lang.annotation.ElementType;

/**
 *description: Java--注解与反射--所有类型的class
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-30 21:54
 */
public class Study02 {

    public static void main(String[] args) {
        // 类
        Class<Object> c1 = Object.class;
        // 接口
        Class<Comparable> c2 = Comparable.class;
        // 一维数组
        Class<String[]> c3 = String[].class;
        // 二维数组
        Class<int[][]> c4 = int[][].class;
        // 注解
        Class<Override> c5 = Override.class;
        // 枚举
        Class<ElementType> c6 = ElementType.class;
        // 基本数据类型
        Class<Integer> c7 = Integer.class;
        // 空类型
        Class<Void> c8 = void.class;
        // class本身
        Class<Class> c9 = Class.class;

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);

        // 只要元素类型与维度一样，所属class一致
        int[] a = new int[10];
        int[] b = new int[100];
        // true
        System.out.println(a.getClass().equals(b.getClass()));
    }
}

类的内存初始化

package com.zy.reflection;

/**
 *description: Java--注解与反射--类的内存初始化
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-30 22:12
 */
public class Study03 {

    /*
        1.加载到内存，会产生一个类对应的class对象
        2.链接，链接结束后 m=0
        3.初始化
            <clinit>(){
                System.out.println("A类静态代码块初始化");
                m = 300;
                m = 100;
            }
            m = 100;

            输出：
                A类静态代码块初始化
                A类的无参构造初始化
                100
     */

    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类的无参构造初始化");
    }
}

类何时初始化

package com.zy.reflection;

/**
 *description: Java--注解与反射--类何时会初始化
 *@program: 基础语法
 *@author: zy
 *@create: 2023-03-30 22:25
 */
public class Study04 {

    static {
        System.out.println("Study04类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        // 1.new 产生主动引用
        //Son son = new Son();

        // 2.反射 产生主动引用
        //Class.forName("com.zy.reflection.Son");

        /*
         不会产生类的引用的方法：
            1.子类调用父类的静态域或静态属性
            2.通过数组定义类引用
            3.引用常量
         */
        //System.out.println(Son.b);
        //Son[] sons = new Son[10];
        System.out.println(Son.M);

    }
}

class Father{

    static int b = 200;

    static {
        System.out.println("Father类被加载");
    }
}

class Son extends Father{
    static {
        System.out.println("Son类被加载");
        m = 300;
    }

    static int m = 100;
    static final int M = 1;
}