Class類的使用

1. Java中，靜態(tài)成員协饲、普通數(shù)據(jù)類型不是對象备蚓，靜態(tài)成員是屬于類的，而不是屬于某個(gè)對象的

2. 類是對象囱稽，類是java.lang.Class類的實(shí)例對象

   public class ClassDemo{
   public static void main(String[] args){
   //Foo的實(shí)例對象
   Foo foo1 = new Foo();
   //Foo這個(gè)類 本身也是一個(gè)實(shí)例對象 它是Class類的實(shí)例對象
   //任何一個(gè)類都是Class類的實(shí)例對象，這個(gè)實(shí)例對象有三種表示方式
   //第一種-->實(shí)際告訴我們?nèi)魏我粋€(gè)類都有一個(gè)隱含的靜態(tài)成員變量class
   Class c1 = Foo.class;

      //第二種-->通過該類的對象的getClass()方法得到
      Class c2 = foo1.getClass();
      
      //c1,c2表示了Foo類的類類型(class type)
      //一個(gè)類只可能是Class類的一個(gè)實(shí)例對象
      
      //第三種
      Class c3 = null;
      try{
          c3 = Class.forName("xxx.Foo");
      }catch(ClassNotFoundException e){
          e.printStackTrace();
      }
      //c1 = c2 = c3
      
      //通過該類的類類型創(chuàng)建該類的對象實(shí)例
      Foo foo = (Foo)c1.newInstance();//需要有無參數(shù)的構(gòu)造方法
    }
   

   }
   class Foo{}

3. 所有的數(shù)據(jù)類型（int, String, Integer）以及void都有自己的類類型二跋，通過int.class可以得到相應(yīng)的類類型

Java動態(tài)加載類

編譯時(shí)加載類時(shí)靜態(tài)加載類战惊，運(yùn)行時(shí)加載類時(shí)動態(tài)加載類，可以通過Class.forName()動態(tài)加載類

下面是一個(gè)靜態(tài)加載類的例子：

Class Test{
  public static void main(String[] args){
    if("A".equals(args[0])){
        A a = new A();
        a.start();
    }
    if("B".equals(args[0])){
        B b = new B();
        b.start();
    }
}
}

Class A{
    public static void start(){
        System.out.println("A start");
    }
}

結(jié)果是編譯出錯(cuò)扎即。

new 創(chuàng)建對象是靜態(tài)加載類吞获，在編譯時(shí)刻就加載所有可能用到的類，就算我們寫了A類谚鄙，但是因?yàn)闆]有B類各拷，編譯時(shí)還是不會通過。如果我們想使用更多的類闷营，我們就要在一開始把所有類寫好烤黍，當(dāng)以后想要擴(kuò)展時(shí)，就要重新編譯傻盟！

下面通過Class.forName()動態(tài)加載類

class Test1{
    public static void main(String[] args){
        Class c1 = null;
        try{
            c1 = Class.forName(args[0]);
        }catch(ClassNotFoundException e){
          e.printStackTrace();
      } 
    }
}

這樣 編譯就不會報(bào)錯(cuò)速蕊，在我們使用的時(shí)候，傳入想要運(yùn)行的類名稱即可娘赴。

接下來我們可以通過上面提到的newInstance()方法來創(chuàng)建對象规哲，并通過強(qiáng)制類型轉(zhuǎn)換編程我們想要用的對象。但是這里有一個(gè)問題诽表，就是我們不知道我們傳入的究竟是A類還是B類唉锌，所以在做強(qiáng)制類型轉(zhuǎn)換的時(shí)候并不知道要轉(zhuǎn)換成什么，解決辦法就是為他們創(chuàng)建一個(gè)接口竿奏，實(shí)現(xiàn)其共有的方法

MyChar myChar = (MyChar)c1.newInstance();
myChar.start();

其中

interface MyChar(){
    public void start();
}

這時(shí)我們只需要用A類實(shí)現(xiàn)該接口即可

class A implements MyChar{
    public void start(){
        System.out.println("A start");
    }
}

編譯通過袄简，我們不需要用B類即可，當(dāng)我們想用B類的時(shí)候议双，只需要用B類實(shí)現(xiàn)該接口即可痘番。如果我們想使用更多的類，只需要實(shí)現(xiàn)該接口即可，不需要每次都重新編譯汞舱。因此伍纫，在設(shè)計(jì)程序時(shí)，可以盡可能的考慮動態(tài)加載類

獲取類的信息

1.獲取方法信息

//首先要得到該類的類類型
Class c = foo1.getClass();
//獲取類的名稱
String name = c.getName();
//獲取類的方法
Methods[] ms = c.getMethods();//萬事萬物皆對象昂芜，每一個(gè)方法都是Method的對象
//getMethods()得到的是所有public函數(shù)莹规，包括從父類繼承來的
//getDeclaredMethods()得到的是該類自己聲明的方法，不論訪問權(quán)限

//獲取方法的信息
for(int i = 0; i<ms.length;i++){
    //得到方法的返回值的類類型泌神，如int.class, String.class
    Class returnType = ms[i].getReturnType();//returnType.getName()即得到返回值的名稱
    //得到方法的名稱
    String methodName = ms[i].getName();
    //獲取參數(shù)類型：得到的是參數(shù)列表的類類型
    Class[] paramTypes = ms[i].getParameterTypes();//遍歷通過getName()即可得到參數(shù)類型名稱
}

下面是獲取某個(gè)具體方法

Method method = XXX.getClass().getMethod(methodName,new Class[0]);
//getMethod第一個(gè)參數(shù)是方法名良漱，第二個(gè)參數(shù)是該方法的參數(shù)類型,按傳入順序，
//因?yàn)榇嬖谕椒煌瑓?shù)這種情況欢际，所以只有同時(shí)指定方法名和參數(shù)類型才能唯一確定一個(gè)方法
//沒有參數(shù)傳入null母市，獲取不傳
//如一個(gè)函數(shù) int test(int a, String b);
//getMethod("Test",int.class,String.class);

得到的是一個(gè)方法對象，通過調(diào)用invoke()函數(shù)來調(diào)用此方法

//函數(shù)原型：Object Java.lang.reflect.Method.invoke(Object receiver, Object... args)

//Method類的invoke(Object obj,Object args[])方法接收的參數(shù)必須為對象损趋，
 //如果參數(shù)為基本類型數(shù)據(jù)患久，必須轉(zhuǎn)換為相應(yīng)的包裝類型的對象。invoke()方法的返回值總是對象浑槽，
  //如果實(shí)際被調(diào)用的方法的返回類型是基本類型數(shù)據(jù)蒋失，那么invoke()方法會把它轉(zhuǎn)換為相應(yīng)的包裝類型的對象，再將其返回

//receiver：該方法所在類的一個(gè)對象
//args： 傳入的參數(shù) 如 100桐玻，“hello”篙挽，沒有就不傳
//下面是一個(gè)完整例子
class Foo{
    public void run(String str) {
        System.out.println("Foo run " + str);
    }
}
public class Demo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Foo foo1 = new Foo();
        Class<? extends Foo> c1 = foo1.getClass();
        System.out.println(c1.getName());
        try {
            Method method = c1.getMethod("run", String.class);
            method.invoke(foo1, "test reflect");
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

運(yùn)行結(jié)果：

study_refect.Foo
Foo run test reflect

2.獲取成員變量的信息

成員變量也是對象，是java.lang.reflect.Field的對象

Field[] fs = c.getFields();//獲取的是public成員變量信息
//getDeclaredFields()獲取的是該類所有成員變量
for(Field field:fs){
    //得到成員變量的類類型
    Class fieldType = field.getType();
    String typeName = fieldType.getName();
    //得到成員變量的名稱
    String fieldName = field.getName();
}

3.獲取構(gòu)造函數(shù)的信息

構(gòu)造函數(shù)也是對象镊靴，是java.lang.Constructor的對象,獲取方法這里不再贅述

通過反射理解泛型的本質(zhì)（類型擦除）

Java中的泛型是通過類型擦除來實(shí)現(xiàn)的铣卡。所謂類型擦除，是指通過類型參數(shù)合并邑闲，將泛型類型實(shí)例關(guān)聯(lián)到同一份字節(jié)碼上算行。編譯器只為泛型類型生成一份字節(jié)碼，并將其實(shí)例關(guān)聯(lián)到這份字節(jié)碼上苫耸。類型擦除的關(guān)鍵在于從泛型類型中清除類型參數(shù)的相關(guān)信息州邢，并且再必要的時(shí)候添加類型檢查和類型轉(zhuǎn)換的方法。

下面通過兩個(gè)例子來證明在編譯時(shí)確實(shí)發(fā)生了類型擦除褪子。

例1分別創(chuàng)建實(shí)際類型為String和Integer的ArrayList對象量淌，通過getClass()方法獲取兩個(gè)實(shí)例的類，最后判斷這個(gè)實(shí)例的類是相等的嫌褪，證明兩個(gè)實(shí)例共享同一個(gè)類呀枢。

// 聲明一個(gè)具體類型為String的ArrayList
ArrayList<String> arrayList1 = new ArrayList<String>();  
arrayList1.add("abc");  

// 聲明一個(gè)具體類型為Integer的ArrayList
ArrayList<Integer> arrayList2 = new ArrayList<Integer>();  
arrayList2.add(123);  

System.out.println(arrayList1.getClass() == arrayList2.getClass());  // 結(jié)果為true

例2創(chuàng)建一個(gè)只能存儲Integer的ArrayList對象，在add一個(gè)整型數(shù)值后笼痛，利用反射調(diào)用add(Object o)add一個(gè)asd字符串裙秋，此時(shí)運(yùn)行代碼不會報(bào)錯(cuò)琅拌，運(yùn)行結(jié)果會打印出1和asd兩個(gè)值。這時(shí)再里利用反射調(diào)用add(Integer o)方法摘刑，運(yùn)行會拋出codeNoSuchMethodException異常进宝。這充分證明了在編譯后，擦除了Integer這個(gè)泛型信息枷恕，只保留了原始類型党晋。

ArrayList<Integer> arrayList3 = new ArrayList<Integer>();
arrayList3.add(1);
arrayList3.getClass().getMethod("add", Object.class).invoke(arrayList3, "asd");
for (int i = 0; i < arrayList3.size(); i++) {
    System.out.println(arrayList3.get(i)); // 輸出1，asd
}
arrayList3.getClass().getMethod("add", Integer.class).invoke(arrayList3, 2); // NoSuchMethodException：java

Java中集合的泛型徐块，是防止錯(cuò)誤輸入的未玻，只在編譯階段有效，繞過編譯階段就無效了胡控，因此可以通過反射繞過編譯