Java核心(类的高级特性- 内部类)

    在一个文件中定义两个类，但其中任何一个类都不在另一个类的内部，而如果在类中再定义一个类，则将在类中再定义的那个类称为内部类。内部类可分为成员内部类、局部内部类以及匿名类。

    一、成员内部类

    1.  成员内部类简介    

    在一个类中使用内部类，可以在内部类中直接存取其所在类的私有成员变量。

    成员内部类的语法：

public class OuterClass{             //外部类
    private class InnerClass{        //内部类
        //....
    }
}

    在内部类中可以随意使用外部类的成员方法以及成员变量，尽管这些类成员被修饰为 private 。

    内部类的实例一定要绑定在外部类的实例上，如果从外部类中初始化一个内部类对象，那么内部类对象就会绑定在外部类对象上。内部类初始化方式与其他类初始化方式相同，都是使用 new  关键字。

    eg ： 在项目中创建 OuterClaa 类，在类中定义 innerClass 内部类和  doit() 方法，在主方法中创建 OuterClass 类的实例对象和 doit() 方法。

package com.ljs;

public class OuterClass {
    innerClass in = new innerClass();        //在外部类实例化内部类对象引用
    public void ouf() {
        in.inf();        //在外部类方法中调用内部类方法
    }
    class innerClass{
    public innerClass() {         //内部类构造方法
	
    }
    public void inf() {        //内部类成员方法
	
    }
    int y = 0;            //定义内部类成员变量
}
public innerClass doit() {        //外部类方法，返回值为内部类引用
    in.y = 4;            //外部类不可以直接访问内部类成员变量 ，通过内部类对象引用调用成员变量 y
    return new innerClass();
}
    public static void main(String[] args) {
        OuterClass out=new OuterClass();
        //内部类的对象实例化操作必须在外部类或外部类的非静态方法中实现
        OuterClass.innerClass in = out.doit();
        OuterClass.innerClass in2 = out.new innerClass();        //实例化内部类对象
    }
}

    外部类创建内部类实例与其他类创建对象引用时相同。内部类可以访问它的外部类成员，但内部类的成员只有在内部类的范围之内是可知的，不能被外部类使用。

    如果在外部类和非静态方法之外实例化内部类对象，需要使用外部类。内部类的形式指定该对象的类型。

   内部类对象会依赖于外部类对象，除非已经存在一个外部类对象，否则类中不会初夏你内部类对象。

    2.  内部类向上转型为接口

    如果将一个权限修饰符为 private 的内部类向上转型为其父类对象，或者直接向上转型为一个接口，在程序中就可以完全隐藏内部类的具体实现过程。可以在外部提供一个接口，在接口中声明一个方法。如果在实现该接口的内部类中实现该接口的方法，就可以定义多个内部类以不同的方式实现接口中同一个方法，而在一般的类中是不能多次实现接口中同一个方法的，这种技巧经常被应用在 Swing 编程中，可以在一个类中做出多个不同的响应事件。

    eg ： 在项目中创建 InterfaceInner 类，并定义接口 OutInterface  ，使内部类 InnerClass 实现这个接口，最后使 doit()  方法返回值类型为该接口。 

package com.ljs;

interface OutInterface{        //定义一个接口
    public void f();
}
public class InterfaceInner {
    public static void main(String[] args) {
        OuterClass2 out = new OuterClass2();
        //调用 doit() 方法，返回一个 OutInterface 接口
        OutInterface outinter =  out.doit();
        outinter.f();
    }
}
class OuterClass2{
    //定义一个内部类实现 OutInterface 接口
    private class InnerClass implements OutInterface {
        InnerClass(String s){        //内部类构造方法
            System.out.println(s);
        }
        public void f() {        //实现接口中的 f() 方法
            System.out.println("访问内部类中的 f() 方法");		
        }
    }
    public OutInterface doit() {        //定义一个方法，返回值类型为 OutInterface 接口
        return new InnerClass("访问内部类构造方法");
    }
}

    运行结果：

访问内部类构造方法
访问内部类中的 f() 方法

    OuterClass2 类中定义了一个修饰权限为 private 的内部类，这个内部类实现了 OutInterface  接口，然后修改 doit() 方法，使该方法返回一个 OutInterface  接口。由于内部类 InnerClass 修饰权限为 private ，所以除了 OuterClass2 类可以访问该内部类之外，其他类都不能访问，而可以访问 doit() 方法。由于该方法返回一个外部接口类型，这个接口可以作为外部使用的接口。它包含一个 f()  方法，在继承此接口的内部类中实现了该方法，如果某个类继承了外部类，由于内部的权限不可以向下转型为内部类 InnerClass ，同时也不嗯能够访问 f() 方法，但是却可以访问接口中的 f() 方法。例如，InterfaceInner 类中最后一条语句，接口引用调用 f() 方法，从执行结果可以看出，这条语句执行的是内部类中的 f() 方法，很好地对继承该类的子类隐藏了实现细节，仅为编写子类的人留下一个接口和一个外部类，同时也可以调用 f() 方法，但是 f() 方法的具体实现过程却被很好地隐藏了，这就是内部类最基本的用途。

    非内部类不能被声明为 private 或 protected 访问类型。

    3.  使用 this  关键字获取内部类与外部类的引用

    如果在外部类中定义的成员变量与内部类的成员变量名称相同，可以使用 this  关键字。

    eg ： 在项目中创建 TheSameName 类，在类中定义成员变量  x  ，再定义一个内部类 Inner ，在内部类中也创建  x  变量，并在内部类的  doit()  方法中分别操作两个  x  变量。

public class TheSameName{
    private int x;
    private class Inner{
        private int x=9;
        public void doit(int x)
            x++;                            //调用的是形参 x
            this.x++;                       //调用内部类的变量 x
            TheSameName.this.x++;           //调用外部类的变量 x
        }
    }
}

    在类中，如果遇到内部类与外部类的成员变量重名的情况，可以使用 this  关键字进行处理。例如，在内部类中使用 this.x  语句可以调用内部类的成员变量 x , 而使用 TheSameName.this.x 语句可以调用外部类的成员变量 x ，即使用外部类名称后跟一个点操作符和 this  关键字便可获取外部类的一个引用。

    二、局部内部类

    内部类不仅可以在类中进行定义，也可以在类的局部位置定义，如在类的方法或任意的作用域中均可以定义内部类。

    eg ： 将 InnerClass 类放在 doit() 方法的内部。

package com.ljs;

interface OutInterface {        // 定义一个接口
    public void f();
}

interface OutInterface2 {        // 定义第二个接口
    public void f2();
}

public class InterfaceInner {
    public static void main(String[] args) {
        OuterClass2 ouClass2 = new OuterClass2();
        // 调用 doit() 方法，返回一个 OutInterface 接口
        OutInterface outinter = ouClass2.doit();
        outinter.f();
        OuterClass3 ouClass3  = new OuterClass3();
        OutInterface2 outinter2= ouClass3.doit("doit");
        outinter2.f2();
    }
}

class OuterClass2 {
    // 定义一个内部类实现 OutInterface 接口
    private class InnerClass implements OutInterface {
        InnerClass(String s) {        // 内部类构造方法
            System.out.println("OuterClass2:"+s);
        }
        public void f() {        // 实现接口中的 f() 方法
            System.out.println("OuterClass2 访问内部类中的 f() 方法");
        }
    }
    public OutInterface doit() {        // 定义一个方法，返回值类型为 OutInterface 接口
        return new InnerClass("OuterClass2 访问内部类构造方法");
    }
}
class OuterClass3 {
    public OutInterface2 doit(final String x) {        // doit() 方法参数为 final 类型
        // 在 doit() 方法中定义一个内部类
        class InnerClass2 implements OutInterface2 {
            public InnerClass2(String s) {
                s = x;
                System.out.println("OuterClass3  访问局部内部类构造方法:"+s);
            }
            @Override
            public void f2() {
                System.out.println("OuterClass3 访问内部类中的 f2() 方法");
            }
        }
        return new InnerClass2("doit");
    }
}

    运行结果为：

OuterClass2:OuterClass2 访问内部类构造方法
OuterClass2 访问内部类中的 f() 方法
OuterClass3  访问局部内部类构造方法:doit
OuterClass3 访问内部类中的 f2() 方法

    内部类被定义在了 doit() 方法内部。但是有一点指的注意，内部类 InnerClass2 是 doit() 方法的一部分，并非 OuterClass3  类中的一部分，所以在 doit() 方法的外部不能访问该内部类，但是该内部类可以访问当前代码块的常量以及此外部类的所有成员。

    如果需要在方法体中使用局部变量，该局部变量需要被设置为 final 类型，换句话说，在方法中定义的内部类只能访问方法中 final 类型的局部变量，这是因为在方法中定义的局部变量相当于一个变量，它的生命周期超出方法运行的生命周期，由于该局部变量被设置为 final ，所以不能再内部类中改变该局部变量的值。

    三、匿名内部类

    在 doit() 方法中将 return 语句和内部类定义语句合并在一起。

package com.ljs;

interface OutInterface {        // 定义一个接口
    public void f();
}

interface OutInterface2 {        // 定义第二个接口
   public void f2();
}

public class InterfaceInner {
    public static void main(String[] args) {
        OuterClass2 ouClass2 = new OuterClass2();
            // 调用 doit() 方法，返回一个 OutInterface 接口
            OutInterface outinter = ouClass2.doit();
            outinter.f();
            OuterClass3 ouClass3  = new OuterClass3();
            OutInterface2 outinter2= ouClass3.doit("doit");
            outinter2.f2();
            OuterClass4 ouClass4  = new OuterClass4();
            OutInterface2 outinter4= ouClass4.doit();
            outinter4.f2();
        }
    }

    class OuterClass2 {
        // 定义一个内部类实现 OutInterface 接口
        private class InnerClass implements OutInterface {
            InnerClass(String s) {        // 内部类构造方法
                System.out.println("OuterClass2:" + s);
            }
            public void f() {        // 实现接口中的 f() 方法
            System.out.println("OuterClass2 访问内部类中的 f() 方法");
            }
        }
        public OutInterface doit() {        // 定义一个方法，返回值类型为 OutInterface 接口
            return new InnerClass("OuterClass2 访问内部类构造方法");
        }
    }
    class OuterClass3 {
        public OutInterface2 doit(final String x) {        // doit() 方法参数为 final 类型
            // 在 doit() 方法中定义一个内部类
            class InnerClass2 implements OutInterface2 {
                public InnerClass2(String s) {
                    s = x;
                    System.out.println("OuterClass3  访问局部内部类构造方法:" + s);
                }
                @Override
                public void f2() {
                    System.out.println("OuterClass3 访问内部类中的 f2() 方法");
                }
            }
            return new InnerClass2("doit");
        }
    }
    class OuterClass4{
        public OutInterface2 doit() {        //定义 doit() 方法
            return new OutInterface2() {        //声明匿名内部类
                private int i=0;
                public int  getValue() {
                    System.out.println("OuterClass4 getValue:"+i);
                    return i;
                }
                @Override
                public void f2() {
                    System.out.println("OuterClass4 访问匿名内部类中的 f2() 方法");
                }
            };
        }
}

    运行结果为：

OuterClass2:OuterClass2 访问内部类构造方法
OuterClass2 访问内部类中的 f() 方法
OuterClass3  访问局部内部类构造方法:doit
OuterClass3 访问内部类中的 f2() 方法
OuterClass4 访问匿名内部类中的 f2() 方法

    在 doit() 方法内部首先返回一个 OutInterface2 的引用，然后再 return 语句中插入了一个定义内部类的代码，由于这个类没有名称，所以这里将该内部类称为匿名内部类。实质上这种内部类的作用就是创建一个实现yO于 OutInterface2 接口的匿名类的对象。

    匿名类的所有实现代码都需要在大括号之间进行编写。语法

return new A(){
    ....        //内部类体
}

    其中 A  为类名

    由于匿名内部类没有名称，所以匿名内部类使用默认构造方法来生成 OutInterface2 对象。在匿名内部类定义结束后，需要加分号标识，这个分号并不是代表定义内部类结束的标识，而是代码创建 OutInterface2 引用表达式的标识。

    匿名内部类编译以后，会产生以 “ 外部类名 $ 序号 ” 为名称的  .class  文件，序号以  1~ n 排列，分别代表 1 ~ n 个匿名内部类。

    四、静态内部类

    在内部类前添加修饰符 static ，这个内部类就变为静态内部类了。一个静态内部类中可以声明 static 成员，但是在非静态内部类中不可以声明静态成员。静态内部类有一个最大的特点，就是不可以使用外部类的非静态成员，所以静态内部类在程序开发中比较少见。

    普通的内部类对象隐式地在外部保存了一个引用，指向创建它的外部类对象，但如果内部类被定义为 static ，就会有更多的限制。静态内部类具有以下两个特点：

    （ 1 ） 如果创建静态内部类的对象，不需要其外部类的对象。

    （ 2 ）不能从静态内部类的对象中访问非静态外部类的对象。

    eg ： 定义一个静态内部类 StaticInnerClass。

public class StaticInnerClass{
    int x=100;
    static class Inner{
        void doitInner(){
            //System.out.println("外部类"+x);        //调用外部类的成员变量 x 但是 x 不是静态的，不能调用
        }
    }
}

    在内部类的 doitInner() 方法中调用成员变量 x ，由于 Inner 被修饰为 static 形式，而成员变量 x 却是非 static 类型的，所以在 doitInner() 方法中不能调用 x 变量。

    进行程序测试时，如果在每一个 Java 文件中都设置一个主方法，将出现很多额外代码，而程序本身并不需要这些主方法，为了解决这个问题，可以将主方法写入静态内部类中。

    eg ： 在静态内部类中定义主方法。

public class StaticInnerClass{
    int x=100;
    static class Inner{
        void doitInner(){
            //System.out.println("外部类"+x);        //调用外部类的成员变量 x 但是 x 不是静态的，不能调用
        }
        public static void main(String args[]){
            System.out.println("a");
        }   
    }
}

    编译此代码，将会生成一个名称为 StaticInnerClass$Inner 的独立类和一个 StaitcInnerClass 类，只要使用 java StaticInnerClass$Inner ，就可以运行主方法中的内容，这样当完成测试，需要将所有 .class 文件打包时，只要删除 StaitcInnerClass$Inner 独立类即可。

    五、内部类的继承

    内部类和其他普通类一样可以被继承，但是继承内部类比继承普通类复杂，需要设置专门的语法来完成。

    eg ： 在项目中创建 OutputInnerClass 类，使 OutputInnerClass 类继承 ClassA 类中的内部类 ClassB.

public class OutputInnerClass  extend ClassA.ClassB{        //继承内部类 ClassB
    public OutputInnerClass (ClassA a){
        a.super();
    }
}
class ClassA{
    class ClassB{

    }
}

    在某个类继承内部类时，必须硬性给予这个类一个带参数的构造方法，并且该构造方法的参数为需要继承内部类的外部类的引用，同时在构造方法体重使用 a.super() 语句，这样才为继承提供了必要的对象引用。