外部類和內部類的關系以及其用法

一. 內部類的定義方式

     1.直接定義在外部類里作為一個屬性的存在（可以理解為和屬性或者方法平級）

     2.定義在外部類的方法中（可以理解為局部變量的那種）

二.內部類的分類

     1.作為屬性的內部類

      a.靜態（此時內部類中可以定義靜態屬性和方法）內部類被編譯后都會是一個單獨的類，只是還存在對外部類的引用而已，被編譯后為Outer$Inner.class，而方法中內部類則為Outer$<N>Inner.class

     相互訪問規則：a-1外部類可以直接訪問內部類的靜態屬性和靜態方法Inner.xx或者Inner.xx();

                         a-2但是調用非靜態屬性和方法時，得創建內部類對象在訪問 new inner.xx等;

                         a-3內部類可以直接訪問外部類的靜態屬性和方法，Outer.xx

 　　　　　　      a-4訪問外部類非靜態屬性和方法，只能 new Outer.xx

    代碼如下

public class OutClass {
    static int score1=150; //外部類的靜態變量
    int score2=61; //外部類的普通變量
     static class Inner { //靜態內部類Inner
        static int score1 = 89; //靜態內部類的靜態變量
        int score2 = 88; //靜態內部類的普通變量

        public  static void show() { //靜態內部類中的靜態方法
            System.out.println(OutClass.score1);
            System.out.println(new OutClass().score2);
            System.out.println(score1);
            System.out.println(new Inner().score2);
        }
    }
    public static void main(String[] args) {
        System.out.println(score1);
        System.out.println(new OutClass().score2);
         //Inner.show();
         System.out.println(Inner.score1);
         System.out.println(new Inner().score1);
        System.out.println(new Inner().score2);
         //Inner.score1;
/*Inner in=new Inner();
in.show();*/
       // new Inner().show();
    }
}

 

  運行結果為 ：150  61 89 89 88    

        b.非靜態

            相互訪問規則：b-1內部類可以外部類的非靜態屬性和方法 寫法如：Outer.this.xx

                                b-2內部類訪問外部類的靜態，可以直接使用的，就當自己的屬性和方法一樣                                       

                            b-3外部類訪問內部類時得先創建內部類對象在進行調用new Outer().new Inner().xx

                            b-4切記，內部類為非靜態時，不容許內部類有靜態屬性和方法

      代碼如下：

 

public class Main {
        int x = 9;
        static int y=10;
        static void find(){
            System.out.println("hao");
    }
        class Inner{
            int x = 8;
            public void test(){
                int x = 7;
                System.out.println(x);
                System.out.println(this.x);
                System.out.println(Main.this.x);
                System.out.println(Main.y);
                find();
                test1();
            }
        }
        private void test1(){
            System.out.println("test");
        }
        public static void main(String[] args) {
            Inner in = new Main().new Inner();
            in.test();
        }
}

     運行結果為：7 8 9 10 hao  test

    2.作為方法中的內部類

            方法中的內部類一般不定義為靜態的，也不容許那么玩，非常耗內存的，同時想像訪問方法中的局部變量，則變量需要使用final修飾，否則會報錯（jdk1.8之前必須加，之后就剋不加了）

       代碼如下

public class OuterClass {
    int num1 = 1; //成員變量

    public void outerMethod() {
        System.out.println("It's Method of OuterClass");
        int num2 = 2; // 方法內局部變量
        class Innerclass {
            public void innerMethod() {
                // 方法中內部類的方法，可以正常訪問外部類的成員變量
                System.out.println(num1);
                // JDK1.8以前，方法中內部類的方法，不能直接訪問外部類的方法的局部變量，必須聲明為final
                System.out.println(num2);
            }
        }
        new Innerclass().innerMethod();
    }

    class Innerclass {
        public void innerMethod() {
            System.out.println("It's Method of innerMethod");
        }
    }
    public static void main(String[] args) {
       new OuterClass().outerMethod();
    }
}