外部类和内部类的关系以及其用法

一. 内部类的定义方式

     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();
    }
}