/**
 * 該注解標(biāo)識(shí)覆蓋的是其父類(lèi)的方法，當(dāng)子類(lèi)重寫(xiě)父類(lèi)方法時(shí)，確保子類(lèi)確實(shí)重寫(xiě)了父類(lèi)的方法，避免出現(xiàn)低級(jí)錯(cuò)誤
 * @return
 */
@Override
public String toString() {
    return super.toString();
}

/**
 * 該注解表示此方法已過(guò)時(shí)，存在危險(xiǎn)，不推薦使用，其有代替方法，如果繼續(xù)使用會(huì)通過(guò)刪除線進(jìn)行標(biāo)識(shí)
 */
@Deprecated
public static void test() {
    System.out.println("標(biāo)記已過(guò)時(shí)");
}

@SuppressWarnings("取消此類(lèi)的所有警告")
public class BuiltAnnotation {
    
    @SuppressWarnings("取消此屬性的警告")
    private String username;

    @SuppressWarnings("取消此方法的警告")
    public static void main(String[] args) {
        // ...
    }
}

/**
 * @Target注解：描述注解的使用范圍
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    /**
     * 類(lèi)或接口：ElementType.TYPE；
     * 字段：ElementType.FIELD；
     * 方法：ElementType.METHOD；
     * 構(gòu)造方法：ElementType.CONSTRUCTOR；
     * 方法參數(shù)：ElementType.PARAMETER；
     * ...
     */
    ElementType[] value();
}

/**
 * @Retention：表示需要在什么級(jí)別保存該注解信息，用于描述注解的生命周期
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
    /**
     * RetentionPolicy.SOURCE：僅編譯期，注解將被編譯器丟棄。
     * RetentionPolicy.CLASS：僅class文件，注釋將由編譯器記錄在類(lèi)文件中，但VM不需要在運(yùn)行時(shí)保留，如果不指定則默認(rèn)為class。
     * RetentionPolicy.RUNTIME：運(yùn)行期，注釋將由編譯器記錄在類(lèi)文件中，并由VM在運(yùn)行時(shí)保留，因此可以反射讀取。通常自定義的注解都是RUNTIME。
     * 范圍：RUNTIME>CLASS>SOURCE
     */
    RetentionPolicy value();
}

/**
 * 1. 使用@interface定義注解；
 * 3. 通過(guò)元注解配置該注解，配置注解的使用范圍和生命周期等
 * @author Loner
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Report{
    /**
     * 2. 添加參數(shù)、默認(rèn)值，如果沒(méi)有默認(rèn)值，就必須給參數(shù)賦值，一般把最常用的參數(shù)定義為value()，推薦所有參數(shù)都盡量設(shè)置默認(rèn)值
     * 形式為：參數(shù)類(lèi)型 參數(shù)名()；
     */
    int type() default 0;
    String value() default "LonerMJ";
}

@Report(type = 1, value = "test")
public class CustomerAnnotation {
    @Report(type = 1, value = "test")
    public void testCustomerAnnotation() {
        System.out.println("測(cè)試自定義注解");
    }
}

public class InstantiationClass {
    public static void main(String[] args) throws ClassNotFoundException {
        Teacher teacher = new Teacher("張三", "123456");

        // 方式一：調(diào)用Class類(lèi)的靜態(tài)方法forName(String className)
        Class<?> c1 = Class.forName("com.loner.mj.reflection.Teacher");

        // 方式二：已知某個(gè)類(lèi)的實(shí)例，調(diào)用該實(shí)例的getClass()方法，getClass是Object類(lèi)中的方法。
        Class<? extends Teacher> c2 = teacher.getClass();

        // 方式三：已知具體類(lèi)，通過(guò)類(lèi)的class屬性獲取，該方法最安全可靠，程序性能最高
        Class<Teacher> c3 = Teacher.class;

        // 方式四：通過(guò)基本內(nèi)置類(lèi)型的包裝類(lèi)的TYPE屬性獲得CLass實(shí)例
        Class<Integer> c4 = Integer.TYPE;

        // 方式五：通過(guò)當(dāng)前子類(lèi)的Class對(duì)象獲得父類(lèi)的Class對(duì)象
        Class<?> c5 = c1.getSuperclass();
    }
}

public class ReflectionMethods {
    public static void main(String[] args) throws NoSuchFieldException, NoSuchMethodException {
        Class<Worker> workerClass = Worker.class;

        /**
         * 類(lèi)
         */
        System.out.println(workerClass.getName());
        System.out.println(workerClass.getSimpleName());
        System.out.println(workerClass.getSuperclass());
        System.out.println(workerClass.getPackage());
        Class<?>[] interfaces = workerClass.getInterfaces();
        for (Class<?> i : interfaces) {
            System.out.println(i);
        }

        /**
         * 屬性
         */
        // 獲取所有的屬性
        Field[] declaredFields = workerClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        // 獲取指定屬性
        System.out.println(workerClass.getDeclaredField("username"));
        // 獲取所有公共屬性
        Field[] fields = workerClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        /**
         * 構(gòu)造方法
         */
        // 獲取所有構(gòu)造方法
        Constructor<?>[] declaredConstructors = workerClass.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }
        // 獲取指定的構(gòu)造方法
        System.out.println(workerClass.getDeclaredConstructor(String.class, String.class));

        /**
         * 方法
         */
        // 獲取所有的方法
        Method[] declaredMethods = workerClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
        // 獲取指定方法
        System.out.println(workerClass.getDeclaredMethod("getUsername", null));
        // 獲取所有功能方法
        Method[] methods = workerClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
    }
}

public class InstantiationClass {
    public static void main(String[] args) throws ClassNotFoundException {
        // 類(lèi)（外部類(lèi)，成員（成員內(nèi)部類(lèi)，靜態(tài)內(nèi)部類(lèi)），局部?jī)?nèi)部類(lèi)，匿名內(nèi)部類(lèi)。）
        Class<Object> objectClass = Object.class;
        // 接口
        Class<Comparable> comparableClass = Comparable.class;
        // 數(shù)組
        Class<String[]> stringClass = String[].class;
        Class<int[][]> intClass = int[][].class;
        // 枚舉
        Class<ElementType> elementTypeClass = ElementType.class;
        // 注解
        Class<Override> overrideClass = Override.class;
        // 基本數(shù)據(jù)類(lèi)型
        Class<Integer> integerClass = Integer.class;
        // void
        Class<Void> voidClass = void.class;
        // Class
        Class<Class> classClass = Class.class;
    }
}

public class UseClass {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        Class<User> userClass = User.class;

        /**
         * 通過(guò)構(gòu)造器實(shí)例化對(duì)象：不使用構(gòu)造器，默認(rèn)通過(guò)無(wú)參構(gòu)造進(jìn)行對(duì)象創(chuàng)建
         */
        Constructor<User> declaredConstructor = userClass.getDeclaredConstructor(String.class, String.class);
        User user = declaredConstructor.newInstance("張三", "123456");
        System.out.println(user);

        /**
         * 調(diào)用方法并執(zhí)行相關(guān)操作
         */
        Method setUsername = userClass.getDeclaredMethod("setUsername", String.class);
        // invoke(Object, 參數(shù))：激活，即執(zhí)行相關(guān)操作為該對(duì)象
        setUsername.invoke(user, "李四");
        Method setPassword = userClass.getDeclaredMethod("setPassword", String.class);
        setPassword.invoke(user, "123456");
        System.out.println(user);

        /**
         * 操作屬性：通過(guò)反射直接操作私有屬性會(huì)報(bào)錯(cuò)，需要通過(guò)setAccessible(ture)關(guān)閉訪問(wèn)安全檢查，此方法屬性、方法和構(gòu)造都具有，會(huì)影響效率
         */
        Field username = userClass.getDeclaredField("username");
        username.setAccessible(true);
        username.set(user, "用戶名");
        System.out.println(user);
    }
}

public class ClassOperateGenerics {
    public Map<String, String> list() {
        System.out.println("返回值是泛型");
        return new HashMap<>();
    }

    public void test(Map<String, User> map, List<Integer> list) {
        System.out.println("參數(shù)是泛型");
    }

    public static void main(String[] args) throws NoSuchMethodException {
        /**
         * 獲取方法參數(shù)的泛型
         */
        Method method = ClassOperateGenerics.class.getMethod("test", Map.class, List.class);
        // 獲取所有方法參數(shù)的泛型
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            // java.util.Map<java.lang.String, com.loner.mj.reflection.User>
            System.out.println(genericParameterType);
            if (genericParameterType instanceof ParameterizedType) {
                // 獲取所有泛型的真實(shí)參數(shù)
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    // String, User, Integer
                    System.out.println(actualTypeArgument);
                }
            }
        }

        /**
         * 獲取方法返回值的泛型
         */
        Method list = ClassOperateGenerics.class.getMethod("list", null);
        // 獲取方法返回值的泛型
        Type genericReturnType = list.getGenericReturnType();
        if (genericReturnType instanceof ParameterizedType) {
            // 獲取所有泛型的真實(shí)參數(shù)
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
}

public class ClassOperateAnnotation {
    public static void main(String[] args) throws NoSuchFieldException {
        Class<People> peopleClass = People.class;

        // 獲取類(lèi)的所有注解
        Annotation[] declaredAnnotations = peopleClass.getDeclaredAnnotations();
        for (Annotation declaredAnnotation : declaredAnnotations) {
            System.out.println(declaredAnnotation);
        }
        // 獲取類(lèi)的注解的值
        Table declaredAnnotation = peopleClass.getDeclaredAnnotation(Table.class);
        System.out.println(declaredAnnotation.value());

        // 獲取屬性的注解
        Field name = peopleClass.getDeclaredField("name");
        Fields annotation = name.getAnnotation(Fields.class);
        System.out.println(annotation.name());
    }
}