Java从入门到精通——第11章 类的高级特性

5.内部类

如果在类中再定义一个类，则将在类中再定义的那个类称为内部类。内部类可以分为成员内部类，局部内部类以及匿名内部类。

5.1成员内部类

1.成员内部类简介
在一个类中使用内部类，可以在内部类中直接存取其所在类的私有成员变量。
成员内部类的语法如下：

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

在内部类中可以随意使用外部类的成员方法以及成员变量，尽管这些类成员被修饰为private。
内部类的实例一定要绑定在外部类的实例上，如果从外部类中初始化一个内部类对象，那么内部类对象就会绑定在外部类对象上。内部类初始化方式与其他类初始化方式相同，都是使用new关键字。
下面看一个实例：在项目中创建OuterClass类，在类中定义innerClass内部类和doit()方法，在主方法中创建OuterClass类的实例对象和doit()方法。

public class OuterClass {
    class innerClass{
        innerClass(){}                      //内部类的构造方法
        public void inf(){}                 //内部类的成员方法
        int y = 0;                          //定义内部类的成员变量
    }

    innerClass in = new innerClass();       //在外部类实例化内部类对象引用
    public void ouf(){
        in.inf();                           //在外部类方法中调用内部类方法
    }
    public innerClass doit(){               //外部类方法，返回值为内部类引用
//      y = 4;                              //外部类不可以直接访问内部类成员变量
        in.y = 4;
        return new innerClass();            //返回内部类引用
    }

    public static void main(String[] args){
        OuterClass out = new OuterClass();
        //内部类的实例化操作必须在外部类或外部类的非静态方法中实现
        OuterClass.innerClass in = out.doit();
        OuterClass.innerClass in2 = out.new innerClass();
    }
}

上例中的外部类创建内部类实例与其他类创建对象引用时相同。内部类可以访问它的外部类成员，但内部类的成员只有在内部类的范围内是可知的，不能被外部类引用，但是可以使用内部类对象引用调用成员变量y。
**注意：**如果在外部类和非静态方法之外实例化内部类对象，需要使用外部类。内部类的形式指定该对象的类型。
在静态方法中为啥不能创建内部类的实例对象

2.内部类向上转型为接口
如果将一个权限修饰符为private的内部类向上转型为其父类对象，或者直接向上转型为一个接口，在程序中就可以完全隐藏内部类的具体实现过程。可以在外部提供一个接口，在接口中声明一个方法。如果在实现该接口的内部类中实现该接口的方法，就可以定义多个内部类以不同的方式实现接口中的同一个方法，而在一般的类中是不能多次实现接口中的同一个方法的。
**实例：**在项目中创建InterfaceInner类，并定义接口OutInterface，使内部类InnerClass实现这个接口，最后使doit()方法返回值类型为接口。代码如下：

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

class OutClass2 {
    //定义一个内部类实现OutInterface接口
    private class InnerClass implements OutInterface{
        InnerClass(String s){                       //内部类构造方法
            System.out.println(s);
        }
        public void f() {                           //实现接口中的f()方法
            System.out.println("访问内部类中的f()方法");
        }
    }

    //定义一个方法，返回类型为OutInterface接口
    public OutInterface doit(){
        return new InnerClass("访问内部类构造方法");
    }
}

public class InterfaceInner {
    public static  void main(String[] args){
        OutClass2 out = new OutClass2();            //实例化一个OuterClass2对象
        OutInterface  outinter = out.doit();        //调用doit()方法，返回一个OutInterface接口
        outinter.f();                               //调用f()方法
    }
}

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

3.使用this关键字或取内部类与外部类的引用
如果在外部类中定义的成员变量与内部类的成员变量名称相同，可以使用this关键字。
实例：在项目中创建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++;                        //调用的是形参
            this.x++;                   //调用的是内部类的变量x
            TheSameName.this.x++;       //调用的是外部类的变量x
        }
    }
}

在类中，如果遇到内部类与外部类的成员变量重名的情况，可以使用this关键字进行处理。例如，在内部类中使用this.x语句可以调用内部类的成员变量x，而使用TheSameName.this.x语句可以调用外部类的成员变量x。
在内存中所有对象均被放置在堆中，方法以及方法中的形参或局部变量放置在栈中。

5.2局部内部类

内部类不仅可以在类中定义，也可以在类的局部位置定义，如在类的方法或任意的作用域中均可定义内部类。
实例：将InnerClass类放在doit()方法的内部。代码如下

interface OutInterface2{                        //定义一个接口
    
}

public class OuterClass3 {
    public OutInterface2 doit(final String x){  //doit()方法参数为final类型
        //在doit()方法中定义一个内部类
        class InnerClass2 implements OutInterface2{
            InnerClass2(String s){
                s = x;
                System.out.println(s);
            }
        }
        return new InnerClass2("doit");
    }
}

从上可以看出，内部类InnerClass2是doit()方法的一部分，并非OuterClass3类中的一部分，所以在doit()方法的外部不能访问该内部类，但是该内部类可以访问当前代码块的常量以及此外部类的所有成员。
上面将doit()方法的参数设置为final类型。如果需要在方法体中使用局部变量，该局部变量需要被设置为final类型的，换句话说，在方法定义的内部类只能访问方法中final类型的局部变量，这是因为在方法中定义的局部变量相当于一个常量，它的生命周期超出方法运行的生命周期，由于该局部变量被设置为final，所以不能在内部类中改变该局部变量的值。

5.3匿名内部类

在doit()方法中将return语句和内部类定义结合合并在一起，下面通过一个实例说明。
实例：在return语句中编写返回值为一个匿名内部类

public class OuterClass4 {
    public OutInterface2 doit(){            //定义doit()方法
        return new OutInterface2() {        //声明匿名内部类
            private int i=0;
            public int getValue(){
                return i;
            }
        };
    }
}

在doit()方法内部首先返回一个OutInterface2的引用，然后在return语句中插入一个定义 内部类的代码，由于这个类没有名称，所以这里将该内部类称为匿名内部类。实质上这种内部类的作用就是创建一个实现于OutInterface2接口匿名类的对象。
匿名类的所有实现代码都需要在大括号之间进行编写。语法如下：

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

其中A指类名。
由于匿名内部类没有名称，所以匿名内部类使用默认构造方法来实现OutInterface2对象。在匿名内部类定义结束后，需要加分号标识，这个分号并不是代表定义内部类结束的标识，而是代表创建OutInterface2引用表达式的标识。
Tips：匿名内部类编译以后，会产生以“外部类名$序号"为名称的.class文件，序号以1 ~ n排列，分别代表1 ~ n个匿名内部类。

5.4静态内部类

在内部类前添加修饰符static，这个内部类就变成静态内部类了。一个静态内部类中可以声明static成员，但是在非静态内部类中不可以声明静态成员。静态内部类由一个最大的特点，就是不可以使用外部类的非静态成员，所以静态内部类在开发中比较少见。
可以这样认为，普通的内部类对象隐式地在外部保存了一个引用，指向创建它的外部类对象，但如果内部类被定义为static，就会有更多的限制。静态内部类有以下两个特点：
1.如果创建静态内部类的对象，不需要其外部类的对象。
2.不能从静态内部类的对象中访问非静态外部类的对象。
实例：定义一个静态内部类StaticInnerClass，可以使用如下代码：

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

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

public class StaticInnerClass{
	int x = 100;
	static class Inner{
		void doitInner(){
			//System.out.println("外部类" + x);
		}
		public static void main(String[] args){
			System.out.println("a");
		}
	}
}

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

5.5内部类的继承

内部类和其他普通一样可以被继承，但是继承内部类比继承普通类复杂，需要设置专门的语法来完成。
实例：在项目中创建OutputInnerClass类，使OutputInnerClass类继承ClassA中的内部类ClassB

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

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