public class B {
    public int b1 = 10;
    public static int b2 = 20;

    public int returnB1_2() {
        return b1 + b2;
    }

    public static int returnB2() {
        //静态方法
        return b2;
    }

    public class BInn {
        //普通内部类只能引用外部类的属性和方法 但不能给外部属性和方法赋值
        //也不可以引用内部静态类和内部普通类的属性
        //普通内部类不可以有静态属性和静态方法
        int bI1 = b1;

        public void change() {
            B.b2 = 30; //若要修改外部静态属性需要通过构造方法实现
        }

        int bI2 = b2;
    }

    public static class BSInn {
        static int bIS2 = returnB2() - 10;
        //静态内部类只能引用外部类的静态属性和方法
        static int bIS1 = b2;
    }

    public int test() {
        class Test1
                //方法内部类不允许用public static private 修饰
        {
            int t3 = b1;
            //方法内部类可以使用外部类的属性和方法
            int t4 = returnB1_2();
            int t1 = 10;
            int t2 = 20;
        }
        //而且方法内部类需要构造
        Test1 test1 = new Test1();
        return test1.t1 + test1.t2;
        //这里无法引用内部静态类和普通类的属性
    }
}

public class Main {
    public static void main(String[] args) {
        B b = new B();
        System.out.println(B.b2); //20
//20 直接引用普通类的静态属性
        System.out.println(B.returnB2());//20
//20 直接引用普通类的静态方法
        System.out.println(b.returnB1_2() + b.returnB2()); //50
//30+20 通过构造引用普通类的普通方法和静态方法
        System.out.println(b.b1 + b.b2 + b.returnB1_2() + b.returnB2());//10+20+30+20
//通过构造引用普通类的所有属性和方法
        System.out.println(B.BSInn.bIS2);
//20-10 直接引用静态内部类的静态属性 但不能引用静态类的普通属性//10
        B.BSInn bsi = new B.BSInn();
        System.out.println(bsi.bIS1 + bsi.bIS2);//20
//通过构造既可以引用普通成员也可以引用静态成员
        B.BInn bi = new B().new BInn();
        bi.change();
//通过方法change修改b2为30 但是没有生效
        System.out.println("修改厚的b2:" + B.b2);
        System.out.println("returnB2的值:" + B.returnB2());
        System.out.println(bi.bI2);//为什么这里20
        System.out.println("again!");
        B.BInn bi2 = new B().new BInn();
        System.out.println(bi2.bI2);
    }
}