Thinking in Java
第四版练习18 创建一个Cycle接口,及其Unicycle、Bicycle、Tricycle实现。对每种类型的Cycle都创建工厂,然后编写代码使用这些工厂。
package interfaces;
interface Cycle{
int wheels();
}
interface CycleFactory{
Cycle getCycle();
}
class Unicycle implements Cycle{
public int wheels(){
return 1;
}
}
class UnicycleFactory implements CycleFactory{
public Cycle getCycle(){
return new Unicycle();
}
}
class Tricycle implements Cycle{
public int wheels(){
return 3;
}
}
class TricycleFactory implements CycleFactory{
public Cycle getCycle(){
return new Tricycle();
}
}
class Bicycle implements Cycle{
public int wheels(){
return 2;
}
}
class BicycleFactory implements CycleFactory{
public Cycle getCycle(){
return new Bicycle();
}
}
public class E18_CycleFactory {
public static void CycleWheels(CycleFactory factory){
Cycle cycle=factory.getCycle();
System.out.println(cycle.wheels());
}
public static void main(String[] args){
CycleWheels(new TricycleFactory());
CycleWheels(new BicycleFactory());
CycleWheels(new UnicycleFactory());
}
}
练习19,使用工厂方法创建一个框架,可以执行抛硬币和掷骰子的功能。
package interfaces;
interface Tossing{
boolean result();
}
interface TossingFactory{
Tossing getTossing();
}
class CoinTossing implements Tossing{
private int events;
private static final int EVENTS=2;
public boolean result(){
System.out.println(events);
return ++events!=EVENTS;
}
}
class CoinTossingFactory implements TossingFactory{
public Tossing getTossing(){
return new CoinTossing();
}
}
class DiceTossing implements Tossing{
private int events;
private static final int EVENTS=6;
public boolean result(){
System.out.println(events);
return ++events!=EVENTS;
}
}
class DiceTossingFactory implements TossingFactory{
public Tossing getTossing(){
return new DiceTossing();
}
}
public class E19_TossingFactory {
public static void simulate(TossingFactory factory){
Tossing t=factory.getTossing();
while(t.result()){
;
}
}
public static void main(String[] args){
simulate(new CoinTossingFactory());
simulate(new DiceTossingFactory());
}
}
接口是实现多重继承的途径,而生成遵循某个接口的对象的典型方式是工厂方法设计模式。
通过工厂方式,代码将完全与接口的实现分离,这样就可以透明的将某个实现替换为另一种实现。