Code code1 = new Code();

Class c = new Class();

private  Class(ClassLoader loader) { 
    classLoader = loader; 
}

Class c1 = Code.class; 這說明任何一個類都有一個隱含的靜態成員變量class，這種方式是通過獲取類的靜態成員變量class得到的
Class c2 = code1.getClass(); code1是Code的一個對象，這種方式是通過一個類的對象的getClass()方法獲得的 
Class c3 = Class.forName("com.trigl.reflect.Code"); 這種方法是Class類調用forName方法，通過一個類的全量限定名獲得

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        //第一種：Class c1 = Code.class;
        Class class1=ReflectDemo.class;
        System.out.println(class1.getName());

        //第二種：Class c2 = code1.getClass();
        ReflectDemo demo2= new ReflectDemo();
        Class c2 = demo2.getClass();
        System.out.println(c2.getName());

        //第三種：Class c3 = Class.forName("com.trigl.reflect.Code");
        Class class3 = Class.forName("com.tengj.reflect.ReflectDemo");
        System.out.println(class3.getName());
    }
}

com.tengj.reflect.ReflectDemo
com.tengj.reflect.ReflectDemo
com.tengj.reflect.ReflectDemo

public Method getDeclaredMethod(String name, Class<?>... parameterTypes) // 得到該類所有的方法，不包括父類的 
public Method getMethod(String name, Class<?>... parameterTypes) // 得到該類所有的public方法，包括父類的

//具體使用
Method[] methods = class1.getDeclaredMethods();//獲取class對象的所有聲明方法 
Method[] allMethods = class1.getMethods();//獲取class對象的所有public方法 包括父類的方法 
Method method = class1.getMethod("info", String.class);//返回次Class對象對應類的、帶指定形參列表的public方法 
Method declaredMethod = class1.getDeclaredMethod("info", String.class);//返回次Class對象對應類的、帶指定形參列表的方法

public void fun(String name,int age) {
        System.out.println("我叫"+name+",今年"+age+"歲");
    }

Class c = Class.forName("com.tengj.reflect.Person");  //先生成class
Object o = c.newInstance();                           //newInstance可以初始化一個實例
Method method = c.getMethod("fun", String.class, int.class);//獲取方法
method.invoke(o, "tengj", 10);                         //通過invoke調用該方法，參數第一個為實例對象，后面為具體參數值

public class Person {
    private String name;
    private int age;
    private String msg="hello wrold";
 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;
  }

    public Person() {
    }

    private Person(String name) {
        this.name = name;
  System.out.println(name);
  }

    public void fun() {
        System.out.println("fun");
  }

    public void fun(String name,int age) {
        System.out.println("我叫"+name+",今年"+age+"歲");
  }
}

public class ReflectDemo {
    public static void main(String[] args){
        try {
            Class c = Class.forName("com.tengj.reflect.Person");
            Object o = c.newInstance();
            Method method = c.getMethod("fun", String.class, int.class);
            method.invoke(o, "tengj", 10);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Class c = Class.forName("com.tengj.reflect.Person");
Method[] methods = c.getDeclaredMethods(); // 得到該類所有的方法，不包括父類的
或者：
Method[] methods = c.getMethods();// 得到該類所有的public方法，包括父類的

for (Method method : methods)

public class ReflectDemo {
    public static void main(String[] args){
        try {
            Class c = Class.forName("com.tengj.reflect.Person");
            Method[] methods = c.getDeclaredMethods();
            for(Method m:methods){
                String  methodName= m.getName();
                System.out.println(methodName);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public Field getDeclaredField(String name) // 獲得該類自身聲明的所有變量，不包括其父類的變量
public Field getField(String name) // 獲得該類自所有的public成員變量，包括其父類變量

//具體實現
Field[] allFields = class1.getDeclaredFields();//獲取class對象的所有屬性 
Field[] publicFields = class1.getFields();//獲取class對象的public屬性 
Field ageField = class1.getDeclaredField("age");//獲取class指定屬性 
Field desField = class1.getField("des");//獲取class指定的public屬性

private int n;

Class c = a.getClass();
Field field = c.getDeclaredField("n");

public class ReflectDemo {
    public static void main(String[] args){
        try {
            Class c = Class.forName("com.tengj.reflect.Person");
            //獲取成員變量
            Field field = c.getDeclaredField("msg"); //因為msg變量是private的，所以不能用getField方法
            Object o = c.newInstance();
            field.setAccessible(true);//設置是否允許訪問，因為該變量是private的，所以要手動設置允許訪問，如果msg是public的就不需要這行了。
            Object msg = field.get(o);
            System.out.println(msg);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Field[] fields = c.getDeclaredFields();

for (Field field : fields)

public class ReflectDemo {
    public static void main(String[] args){
        try {
            Class c = Class.forName("com.tengj.reflect.Person");
            Field[] fields = c.getDeclaredFields();
            for(Field field :fields){
                System.out.println(field.getName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) //  獲得該類所有的構造器，不包括其父類的構造器
public Constructor<T> getConstructor(Class<?>... parameterTypes) // 獲得該類所以public構造器，包括父類

//具體
Constructor<?>[] allConstructors = class1.getDeclaredConstructors();//獲取class對象的所有聲明構造函數 
Constructor<?>[] publicConstructors = class1.getConstructors();//獲取class對象public構造函數 
Constructor<?> constructor = class1.getDeclaredConstructor(String.class);//獲取指定聲明構造函數 
Constructor publicConstructor = class1.getConstructor(String.class);//獲取指定聲明的public構造函數

public A(String a, int b) {
    // code body
}

Constructor constructor = a.getDeclaredConstructor(String.class, int.class);

public class ReflectDemo {
    public static void main(String[] args){
        try {
            Class c = Class.forName("com.tengj.reflect.Person");
            //獲取構造函數
            Constructor constructor = c.getDeclaredConstructor(String.class);
            constructor.setAccessible(true);//設置是否允許訪問，因為該構造器是private的，所以要手動設置允許訪問，如果構造器是public的就不需要這行了。
            constructor.newInstance("tengj");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

fromClass.getDeclaredConstructor(String.class).newInstance("tengj");

Constructor[] constructors = c.getDeclaredConstructors();

for (Constructor constructor : constructors)

public class ReflectDemo {
    public static void main(String[] args){
            Constructor[] constructors = c.getDeclaredConstructors();
            for(Constructor constructor:constructors){
                System.out.println(constructor);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Annotation[] annotations = (Annotation[]) class1.getAnnotations();//獲取class對象的所有注解 
Annotation annotation = (Annotation) class1.getAnnotation(Deprecated.class);//獲取class對象指定注解 
Type genericSuperclass = class1.getGenericSuperclass();//獲取class對象的直接超類的 
Type Type[] interfaceTypes = class1.getGenericInterfaces();//獲取class對象的所有接口的type集合

boolean isPrimitive = class1.isPrimitive();//判斷是否是基礎類型 
boolean isArray = class1.isArray();//判斷是否是集合類
 boolean isAnnotation = class1.isAnnotation();//判斷是否是注解類 
boolean isInterface = class1.isInterface();//判斷是否是接口類 
boolean isEnum = class1.isEnum();//判斷是否是枚舉類 
boolean isAnonymousClass = class1.isAnonymousClass();//判斷是否是匿名內部類 
boolean isAnnotationPresent = class1.isAnnotationPresent(Deprecated.class);//判斷是否被某個注解類修飾 
String className = class1.getName();//獲取class名字 包含包名路徑 
Package aPackage = class1.getPackage();//獲取class的包信息 
String simpleName = class1.getSimpleName();//獲取class類名 
int modifiers = class1.getModifiers();//獲取class訪問權限 
Class<?>[] declaredClasses = class1.getDeclaredClasses();//內部類 
Class<?> declaringClass = class1.getDeclaringClass();//外部類

getSuperclass()：獲取某類的父類  
getInterfaces()：獲取某類實現的接口

/**
 * 集合泛型的本質
 */
public class GenericEssence {
    public static void main(String[] args) {
        List list1 = new ArrayList(); // 沒有泛型 
        List<String> list2 = new ArrayList<String>(); // 有泛型


        /*
         * 1.首先觀察正常添加元素方式，在編譯器檢查泛型，
         * 這個時候如果list2添加int類型會報錯
         */
        list2.add("hello");
//      list2.add(20); // 報錯！list2有泛型限制，只能添加String，添加int報錯
        System.out.println("list2的長度是：" + list2.size()); // 此時list2長度為1


        /*
         * 2.然后通過反射添加元素方式，在運行期動態加載類，首先得到list1和list2
         * 的類類型相同，然后再通過方法反射繞過編譯器來調用add方法，看能否插入int
         * 型的元素
         */
        Class c1 = list1.getClass();
        Class c2 = list2.getClass();
        System.out.println(c1 == c2); // 結果：true，說明類類型完全相同

        // 驗證：我們可以通過方法的反射來給list2添加元素，這樣可以繞過編譯檢查
        try {
            Method m = c2.getMethod("add", Object.class); // 通過方法反射得到add方法
            m.invoke(list2, 20); // 給list2添加一個int型的，上面顯示在編譯器是會報錯的
            System.out.println("list2的長度是：" + list2.size()); // 結果：2，說明list2長度增加了，并沒有泛型檢查
        } catch (Exception e) {
            e.printStackTrace();
        }

        /*
         * 綜上可以看出，在編譯器的時候，泛型會限制集合內元素類型保持一致，但是編譯器結束進入
         * 運行期以后，泛型就不再起作用了，即使是不同類型的元素也可以插入集合。
         */
    }
}

@Override
void myMethod() { 
......
}

@Target({ElementType.METHOD})
public @interface MyCustomAnnotation {

}

//使用
public class MyClass {
   @MyCustomAnnotation
   public void myMethod()
   {
    ......
   }
}

/***
 * 字段注解接口
 */
@Target(value = {ElementType.FIELD})//注解可以被添加在屬性上
@Retention(value = RetentionPolicy.RUNTIME)//注解保存在JVM運行時刻,能夠在運行時刻通過反射API來獲取到注解的信息
public @interface Column {
    String name();//注解的name屬性
}

java.lang.annotation.Documented
@Documented
public @interface MyCustomAnnotation { //Annotation body}

java.lang.annotation.Inherited
@Inherited
public @interface MyCustomAnnotation {
}

@MyCustomAnnotation
public class MyParentClass { 
  ... 
}

public class MyChildClass extends MyParentClass { 
   ... 
}

public @interface 注解名{
  定義體
}

/**
 * test注解
 * @author ddk
 *
 */ 
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TestAnnotation {
    /**
     * id
     * @return
     */
    public int id() default -1;
    /**
     * name
     * @return
     */
    public String name() default "";
}

/***********注解聲明***************/

/**
 * 水果名稱注解
 * @author peida
 *
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FruitName {
    String value() default "";
}

/**
 * 水果顏色注解
 * @author peida
 *
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FruitColor {
    /**
     * 顏色枚舉
     * @author peida
     *
     */
    public enum Color{ BULE,RED,GREEN};
    
    /**
     * 顏色屬性
     * @return
     */
    Color fruitColor() default Color.GREEN;

}

/**
 * 水果供應者注解
 * @author peida
 *
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FruitProvider {
    /**
     * 供應商編號
     * @return
     */
    public int id() default -1;
    
    /**
     * 供應商名稱
     * @return
     */
    public String name() default "";
    
    /**
     * 供應商地址
     * @return
     */
    public String address() default "";
}

/***********注解使用***************/

public class Apple {
    
    @FruitName("Apple")
    private String appleName;
    
    @FruitColor(fruitColor=Color.RED)
    private String appleColor;
    
    @FruitProvider(id=1,name="陜西紅富士集團",address="陜西省西安市延安路89號紅富士大廈")
    private String appleProvider;
    
    public void setAppleColor(String appleColor) {
        this.appleColor = appleColor;
    }
    public String getAppleColor() {
        return appleColor;
    }
    
    public void setAppleName(String appleName) {
        this.appleName = appleName;
    }
    public String getAppleName() {
        return appleName;
    }
    
    public void setAppleProvider(String appleProvider) {
        this.appleProvider = appleProvider;
    }
    public String getAppleProvider() {
        return appleProvider;
    }
    
    public void displayName(){
        System.out.println("水果的名字是：蘋果");
    }
}

/***********注解處理器***************/
//其實是用的反射


public class FruitInfoUtil {
    public static void getFruitInfo(Class<?> clazz){
        
        String strFruitName=" 水果名稱：";
        String strFruitColor=" 水果顏色：";
        String strFruitProvicer="供應商信息：";
        
        Field[] fields = clazz.getDeclaredFields();
        
        for(Field field :fields){
            if(field.isAnnotationPresent(FruitName.class)){
                FruitName fruitName = (FruitName) field.getAnnotation(FruitName.class);
                strFruitName=strFruitName+fruitName.value();
                System.out.println(strFruitName);
            }
            else if(field.isAnnotationPresent(FruitColor.class)){
                FruitColor fruitColor= (FruitColor) field.getAnnotation(FruitColor.class);
                strFruitColor=strFruitColor+fruitColor.fruitColor().toString();
                System.out.println(strFruitColor);
            }
            else if(field.isAnnotationPresent(FruitProvider.class)){
                FruitProvider fruitProvider= (FruitProvider) field.getAnnotation(FruitProvider.class);
                strFruitProvicer=" 供應商編號："+fruitProvider.id()+" 供應商名稱："+fruitProvider.name()+" 供應商地址："+fruitProvider.address();
                System.out.println(strFruitProvicer);
            }
        }
    }
}

/***********輸出結果***************/
public class FruitRun {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        FruitInfoUtil.getFruitInfo(Apple.class);
        
    }

}

====================================
 水果名稱：Apple
 水果顏色：RED
 供應商編號：1 供應商名稱：陜西紅富士集團 供應商地址：陜西省西安市延安路89號紅富士大廈

 //初始化對象時
String myString = new @NotNull String();
//對象類型轉化時
myString = (@NonNull String) str;
//使用 implements 表達式時
class MyList<T> implements @ReadOnly List<@ReadOnly T>{
...
}
//使用 throws 表達式時
public void validateValues() throws @Critical ValidationFailedException{
...
}