第10章内部类
一、概述
package com.test;
/**
*
* 可以将一个类的定义放在另一个类的内部，这就是内部类。
*
* 在拥有外部类对象之前是不可能创建内部类对象的。
* 但是，如果创建的是嵌套类（静态内部类），就不需要外部类对象了。
* @author Administrator
*
*/
public class Parcel2 {
class Contents {
private int i = 11;
public int value() {
return i;
}
}
class Destination {
private String label;
Destination(String whereTo) {
label = whereTo;
}
String readLabel() {
return label;
}
}
public Destination to(String s) {
return new Destination(s);
}
public Contents contents() {
return new Contents();
}
public void ship(String dest) {
Contents c = contents();
Destination d = to(dest);
System.out.println(d.readLabel());
}
public static void main(String[] args) {
Parcel2 p = new Parcel2();
p.ship("Tasmania");
Parcel2 q = new Parcel2();
// Defining references to inner classes:
Parcel2.Contents c = q.contents();
Parcel2.Destination d = q.to("Borneo");
}
}
二、访问外围类的成员
package com.test;
interface Selector {
boolean end();
Object current();
void next();
}
public class Sequence {
private Object[] items;
private int next = 0;
public Sequence(int size) {
items = new Object[size];
}
public void add(Object x) {
if (next < items.length)
items[next++] = x;
}
/**
* 内部类自动拥有对其外部类所有成员的访问权，无论是公共还是私有的
* @author Administrator
*
*/
private class SequenceSelector implements Selector {
private int i = 0;
public boolean end() {
return i == items.length;
}
public Object current() {
return items[i];
}
public void next() {
if (i < items.length)
i++;
}
}
public Selector selector() {
return new SequenceSelector();
}
public static void main(String[] args) {
Sequence sequence = new Sequence(10);
for (int i = 0; i < 10; i++)
sequence.add(Integer.toString(i));
//创建内部类对象，并返回其引用
Selector selector = sequence.selector();
while (!selector.end()) {
System.out.print(selector.current() + " ");
selector.next();
}
}
}
三、使用this和new
public class DotThis {
private int i=0;
public void setI(int i){
this.i=i;
}
void f() {
System.out.println("DotThis.f()"+i);
}
public class Inner {
public DotThis outer() {
//通过this可以生成外围类对象的引用
return DotThis.this;
// A plain "this" would be Inner's "this"
}
}
public Inner inner() {
return new Inner();
}
public static void main(String[] args) {
DotThis dt = new DotThis();
dt.setI(10);
DotThis.Inner dti = dt.inner();
dti.outer().f();
}
} package com.test;
public class DotNew {
public class Inner {
}
public static void main(String[] args) {
DotNew dn = new DotNew();
//使用new可以在外面创建内部类的对象
//不能使用类名，必须使用对象名创建
DotNew.Inner dni = dn.new Inner();
}
}
四、内部类向上转型
下面的代码可以很方便地隐藏实现的细节
class Parcel4 {
private class PContents implements Contents {
private int i = 11;
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");
// Illegal -- can't access private class:
//! Parcel4.PContents pc = p.new PContents();
}
}
五、在方法作用域内的内部类
public class Parcel5 {
/**
* 在方法的内部创建类，称为局部内部类
*
* @param s
* @return
*/
public Destination destination(String s) {
class PDestination implements Destination {
private String label;
private PDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
return new PDestination(s);
}
public static void main(String[] args) {
Parcel5 p = new Parcel5();
// 在方法内定义的内部类对象，方法执行完毕后
// 并不意味着内部类对象就不可用了
Destination d = p.destination("Tasmania");
System.out.println(d.readLabel());
}
}
/**
* 在任意的作用域嵌入内部类
* @author Administrator
*
*/
class Parcel6 {
private void internalTracking(boolean b) {
if (b) {
class TrackingSlip {
private String id;
TrackingSlip(String s) {
id = s;
}
String getSlip() {
return id;
}
}
TrackingSlip ts = new TrackingSlip("slip");
String s = ts.getSlip();
}
// Can't use it here! Out of scope:
// ! TrackingSlip ts = new TrackingSlip("x");
}
public void track() {
internalTracking(true);
}
public static void main(String[] args) {
Parcel6 p = new Parcel6();
p.track();
}
}
六、匿名内部类
/**
* 使用了默认的构造器
* @author Administrator
*
*/
public class Parcel7 {
public Contents contents() {
return new Contents() { // Insert a class definition
private int i = 11;
public int value() {
return i;
}
}; // Semicolon required in this case
}
public static void main(String[] args) {
Parcel7 p = new Parcel7();
Contents c = p.contents();
}
}
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) {
// Base constructor call:
return new Wrapping(x) { // Pass constructor argument.
public int value() {
return super.value() * 47;
}
}; // Semicolon required
}
public static void main(String[] args) {
Parcel8 p = new Parcel8();
Wrapping w = p.wrapping(10);
}
} /**
* 如果想在匿名内部类中使用外围类的对象
* 那么对象的引用必须是final的
* 当时传递给匿名内部类构造器的参数不必是final的
*
* 可以在匿名内部类中进行实例化
* @author Administrator
*
*/
public class Parcel9 {
// Argument must be final to use inside
// anonymous inner class:
public Destination destination(final String dest) {
return new Destination() {
{System.out.println("sss");}
private String label = dest;
public String readLabel() {
return label;
}
};
}
public static void main(String[] args) {
Parcel9 p = new Parcel9();
Destination d = p.destination("Tasmania");
}
}
六、嵌套类
/**
* 将内部类声明为static，这样的内部类通常称为嵌套类
* 普通内部类对象隐式地保存了一个外围类对象的引用，而内部类没有
* 特点：
* 1.创建嵌套类的对象不需要外围类对象；
* 2.不能从嵌套类的对象中访问非静态的外围类对象
* 3.普通内部类不能含有static成员；
* 4.普通内部类内部也不能声明嵌套类；
* @author Administrator
*
*/
public class Parcel11 {
private static class ParcelContents implements Contents {
private int i = 11;
public int value() {
return i;
}
}
protected static class ParcelDestination implements Destination {
private String label;
private ParcelDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
// Nested classes can contain other static elements:
public static void f() {
}
static int x = 10;
static class AnotherLevel {
public static void f() {
}
static int x = 10;
}
}
public static Destination destination(String s) {
return new ParcelDestination(s);
}
public static Contents contents() {
return new ParcelContents();
}
public static void main(String[] args) {
Contents c = contents();
Destination d = destination("Tasmania");
}
}
七、接口内部类
/**
* 嵌套类可以放到接口中
* 接口中得任何类都自动为public、static
* 甚至可以在嵌套类中实现外围接口
* @author Administrator
*
*/
public interface ClassInInterface {
void howdy();
class Test implements ClassInInterface {
public void howdy() {
System.out.println("Howdy!");
}
public static void main(String[] args) {
new Test().howdy();
}
}
}
八、多层嵌套内部类
class MNA {
private void f() {
}
class A {
private void g() {
}
public class B {
void h() {
g();
f();
}
}
}
}
/**
* 多层内部类
* 它可以透明地访问所有嵌入它的外围类的所有成员
* @author Administrator
*
*/
public class MultiNestingAccess {
public static void main(String[] args) {
MNA mna = new MNA();
MNA.A mnaa = mna.new A();
MNA.A.B mnaab = mnaa.new B();
mnaab.h();
}
}
九、为什么需要内部类
interface A {
}
interface B {
}
class X implements A, B {
}
class Y implements A {
B makeB() {
// Anonymous inner class:
return new B() {
};
}
}
/**
* 为什么需要内部类？
* 每个内部类都能独立地继承一个实现，所以无论外围类是否已经继承了某个实现，对于内部类都没有影响；
* 内部类使得多重继承的解决方案变得完整
* 接口解决了部分问题，内部类有效地实现了多重继承
* @author Administrator
*
*/
public class MultiInterfaces {
static void takesA(A a) {
}
static void takesB(B b) {
}
public static void main(String[] args) {
X x = new X();
Y y = new Y();
takesA(x);
takesA(y);
takesB(x);
takesB(y.makeB());
}
}
十、闭包与回调
interface Incrementable {
void increment();
}
// Very simple to just implement the interface:
class Callee1 implements Incrementable {
private int i = 0;
public void increment() {
i++;
System.out.println(i);
}
}
class MyIncrement {
public void increment() {
System.out.println("Other operation");
}
static void f(MyIncrement mi) {
mi.increment();
}
}
// If your class must implement increment() in
// some other way, you must use an inner class:
class Callee2 extends MyIncrement {
private int i = 0;
public void increment() {
super.increment();
i++;
System.out.println(i);
}
/**
* 已经继承了MyIncrement类，就不能为了Incrementable的
* 用途而覆盖Increment方法，于是只能使用内部类独立地实现
* Incrementable
* @author Administrator
*
*/
private class Closure implements Incrementable {
public void increment() {
// Specify outer-class method, otherwise
// you'd get an infinite recursion:
Callee2.this.increment();
}
}
Incrementable getCallbackReference() {
return new Closure();
}
}
class Caller {
private Incrementable callbackReference;
Caller(Incrementable cbh) {
callbackReference = cbh;
}
void go() {
callbackReference.increment();
}
}
/**
* 闭包（closure），是一个可调用的对象，它记录了一些信息，这些信息来自于创建
* 它的作用域。通过这个定义，可以看出内部类是面向对象的闭包，因为它不仅包含外
* 围类的对象的信息，还自动拥有指向外围类对象的引用，在此作用域内，内部类有权
* 操作所有的成员，包括private。
* @author Administrator
*
*/
public class Callbacks {
public static void main(String[] args) {
Callee1 c1 = new Callee1();
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();
}
}
十一、内部类的继承
class WithInner {
class Inner {}
}
public class InheritInner extends WithInner.Inner {
//! InheritInner() {} // Won't compile
InheritInner(WithInner wi) {
wi.super();
}
public static void main(String[] args) {
WithInner wi = new WithInner();
InheritInner ii = new InheritInner(wi);
}
}
十二、内部类的覆盖