java中靜態內部類和非靜態內部類詳細區別

package static_neibulei_yu_fei_static;

public class Static_neibulei_Test {

private static int eye = 2;
private String name;

Static_neibulei_Test() {

}

Static_neibulei_Test(String name) {
this.name = name;
}

class Nei {
private int numNei = 0;
// private static int numNei2 = 1; // 非靜態內部類不能聲明靜態成員
private static final int numNei2 = 1; // 此處是宏定義，不是真正的靜態成員

public void funnei() { //

System.out.println(eye); // 可以訪問外部類靜態，非靜態成員
System.out.println(name); // 可以訪問外部類靜態，非靜態成員
fun();
funStatic();
}

}

static class StaticNei {

// 靜態內部類可以有靜態成員，而非靜態內部類則不能有靜態成員。
private int numNeiStatic = 0;
private static int numNeiStatic2 = 0;

// 靜態內部類的非靜態成員可以訪問外部類的靜態變數，而不可訪問外部類的非靜態變數；
StaticNei() {
}

StaticNei(int num) {

this.numNeiStatic = num;

}

public void funnei() {

System.out.println(eye);
// System.out.println(name); //不能訪問非靜態外部成員

}

public static void funneiStatic() {

System.out.println(eye);
// System.out.println(name); //不能訪問非靜態外部成員

}

}

public void fun() {
System.out.println(new StaticNei().numNeiStatic);
System.out.println(StaticNei.numNeiStatic2); // 外部非靜態方法可以訪問靜態內部類的靜態成員
new StaticNei().funnei();
StaticNei.funneiStatic();
}

public static void funStatic() {

// System.out.println(name); //靜態方法不能直接存取非靜態成員

}

public static void main(String[] args) {
// 產生一個靜態內部類不需要外部類成員：這是靜態內部類和成員內部類的區別。靜態內部類的對象可以直接產生：
// Outer.Inner in = new Outer.Inner();而不需要通過產生外部類對象來產生。這樣實際上使
// 靜態內部類成為了一個頂級類(正常情況下，你不能在介面內部放置任何代碼，但嵌套類可以作為介面的一部分，
// 因為它是static 的。只是將嵌套類置於介面的命名空間內，這並不違反介面的規則）

// 建立靜態內部類的對象
Static_neibulei_Test.StaticNei staticnei = new StaticNei();
// 建立非靜態內部類對象
Nei nei = new Static_neibulei_Test("外部類").getNei();

System.out.println(staticnei.numNeiStatic);
staticnei.funnei();
Static_neibulei_Test.StaticNei.funneiStatic();
nei.funnei();
System.out.println(Static_neibulei_Test.Nei.numNei2); //這裡並不是用非靜態內部類去訪問其靜態成員，numNei2是屬於宏定義

}

private Nei getNei() {
// TODO Auto-generated method stub
return new Nei();
}

}

運行結果：

靜態內部類和非靜態內部類的區別

package com.devin;

public class MyMain{
    private static String name = "woobo";
    private String num = "X001";
 
    // 靜態內部類可以用public,protected,private修飾
    static class Person {
        // 靜態內部類中可以定義靜態或者非靜態成員
        private String address = "China";

        private static String x = "as";
        public String mail = "kongbowoo@yahoo.com.cn";// 內部類公有成員

        public void display() {
            // System.out.println(num);//不能直接存取外部類的非靜態成員

            // 靜態內部類不能訪問外部類的非靜態成員(包括非靜態變數和非靜態方法)
            System.out.println(name);// 只能直接存取外部類的靜態成員

            // 靜態內部類只能訪問外部類的靜態成員(包括靜態變數和靜態方法)
            System.out.println("Inner " + address);// 訪問本內部類成員。
        }
    }

    public void printInfo() {
        Person person = new Person();

        // 外部類訪問內部類的非靜態成員:執行個體化內部類即可
        person.display();

        // System.out.println(mail);//不可訪問
        // System.out.println(address);//不可訪問
        System.out.println(person.address);// 可以訪問內部類的私人成員

        System.out.println(Person.x);// 外部類訪問內部類的靜態成員：內部類.靜態成員
        System.out.println(person.mail);// 可以訪問內部類的公有成員
    }

    public static void main(String[] args) {
        MyMain staticTest = new MyMain();
        staticTest.printInfo();
    }
}

1. 嵌套類的對象，並不需要其外圍類的對象。 即它可以不依賴於外部類執行個體被執行個體化。

2. 不能從嵌套類的對象中訪問非靜態外圍類對象。 這是由Java文法中"靜態方法不能直接存取非靜態成員"所限定

3. 外部類訪問內部類的的成員有些特別, 不能直接存取, 但可以通過內部類執行個體來訪問, 這是因為靜態嵌套內的所有成員和方法預設為靜態了.同時注意, 內部靜態類Person只在類StaticTest 範圍內可見, 若在其它類中引用或初始化, 均是錯誤的.
4 . 靜態內部類可以有靜態成員，而非靜態內部類則不能有靜態成員。
5. 靜態內部類的非靜態成員可以訪問外部類的靜態變數，而不可訪問外部類的非靜態變數；

6 . 非靜態內部類的非靜態成員可以訪問外部類的非靜態變數。
    產生一個靜態內部類不需要外部類成員：這是靜態內部類和成員內部類的區別。靜態內部類的對象可以直接產生：Outer.Inner in = new Outer.Inner();而不需要通過產生外部類對象來產生。這樣實際上使靜態內部類成為了一個頂級類(正常情況下，你不能在介面內部放置任何代碼，但嵌套類可以作為介面的一部分，因為它是static 的。只是將嵌套類置於介面的命名空間內，這並不違反介面的規則）
    

問：java中靜態內部類和內部類的區別

答：和普通的類一樣，內部類也可以有靜態。不過和非靜態內部類相比，區別就在於靜態內部類沒有了指向外部的引用。這實際上和C++中的嵌套類很相像了，Java內部類與C++嵌套類最大的不同就在於是否有指向外部的引用這一點上，當然從設計的角度以及以它一些細節來講還有區別。

除此之外，在任何非靜態內部類中，都不能有待用資料，靜態方法或者又一個靜態內部類（內部類的嵌套可以不止一層）。不過靜態內部類中卻可以擁有這一切。