- 10.1创建内部类
- 10.2链接到外部类
- 10.3使用this与new
- 10.4内部类与向上转型
- 10.5在方法和作用域内的内部类
- 10.6匿名内部类
- 10.7嵌套类
- 10.8为什么需要内部类
- 10.9内部类的继承
- 10.10内部类可以被覆盖吗
- 10.11局部内部类
- 10.12内部类标识符
- 10.13总结
内部类：一个类的定义放在另一个类的定义内部
- 逻辑相关的类组织在一起，并控制位于内部的类的可视性。
- 与组合是完全不同的概念。
10.1 创建内部类
// 创建内部类
public class Parcel1 {
class Contents{
private int i = 11;
public int value(){ return i;}
}
class Destination{
private String label;
Destination(String whereTo){ label = whereTo;}
String readLable(){ return label;}
}
// Using inner classes looks just like using any other class. within Parcel1:
public void ship(String dest){ // 使用内部类
Contents c = new Contents();
Destination d = new Destination(dest);
System.out.println(d.readLable());
}
public static void main(String[] args) {
Parcel1 p = new Parcel1();
p.ship("Tasmania");
}
}
// 返回一个指向内部类的引用
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();
Parcel2.Contents c = q.contents(); // 创建内部类对象 outerClassName.InnerClassName
Parcel2.Destination d = q.to("Borneo");
}
}
10.2 创建到外部类
内部类对象拥有一个对外围类对象的引用
package chapter10Innerclasses;
//
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;
}
private class SequenceSelector implements Selector {
private int i = 0;
@Override
public boolean end() {
return i == items.length;
}
@Override
public Object current() {
return items[i];
}
@Override
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.println(selector.current() + " ");
selector.next();
}
}
}
10.3 使用.this与.new
package chapter10Innerclasses;
public class DotThis {
void f(){
System.out.println("DotThis.f()");
}
public class Inner{
public DotThis outer(){
return DotThis.this; // 外部类.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();
}
}/* Output
DotThis.f()
*/
public class DotNew {
public class Inner{}
public static void main(String[] args) {
DotNew dn = new DotNew();
DotNew.Inner dni = dn.new Inner(); // 创建某个内部类的对象 不能用外部类名称如DotNew，而是用外部类的对象创建
}
}
package chapter10Innerclasses;
public class Parcel3 {
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 static void main(String[] args) {
Parcel3 p = new Parcel3();
Parcel3.Contents c = p.new Contents();
Parcel3.Destination d = p.new Destination("Tasmania"); // 内部类对象会 暗暗的连接到创建它到外部类对象上。
// 如果创建到是嵌套类（静态内部类），就不需要对外部类对象对引用。这句话没有例子
}
}
10.4 内部类与向上转型
package chapter10Innerclasses;
class Parcle4{
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;
}
@Override
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) {
Parcle4 p = new Parcle4();
Contents c = p.contents(); // 向上转型
Destination d = p.destination("Tasmania");
// Parcle4.PContents pc = p.new PContents(); // 不能访问私有类 不能向下转型
}
}
package chapter10Innerclasses.e6.package1;
public interface Interface01 {
void f();
}
package chapter10Innerclasses.e6.package2;
import chapter10Innerclasses.e6.package1.Interface01;
public class Class2 {
protected class Inner implements Interface01{
@Override
public void f() {
System.out.println("class2.inner.method()");
}
public Inner(){} // Inner 为 protected，强制 构造函数为public
}
}
package chapter10Innerclasses.e6.package3;
import chapter10Innerclasses.e6.package1.Interface01;
import chapter10Innerclasses.e6.package2.Class2;
public class Class3 extends Class2 {
public Interface01 get(){
return new Inner(); // 构造函数为public 才能new
}
public static void main(String[] args) {
new Class3().get().f();
}
}
package chapter10Innerclasses.e7;
public class ClassA {
private int i = 10;
private void methodA(){
System.out.println("ClassA private methodA(),and i = " + i);
}
class Inner{
void methodB(){
i++;
methodA(); // 内部类可以访问 外围类的私有字段和私有方法
System.out.println("ClassA Inner methodB(),and i = " + i);
}
}
public void methodC(){
Inner inner = new Inner();
inner.methodB();
System.out.println("methodC and i = " + i);
}
public static void main(String[] args) {
ClassA classA = new ClassA();
classA.methodC();
}
}
10.5 在方法和作用域内的内部类
内部类作用
- 实现某类型的接口，可以创建并返回对其对引用
- 解决复杂问题，创建一个类辅助解决，不希望它公共可用
-
局部内部类：方法中的类
package chapter10Innerclasses;
public class Parcel5 {
public Destination destination(String s){
class PDestination implements Destination{ // 方法中的类
private String label;
private PDestination(String whereTo){
label = whereTo;
}
@Override
public String readLabel() {
return label;
}
}
return new PDestination(s); // 返回的是 Destination 的引用
}
public static void main(String[] args) {
Parcel5 p = new Parcel5();
Destination d = p.destination("Tasmania"); // Destination 向上转型
System.out.println(d.readLabel());
}
}
-
作用域中嵌入内部类
package chapter10Innerclasses;
// 作用域内嵌入一个内部类
public class Parcel6 {
private void interalTracking(boolean b){
if (b){
class TrackingSlip{ // 跟踪单 嵌入在if作用域中，并不是说该类创建是有条件的。它其实是与别的类一起编译的。 超出作用域外，不可用。除此之外，与普通类一样。
private String id;
TrackingSlip(String s){
id = s;
}
String getSlip(){
return id;
}
}
TrackingSlip ts = new TrackingSlip("slip");
String s = ts.getSlip();
}
// TrackingSlip ts = new TrackingSlip("slip"); // 不能用在这里，超出作用域
}
public void track(){interalTracking(true);}
public static void main(String[] args) {
Parcel6 p = new Parcel6();
p.track();
}
}
10.6 匿名内部类
-
实现了接口的匿名类
package chapter10Innerclasses;
public class Parcel7 {
public Contents contents(){
return new Contents() { // 使用默认构造器生成Contents
private int i = 11;
@Override
public int value() {
return i;
}
}; //需要分号
}
public static void main(String[] args) {
Parcel7 p = new Parcel7();
Contents c = p.contents();
}
}
-
扩展了有非默认构造器的类
package chapter10Innerclasses;
class Wrapping {
private int i ;
Wrapping(int x) {
i = x;
System.out.println("Wrapping constructor x = " + 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);
System.out.println(w.value());
}
}
-
执行字段初始化
package chapter10Innerclasses;
public class Parcel9 {
public Destination destination(final String dest){ // 参数必须final JDK 8编译器会自动加上，可以把class文件反编译出来看看，编译期会自动加上final关键字
// dest = "test";
//
// String finalDest = dest; //Local variable a defined in an enclosing scope must be final or effectively final
return new Destination() { // 匿名类 初始化 是Parcel5的简化版
private String label = dest;
@Override
public String readLabel() {
System.out.println("dest is " + dest);
return label;
}
};
}
public static void main(String[] args) {
Parcel9 p = new Parcel9();
Destination d = p.destination("Tasmania");
System.out.println(d.readLabel());
}
}
-
通过实例初始化实现构造（匿名类不可能有构造器）
package chapter10Innerclasses;
abstract class Base{
public Base(int i){
System.out.println("Base constructor.i = " + i);
}
public abstract void f();
}
public class AnonymousConstructor {
public static Base getBase(int i ){
return new Base(i){ // 变量i 不一定是final 因为i 是被传递给匿名类的基类的构造器，它不会在匿名类内部被直接使用
{
System.out.println("Inside instance initializer");
}
@Override
public void f() {
System.out.println("In anonymous f()");
}
};
}
public static void main(String[] args) {
Base base = getBase(47);
base.f();
}
}
/*
Base constructor.i = 47
Inside instance initializer
In anonymous f()
*/
package chapter10Innerclasses;
// 实例初始化
public class Parcel10 {
public Destination destination(final String dest,final float price){
return new Destination() { // 实现接口
private int cost;
// 为每个object 初始化实例
{
cost = Math.round(price);
if (cost > 100)
System.out.println("Over budget");
}
private String label = dest;
@Override
public String readLabel() {
return label;
}
};
}
public static void main(String[] args) {
Parcel10 p = new Parcel10();
Destination d = p.destination("Tasmania",101.295F);
d.readLabel();
}
}
作业12
package chapter10Innerclasses.e12;
public class ClassA {
private int i = 10;
private void methodA(){
System.out.println("ClassA private methodA(),and i = " + i);
}
public void methodC(){
new Object(){
void methodB(){
i++;
methodA(); // 内部类可以访问 外围类的私有字段和私有方法
System.out.println("ClassA Inner methodB(),and i = " + i);
}
}.methodB(); //匿名内部类 实例的方法
System.out.println("methodC and i = " + i);
}
public static void main(String[] args) {
ClassA classA = new ClassA();
classA.methodC();
}
}
10.6.1 再访工厂方法
package chapter10Innerclasses;
interface Service{
void method1();
void method2();
}
interface ServiceFactory{ // 生成某个接口的对象
Service getService();
}
class Implementation1 implements Service {
private Implementation1(){} // 构造方法 为private
@Override
public void method1() {
System.out.println("Implementation1.method1()");
}
@Override
public void method2() {
System.out.println("Implementation1.method2()");
}
public static ServiceFactory factory = new ServiceFactory(){ // 工厂对象为 static 字段对象
@Override
public Service getService() {
return new Implementation1();
}
};
}
//class Implementation1Factory implements ServiceFactory {
//
// @Override
// public Service getService() {
// return new Implementation1(); //生成接口的某个实现的对象
// }
//}
class Implementation2 implements Service {
private Implementation2(){}
@Override
public void method1() {
System.out.println("Implementation2.method1()");
}
@Override
public void method2() {
System.out.println("Implementation2.method2()");
}
public static ServiceFactory factory = new ServiceFactory() {
@Override
public Service getService() {
return new Implementation2();
}
};
}
//class Implementation2Factory implements ServiceFactory {
//
// @Override
// public Service getService() {
// return new Implementation2();
// }
//}
public class Factories {
public static void serviceConsumer(ServiceFactory fact){
Service s = fact.getService();
s.method1();
s.method2();
}
public static void main(String[] args) {
serviceConsumer(Implementation1.factory);
serviceConsumer(Implementation2.factory);
}
}
/*
Implementation1.method1()
Implementation1.method2()
Implementation2.method1()
Implementation2.method2()
*/
package chapter10Innerclasses;
interface Game{boolean move();}
interface GameFactory{
Game getGame();}
class Checkers implements Game { //西洋跳棋
private int moves = 0;
private static final int MOVES =3;
@Override
public boolean move() {
System.out.println("Checkers move " + moves);
return ++moves != MOVES;
}
public static GameFactory checkersFactory = new GameFactory(){
@Override
public Game getGame() {
return new Checkers();
}
};
}
//class CheckersFactory implements GameFactory {
//
// @Override
// public Game getGame() {
// return new Checkers();
// }
//}
class Chess implements Game {
private int moves = 0;
private static final int MOVES =4;
@Override
public boolean move() {
System.out.println("Chess " + moves);
return ++moves != MOVES;
}
public static GameFactory chessFactory = new GameFactory() {
@Override
public Game getGame() {
return new Chess();
}
};
}
//class ChessFactory implements GameFactory {
//
// @Override
// public Game getGame() {
// return new Chess();
// }
//}
public class Games {
public static void playGame(GameFactory factory){
Game s = factory.getGame();
while (s.move())
;
}
public static void main(String[] args) {
playGame(Checkers.checkersFactory);
playGame(Chess.chessFactory);
}
}
/*
Checkers move 0
Checkers move 1
Checkers move 2
Chess 0
Chess 1
Chess 2
Chess 3
*/
优先使用类，而不是接口
10.7嵌套类
- 内部类 对象 隐式 保留一个引用 指向创建它的外围类对象
- 但
- static 嵌套类：不需要其外围类的对象
- 不能从嵌套类的对象中 访问 非静态的 外围类对象
- 普通内部类 字段方法 放在类的外部层次 不能有static 数据和字段
- 嵌套类 可以包含
package chapter10Innerclasses.e18;
public class E18 {
static class NestedClass{
void f(){
System.out.println("NestedClass.f()");
}
}
public static void main(String[] args) {
NestedClass ne = new NestedClass(); // 嵌套类内直接使用类名
ne.f();
}
}
class other { // 类作用域之外，通过outer class.nested class
void f(){
E18.NestedClass ne =new E18.NestedClass();
}
}
package chapter10Innerclasses.e19;
public class E19 {
class Inner1{
class Inner2{
void f(){}
}
Inner2 makeInner2(){return new Inner2();}
}
Inner1 makeInner1(){return new Inner1();}
static class Nested1{
static class Nested2{
void f(){}
}
void f(){}
}
public static void main(String[] args) {
new E19.Nested1().f(); // 调用类，不用() 实例化需要生成对象
new E19.Nested1.Nested2().f();
E19 x1 = new E19();
E19.Inner1 x2 = x1.makeInner1();
E19.Inner1.Inner2 x3 = x2.makeInner2();
x3.f();
}
}
/*
生成的class文件名称
E19$Inner1$Inner2.class E19$Nested1.class
E19$Inner1.class E19.class
E19$Nested1$Nested2.class
*/
10.7.1接口内部的类
创建某些公共代码，被某接口所有不同实现所共用。
package chapter10Innerclasses;
public interface ClassInInterface {
void howdy();
class Test implements ClassInInterface{ // 嵌套类可以作为 接口的一部分，放到接口的类 自动都是public static。
// 类是static ,只是将嵌套类 置于接口的命名空间内，不违反接口规则。甚至可以在内部类中，实现外围接口
@Override
public void howdy() {
System.out.println("howdy！");
}
public static void main(String[] args) {
new Test().howdy();
}
}
}
package chapter10Innerclasses;
public class TestBed {
public void f(){
System.out.println("f()");
}
public static class Tester{
public static void main(String[] args) {
TestBed t = new TestBed();
t.f();
}
}
}
//每个类中 都写个main()测试 ，缺点： 带着编译后都额外代码
//嵌套类 放置测试代码，生成两个类
// TestBed$Tester.class 执行java TestBed$Tester.class $ 转义
//TestBed.class
// 产品打包前删除 TestBed$Tester.class
package chapter10Innerclasses.e20;
interface Outer{
class Inner{
public void g(){
System.out.println("Inner.g()");
}
}
}
public class E20 implements Outer { //即使接口本身没有什么用，但接口中的类仍旧有用。
public static void main(String[] args) {
E20 e20 = new E20();
Outer.Inner in = new Outer.Inner();
in.g();
}
}
package chapter10Innerclasses.e21;
interface I{
void f();
class C{ //包含嵌套类的接口
static void g(I i){ // static方法，调用接口中的方法
System.out.println("calling I.f");
i.f();
}
}
}
public class E21 {
public static void main(String[] args) {
I impl = new I(){ // 实现接口
@Override
public void f() {
}
};
I.C.g(impl); // 将实现的实例传递给这个方法
}
}
10.7.2从多层嵌套类中访问外部类的成员
package chapter10Innerclasses;
// 嵌套类 能访问 外围层的所有成员,包括私有，如下例 g() f()
class MNA{
private void f(){}
class A{
private void g(){}
public class B{
void h(){
g();
f();
}
}
}
}
public class MultiNestingAccess {
public static void main(String[] args) {
MNA mna = new MNA();
MNA.A mnaa = mna.new A(); // .new语法能产生正确的作用域，不必在调用构造器时限定类名
MNA.A.B mnaab = mnaa.new B();
mnaab.h();
}
}
10.8为什么需要内部类
内部类提供 某种进入其外围类的窗口
- 内部类继承自某个类或实现某个接口
- 内部类的代码 操作 创建它的外围类的对象。
每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
package chapter10Innerclasses;
// 两种方法 一个类 实现 多个接口
interface A{}
interface B{}
class X implements A,B{}
class Y implements A{
B makeB(){
return new B(){}; //匿名内部类
}
}
public class MultiInterfaces {
static void takesA(A a){}
static void takesB(B a){}
public static void main(String[] args) {
X x = new X();
Y y = new Y();
takesA(x);
takesA(y);
takesB(x);
takesB(y.makeB());// 通过使用内部类实现接口
}
}
package chapter10Innerclasses;
// 拥有具体的类或抽象类，而不是接口。只能 内部类 实现多重继承。
// 若不需要解决 多重问题，可以用其他方式编码
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());
}
}
内部类的其他特性：
可以有多个实例，每个实例都有自己的状态信息，与外围类对象信息相互独立
单个外围类，可以多个内部类以不同方式实现一个接口或继承同一个类
练习22
package chapter10Innerclasses.e22;
//
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;
}
//正序
private class SequenceSelector implements Selector {
private int i = 0;
@Override
public boolean end() {
return i == items.length;
}
@Override
public Object current() {
return items[i];
}
@Override
public void next() {
if (i < items.length) i++;
}
public Sequence outer(){ // 对外部类 Sequence 的引用
return Sequence.this;
}
}
public Selector selector(){
return new SequenceSelector();
}
public boolean check(){
return this == ((SequenceSelector)selector()).outer(); //校验 SequenceSelector 为私有
}
// 逆序
private class ReverseSelector implements Selector{
private int i = items.length -1;
@Override
public boolean end() {
return i == 0;
}
@Override
public Object current() {
return items[i];
}
@Override
public void next() {
if(i>0) i--;
}
public Sequence outer(){ // 对外部类 Sequence 的引用
return Sequence.this;
}
}
public Selector reverseSelector(){return new ReverseSelector();}
public boolean checkReverse(){
return this == ((ReverseSelector)reverseSelector()).outer(); //校验
}
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.println(selector.current() + " ");
selector.next();
}
System.out.println(sequence.check());
//逆序
Selector rs = sequence.reverseSelector();
while (!rs.end()){
System.out.println(rs.current() + "");
rs.next();
}
System.out.println(sequence.checkReverse());
}
}
package chapter10Innerclasses.e23;
interface U {
void method1();
void method2();
void method3();
}
class A {
int i = 0;
A(int i) {
this.i = i;
}
public U getU() { // 创建一个匿名内部类，生成指向U的引用
return new U() {
@Override
public void method1() {
System.out.println("A method1 ,i = " + i);
}
@Override
public void method2() {
System.out.println("A method2 ,i = " + i);
}
@Override
public void method3() {
System.out.println("A method3 ,i = " + i);
}
};
}
}
class B {
private U[] ua; // U的数组，此例子中用A产生的对象来填充
public B(int size) {
ua = new U[size];
}
public boolean add(U u, int index) {
for (int i = 0; i < ua.length; i++) {
if (ua[i] == null){
ua[index] = u;
return true;
}
}
return false; // 找不到空位
}
public boolean setNull(int i) {
if (i<0 || i>= ua.length)
return false; // 越界 抛出异常
ua[i] = null;
return true;
}
void callMethods() {
for (int i = 0; i < ua.length; i++) {
if (ua[i] != null) {
ua[i].method1();
// ua[i].method2();
// ua[i].method3();
}
}
}
}
public class E23 {
public static void main(String[] args) {
int size = 3;
B b = new B(size);
for (int i = 0; i < size; i++) {
A a = new A(i);
b.add(a.getU(), i);
}
b.callMethods();
b.setNull(0);
b.callMethods();
}
}
/*
A method1 ,i = 0
A method1 ,i = 1
A method1 ,i = 2
A method1 ,i = 1
A method1 ,i = 2
*/
10.8.1闭包与回调
闭包的定义：
- 可调用的对象。记录了来自创建于它的作用域的信息。
内部类：面向对象的闭包
- 包含外围类对象的信息
- 自动拥有外围类对象的引用
- 内部类可以操作包括private成员
package chapter10Innerclasses;
/*闭包 回调
闭包 用一个类把另一个类包装起来。其构造比内部类复杂。作用有二
1闭包 能保护内部类里面的变量安全，不会被外部访问
2 能维持一个变量一直存活在内存中，不被CG掉
回调
同步调用
异步调用
回调 与异步 区别，以后补
*/
//创建个接口，包含一个函数
interface Incrementable{
void increment();
}
// 接口中没有上面特别的地方，实现这个接口，直接覆盖方法。
class Callee1 implements Incrementable{
private int i;
@Override
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();} //测试一下increment方法而已
}
//如果必须继承上面的MyIncrement的话，那上面已经有了具体的方法实现。把它覆盖，则上面的功能就不能用了
class Callee2 extends MyIncrement{
private int i = 0;
public void increment(){// 同样写类这个方法，覆盖父类方法，中间还调用父类方法
super.increment();
i++;
System.out.println(i);
}
//闭包具体实现 内部类实现类接口，并直接调用外部类的方法作为具体实现。
private class Closure implements Incrementable{
@Override
public void increment() {
// 具体 外围的方法，否则 会 无限回调
Callee2.this.increment(); //调用外部类的方法
}
}
//钩子getCallbackReference方法， 返回内部类的对象，实现内部和外部的链接。
//只有Callee2的对象可以访问
Incrementable getCallbackReference(){return new Closure();}
}
// 专门调用函数的 调用者
// 唤醒作用，通过接受不同的接口对象，实现不同的操作。
// 等待接受一个内部类对象，来产生回调。
class Caller{
private Incrementable callbackReference;
Caller(Incrementable cbh){callbackReference = cbh;}
void go(){callbackReference.increment();}
}
public class Callbacks {
public static void main(String[] args) {
Callee1 c1 = new Callee1();
Callee2 c2 = new Callee2();
// MyIncrement.f(c2);
System.out.println("------");
Caller caller1 = new Caller(c1);
Caller caller2 = new Caller(c2.getCallbackReference()); //
caller1.go();
caller1.go();
System.out.println("------");
caller2.go();
caller2.go();
}
}
/*
other operation
1
------
1
2
------
other operation
2
other operation
3
*/
10.8.2内部类与控制框架
package chapter10Innerclasses.controller;
// 要控制的事件
// 基于时间去执行控制，使用抽象类代替实际接口
public abstract class Event {
private long eventTime;
protected final long delayTime;
public Event(long delayTime) {
this.delayTime = delayTime;
start();
}
public void start(){ // 没有包含在构造器内，可以允许重启
eventTime = System.nanoTime() + delayTime;
}
public boolean ready(){ //何时可以运行action方法了 在导出类中 可以覆盖ready()方法，使得Event能够基于时间以外的其他因素而触发
return System.nanoTime() >= eventTime; //当前时间 大于 延时时间，说明已经准备完毕
}
public abstract void action(); // 重复事件，则在action中调用start方法
}
package chapter10Innerclasses.controller;
// 控制系统的可重用的框架
import java.util.ArrayList;
import java.util.List;
public class Controller {
private List<Event> eventlist = new ArrayList<Event>();
public void addEvent(Event c) {
eventlist.add(c);
}
public void run() {
while (eventlist.size() > 0)
//对eventList做一个拷贝，免得改动了原来的数据
for(Event e: new ArrayList<Event>(eventlist))
if (e.ready()){
System.out.println(e);
e.action();
eventlist.remove(e);
}
}
}
package chapter10Innerclasses.controller;
//{Args:5000}
/*
功能:控制框架的实现,
1、控制框架的完整实现是由单个的类创建的，从而使得实现的细节被封装了起来。内部类用来表示解决问题所必须的各种不同的action
2、内部类能够很容易地访问外围类的任意成员，所以可以避免这种实现变得笨拙。
*/
public class GreenhouseControl extends Controller {
private boolean light = false;
public class LightOn extends Event {// //由于event是抽象类，所以必须实现构造函数和抽象函数
public LightOn(long delayTime) {
super(delayTime);
}
@Override
public void action() {
//
light = true;
}
public String toString() {
return "Light is on";
}
}
public class LightOff extends Event {
public LightOff(long delayTime) {
super(delayTime);
}
@Override
public void action() {
//
light = false;
}
public String toString() {
return "Light is off";
}
}
private boolean water = false;
public class WaterOn extends Event //由于event是抽象类，所以必须实现构造函数和抽象函数
{
public WaterOn(long delayTime) {
super(delayTime);
}
@Override
public void action() {
water = true;
}
public String toString() {
return "Greenhouse is on";
}
}
public class WaterOff extends Event //由于event是抽象类，所以必须实现构造函数和抽象函数
{
public WaterOff(long delayTime) {
super(delayTime);
}
@Override
public void action() {
water = false;
}
public String toString() {
return "Greenhouse is off";
}
}
private String thermostat = "Day";
public class ThermostatDay extends Event //由于event是抽象类，所以必须实现构造函数和抽象函数
{
public ThermostatDay(long delayTime) {
super(delayTime);
}
@Override
public void action() {
thermostat = "Day";
}
public String toString() {
return "Thermostat on day setting";
}
}
public class ThermostatNight extends Event //由于event是抽象类，所以必须实现构造函数和抽象函数
{
public ThermostatNight(long delayTime) {
super(delayTime);
}
@Override
public void action() {
thermostat = "Night";
}
public String toString() {
return "Thermostat on night setting";
}
}
public class Bell extends Event {
public Bell(long delayTime) {
super(delayTime);
}
@Override
public void action() {
addEvent(new Bell(delayTime));
}
public String toString() {
return "Bing!";
}
}
public class Restart extends Event {
private Event[] eventList;
public Restart(long delayTime, Event[] eventList) {
super(delayTime);
this.eventList = eventList;
for (Event e : eventList)
addEvent(e);
}
@Override
public void action() {
for (Event e : eventList) {
e.start(); // rerun 每个event
}
start(); // rerun 这个事件
addEvent(this);
}
public String toString() {
return "Restarting system!";
}
}
public static class Terminate extends Event {
public Terminate(long delayTime) {
super(delayTime);
}
@Override
public void action() {
System.exit(0);
}
public String toString() {
return "Terminate system!";
}
}
//配置 并 执行系统
public static void main(String[] args) {
GreenhouseControl gc = new GreenhouseControl();
gc.addEvent(gc.new Bell(900));
Event[] eventList ={
gc.new ThermostatNight(0),
gc.new LightOn(200),
gc.new LightOff(200),
gc.new WaterOn(600),
gc.new WaterOff(800),
gc.new ThermostatDay(1400),
};
gc.addEvent(gc.new Restart(2000,eventList));
if(args.length == 1)
gc.addEvent(new GreenhouseControl.Terminate(new Integer(args[0])));
gc.run();
}
}
内部类的继承
package chapter10Innerclasses;
//内部类的继承
class WithInner{
class Inner{}
}
public class InheritInner extends WithInner.Inner{
InheritInner(WithInner wi){
wi.super(); //这个看不懂
}
public static void main(String[] args) {
WithInner wi = new WithInner();
InheritInner ii = new InheritInner(wi);
}
}
此练习已吐血
package chapter10Innerclasses.e26;
class WithInner {
class Inner {
Inner(int i) {
System.out.println("Inner i:" + i);
}
}
}
class WithInner2 {
class Inner2 extends WithInner.Inner {
public Inner2(WithInner wnd, int i) {
wnd.super(i);
}
}
public static void main(String[] args) {
WithInner wi = new WithInner();
WithInner2 wi2 = new WithInner2();
Inner2 i2 = wi2.new Inner2(wi, 47);
}
}
public class E26 {
}
10.10内部类可以被覆盖吗
package chapter10Innerclasses;
// 内部类不能像方法那样被覆盖
// 继承某个外围类时，相同的内部类，是两个完全独立的实体，各自在自己的命名空间内。
class Egg{
private Yolk y;
protected class Yolk{
public Yolk(){
System.out.println("Egg.Yolk()");
}
}
public Egg(){
System.out.println("New Egg()");
y = new Yolk();
}
}
public class BigEgg extends Egg{
public class Yolk{
public Yolk(){
System.out.println("BigEgg.Yolk()");
}
}
public static void main(String[] args) {
new BigEgg();
}
}
/*
New Egg()
Egg.Yolk()
*/
package chapter10Innerclasses;
// 内部类不能想方法那样被覆盖
// 但 内部类如果明确继承某个内部类，也是可以的。
class Egg2{
protected class Yolk{
public Yolk(){
System.out.println("Egg2.Yolk()");
}
public void f(){
System.out.println("Egg2.Yolk().f()");
}
}
private Yolk y = new Yolk();
public Egg2(){
System.out.println("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(){
System.out.println("BigEgg2.Yolk()");
}
public void f(){
System.out.println("BigEgg2.Yolk.f()");
}
}
public BigEgg2(){insertYolk(new Yolk());} // 向上转型
public static void main(String[] args) {
Egg2 egg2 = new BigEgg2();
egg2.g(); // 调用新的f()
}
}
/*
Egg2.Yolk()
New Egg2()
Egg2.Yolk()
BigEgg2.Yolk()
BigEgg2.Yolk.f()
*/
局部内部类
局部内部类：在方法和及方法的作用域内的类
不能有访问说明符，因为它不是外围类的一部分。
但可以访问当前代码块的常量，以及外围类的所有成员。
package chapter10Innerclasses;
interface Counter {
int next();
}
public class LocalInnerClass {
private int count = 0;
// 局部内部类
Counter getCounter(final String name) {
class LocalCounter implements Counter {
LocalCounter() {
System.out.println("LocalCounter() 构造器");
}
@Override
public int next() {
System.out.print(name); // 访问local final
return count++;
}
}
return new LocalCounter();
}
// 匿名内部类
Counter getCounter2(final String name) {
return new Counter() { // 匿名内部类 没有带名字的构造器，只有一个实例的初始化
{
System.out.println("Counter");
}
@Override
public int next() {
System.out.print(name); // 访问local final
return count++;
}
};
}
public static void main(String[] args) {
LocalInnerClass lic = new LocalInnerClass();
Counter c1 = lic.getCounter("局部内部类"),
c2 = lic.getCounter2("匿名内部类");
for (int i = 0; i < 5; i++)
System.out.println(c1.next());
for (int i = 0; i < 5; i++)
System.out.println(c2.next());
}
}
/*
LocalCounter() 构造器
Counter
局部内部类0
局部内部类1
局部内部类2
局部内部类3
局部内部类4
匿名内部类5
匿名内部类6
匿名内部类7
匿名内部类8
匿名内部类9
*/
局部内部类和匿名内部类实现的功能，具有相同的行为和能力。
- 匿名内部类：用于实例初始化
- 局部内部类：
- 理由1:需要一个已经命名的构造器，或者需要重载构造器。
- 理由2:需要不止一个该内部类的对象。
10.12内部类标识符
每个类都生成.class文件
- Out.class
- Out$1.class 匿名类
- Out$1Inner2.class局部内部类
- Out$Inner3.class内部类嵌套
posted on
