内部类

成员内部类

• 不能有静态方法和静态变量
• 可以访问外部类的变量,静态变量,普通方法，静态方法
• 外部类创建对象 new OutClass().new Inter1();
• 可以通过内部类对象访问内部变量和方法
• 内部存在持有外部类实例的引用

静态内部类

• 可以存在静态和非静态变量和方法
• 只能访问外部类的静态变量和静态方法
• 外部类创建对象new OutClass.Intet2();
• 可以通过类名直接访问内部类的静态变量和静态方法

方法内部类

• 仅仅存在方法内部，不能是静态的，相当局部变量

匿名内部类

• 没有构造方法，通常实现接口，用来方法回调参数
• 需要初始化，可以使用代码块

优点-----（出自微信号-码农每日一题）

• 内部类可以很好的实现隐蔽，一般的非内部类，是不允许有 private 与 protected 等权限的，但内部类（除过方法内部类）可以通过这些修饰符来实现隐藏。

• 内部类拥有外部类的的访问权限（分静态非静态情况），通过这一特性可以比较好的处理类之间的关联性，将一类事物的流程放在一起内部处理。

• 通过内部类可以实现多重继承，java 默认是单继承，我们可以通过多个内部类继承实现多个父类，接着由于外部类完全可访问内部类，所以就实现了类似多继承的效果。

• 通过内部类可以避免修改接口而实现同一个类中两种同名方法的调用（譬如你的类 A 中有一个参数为 int 的 func 方法，现在类 A需要继承实现一个接口 B，而接口 B 中也有一个参数为 int 的 func方法，此时如果直接继承实现就会出现同名方法矛盾问题，这时候如果不允许修改 A、B 类的 func 方法名则可以通过内部类来实现 B 接口，因为内部类对外部类来说是完全可访问的）。

public class OutClass {
    public int a = 0;
    public static String b = "b";
    public void show(){
        System.out.println("outClass-show");
        //不能是静态内部类
        class Inter3{
        }
        new Inter3();
    };
    public static void show1(){
        System.out.println("outClass-static-show");
        //不能是静态内部类
         class  Inter4{
         }
        new Inter4();
    };

    public class Inter1 {
        //不能有静态变量
        int a1 = 1;
         String b1 = "b1";
        //不能有静态方法
        public  void show() {
            System.out.println("Intet1-outClass-a="+a);
            System.out.println("Intet1-outClass-b="+b);
            OutClass.this.show();
            show1();
        }
    }

    public static class Intet2 {
        int a2 = 2;
        public static String b2 = "b2";

        public void show() {
            //只能访问外部类的静态变量
            System.out.println("Intet2-outClass-b="+b);
            OutClass.show1();
        }
        public static void show1() {
            //只能访问外部类的静态变量
            System.out.println("Intet2-outClass-b="+b);
            OutClass.show1();
        }
    }

}

外部调用

    public static void main(String[] args){
        OutClass interClass = new OutClass();

        System.out.println(interClass.a);
        System.out.println(interClass.b);
        System.out.println(OutClass.b);
        OutClass.Inter1 inter1 = new OutClass().new Inter1();
        inter1.show();
        OutClass.Intet2 intet2=new OutClass.Intet2();
        intet2.show();
        System.out.println(OutClass.Intet2.b2);
        OutClass.Intet2.show1();
    }

运行结果

0
b
b
Intet1-outClass-a=0
Intet1-outClass-b=b
outClass-show
outClass-static-show
Intet2-outClass-b=b
outClass-static-show
b2
Intet2-outClass-b=b
outClass-static-show

应用：

• 单例模式

public class Single {
    //私有化构造防止外部创建多个实例
    private Single() {
    }
    public static Single getInstance(){
        return SingleHold.SINGLE;
    }

    private static class SingleHold{
        private static  Single SINGLE=new Single();
    }
}

• Build 构建模式

public class DialogBuild {
    protected String context;
    protected String theme;
    protected String title;

    public DialogBuild(String context, String theme, String title) {
        this.context = context;
        this.theme = theme;
        this.title = title;
    }

    public void setTheme(String theme) {
        this.theme = theme;
    }

    public void setTitle(String title) {
        this.title = title;
    }


    public String getTheme() {
        return theme;
    }

    public String getTitle() {
        return title;
    }
    public static class Build{
        private String context;
        private String theme;
        private String title;
        public Build(String context) {
            this.context = context;
        }

        public Build setTheme(String theme) {
            this.theme = theme;
            return this;
        }

        public Build setTitle(String title) {
            this.title = title;
            return this;
        }
        public  DialogBuild create(){
            DialogBuild dialogBuild = new DialogBuild(this.context, this.theme, this.title);
            return dialogBuild;
        }
    }
}