内部类
可以将一个类的定义放在另一个类的定义内部,这就是内部类
内部类是一种非常有用的特性,因为他允许你把一些逻辑相关的泪组织在一起,并控制位于内部的类的可视性,然而必须要了解,内部类与组合是完全不同的概念,这一点很重要.
10.1创建内部类
- 如果想从外从外部类的非静态方法之外的任意位置创建某个内部类的对象,那么必须像在main()方法中那样,具体指明这个对象的类型:OuterClassName.InnerClassName.
10.2链接到外部类
- 当生成一个内部类对象时,此对象与制造它的外围对象(enclosing object)之间就有了一种联系,使用它能访问其外围对象的所有成员,而不需要任何条件.
- 当外部类的对象创建了一个内部类对象时,此内部类对象必定会秘密地捕获一个指向那个外围类对象的引用.然后你在访问此外围类的成员时,就是用那个引用来选择外围类的成员.
//这个例子可以和10.3一起来看
//利用外部方法来创建内部类对象
//Selector selector = sequence.selector();
//相当于this.newSequenceSelector();
interface Selector{
}
public class Sequence {
public void add(Object x){}
private class SequenceSelector implements Selector{}
public Selector selector(){
return new SequenceSelector();
}
public static void main(String[] args){
Sequence sequence = new Sequence(10);
Selector selector = sequence.selector();
}
}10.3使用.this与.new
内部类就像一个方法一样用外部类”.”外部类调用
- 如果你需要生成对外部类对象的引用,可以使用外部类的名字后面紧跟圆点和this.
//DotThis.this;返回一个外部类的引用,前面讲了
//>当外部类的对象创建了一个内部类对象时,此内部类对象必定会秘密地捕获一个指向那个外围类对象的引用.
//所以利用DotThis.this可以获取DotThis对象
public class DotThis {
void f(){
System.out.println("DoThis.f()");
}
public class Inner{
public DotThis outer(){
return DotThis.this;
}
}
public Inner inner(){
return new Inner();
}
public static void main(String[] args) {
DotThis dt = new DotThis();
DotThis.Inner dti = dt.inner();
dti.outer().f();
}
}- 创建其某个内部类的对象.实现此目的,你必须在new表达式中提供对其他外部类对象的引用,这是需要使用.new语法.
public class DotNew {
public class Inner{}
public static void main(String[] args) {
DotNew dn = new DotNew();
DotNew.Inner dni = dn.new Inner();
}
}- 在拥有外部类对象之前是不可能创建内部类对象的.这是因为内部类对象会暗暗地连接到创建它的外部类对象上.但是,如果你创建的是嵌套类(静态内部类),那么它就不需要对外部类对象的引用.
10.4内部类与向上转型
- 当将内部类向上转型为其基类,尤其是转型为一个接口的时候,内部类就有了用武之地(从实现了某个接口的对象,得到对此接口的引用,与向上转型为这个对象的基类,实质上效果是一样的.)这是因为此内部类–某个接口的实现–能够完全不可见,并且不可用.所得到的知识指向基类或接口的引用,使用能够很方便地隐藏实现细节.
public interface Contents {
int value();
}
public interface Destination {
String readLabel();
}
class Parcel4{
private class PContents implements Contents{
private int i = 11;
@Override
public int value() {
return i;
}
}
protected class PDestination implements Destination{
private String label;
private PDestination(String whereTo){
label = whereTo;
}
public String readLabel(){
return label;
}
}
public Destination destination(String s){
return new PDestination(s);
}
public Contents contents(){
return new PContents();
}
}
public class TestParcel {
public static void main(String[] args) {
Parcel4 p = new Parcel4();
Contents c = p.contents();
Destination d = p.destination("Tasmania");
}
}10.5 在方法和作用域内的内部类
- 声明定义内部类的两个理由
- 你实现了某类型的接口,于是可以创建并返回对其的引用.
- 你要解决一个复杂的问题,想创建一个类来辅助你的解决方案,但是又不希望这个类时公共可用的.
- 定义类的方式
- 一个定义在方法中的类
- 一个定义在作用域内的类,此作用域在方法的内部.
- 一个实现了接口的匿名类
- 一个匿名类,它扩展了有非默认构造器的类
- 一个匿名类,他执行字段初始化
- 一个匿名类,它通过实例初始化实现构造(匿名类不可能有构造器)
10.6匿名内部类
//两个知识点
//1. 如果基类需要一个有参数的构造器,只需要简单地传递合适的参数给基类的构造器即可
//2. 尽管Wrapping只是一个具有具体实现的普通类,但它还是被其导出类当作公共"接口"来使用
public class Wrapping {
private int i;
public Wrapping(int x){
i = x;
}
public int value(){
return i;
}
}
public class Parcel8 {
public Wrapping wrapping(int x){
return new Wrapping(x){
public int value(){
return super.value() * 47;
}
};
}
public static void main(String[] args) {
Parcel8 p = new Parcel8();
Wrapping w = p.wrapping(10);
}
}- 如果定义一个匿名内部类,并且希望它使用一个在他其他外部定义的对象,那么编译器会要求其参数引用是final的.
10.7嵌套类
- 如果不需要内部类对象与外围类对象之间有联系,那么可以将内部类声明为static.
- 理解static应用于内部类时的含义,就必须记住,普通的内部类对象隐式地保存了一个引用,指向创建它的外围类对象.然而,当内部类时static时,就不是这样了.
- 嵌套类意味着:
- 要创建嵌套类的对象,并不需要其外围类的对象.
- 不能从嵌套类的对象中访问非静态的外围类对象.
- 嵌套类与普通的内部类还有一个区别.普通内部类的字段与方法,只能放在累的外部层次上,所以普通的内部类不能有static数据和static字段,也不能包含嵌套类.但是嵌套类可以包含所有东西.
10.8 为什么需要内部类
- 每个内部类都能独立地继承自一个(接口的)实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响.
- 内部类可以继承多个具体的或抽象的类的能力.从这个角度看,内部类使得多重继承的继承解决方案变得完整.接口解决了部分问题,而内部类有效地实现了”多重继承”.也就是说,内部类允许继承多个非接口类型(译注:类或抽象类)
class D{}//具体类
abstract class E{}//抽象类
class Z extends D{
E makeE(){
return new E(){};
}
}
public class MultiImplementation {
static void takesD(D d){}
static void takesE(E e){}
public static void main(String[] args){
Z z = new Z();
takesD(z);
takesE(z.makeE());
}
}- 如果不需要解决”多重继承”问题,那么自然可以用别的方式编码,而不需要使用内部类.但如果使用内部类,还可以获得其他一些特性:
- 内部类可以有多个实例,每个实例都有自己的状态信息,并且与其外围类对象的信息相互独立.
- 再单个外围类中,可以让多个内部类以不同的方式实现同一个接口,或继承同一个类.
- 创建内部类对象的时刻并不依赖与外围类对象的创建
- 内部类并没有令人迷惑的”is - a”关系;他就是一个独立的实体
//分析程序的时候要分开来看先看Callee1然后看Callee2的运行
interface Incrementable{
void increment();
}
class Calleel implements Incrementable{
private int i =0;
@Override
public void increment() {
i++;
print(i);
}
}
class MyIncrement{
public void increment(){
print("Other operatortion");
}
static void f(MyIncrement mi){
mi.increment();
}
}
//if your class must implement increment() in
//some other way ,you must use an inner class
//上面的注释很重要,就是如果你想要使用interface Increment中的increment方法只能用内部类因为继承中的MyIncrement中已经有了一个increment方法
class Callee2 extends MyIncrement{
private int i = 0;
public void increment(){
super.increment();
i++;
print(i);
}
private class Closure implements Incrementable{
public void increment(){
//Specify outer-class method. therwise
//you'd get an infinite recursion
Callee2.this.increment();//用外部类来调用方法
}
}
Incrementable getCallbackReference(){
return new Closure();
}
}
//Caller的构造器需要一个Incrementable的引用作为参数,然后在以后的某个时刻,Caller对象可以使用此引用回调Callee类
//回调的价值在于它的灵活性--可以在运行时动态地解决需要调用什么方法.
class Caller{
private Incrementable callbackReference;
Caller(Incrementable cbh){callbackReference = cbh;}
void go(){callbackReference.increment();}
}
public class Callbacks {
public static void main(String[] args) {
Calleel c1 = new Calleel();
Callee2 c2 = new Callee2();
MyIncrement.f(c2);
Caller caller1 = new Caller(c1);
Caller caller2 = new Caller(c2.getCallbackReference());
caller1.go();
caller1.go();
caller2.go();
caller2.go();
}
}- P208有一个设计模式内部类的设计可以研究一下
10.9内部类的继承
- 语法: enclosingClassReference.super()
class WithInner{
class Inner{}
}
public class InheritInner extends WithInner.Inner{
//! InheritInner(){} //Won't complile
InheritInner(WithInner wi){
wi.super();
}
public static void main(String[] args) {
WithInner wi = new WithInner();
InheritInner ii = new InheritInner(wi);
}
}10.10内部类可以被覆盖吗
- 下面程序解释现在BigEgg2.Yolk通过extends Egg2.Yolk明确的继承此内部类,并覆盖了其中的方法.insertYolk()方法允许BigEgg2将它自己的Yolk对象向上转型为Egg2中的引用y.
- 使用当g()调用y.f()时,覆盖后的新版的f()被执行.第二次调用Egg2.Yolk(),结果好似BigEgg2.Yolk的构造器调用了其基类的构造器.
//看得我贼蒙圈等下我debug调试一下
//1.进入main方法
//2.找到public BigEgg2()构造方法
//3.找到public Egg2()构造方法
//4.初始化private Yolk y = new Yolk();此时Yolk=null
//5.找到public Yolk()构造方法
//6.输出print("Egg2.Yolk()");
//7.此时创建Yolk对象private Yolk y = new Yolk();
//8.输出print("New Egg2()");
//9.回到public BigEgg2()运行 insertYolk(new Yolk());
//10.找到 public Yolk()再找到父类Yolk并输出print("Egg2.Yolk()");
//再输出 print("BigEgg2.Yolk()");
//11.运行insertYolk(Yolk yy)方法并为y赋值yy
//12.运行e2.g();找到 public void g()
//13.运行y.f()运行子类中的新f()
//14.输出 print("BigEgg2.Yolk()");
class Egg2{
protected class Yolk{
public Yolk(){
print("Egg2.Yolk()");
}
public void f(){
print("Egg2.Yolk.f()");
}
}
private Yolk y = new Yolk();
public Egg2(){
print("New Egg2()");
}
public void insertYolk(Yolk yy){
y = yy;
}
public void g(){
y.f();
}
}
public class BigEgg2 extends Egg2{
public class Yolk extends Egg2.Yolk{
public Yolk(){
print("BigEgg2.Yolk()");
}
public void f(){
print("BigEgg2.Yolk()");
}
}
public BigEgg2(){
insertYolk(new Yolk());
}
public static void main(String[] args) {
Egg2 e2 = new BigEgg2();
e2.g();
}
}- 当继承了某个外围类的时候,内部类并没有发生什么特别神奇的变化.这两个内部类是完全独立地两个实体,各自在自己的命名空间内.当然明确地继承某个内部类也是可以的.
10.11局部内部类
- 使用局部内部类而不是使用匿名内部类的唯一理由就是,我们需要一个已命名的构造器,或者需要重载构造器,而匿名内部类只能用于实例初始化.
- 局部内部类访问外部类方法的局部变量,这个局部变量必须是有效final—>将这个变量变成常量,存储到常量池中,保证声明周期延长.