设计模式的应用场景(2)--工厂相关模式

简单工厂模式

定义：简单工厂模式又叫做静态工厂模式，它定义一个具体的工厂类来 负责创建一些类的实例，而这些被创建的类应该有一个共同的父类， 这样就可以面向抽象而不是面向具体编程。

说明：不属于23种GOF设计模式；工厂方法一般设成静态方法，返回值一般是抽象类或接口，具体的产品类一般继承或实现抽象类、接口；

优点：产品使用者不需要关心产品类的创建过程，与具体产品的实现类达到解耦的效果；

缺点：违背”开放–封闭”原则(OCP)，因为新增一个产品类的时候，需要修改原先的工厂方法；

适用时机：当工厂类负责创建的对象比较少的时候；

下面举例说明应用场景

小巩要做一个动物管理系统，要求对动物的属性，日常生活记录。

public interface Animal{
public void  eat();
}
public class Dolphin implements Animal {
/*海豚会游泳*/
public void swim() {
System.out.println("海豚会游泳");
}
/*海豚会吃*/
public void eat() {
System.out.println("海豚会吃");
}
}
public class Tiger implements Animal {
/*老虎会跑*/
public void run() {
System.out.println("老虎会跑");
}
/*老虎会吃*/
public void eat() {
System.out.println("老虎会吃");
}
}

问题来了，创建老虎类的时候，要初始化很多变量，老虎的年龄，腿，是否生病等，这样一来，客户端需要加很多代码。

解决方法：用一个单独的类来创建对象和初始化变量，客户端只负责调用，职责清楚，代码变短，利于维护。

public class SampleFactory {
/*根据参数创建不同的对象*/
public static Ani
4000
mal createAnimal (String animalName) {
if ("Tiger".equals(animalName))
return new Tiger();
else if ("Dolphin".equals(animalName))
return new Dolphin();
return null;
}
}
public class Client {
public static void main(String[] args) {
Animal animal = SampleFactory.createAnimal("Tiger");
animal.eat();
animal = SampleFactory.createAnimal("Dolphin");
animal.eat();
}
}

但是，当有新的动物加进来，需要修改原来的工厂类代码，怎么办呢？

工厂方法模式

定义：工厂方法模式中抽象工厂负责定义创建对象的接口， 具体对象的创建工作由实现抽象工厂的具体工厂类来完成。

优点： 在工厂方法模式中，客户端不再负责对象的创建，而是把这个责任交给了具体的工厂类，客户端只负责对象的调用，明确了各个类的职责。 如果有新的产品加进来，只需要增加一个具体的创建产品工厂类和具体的产品类，不会影响其他原有的代码，后期维护更加容易，增强了系统的可扩展性。

缺点： 需要额外的编写代码，增加了工作量。

使用时机：适合比较复杂对象的创建。

//设计一个只负责定义创建方式的抽象工厂类：

public interface Factory
{
public Animal createAnimail();
}

//再分别设计老虎、海豚的具体工厂实现类，都继承抽象工厂类：

public class Trigerfactory implements Factory
{
public Animal createAnimal(){
return new Triger();
}
}

public class Dolphinfactory implements Factory
{
public Animal createAnimal(){
return new Dolphin();
}
}

//客户端调用：

public class Client
{
public static void main(String[] args)
{
Factory factory = new TrierFactory();
Animal animal = factory.createAnimal();
animal.eat();
factory = new DolphinFactory();
animal = fatory.createAnimal();
animal.eat();
}
}

抽象工厂模式

定义：如果客户端需要创建一些产品结构，而这些产品结构由分别属于不同的产品类别，则可以使用抽象工厂模式，抽象工厂模式中的抽象工厂类负责定义创建对象的接口，而这一系列对象的创建工作由实现抽象工厂类的具体工厂类来完成。

原理：抽象工厂模式主要有四部分组成：抽象工厂类，实现抽象工厂类的具体实现类、抽象类和实现抽象类的具体实现类。

优点：在抽象工厂模式中，客户端不再需要负责对象的创建，而是把这个责任交给了具体的工厂类，客户端只负责对对象的调用，明确了各个类的职责。当一系列相互关联的产品被设计到一个工厂里面后，客户端的调用变得简单，而且，更换这一列的产品时，只需要更换一个工厂类即可。

缺点：如果有新的产品加进来，则需要修改抽象工厂类的设计，并同时修改实现这个抽象工厂类的具体实现类，需要额外编写代码，增加了工作量。

使用时机：当系统创建一系列相互关联的对象时，就需要时用抽象工厂模式。

public class AsiaTriger extends Triger
{
public void run(){
System.out.println("亚洲老虎在跑");
}
public void eat(){
System.out.println("亚洲老虎吃东西");
}
}
public class AfricaTriger extends Triger
{
public void run(){}
public void eat(){}
}
public class AfricaDolphin extends Dolphin
{

}
public class AfricaDophin extends Dolphin
{

}

//然后设计一个只负责定义创建方式的抽象工厂类：

public interface Factory
{
Triger createTriger();
Dolphin createDolphin();
}

//再设计适合亚洲老虎，亚洲海豚的具体工厂类；

public class AsiaFactory implements Factory
{
public Triger createTriger(){
return new AsiaTriger();
};
public Dolphin createDolphin(){
return new AsiaDolphin();
};
}

//再设计适合非洲老虎，非洲海豚的具体工厂类；

public class AfricaFactory implements Factory
{
public Triger createTriger(){
return new AfricaTriger();
};
public Dolphin createDolphin(){
return new AfricaDolphin();
};
}

public class Client
{
public static void main(String[] args)
{
Factory factory = new AsiaFactory();
factory.createTriger();
}
}