设计模式的应用场景(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 Animal 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();  
    }  
}