Thinking in Java笔记6

（第7章笔记）

 

 package com;public class Test6_1 {//定义2个内部类class Contents{private int i = 11;public int value() {return i;}Contents() {System.out.println("Content()");}}class Destination{private String label;Destination(String whereTo){label = whereTo;System.out.println("Destination: "+label);}String readLabel() { return label;}}//ship(String dest)生成两个类的对象public void ship(String dest){Contents c = new Contents();Destination d = new Destination(dest);}public Contents newCont(){return new Contents();}public Destination newDest(String dest){return new Destination(dest);}public static void main(String[] args) {Wind w = new Wind();Brass b = new Brass();//Instrument i = new Instrument();//不允许创建一个abstract类的实例tune(w);//上溯造型tune(b);//Java通过动态绑定(运行期绑定)实现//在Java里所有的非final方法都会自动实行动态绑定Triangle t = new Triangle();RightTriangle rt = new RightTriangle();Circle c = new Circle();draw(t);draw(rt);draw(c);Test6_1 t6 = new Test6_1();t6.ship("China");//在ship()内生成两个对象//一下是两种不同的生成内部类的方法，都要用到外部类的一个实例Contents cont = t6.newCont();//在类外部使用Contents必须加上Test6.//由于Destination()与Contents()都是非static，所以要通过一个实例来调用Destination dest = t6.new Destination("America"); T tt = new T();Animal animal = tt.newAnimal("cat");animal.say();Plant plant = tt.newPlant("rose");plant.name();T2 t2 = new T2();Shape s1 = t2.newShape();s1.play();T3 t3 = new T3();t3.ff(true);T4 t4 = new T4();Plant p1 = t4.newPlant();p1.name();Sequence seq = new Sequence(5);for(int i=0;i<5;i++)seq.add(Integer.toString(i));Selector sel = seq.getSelector();while(!sel.end()){System.out.println((String)sel.current());sel.next();}}public static void tune(Instrument i){i.play();}public static void draw(Shape s){s.play();}}//抽象类的分析abstract class Instrument{//不能生成实例//一个类里包含了一个或多个抽象方法，类就必须指定成abstract（抽象）abstract public void play();//abstract方法不允许有主体//{//System.out.println("Instrument.play()");//}public String what(){//抽象类不需要只包含抽象的方法return "Instrument";}}class Wind extends Instrument{public void play(){//继承抽象类，必须对其中的抽象方法提供方法定义//否则衍生类也会是抽象的，编译器会强迫使用abstract标识该类的"抽象"本质System.out.println("Wind.play()");}public String what(){return "Wind";}}class Brass extends Instrument{public void play(){System.out.println("Brass.play()");}}//接口的分析interface Shape{//可将接口想象为一个"纯"抽象类，用interface，而不是class，注意接口实际是要被"继承"的！(可加上public)//允许创建者规定一个类的基本形式：方法名、自变量列表以及返回类型，但不规定方法主体String name = "Shape"; //编译器默认为static和final，所以必须初始化Wind w = new Wind();void play();//编译器默认为public，并且不允许定义主体String what();}class Triangle implements Shape{public void play(){//必须将实现的接口定义为publicSystem.out.println("This is a triangle");}public String what() {return "triangle";}}class Circle implements Shape{public void play(){System.out.println("This is a circle");}public String what(){return "circle";}}class RightTriangle extends Triangle{public void play(){System.out.println("This is a right triangle");}}class WindAndShape extends Wind implements Shape {//具体类(Wind)必须位于接口(Shape)之前//由于Wind里刚好实现了play()和what()方法，所以编译器并没有报错}//使用接口的原因：//1.能上溯造型至多个基础类//2.与使用抽象基础类的原因是一样的：防止客户程序员制作这个类的一个对象，以及规定它仅仅是一个接口//到底应该使用一个接口还是一个抽象类呢？//若使用接口，我们可以同时获得抽象类以及接口的好处。所以假如想创建的基础类没有任何方法定义或者//成员变量，那么无论如何都愿意使用接口，而不要选择抽象类。事实上，如果事先知道某种东西会成为//基础类，那么第一个选择就是把它变成一个接口。只有在必须使用方法定义或者成员变量的时候，才应考虑采用抽象类。interface X{}interface Y{}interface Z extends X,Y{}//可以用此方法扩展接口，注意X,Y只能是接口class ee implements X{}//内部类的分析//部分见上//隐藏实施细节举例//可以从下面的类T中获得Animal和Plant的句柄，甚至我们可能并不知道准确的类型是什么//通过设置Dog和Flower的访问权限，类设计人员可以完全禁止其他人以来类型编码。并将具体实施细节完全隐藏//使用见上面main()函数abstract class Animal{//这里Animal和Plant不一定是抽象类和接口String name;abstract public void say(); }interface Plant{void name();}class T{private class Panimal extends Animal{public Panimal(String name){this.name = name;//如果需要在内部类中引用外部类的句柄，则可以使用T.this.newAnimal("dd")的形式}public void say(){System.out.println("I'm a "+name);}}protected class Pplant implements Plant{String name;public Pplant(String name){this.name = name;}public void name(){System.out.println("This is a "+name);}}public Animal newAnimal(String name){return new Panimal(name);//内部类的对象默认持有创建它的那个封装类的一个对象的句柄}public Plant newPlant(String name){return new Pplant(name);}}//方法和作用域中的内部类class T2{//在方法内定义类public Shape newShape(){class Pshape implements Shape{//类Pshape不可从newShape()外被访问，但这不意味着newShape返回的不是一个有效的休想public void play(){System.out.println("Pshape in class T2");}public String what(){return "Pshape";}}return new Pshape();}}//作用域内定义类class T3{private void f(boolean b){if(b){class H{//这并不意味着类是有条件创建的，它会随同其他所有东西得到编译public void p(){System.out.println("I'm class H");}}H h = new H();h.p();}}public void ff(boolean b){f(b);}}//匿名类class T4{public Plant newPlant(){return new Plant(){//如果构造Plant需要参数如Plant(a)，则匿名内部类外的对象a必须是final属性public void name(){System.out.println("I'm a plant");}};//分号不可少}}//链接到外部类interface Selector {boolean end();Object current();void next();}class Sequence {private Object[] o;private int next = 0;public Sequence(int size){o = new Object[size];}public void add(Object x) {if(next < o.length) {o[next] = x;next++;}}private class SSelector implements Selector {int i = 0;public boolean end() {return i == o.length;}public Object current() {return o[i];}public void next() {if(i < o.length) i++;}}public Selector getSelector() {return new SSelector();//从类内部生成private内部类的对象//虽然SSelector是private，但Selector s = new Sequence().getSelector()//s是可以操作SSelector内的方法的，使用见上。}}/*class S{//置于文件S.java中，编译后生成S.class和S$Tester.class，javaS$Tester即可运行测试 S() {}void f() { System.out.println("f()"); }public static class Tester {//可用于测试public static void main(String[] args) {S t = new S();t.f();}}}*///继承内部类class A1{class B{}}class C extends A1.B{//C(){};//不会得到编译C(A1 aa){//继承内部类必须这样写构造器aa.super();}} 

运行结果：

 

Wind.play()

Brass.play()

This is a triangle

This is a right triangle

This is a circle

Content()

Destination: China

Content()

Destination: America

I'm a cat

This is a rose

Pshape in class T2

I'm class H

I'm a plant

0

1

2

3

4

 

package com;//为什么要是使用内部类？答案就在于我们在这里要学习的"控制框架"abstract class Event{private long evtTime;public Event(long eventTime){evtTime = eventTime;}public boolean ready(){return System.currentTimeMillis()>=evtTime;}abstract public void action();abstract public String description();}class EventSet{private Event[] events = new Event[20];private int index = 0;private int next = 0;public void add(Event e){if(index >= events.length)return;events[index++] = e;}public Event getNext(){boolean looped = false;int start = next;do{next = (next + 1)%events.length;if(start == next)looped = true;if((next == (start + 1)%events.length)&&looped)return null;}while(events[next] == null);return events[next];}public void removeCurrent(){//注意removeCurrent()并不只是指示一些标志，指出对象不再使用。相反，它将句柄设为null。//这一点是非常重要，因为假如垃圾收集器发现一个句柄仍在使用，就不会清除对象。//若认为自己的句柄可能象现在这样被挂起，那么最好将其设为null ，使垃圾收集器能够正常地清除它们events[next] = null;}}class Controller{private EventSet es = new EventSet();public void addEvent(Event c){es.add(c);}public void run(){Event e;while((e = es.getNext())!= null){if(e.ready()){e.action();System.out.println(e.description());es.removeCurrent();}}}}//注意在迄今为止的所有设计中，我们仍然不能准确地知道一个“事件”要做什么。这正是整个设计的关键//它怎样"将发生变化的东西同没有变化的东西区分开"？或者用我的话来讲，"改变的意图"造成了各类//Event对象的不同行动。我们通过创建不同的Event 子类，从而表达出不同的行动。//这里正是内部类大显身手的地方，它们允许我们做两件事情：//(1)在单独一个类里表达一个控制框架应用的全部实施细节，从而完整地封装与那个实施有关的所有东西。//内部类用于表达多种不同类型的action()，它们用于解决实际的问题。除此以外，后续的例子使用了//private 内部类，所以实施细节会完全隐藏起来，可以安全地修改。//(2) 内部类使我们具体的实施变得更加巧妙，因为能方便地访问外部类的任何成员。//若不具备这种能力，代码看起来就可能没那么使人舒服，最后不得不寻找其他方法解决。public class GreenhouseControls extends Controller{private boolean light = false;private boolean water = false;private String thermostat = "Day";private class LightOn extends Event{public LightOn(long eventTime){super(eventTime);}public void action(){light = true;}public String description(){return "Light is on";}}private class LightOff extends Event{public LightOff(long eventTime){super(eventTime);}public void action(){light = false;}public String description(){return "Light is off";}}private class WaterOn extends Event {public WaterOn(long eventTime) {super(eventTime);}public void action() {water = true;}public String description(){return "Greenhouse water is on";}}private class WaterOff extends Event {public WaterOff(long eventTime) {super(eventTime);}public void action() {water = false;}public String description() {return "Greenhouse water is off";}}private class ThermostatNight extends Event {public ThermostatNight(long eventTime) {super(eventTime);}public void action() {thermostat = "Night";}public String description() {return "Thermostat on night setting";}}private class ThermostatDay extends Event {public ThermostatDay(long eventTime) {super(eventTime);}public void action() {thermostat = "Day";}public String description() {return "Thermostat on day setting";}}private int rings;private class Bell extends Event{public Bell(long eventTime){super(eventTime);}public void action(){System.out.println("Bing!");if(--rings>0)addEvent(new Bell(System.currentTimeMillis() + 2000));}public String description(){return "Ring bell";}}private class Restart extends Event{public Restart(long eventTime){super(eventTime);}public void action(){long tm = System.currentTimeMillis();rings = 5;addEvent(new ThermostatNight(tm));addEvent(new LightOn(tm + 1000));addEvent(new LightOff(tm + 2000));addEvent(new WaterOn(tm + 3000));addEvent(new WaterOff(tm + 8000));addEvent(new Bell(tm + 9000));addEvent(new ThermostatDay(tm + 10000));addEvent(new Restart(tm + 20000));}public String description() {return "Restarting system";}}public static void main(String[] args) {GreenhouseControls gc = new GreenhouseControls();long tm = System.currentTimeMillis();gc.addEvent(gc.new Restart(tm));gc.run();}} 

运行结果：

 

Restarting system

Thermostat on night setting

Light is on

Light is off

Greenhouse water is on

Greenhouse water is off

Bing!

Ring bell

Thermostat on day setting

Bing!

Ring bell

Bing!

Ring bell

Bing!

Ring bell

Bing!

Ring bell

Restarting system

Thermostat on night setting

Light is on

Light is off

Greenhouse water is on

Greenhouse water is off

Bing!

Ring bell

Thermostat on day setting