内部类的规范和使用

package com.yanke.innerClass;

public class Outer {
    private int id;
    private String name;
    private String str="OuterClass";

    public void show(){
        System.out.println("外部类："+this.id+"---"+this.name);
        // 5、在外部类中如果想访问内部类中的成员属性，需要先创建内部类的实例对象，再通过对象访问该属性,而不能直接访问。
        Inner inner=new Inner();
        System.out.println("+++"+inner.str);
    }

    // 1、该内部类可以使用private protected public 或者默认的修饰权限符,可以看做一个成员变量，只是这是一个
    // class类型的变量。
    class Inner{
        private  String  str="InnerClass";
        // 6、在内部类中不能有静态常量
        //static int a =100;  错误
        public void show(){
            System.out.println(this.str);
            // 3、内部类可以正常的访问外部类的属性和方法
            System.out.println("内部类访问外部类的成员变量："+id+"--"+name);
            // 4、如果外部类中有和内部类相同名称的成员属性时，访问外部类需要加 外部类.this
            System.out.println(Outer.this.str);
            Outer.this.show();
        }

    }

//    public static void main(String[] args) {
//        Inner inner=new Outer().new Inner();
//        inner.show();
//    }
}

package com.yanke.innerClass;

public class Test {
    public static void main(String[] args) {

        //2、普通的成员内部类要想在外部使用，和正常的类的创建方式不一样
        Outer.Inner inner=new Outer().new Inner();
        inner.show();
    }
}

package com.yanke.innerClass2;

public class StaticOuterClass {

    private int id;
    private String name="haha";
    static String str="staticOuterClass";

    public  void show(){
        System.out.println(this.id+"--"+this.name);
        // 4、访问静态内部类的静态常量和普通常量
        System.out.println(StaticInnerClass.str);
        StaticInnerClass staticInnerClass=new StaticInnerClass();
        System.out.println(staticInnerClass.name);
    }

    static  class StaticInnerClass{
        //1、静态内部类中可以有静态常量
        static String str="staticInnerClass";
        private String name="hehe";
        public void show(){
            StaticOuterClass staticOuterClass=new StaticOuterClass();
            // 2、在静态内部类中需要通过外部类的对象来访问外部类的非静态属性，这点和普通成员内部类不一样
            System.out.println("静态内部类中的name："+name+";静态外部类中的name："+staticOuterClass.name);
        }
    }

//    public static void main(String[] args) {
//        StaticInnerClass staticInnerClass=new StaticInnerClass();
//        System.out.println(StaticInnerClass.str+"--"+staticInnerClass.name);
//        staticInnerClass.show();
//    }
}

package com.yanke.innerClass2;


public class Test {
    public static void main(String[] args) {

        //3、静态内部类要想在外部使用，和正常的类的创建方式也不一样
        StaticOuterClass.StaticInnerClass staticInnerClass=new StaticOuterClass.StaticInnerClass();
        staticInnerClass.show();
        StaticOuterClass staticOuterClass=new StaticOuterClass();
        staticOuterClass.show();
    }
}

package com.yanke.innerClass3;

public class NoNameClass {
    // 匿名内部类：不需要对象名称，只需要实现接口或者抽象类中的方法即可
    Thread thread=new Thread(new Runnable() {
        @Override
        public void run() {

        }
    });
}

package com.yanke.innerClass3;

public class MethodOuterClass {
    private int id=1;
    private String name="zhangsan";

    public void show(){

        class MethodInnerClass{
            private String str="methodInnerClass";

            public void print(){
                System.out.println(MethodOuterClass.this.id+"--"+MethodOuterClass.this.name+"--"+str);
            }
        }

        // 方法内部类的作用域只局限在该方法内部
        MethodInnerClass methodInnerClass=new MethodInnerClass();
        methodInnerClass.print();
    }

    public static void main(String[] args) {
        MethodOuterClass methodOuterClass=new MethodOuterClass();
        methodOuterClass.show();
    }
}