---

經由過程反射結構外部類對象
起首在 javalang 包下寫一個包括外部類的類：

package javalang;

public class Outer {
  public static class Inner1{}
}

留意這個類是 public static，前面我們漸漸把這些潤飾符去失落。

要想經由過程反射來創立 Inner1 對象，起首要取得 Inner1 的 Class 對象。我們在 Outer 中寫上 main 辦法：

public class Outer {
  public static class Inner1{}
  
  public static void main(String[] args) {
    System.out.println(Inner1.class);
  }
}

 

輸入成果：

class javalang.Outer$Inner1

然後我們試一下這個類名對纰謬：

public static void main(String[] args) throws Exception {
  System.out.println(Class.forName("javalang.Outer$Inner1"));
}

 

運轉一下，沒錯。然後就是用它來創立對象。創立對象要靠結構辦法。這個類有無結構辦法呢？我們可以這麼寫：

public static void main(String[] args) throws Exception {
  System.out.println(Class.forName("javalang.Outer$Inner1").getConstructors().length);
}

 

運轉一下，輸入 1。看來有。然後看看這個結構辦法是甚麼模樣的：

public static void main(String[] args) throws Exception {
  System.out.println(Class.forName("javalang.Outer$Inner1").getConstructors()[0]);
}

 

輸入成果：public javalang.Outer$Inner1()。這就是缺省結構辦法嘛。所以我們可以如許寫：

public static void main(String[] args) throws Exception {
  System.out.println(Class.forName("javalang.Outer$Inner1")
      .getConstructors()[0].neWinstance();
}

 

輸入成果：javalang.Outer$Inner1@ca0b6。這解釋履行勝利了。

接上去我們把 Inner 的 public 症結字去失落，然後再運轉。成果報錯了：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0

這解釋沒有找到結構辦法。真的沒有嗎？我們把 main 辦法改回來：

public static void main(String[] args) throws Exception {
  System.out.println(Class.forName("javalang.Outer$Inner1")
      .getConstructors().length);
}

 

輸入成果：0。真的沒有結構辦法嗎？其實不是，只是結構辦法不是地下的。這時候我們必需用 getDeclaredConstructors() 來取得：

public static void main(String[] args) throws Exception {
  System.out.println(Class.forName("javalang.Outer$Inner1")
      .getDeclaredConstructors().length);
}

 

輸入成果：1。這就把結構辦法找到了。然後我們持續挪用這個結構辦法：

public static void main(String[] args) throws Exception {
  System.out.println(Class.forName("javalang.Outer$Inner1")
      .getDeclaredConstructors()[0].neWinstance());
}

 

輸入成果：javalang.Outer$Inner1@ca0b6。如今我們可以用反射來結構非地下外部類的對象了。

接上去，我們再把 static 症結字去失落。這時候候報錯了：
Exception in thread "main" java.lang.IllegalArgumentException: wrong number of arguments

這解釋甚麼呢？我們挪用的時刻沒有傳參數，而毛病內容就是說參數數目不准確。那末這個結構辦法有甚麼參數呢？我們改一下代碼看看：

public static void main(String[] args) throws Exception {
  System.out.println(Class.forName("javalang.Outer$Inner1")
      .getDeclaredConstructors()[0]);
}

 

輸入成果：javalang.Outer$Inner1(javalang.Outer)

本來結構辦法外面須要一個 Outer 類型的參數。這好辦：

public static void main(String[] args) throws Exception {
  System.out.println(Class.forName("javalang.Outer$Inner1")
      .getDeclaredConstructors()[0].neWinstance(new Outer()));
}

輸入成果：

javalang.Outer$Inner1@ca0b6

OK，本來如斯。看來非靜態的外部類沒出缺省的結構辦法，結構時須要傳一個內部類的實例作為參數。

Java: 若何拜訪一個對象
對 Java 初學者來講一個頭疼的成績是，若何決議把一個對象是界說為辦法變量，照樣界說為成員變量？
 
最開端初學者還不會關懷這點。然則當寫出來的法式愈來愈年夜，類愈來愈多時，這類憂?也應運而生。
 
但我這裡要寫的是：若何為所欲為的支配一個對象，讓你隨時可以拜訪。控制了這點，你便可以自在的決議將一個對象放在甚麼處所了。
 
上面舉一個簡略的例子：

public class AccessingObject { 
  
  public static void main(String[] args) { 
    Date date = new Date(); 
  } 
  
  // 取得 date 對象一小時後的時光 
  private static void anHourLater() { 
    // 這裡若何取得 main() 辦法中的 date 變量？ 
  } 
} 

正如 anHourLater() 辦法中描寫的，想要取得 date 一小時後的時光。怎樣辦呢？有上面幾種辦法。
 
（1）參數傳遞

public class AccessingObject { 
  
  public static void main(String[] args) { 
    Date date = new Date(); 
    anHourLater(date); 
  } 
  
  // 取得 date 對象一小時後的時光 
  private static void anHourLater(Date d) { 
    Date anHourLater = new Date(d.getTime() + 3600000); 
  } 
} 

（2）界說為成員。成員可以由一切辦法拜訪，成員的初始化可以放在界說的處所，也能夠放在任何一個辦法裡。

public class AccessingObject { 
  
  private static Date date; 
  
  public static void main(String[] args) { 
    date = new Date(); 
    anHourLater(); 
  } 
  
  // 取得 date 對象一小時後的時光 
  private static void anHourLater() { 
    Date anHourLater = new Date(date.getTime() + 3600000); 
  } 
} 

（3）放到別的一個類傍邊去。鄙人面的例子中，DateHolder.date 可以被統一個包中的一切類拜訪，而不只限於 AccessingObject 類。

public class AccessingObject { 
  
  public static void main(String[] args) { 
    DateHolder.date = new Date(); 
  } 
  
  // 取得 date 對象一小時後的時光 
  private static void anHourLater() { 
    Date anHourLater = new Date(DateHolder.date.getTime() + 3600000); 
  } 
} 
  
class DateHolder { 
  public static Date date; 
} 

這三個例子比擬起來，前兩個只能在類的外部應用，絕對比擬平安。假如你不願望這個對象被其余類直接修正，就不要用第三種方法。
 
第一種方法和第二種方法的差別在於：假如一個對象只在辦法中應用，那末當辦法履行完後，這個對象可以或許很輕易的被收受接管（留意，不是立時被收受接管）。假如界說為類的成員，那末只要當它地點的類被收受接管以後，這個對象才會被收受接管。明顯，第一種方法是最勤儉資本的，我們應當盡可能應用第一種方法。
 
回頭再看看這三個例子，假如 main() 辦法要取得 anHourLater() 辦法中得出的一小時後時光，它也有幾種對應的方法。後兩個例子就不消改了，date 對象是可以直接拜訪的；第一個例子，有兩種修正方法：
 
（1）作為前往值

public class AccessingObject { 
  
  public static void main(String[] args) { 
    Date date = new Date(); 
    Date anHourLater = anHourLater(date); 
  } 
  
  // 取得 date 對象一小時後的時光 
  private static Date anHourLater(Date d) { 
    return new Date(d.getTime() + 3600000); 
  } 
} 

（2）直接修正參數的內容

public class AccessingObject { 
  
  public static void main(String[] args) { 
    Date date = new Date(); 
    anHourLater(date); 
  } 
  
  // 取得 date 對象一小時後的時光 
  private static void anHourLater(Date d) { 
    d.setTime(d.getTime() + 3600000); 
  } 
} 

個中第二種辦法要慎用，由於隨意動聽家的器械是纰謬的，你不曉得辦法的挪用者喜不愛好你這麼做。

【講授Java中若何結構外部類對象和拜訪對象】的相關資料介紹到這裡，希望對您有所幫助！ 提示：不會對讀者因本文所帶來的任何損失負責。如果您支持就請把本站添加至收藏夾哦！