内部类、装箱和拆箱

public class Test {
//    测试成员内部类
    public static int i = 1;
    private static int ii = 1;
    private int a = 97;
    public int aa = 65;
    public static void add(){
        System.out.println("私有静态方法");
    }
    public static void sub(){
        System.out.println("公共静态");
    }
    public void sum(){
//        inner inner = new inner();
//        inner.inner1();
//        inner.inner2();
//        inner.i;
//        inner.a;
//        Not a statement 不能声明
        System.out.println("非静态公共方法");
    }
    private void sumS(){
        System.out.println("非静态私有方法");
    }
    class inner{
//        private static int i = 1;成员内部类不允许存在静态的变量
        private int i = 1;
        private int a = 99;//内部类中外部类的实例变量可以共存
        public int b = 4;

       public void inner1(){
            Test.add();
            Test.sub();
            sum();
            sumS();
            System.out.println("内部变量"+a+this.a);
//            this.变量名 访问内部变量
        }
        private void inner2(){
            Test.add();
            Test.sub();
            sum();
            sumS();
            System.out.println("内部变量"+a+this.a);
//            this.变量名 访问内部变量
        }
//        static void innerS(){
//            成员内部类不允许存在静态的属性和方法
//        }

        public inner() {
            System.out.println("外部变量"+aa+Test.this.a+Test.i);
            //访问外部类中与内部类同名的实例变量可用"外部类名.this.变量名"
            //外部类的变量如果和内部类的变量没有同名的，则可以直接用变量名访问外部类的变量
        }
    }
}

class Outers {
    private static int i = 1;
    private int j = 10;
    public static void outer_f1(){
        System.out.println("外部类的静态方法");
    }
    public void outer_f2(){
        System.out.println("外部类的非静态方法");
    }
    // 静态内部类可以用public,protected,private修饰
// 静态内部类中可以定义静态或者非静态的成员
    static class Inner{
        static int inner_i = 100;
        int inner_j = 200;
        static void inner_f1(){
            System.out.println("Outer.i"+i);//静态内部类只能访问外部类的静态成员
            outer_f1();//包括静态变量和静态方法

        }
        void inner_f2(){
// System.out.println("Outer.i"+j);//静态内部类不能访问外部类的非静态成员
// outer_f2();//包括非静态变量和非静态方法
            System.out.println("静态内部类的非静态方法");
        }

    }

    public void outer_f3(){
// 外部类访问内部类的静态成员:内部类.静态成员
        System.out.println(Inner.inner_i);
        Inner.inner_f1();
// 外部类访问内部类的非静态成员:实例化内部类即可
        Inner inner = new Inner();
        inner.inner_f2();

    }
    public static void main(String[] args) {
        new Outers().outer_f3();
    }

}

/**
 * 局部内部类：方法中的内部类
 */
 class Outer {
    private int s = 100;
    private int out_i = 1;
    public void f(final int k){
        final int s = 200;
        int i = 1;
        final int j = 10;
        class Inner{ //定义在方法内部
            int s = 300;//可以定义与外部类同名的变量
            //static int m = 20;//不可以定义静态变量
            Inner(int k){
                inner_f(k);
            }
            int inner_i = 100;
            void inner_f(int k){
                System.out.println(out_i);//如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量
                System.out.println(k);//*****可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的*****
 System.out.println(j);
                System.out.println(s);//如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量
                System.out.println(this.s);//用"this.变量名" 访问的也是内部类变量
                System.out.println(Outer.this.s);//用外部"外部类类名.this.变量名" 访问的是外部类变量
            }
        }
        new Inner(k);
    }

    public static void main(String[] args) {
        //访问局部内部类必须先有外部类对象
        Outer out = new Outer();
        out.f(3);
    }

}