java內部類載入

㈠ java 內部類為什麼不能static

java為什麼非靜態內部類中不能有static修飾的屬性，但卻可以有常量？
如：
public class InnerClassDemo{
int x;
class A{
static int a = 0;//這樣寫是不合法的.
static final int b=0;//這樣寫是合做仿兆法的
}
}
java類載入順序，首先載入類，執行static變數初始化，接下來執行對象的創建，如果我們要執行代碼中的變數大橘int a 初始化，那麼必須先執行載入外部類，再載入內部類，最後初始化靜態變數 a ,問題就出在載入內部類上面，我們可純租以把內部類看成外部類的非靜態成員，它的初始化必須在外部類對象創建後以後進行，要載入內部類必須在實例化外部類之後完成 ，java虛擬機要求所有的靜態變數必須在對象創建之前完成，這樣便產生了矛盾。
(有點繞，呵呵)
而java常量放在內存中常量池，它的機制與變數是不同的，編譯時，載入常量是不需要載入類的，所以就沒有上面那種矛盾。

㈡ java內部類，集合，反射

反射，很有用，在著名的框架中，SSh就大量使用反射機制，例如可以在xml中設置一個分割中文字體的類，在java運行的時候，就可以讀取xml知道類的路徑，然後使用反射將這個類給載入了，就可以使用這個類啦。
集合的話，相當於數組，但是數組只可以固定大小，集合可以隨便大小，是動態的，這樣就方便多了。還有的集合提供鍵-值關系映射，例如Map，很方便。

內部類也很好用，例如你想用一個類，但是這個類又沒有必要用作他用，就可以聲明內部類，當成一個成員使用啦，這樣結構更清晰吧。還有匿名內部類
匿名內部類：
T a=new T(){
public H(){
}
};
例如上面的T是一個介面或抽象類，想要給這個介面或抽象類聲明一個實現類，但是這個實現類只用一次就行了，其他的沒有用到的，就可以用匿名內部類。不用另外去苦逼的去聲明。方便

㈢ 關於Java 匿名內部類的疑問！

1.使用介面創建出來的而非使用類實現介面出來的就是匿名類了。
因為介面是無法new的，而使用介面new對象實際是就是產生了一個沒有進行命名的類，而這種類就叫做匿名類了。
interface Abc{
public void fn();
}
class Test{
void fn(){
//這里的new Abc()就是一個匿名類，由介面直接產生，而未通過class XXX implements Abc得到
new Abc(){
public void fn(){}
}
}
}

2.不太清楚你問的東西大概什麼意思？說一下我的理敏銀笑解搏雹
一個類定義完畢，如果JAVA虛擬機載入了這個類，那麼它會將所有的static修飾的成員（變數和方法）載入入棧內存，這一部分內存只有一種時候才會被釋放，就是JVM退出的時候。
如果使用該類定義了一個對象，也就是new出來的東西，那麼會在堆內存中創建一塊內存地址，用於存放這個對象，當該對象被釋放掉時（JVM不退出，僅僅是回收了這一塊內存），被佔用內存將清空。
至於內部類的問題，本人認為內部類實際上就是在一個類中定義了一種新的數據類型，當這種數據類型沒有被使用時，JVM不會載入它，換句話說，內部類也是一種類，不使用就不載入，只不過它的格式特殊一些而已，單從JAVA編譯後的形態來看，內部類獨立成一個.class文件，只不過類名是:外部類名$內部類名.class。所以內部類操作時和普通類是一樣的，完全滿橋含足普通類的各種載入釋放原理。
引用LZ的原話「方法的局部變數位於棧上」這句話我不能苟同，本人認為局部變數是在堆內存中的。

㈣ java 內部類為什麼不能用靜態方法

靜態的對象，在內存中實默認實例派察化塵咐茄的，在載入的時候就會存放到內存中。也就是可以直接調用而不需要手動實例化。理解這個就不難理解樓主說的問題了。首先內部的靜態類他是不能直接被實例化的。你必須實例化外部類才能實例簡畝化它。而外部類不是默認載入的，他只有在手動實例化之後才有內存分配。這時問題出現了。既然靜態對象是默認載入，那麼靜態內部類應該先於外部類被載入到內存中。那麼這是又和我們之前的一個結論相反（首先內部的靜態類他是不能直接被實例化的。你必須實例化外部類才能實例化它。）所以這種寫法是錯誤的。

㈤ Java 靜態內部類作用

1、變值許可權修飾作用，在定義內部類的時候，可以在其前面加上一個許可權修飾符static。此時這個內部類就變為了靜態內部類。

2、在某些特殊的情況下，少了這個靜態內部類還真是不行。如在進行代碼程序測試的時候，如果在每一個Java源文件中都設置一個主方法(主方法是某個應用程序的入口，必須具有)，那麼會出現很多額外的代碼。

3、最主要的時這段主程序的代碼對於Java文件來說，只是一個形式，其本身並不需要這種主方法。但是少了這個主方法又是萬萬不行的。在這種情況下，就可以將主方法寫入到靜態內部類中，從而不用為每個Java源文件都設置一個類似的主方法。

這對於代碼測試是非常有用的。在一些中大型的應用程序開發中，則是一個常用的技術手段。

(5)java內部類載入擴展閱讀

例如：

對於兩個類，擁有相同的方法：

class People{

run();

}

interface Machine{

run();

}

此時有一個robot類：

class Robot extends People implement Machine.

此時run()不可直接實現。

interface Machine{

void run();

}

class Person{

void run(){

System.out.println("run");

}

}

class Robot extends Person{

private class MachineHeart implements Machine{

public void run(){

System.out.println("heart run");

}

}

public void run(){

System.out.println("Robot run");

}

Machine.getMachine(){returnnew MachineHeart();

}

class Test{

publicstaticvoid main(String[] args){

Robot robot=new Robot();

Machine m=robot.getMachine();

m.run();

robot.run();

}

}

㈥ Android類載入器以及與Java類載入器區別

載入的位元組碼不同

• 相同的是，在程序運行時首先把描述類的數據文件（位元組碼）載入到內存；

• 不同的是，Android虛擬機運行的是dex位元組碼，Java虛擬機運行的class位元組碼。
  (dex位元組碼：是對class文件優化的產物，不同class文件重復的東西只需保留一份。)

類載入器不同以及類載入器的類體系結構不同

Android類載入器和Java的類載入器的類體系結構不一樣：

Android的BootClassLoader和Java的BootStrapClassLoader區別：

• Android虛擬機中BootClassLoader是ClassLoader內部類，由java代碼實現而不是c++實現，是Android平台上所有ClassLoader的最終parent，這個內部類是包內可見,所以我們沒法使用。

• Java虛擬機中BootStrapClassLoader是由原生代碼(C++)編寫的，負責載入java核心類庫(例如rt.jar等) .

Android類載入器和Java的類載入器工作機制是類似的，使用雙親委託機制。

㈦ Java：靜態內部類調用外部類的方法

static 用在類前面只是表示這個內部類與外面的類之間沒有實例之間的兄虧引用關系，是可以在內部類中直接創建外面的類的實例的。編譯器不會為我們自動創羨彎神建關聯引用，但我們可以創建非關聯的實例。

這個時候相當於只是給了特定的可見性控制。

你創建兩個內部類，一個 static，一個非 static 然後在 eclipse 的 navigator 視圖中打開你的類觀察，那個非 static 類，編譯器自動創建了一個成員變數用來在外部類和內鬧譽部類之間建立關聯。

㈧ java中靜態內部類什麼時候載入

只有在載入內部類的時候才初始化
看懂以下的代碼，那麼對於類的載入，基本上就沒問題了，最後類的載入過程的解釋
public class Test6 {
public static void main(String[] args){
new B();
new A.C();
}
}

class A{
private P p1 = new P("A--p1");
static P p3 = new P("A--p3");
public A(){
System.out.println("A()");
}
private P p2 =new P("A--p2");
static{
new P("A--static");
}
{new P("A{...}");}

public static class C {
private P p1 = new P("C--p1");
static P p3 = new P("C--p3");
public C(){
System.out.println("C()");
}
private P p2 =new P("C--p2");
static{
new P("C--static");
}
{new P("C{...}");}
}
}

class B extends A {
private P p1 = new P("B --p1");
static P p3 = new P("B -- p3");
public B() {
System.out.println("B()");
}
public P p2 = new P("B -- p2");
static {
new P("B -- static");
}

{new P("B{...}");}
}

class P {
public P(String s) {
System.out.println(s);
}
}
/*

有父類的情況
1. 載入父類
1.1 為靜態屬性分配存儲空間並賦初始值
1.2 執行靜態初始化塊和靜態初始化語句（從上至下）
2. 載入子類
2.1 為靜態屬性分配存儲空間
2.2 執行靜態初始化塊和靜態初始化語句（從上至下掘森前）
3. 載入父類構造器
3.1 為實例屬性分配存數空間並賦初始值
3.2 執判清行實例初始化塊和實例初始化語句
3.3 執行構造春滑器內容
4. 載入子類構造器
4.1 為實例屬性分配存數空間並賦初始值
4.2 執行實例初始化塊和實例初始化語句
4.3 執行構造器內容
5 回到main()
內部類的載入過程也一樣

㈨ java類載入器有幾種

Java中消拍載入器的種類大致可以分為四種：Bootstrap ClassLoader(由C++語言寫成），系統載入器（也就是內部類AppClassLoader),ExtClassLoader，以及java.net.UrlClassLoader.
當我們運行一個程序時，首先是找到JDK安裝目下的jvm.dll來啟動JAVA虛擬機，而後Bootstrap ClassLoader產生，接下來就是Bootstrap ClassLoader來載入ExtClassLoader，並且指定ExtClassLoader的父載入器為Bootstrap ClassLoader，但是因為Bootstrap ClassLoader用C++語言寫的，所以用JAVA的觀點來看，這個載入器的實例是不存在的，所以拿腔羨ExtClassLoader的父載入器被設置為了null，然後就是Bootstrap ClassLoader將AppClassLoader裝載，並指定其父載入器為ExtClassLoader。
JAVA是按照載入器的圓李委派模型來實現的。這種模型是JAVA安全性機制的保證。並且值得我們注意的就是這幾個載入器的默認載入類的路徑。對於AppCLassLoder來說，它的路徑也就是我們的classpath裡面的路徑。而對於ExtClassLoader來說，它的路徑是jre\lib\ext\classes.對於URLClassLoader來說，它的載入路徑是我們指定的url。

㈩ java 中靜態內部類欄位什麼時候初始化

不是的，只有在載入內部類的時候才初始化 //有問題可以繼續交神瞎租流x0dx0a樓主只要看懂一下的代碼x0dx0a那麼對於類的載入x0dx0a基本上就沒問神埋題了x0dx0a最後類的載入過程的解釋x0dx0apublic class Test6 {x0dx0a public static void main(String[] args){x0dx0a new B();x0dx0a new A.C();x0dx0a }x0dx0a}x0dx0ax0dx0aclass A{x0dx0a private P p1 = new P("A--p1");x0dx0a static P p3 = new P("A--p3");x0dx0a public A(){x0dx0a System.out.println("A()");x0dx0a }x0dx0a private P p2 =new P("A--p2");x0dx0a static{x0dx0a new P("A--static"); x0dx0a }x0dx0a {new P("A{...}");}x0dx0a x0dx0a public static class C {x0dx0a private P p1 = new P("C--p1");x0dx0a static P p3 = new P("C--p3");x0dx0a public C(){x0dx0a System.out.println("C()");x0dx0a }x0dx0a private P p2 =new P("C--p2");x0dx0a static{x0dx0a new P("C--static"); x0dx0a }x0dx0a {new P("C{...}");}x0dx0a }x0dx0a}x0dx0ax0dx0aclass B extends A {x0dx0a private P p1 = new P("B --p1");x0dx0a static P p3 = new P("B -- p3");x0dx0a public B() {x0dx0a System.out.println("B()"); x0dx0a }x0dx0a public P p2 = new P("B -- p2");x0dx0a static {x0dx0a new P("B -- static");x0dx0a }x0dx0a x0dx0a {new P("B{...}");}x0dx0a}x0dx0ax0dx0aclass P {x0dx0a public P(String s) {x0dx0a System.out.println(s);x0dx0a } x0dx0a}x0dx0a/*x0dx0a x0dx0a有父類的情況x0dx0a1. 載入父類x0dx0a 1.1 為靜態屬性分配存儲空間並賦初始值 x0dx0a 1.2 執行靜態初始化塊和靜態初始化語句（從上至下）x0dx0a2. 載入子類x0dx0a 2.1 為靜態屬性分配存儲空間x0dx0a 2.2 執行靜態游兆初始化塊和靜態初始化語句（從上至下）x0dx0a3. 載入父類構造器x0dx0a 3.1 為實例屬性分配存數空間並賦初始值 x0dx0a 3.2 執行實例初始化塊和實例初始化語句x0dx0a 3.3 執行構造器內容x0dx0a4. 載入子類構造器x0dx0a 4.1 為實例屬性分配存數空間並賦初始值 x0dx0a 4.2 執行實例初始化塊和實例初始化語句x0dx0a 4.3 執行構造器內容x0dx0a5 回到main()x0dx0a內部類的載入過程也一樣x0dx0a*/