JAVA内部类

一、内部类定义

    将一个类定义在另一个类里面或者一个方法里面，称之为内部类，内部类分为四种类型：成员内部类、局部内部类、匿名内部类和静态内部类。

二、内部类详细介绍

2.1 成员内部类

    成员内部类看起来是外部类的一个变量，可以访问外部类的变量和方法，即使是private权限的变量或者方法。内部类作为外部类的成员变量，可以使用static修饰（class类唯一可以用static修饰符的方法）。

• 使用static修改的内部类，为静态内部类。
• 未使用static修饰的内部类，为非静态内部类。

2.1.1 静态内部类

    用static修饰的内部类，称之为静态内部类，非静态内部类，编译完成后，会隐含的保存着一个指向外部类的引用，使用内部类，必须通过外部类，而静态内部类却没有，意味着：

• 静态类的创建，不需要依赖外部类的对象。
• 它只能只用外部类的静态变量和方法。
• 静态内部类内部允许static属性和方法。

注：以下内容，如果不特殊说明“静态内部类”，都是指非静态内部类

2.1.2 成员内部类访问外部类信息

    当外部类和内部类变量或者方法名不重名时，可以直接写名称，但是重名时，默认访问的是内部类变量或者方法，如果要访问外部类同名的变量或者方法，使用：

外部类.this.成员变量
外部类.this.成员方法

2.1.3 外部类访问成员内部类信息

    外部类可以访问内部类信息，创建内部类对象即可，这部分很好理解，不多说。

2.1.4 创建内部类

    内部类作为外部类一个成员，通过get方法获取，实现代码如下：

public class OutClass {

    private String name = "innerTest";

    private InnerClass getInnerClass(){
        return new InnerClass();
    }
    public class InnerClass{

        public InnerClass(){
            System.out.println(name);
        }
    }


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

        InnerClass innerClass = outClass.getInnerClass();
    }
}

2.1.5 内部类实现继承多个类

 内部类可以帮助外部类实现继承多个类

public class Son {

    class Father_1 extends Father{
        public int str(){
            return super.str()+1;
        }
    }

    class Mother_1 extends Mother{
        public int can(){
            return super.can()-2;
        }
    }

    public int get(){
        return new Father_1().str();
    }

    public int getCan(){
        return new Mother_1().can();
    }


    public static void main(String[] args){
        Son son = new Son();
        System.out.println(son.get());
        System.out.println(son.getCan());
    }
}

2.2 局部内部类

    局部内部类，是定义在一个方法或者作用域内不的类，和成员内部类的区别在于它只能在这个方法里面使用。

    内部类像局部方法一样，是不能有public、protected、private、static修饰符的。

public class OuterClassTest {

    public void Test(){
        class InnerClass{
            private String name;
            final static String test = "1";

            public InnerClass(String name){
                this.name = name;
            }

            public void say(){
                System.out.println(name+": "+test);
            }
        }

        new InnerClass("test").say();
    }

    public static void main(String[] args){
        OuterClassTest outerClassTest = new OuterClassTest();
        outerClassTest.Test();
    }
}

2.4 匿名内部类

    匿名内部类是唯一没有构造器的类，正因为没有构造器，所以内部类的使用范围非常有限，大部分用于接口的回调，匿名内部类继承其他类或者接口，只对继承方法实现或者重写，不会额外新增方法。

public class Demo {

    private Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("匿名内部类展示");
        }
    };
}