java-內部類訪問特點-私有成員內部類-靜態成員內部類-局部內部類訪問局部變量

1、內部類訪問特點：

 -　　內部類可以直接訪問外部類的成員，包括私有。

 -　　外部類要訪問內部類的成員，必須創建對象。

 -　　外部類名.內部類名 對象名 = 外部類對象.內部類對象；

 -　　例：

class Demo {
    public static void main(String[] args) {
        //外部類名.內部類名 = 外部類對象.內部類對象
        Outer.Inner oi = new Outer().new Inner();            //創建內部類對象
        oi.method();

    }
}

class Outer {
    private int num = 10;
    class Inner {
        public void method() {
            System.out.println(num);
        }
    }
}

 

 

2、私有成員內部類

 -　　通過本類中提供一個公共的方法來訪問私有成員內部類。

 -　　例：

class Demo {
    public static void main(String[] args) {
        //Outer.Inner oi = new Outer().new Inner();
        //oi.method();   //這種方法不可以訪問，因為成員內部類已經私有了

        Outer o = new Outer();
        o.print();
    }
}

class Outer {
    private int num = 10;
    private class Inner {
        public void method() {
            System.out.println(num);
        }
    }

    //本類中提供一個公共的訪問方式，通過本類中的方法訪問私有成員內部類
    public void print() {
        Inner i = new Inner();
        i.method();
    }
}

 

 

3、靜態成員內部類

 -　　例：

class Demo {
    public static void main(String[] args) {
        //外部類名.內部類名 對象名 = 外部類名.內部類對象;
        //其實這句話中new的位置是在Inner()前，new是修飾Inner()的：Outer.new Inner();
        //但是一般將new提到最前面，否則編譯會報錯，所以就寫成下面這樣了
        Outer.Inner oi = new Outer.Inner();
        oi.method();
        //內部類里面靜態方法的訪問特點:外部類.內部類.靜態方法名();
        Outer.Inner2.print();
    }
}

class Outer {
    static class Inner {
        public void method() {
            System.out.println("method");
        }
    }

    static class Inner2 {
        public static void print() {
            System.out.println("print");
        }
    }
}

 

 

4、局部內部類訪問局部變量

 -　　局部內部類訪問局部變量，該局部變量必須用final修飾

 -　　局部內部類在訪問他所在方法中的局部變量必須用final修飾，為什么？

  　　*　　因為當調用這個方法時，局部變量如果沒有用final修飾，他的生命周期和方法的生命周期是一樣的，當方法彈棧，這個局部變量也會消失，那么如果局部內部類對象還沒有馬上消失想用這個局部變量，就沒有了。如果用final修飾會在類加載的時候進入常量池，即使方法彈棧，常量池的常量還在，也可以繼續使用。

  　　*　　但是jdk 1.8取消了這個事情，所以我認為這是個bug。

 -　　例：

class Demo {
    public static void main(String[] args) {
        Outer o = new Outer();
        //o.run();   //錯誤，因為Inner在method方法中，屬於局部成員。方法外無法訪問
        o.method();
    }
}

class Outer {
    public void method() {
        //int num = 10;   //錯誤: 從內部類中訪問本地變量num; 需要被聲明為最終類型
        final int num=10;
        class Inner {
            public void print() {
                System.out.println(num);
            }
        }

        Inner i = new Inner();
        i.print();
    }

    /*public void run() {
        Inner i = new Inner();                //局部內部類,只能在其所在的方法中訪問
        i.print();
    }*/
}

 

 

5、面試題

 -　　例：

class Test {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}
//要求：使用已知的變量，在控制台輸出30，20，10。
//內部類之所以能獲取到外部類的成員,是因為他能獲取到外部類的引用。外部類名.this
class Outer {
    public int num = 10;
    class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(num);
            System.out.println(this.num);
            //System.out.println(new Outer().num); //使用對象來訪問成員變量
            System.out.println(Outer.this.num);
        }
    }
}

 

 

6、個人總結：

 -　　普通內部類可通過在別的類中直接實例化訪問，或者將該內部類的實例化寫在該內部類所在的類中的一個方法里，外部通過調用該方法訪問內部類。

 -　　私有成員內部類是將內部類的實例化放在了該內部類所在的類中的一個方法里，該方法提供了一個可供外部公共訪問的方式，外部可通過該方法訪問私有成員內部類。

 -　　靜態成員內部類與普通內部類相似，可在別的類中直接（實例化）訪問或在該內部類所在的類中寫一個方法用來（實例化）訪問該內部類。只不過靜態成員內部類可通過類名調用來訪問。

 -　　局部內部類是將該內部類的實例化直接寫在了該內部類所在的方法體中，因為它相當於一個局部變量，在方法體外是訪問不到的。