Java外部类（非静态）访问内部类（静态非静态）

Java外部类（非静态）访问内部类（静态/非静态）

public class OutClass {
    
    
    public int a1 = 1;
    public static int b1 = 1;
    public void outerConMethod(){
    
    
        System.out.println("外部类的普通方法!");
        /*1、外部类非静态方法访问实例内部类非静态方法, 和成员*/
        //方法1: 获取get方法中new的实例内部类对象来调用
        getInstance().instanceConMethod();
        a1 = getInstance().b2;
        getInstance().a2 = 3;
        //方法2: 不调用get方法,自己new对象来引用
        instanceInnerClass inner1 = new instanceInnerClass();
        inner1.instanceConMethod();
        //方法3: 外部类.内部类然后在new对象(繁琐不推荐)
        OutClass.instanceInnerClass inner2 = new OutClass.instanceInnerClass();
        inner2.instanceConMethod();

        /*2、外部类非静态方法访问静态内部类静态方法, 和成员*/
        //直接调用即可
        staticInnerClass.innerStaticMethod();
        System.out.println(staticInnerClass.b3);

        /*3、外部类非静态方法访问静态内部类非静态方法, 和成员*/
        //方法1: new 外部类.内部类
        OutClass.staticInnerClass staticInner1 = new OutClass.staticInnerClass();
        staticInner1.InnerConMethod();
        System.out.println(staticInner1.a3);
        //方法2: 静态内部类的引用
        staticInnerClass staticInner2 = new staticInnerClass();
        staticInner2.InnerConMethod();
        System.out.println(staticInner2.a3);
    }

    public static void outerStaticMethod(){
    
    
        System.out.println("外部类的静态方法!");
        /*4、外部类静态方法访问实例内部类非静态方法, 和成员*/
        OutClass outClass = new OutClass(); //第一步，建立外部类对象
        instanceInnerClass instanceInnerClass = outClass.new instanceInnerClass();//第二步，根据外部类对象建立内部类对象
        instanceInnerClass.instanceConMethod();//第三步，访问内部类非静态方法
        System.out.println(instanceInnerClass.a2);
        System.out.println(instanceInnerClass.b2);

        /*5、外部类静态方法访问静态内部类非静态方法, 和成员*/
        OutClass.staticInnerClass staticInner = new OutClass.staticInnerClass();
        staticInner.InnerConMethod();
        System.out.println(staticInner.a3);

        /*6、外部类静态方法访问静态内部类静态方法, 和成员*/
        staticInnerClass.innerStaticMethod();
        System.out.println(staticInnerClass.b3);//直接调用
    }
    //实例内部类
    class instanceInnerClass{
    
    
        public int a2 = 2;
        public static final int b2 = 2;     //实例内部类的类变量必须加final变成常量
        //public static void InnerClass1(){}  //实例内部类一定不允许出现静态方法!
        public void instanceConMethod(){
    
    
            System.out.println("实例内部类非静态方法");
            System.out.println(a2);
            System.out.println(b2);

            /*7、实例内部类普通方法访问外部类的静态成员,静态方法,普通方法和成员都是直接调用*/
            System.out.println(a1);
            System.out.println(b1);
            outerConMethod();
            outerStaticMethod();
            /*8、实例内部类普通方法访问静态内部类的静态成员,静态方法,普通方法和成员都是直接调用*/
            //静态内部类名调用
            System.out.println(staticInnerClass.b3);
            staticInnerClass.innerStaticMethod();

            /*9、实例内部类普通方法访问静态内部类的普通方法和成员都是直接调用*/
            //先要创建静态内部类的对象
            staticInnerClass staticInnerClass = new staticInnerClass();
            System.out.println(staticInnerClass.a3);
            staticInnerClass.InnerConMethod();
        }
    }

    // 静态内部类：被static修饰的成员内部类
    static class staticInnerClass{
    
    
        public int a3 = 3;
        public static int b3 = 3;
        public void InnerConMethod(){
    
    
            System.out.println("静态内部类非静态方法");
            System.out.println(a3);
            /*10、静态内部类普通方法访问外部类的静态成员,静态方法,及静态内部静态方法都是直接调用*/
            outerStaticMethod();
            System.out.println(b1);
            innerStaticMethod();
            /*11、静态内部类普通方法访问外部类的普通方法和成员*/
            OutClass outClass = new OutClass();
            System.out.println(outClass.a1);
            outClass.outerConMethod();
            /*12、静态内部类普通方法访问实例内部部类的普通方法和成员*/
            OutClass outClass1 = new OutClass();
            instanceInnerClass instanceInnerClass1 = outClass1.new instanceInnerClass();
            System.out.println(instanceInnerClass1.a2);
            instanceInnerClass1.instanceConMethod();
            /*13、静态内部类普通方法访问静态内部部类的静态方法和成员*/
            System.out.println(a3);
            innerStaticMethod();
        }
        public static void innerStaticMethod(){
    
    
            System.out.println("静态内部类静态方法");
            /*14、静态内部类静态方法访问外部类的非静态成员,非静态方法,*/
            OutClass outClass = new OutClass();
            System.out.println(outClass.a1);
            outClass.outerConMethod();
            /*15、静态内部类静态方法访问外部类的静态成员,静态方法,*/
            System.out.println(b1);
            outerStaticMethod();
            /*16、静态内部类静态方法访问实例内部类的非静态成员,非静态方法,*/
            OutClass outClass2 = new OutClass();
            instanceInnerClass instanceInnerClass1 = outClass2.new instanceInnerClass();
            System.out.println(instanceInnerClass1.a2);
            System.out.println(instanceInnerClass1.b2);
            instanceInnerClass1.instanceConMethod();
            /*17、静态内部类静态方法访问静态内部类的非静态成员,非静态方法,*/
            OutClass.staticInnerClass staticInnerClass2 = new OutClass.staticInnerClass();
            System.out.println(staticInnerClass2.a3);
            staticInnerClass2.InnerConMethod();
        }
    }
    public instanceInnerClass getInstance(){
    
    
        //创建一个get方法, 返回new的实例内部类对象
        return new instanceInnerClass();
    }
    public static void main(String[] args) {
    
    
        // 实例化一个静态内部类
        OutClass.staticInnerClass innerClass3 = new OutClass.staticInnerClass();
        innerClass3.InnerConMethod();
    }
}