面向对象及工厂模式和单体模式的简单介绍

首先，我们来看一个简单的例子，我们用必胜客的pizza来做个例子

首先定义一个interface，抽象出生产比萨的过程。

Pizza.java

1. public interface Pizza {   
2.     public void prepare();   
3.   
4.     public void bake();   
5.   
6.     public void cut();   
7.   
8.     public void box();   
9. }  

然后由各种具体的pizza实现它

香荤至尊比萨

MeatPizza.java

1. public class MeatPizza implements Pizza {   
2.     public void prepare() {   
3.         System.out.println("香荤至尊开始准备了");   
4.     }   
5.   
6.     public void bake() {   
7.         System.out.println("香荤至尊开始烘烤");   
8.     }   
9.   
10.     public void cut() {   
11.         System.out.println("香荤至尊切咯");   
12.     }   
13.   
14.     public void box() {   
15.         System.out.println("香荤至尊打包");   
16.     }   
17.   
18. }  

金枪鱼比萨

TunaPizza.java

1. public class TunaPizza implements Pizza {   
2.     public void prepare() {   
3.         System.out.println("金枪鱼开始准备了");   
4.     }   
5.   
6.     public void bake() {   
7.         System.out.println("金枪鱼开始烘烤");   
8.     }   
9.   
10.     public void cut() {   
11.         System.out.println("金枪鱼切咯");   
12.     }   
13.   
14.     public void box() {   
15.         System.out.println("金枪鱼打包");   
16.     }   
17. }  

夏威夷比萨

HawaiianPizza.java

1. public class HawaiianPizza implements Pizza{   
2.     public void prepare() {   
3.         System.out.println("夏威夷开始准备了");   
4.     }   
5.   
6.     public void bake() {   
7.         System.out.println("夏威夷开始烘烤");   
8.     }   
9.   
10.     public void cut() {   
11.         System.out.println("夏威夷切咯");   
12.     }   
13.   
14.     public void box() {   
15.         System.out.println("夏威夷打包");   
16.     }   
17. }  

我们利用多态为我们提供的接口与实现分离，改善程序的组织架构及可读性

下边的代码我们可以看到我们完全可以忘记掉对象类型(type)

1. public class Test {   
2.     public static Pizza orderPizza (String type){   
3.         Pizza pizza = null;   
4.         if (type.equals("Meat"))   
5.         pizza = new MeatPizza();   
6.         else if (type.equals("Tuna"))   
7.         pizza = new TunaPizza();   
8.         else if (type.equals("Hawaiian"))   
9.         pizza = new HawaiianPizza();   
10.         pizza.prepare();   
11.         pizza.bake();   
12.         pizza.cut();   
13.         pizza.box();   
14.         return pizza;   
15.     }   
16.     public static void main(String[] args) {   
17.         System.out.println("金枪鱼比萨");   
18.         Test.orderPizza("Tuna");   
19.         System.out.println("香荤至尊比萨");   
20.         Test.orderPizza("Meat");   
21.         System.out.println("夏威夷比萨");   
22.         Test.orderPizza("Hawaiian");   
23.     }   
24. }  

在这里，我先把这个程序的执行结果帖上，看能不能理解

金枪鱼比萨
金枪鱼开始准备了
金枪鱼开始烘烤
金枪鱼切咯
金枪鱼打包
香荤至尊比萨
香荤至尊开始准备了
香荤至尊开始烘烤
香荤至尊切咯
香荤至尊打包
夏威夷比萨
夏威夷开始准备了
夏威夷开始烘烤
夏威夷切咯
夏威夷打包

 

可能大家无法理解编译器如何知道这个reference（引用）指向的是derived class而不是base class呢？其实编译器是不知道的，其实是binding的缘故，而且是执行期绑定(run-time binding)

这就是多态性的一个重要方面——向上转型(upcasting)

我为什么要给出这个例子呢？还有别的用途，就是想说明一种设计模式——工厂模式

这个例子给出了一个工厂方法，orderPizza,借助这个方法可以生成不同的对象