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

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  
 

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
Java反射與註解
     
 
							
							
							JAVA反射
主要是指程式可以訪問，檢測和修改它本身狀態或行為的一種能力，並能根據自身行為的狀態和結果，調整或修改應用所描述行為的狀態和相關的語義。

反射機制是什麼
面試有可能會問到，這句話不管你能不能理解，但是你只要記住就可以了

反射機制就是在執行狀態中， 

  
 

    

    
    
Java 基礎-反射與註解
     
 
								
								            
							
							
							一、Class

1. Class 型別的獲取


Clazz.class;
clazz.getClass();
Class.forName(String className);




2. 根據 C 

  
 

    

    
    
java反射與動態代理的理解
     
 system   對象的訪問   讓我   integer   打破   類屬性   全部   列表   ces   一、什麽是反射機制？
　　反射的官方定義是這樣的：在運行狀態中，對於任意的一個類，都能夠知道這個類的所有屬性和方法，對任意一個對象都能夠通過反射機制調用一個類的任意方法，這種動態獲取類信息及動 

  
 

    

    
    
JAVA反射_註解
     
  
 
 概念及作用
 
 
 Java註解，從名字上看是註釋，解釋。但功能卻不僅僅是註釋那麼簡單。註解(Annotation)即元資料,就是原始碼的元資料註解(Annotation)為我們在程式碼中新增資訊提供了一種形式化的方法，使我們可以在稍後某個時刻方便地使用這些資料（通過解析註解來使用這些資料）.
  

  
 

    

    
    
JAVA反射 與 Android藍芽反射
     
  
 
 
 　　要想理解反射的原理，首先要了解什麼是型別資訊。Java讓我們在執行時識別物件和類的資訊，主要有2種方式：一種是傳統的RTTI，它假定我們在編譯時已經知道了所有的型別資訊；另一種是反射機制，它允許我們在執行時發現和使用類的資訊。 
 1、Class物件 
 　　理解RTTI在Java中的工作原 

  
 

    

    
    
Spring實戰-第一次內作業-Java反射和註解
     
 
							
							
							第一次內作業

詳細理解Java反射機制

反射是什麼

反射的作用用一句簡單的話來講就是可以對程式碼進行操作的程式碼，這個特性經常在被用於建立JavaBean中，通常造輪子的人會用到這個特性，而應用程式設計師用到這個特性的場景則較少。

能夠分析類能力的程式就 

  
 

    

    
    
【知了堂學習筆記】JAVA反射及註解--輕鬆學會註解
     
 
							
							
							Java註解在程式開發中廣泛被使用,註解的使用更加的規範了程式，一般註解有兩個用法：
1.對程式本身做解釋
2.被其他程式讀取
註解比較常見的有如下幾種：
內建註解：

@Override–>表示方法重寫。
如圖該方法父類沒有，不是重寫，所以程式碼會報錯！ 

  
 

    

    
    
Java反射與簡單Java類
     
 
                設計思路如下：所有的操作是通過TestDemo類呼叫EmpActiob類的主要作用是在於定位要操作的屬性型別，同時該程式符合所有簡單的Java類開發形式，所以用一個單獨的類(BeanOperation)實現此適配。如：Emp類設計：package vo;

public cl 

  
 

    

    
    
Java反射和註解一些總結
     
 
							
							
							Java 反射和註解的一些總結



反射



// There are five kinds of classes (or interfaces):
// a) Top level classes
// b) Nested classes (static m 

  
 

    

    
    
java反射與函式回撥(一)
     
 
                
一、java的反射
  反射的概念是由Smith在1982年首次提出的，主要是指程式可以訪問、檢測和修改它本身狀態或行為的一種能力。java語言在執行時擁有一項自觀的能力。

   java反射機制是在執行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法;對於任意一 

  
 

    

    
    
java反射和註解
     
 
							
							
							ReflectionAndAnnotation

本文講解java的 Reflect、Annotation 反射 和 註解的使用 
文中的測試程式碼請前往 ReflectAndAnnotation

反射





本文主要從應用的角度講解反射。

先寫一個Be 

  
 

    

    
    
java反射與xml檔案解析
     
 
                
    在專案開發的過程中，遇到了要將日誌匯出為xml格式和將xml匯入到日誌資料庫中的功能需求，因為專案中存在多種日誌形式（這聽起來很奇葩是不是？），我實在懶得為每一種日誌都寫一個方法。想到在開始的設計過程中，將每種的日誌都對映為一個pojo，故想到了java的反射機制， 

  
 

    

    
    
java反射與泛型
     
 
                
黑馬程式設計師_反射和泛型---------------------- <a href="http://edu.csdn.net/heima" target="blank">android培訓</a>、<a href="http://edu.c 

  
 

    

    
    
Java 反射與單級VO操作
     
 
							
							
							反射與單級VO操作 
先看一個基本程式



package www.bit.java.vo;
class Emp{
    private String ename ;
    private String job ;
    public String ge 

  
 

    

    
    
反射與註解
     
 
							
							
							註解其實是對類、方法、屬性這些位元組碼的進一步修飾 
通過註解，可以輕鬆地對這些位元組碼作進一步擴充套件，而不需要修改原有的內容

而反射可以獲取到這些註解，那麼就可以對執行時的例項物件做進一步處理 
註解和反射形成配合，將位元組碼的一部分共性抽離出來，通用地處 

  
 

    

    
    
Android開發之反射與註解
     
 
                

反射

類型別Class的使用

類型別Class的例項獲取方式有一下三種







1

2

3

4

5

6

7

8

9

10

11

12

13

14

15 

  
 

    

    
    
Java 反射與類載入
     
 
							
							
							一 Class物件

一個類中有屬性，方法，構造器等，一個Class物件包含了某個特定類的相關資訊，class是描述類的類。

獲取Class物件的三種方式： 
1.通過類名獲取      類名.class 
2.通過物件獲取      物件名.getClass 

  
 

    

    
    
java反射與CGLIB代理的一個細節。
     
 
                需求：一個類被CGLIB代理，並且，這個類要通過反射執行自己的函式。（應用層通過spring動態注入controller，並且，通過抽象父類來負責反射子類的具體跳轉函式。）
這個時候會遇到一個問題。在類自己反射自己的過程中，this返回的並不是CGLIB的代理類，所以要做一個 

  
 

    

    
    
java反射+註解實現Entity類與Dto類相互轉換
     
  序言 
　　近期在工作中管理程式碼時發現，在專案中從Dao層到Service層資料傳遞中通過大量的get(),set()方法去一個一個的去拿值去賦值，導致程式碼篇幅過長，對此甚是討厭，並且嚴重消耗開發時間。起初找過些關於這塊的資料，現在大部分都是Entity類和Dto類的屬性名相同的前提下，利用反 

  
 

    

    
    
JAVA 與 MyCat（5） 類的載入 Java內省/反射機制 註解Annotation 詳解
     
 
                

通過mycat來學習java了^^。





上一篇瞭解了XML解析的四種方式，並對MyCat的原始碼進行了修改，這一篇接著往下看：

dtd = XMLRuleLoader.class.getResourceAsStream(dtdFile);
x