第四章 面向对象程序设计方法
1.题目分析
对于题目一,使用简单工厂模式模拟女娲(Nvwa)造人(Person),女娲充当工厂的角色,而人可以设计为抽象基类,男人,女人,机器人均继承并实现该类。
对于题目二,使用工厂方法模式模拟海尔工厂(Haier)生产海尔空调(HaierAirCondition),美的工厂(Midea)生产美的空调(MideaAirCondition)的情景,相较于题目一中的简单工厂模式,实质上就是细化了工厂的生产分配,即某类产品由唯一的工厂负责生产,互不干涉。因此设计一个抽象工厂基类和抽象空调基类用于继承。
对于题目三,使用抽象工厂模式实现电脑配件生产过程,这就相当于在题目二的基础上又增加了一种不同类别的产品,因此需要再设计一个产品抽象基类,每个工厂并且多生产一种产品。
2.类图设计
一、简单工厂模式
二、工厂方法模式
三、抽象工厂模式
3.程序实现
一、简单工厂模式
package package1;
//抽象基类
abstract class Person{
public abstract void show();//定义的抽象方法
}
//继承并实现抽象基类
class Man extends Person{
//实现抽象方法
public void show(){
System.out.println(“创造了一个Man对象”);
}
}
//继承并实现抽象基类
class Woman extends Person{
//实现抽象方法
public void show(){
System.out.println(“创造了一个Woman对象”);
}
}
//继承并实现抽象基类
class Robot extends Person{
//实现抽象方法
public void show(){
System.out.println(“创造了一个Robot对象”);
}
}
//女娲工厂类,用于造人
class Nvwa{
//根据参数返回具体的子类对象
public Person getPerson(String params){
if(params.equals(“M”))
return new Man();
if(params.equals(“W”))
return new Woman();
if(params.equals(“R”))
return new Robot();
return null;
}
}
//实现类
public class Create {
public static void main(String[] args){
Nvwa nvwa=new Nvwa();//女娲对象
Person person;//Person抽象基类对象
person=nvwa.getPerson(“M”);//Person抽象基类对象指向由女娲工厂生产的Man对象
person.show();//调用Man类实现的show方法
person=nvwa.getPerson(“W”);//Person抽象基类对象指向由女娲工厂生产的Woman对象
person.show();//调用Woman类实现的show方法
person=nvwa.getPerson(“R”);//Person抽象基类对象指向由女娲工厂生产的Robot对象
person.show();//调用Robot类实现的show方法
}
}
二、工厂方法模式
package package1;
//空调基类
abstract class AirCondition{
public abstract void show();
}
//工厂基类
abstract class Factory{
public abstract AirCondition getAirCondition();
}
//继承空调基类的海尔空调类
class HaierAirCondition extends AirCondition{
public void show(){
System.out.println(“生产了Haier空调”);
}
}
//继承空调基类的美的空调类
class MideaAirCondition extends AirCondition{
public void show(){
System.out.println(“生产了Midea空调”);
}
}
//继承工厂基类的海尔工厂类
class HaierFactory extends Factory{
public AirCondition getAirCondition(){
return new HaierAirCondition();
}
}
//继承工厂基类的美的工厂类
class MideaFactory extends Factory{
public AirCondition getAirCondition(){
return new MideaAirCondition();
}
}
//具体实现类
public class TestFactory {
public static void main(String[] args) {
AirCondition aircondition;//定义抽象基类
HaierFactory haierfactory=new HaierFactory();//海尔工厂对象
aircondition=haierfactory.getAirCondition();//抽象空调基类对象指向由海尔工厂生产的海尔空调对象
aircondition.show();//调用海尔空调类中实现的show方法
MideaFactory mideafactory=new MideaFactory();//美的工厂对象
aircondition=mideafactory.getAirCondition();//抽象空调基类对象指向由美的工厂生产的美的空调对象
aircondition.show();//调用美的空调类中实现的show方法
}
}
三、抽象工厂模式
package package1;
//RAM抽象基类
abstract class RAM{
public abstract void show();
}
//CPU抽象基类
abstract class CPU{
public abstract void show();
}
//工厂抽象基类
abstract class Plant{
public abstract RAM getRam();
public abstract CPU getCpu();
}
//继承RAM基类的PcRAM子类
class PcRAM extends RAM{
public void show(){
System.out.println(“生产了PcRAM”);
}
}
//继承RAM基类的MacRAM子类
class MacRAM extends RAM{
public void show(){
System.out.println(“生产了MacRAM”);
}
}
//继承CPU基类的PcCPU子类
class PcCPU extends CPU{
public void show(){
System.out.println(“生产了PcCPU”);
}
}
//继承CPU基类的MacCPU子类
class MacCPU extends CPU{
public void show(){
System.out.println(“生产了PcCPU”);
}
}
//继承Plant工厂基类的PcPlant子类
class PcPlant extends Plant{
public RAM getRam(){
return new PcRAM();
}
public CPU getCpu(){
return new PcCPU();
}
}
//继承Plant工厂基类的MacPlant子类
class MacPlant extends Plant{
public RAM getRam(){
return new MacRAM();
}
public CPU getCpu(){
return new MacCPU();
}
}
//具体实现类
public class TestAbstractFactory {
public static void main(String[] args){
RAM ram;//RAM抽象基类对象
CPU cpu;//CPU抽象基类对象
PcPlant pcfactory=new PcPlant();//PcPlant工厂子类对象
MacPlant macfactory=new MacPlant();//MacPlant工厂子类对象
ram=pcfactory.getRam();//RAM抽象基类对象指向PcPlant工厂子类对象生产的PcRAM对象
ram.show();//调用子类已实现方法
cpu=pcfactory.getCpu();//CPU抽象基类对象指向PcPlant工厂子类对象生产的PcCPU对象
cpu.show();//调用子类已实现方法
ram=macfactory.getRam();//RAM抽象基类对象指向MacPlant工厂子类对象生产的MacRAM对象
ram.show();//调用子类已实现方法
cpu=macfactory.getCpu();//CPU抽象基类对象指向MacPlant工厂子类对象生产的MacCPU对象
cpu.show();//调用子类已实现方法
}
}
4.调试、测试及运行结果
一、简单工厂模式
如上图:每通过女娲生产一个子类对象便调用子类中继承自基类并实现的方法。程序运行结果:
二、工厂方法模式
类似于题目一,不过每个产品由专一且唯一的工厂生产,程序运行结果:
三、抽象工厂模式
类似于题目二,每个工厂新增一项能生产的产品,形成一个产品族,程序运行结果:
5.经验归纳
简单工厂模式:他的最大优点就是在于工厂类包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖,当算法比较稳定,一般不会对它进行新增,或删除等就适合用词模式;否则就会违背了“开放-封闭”原则。
工厂方法模式:它定义了用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延迟到其子类。
抽象方法模式:当产品有不同的系列,而不同的系列又有不同的创建方式,此时就适合用此模式。