工厂模式

目的：为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性。 

一、分类

       1、简单工厂模式，又叫静态工厂模式

       2、工厂方法模式

       3、抽象工厂模式

二、简单工厂模式

         1、定义：定义了一个可选择对象实例化的接口

         2、优点：屏蔽了对象的创建过程，增加对象是无需改变客户端

         3、缺点：对
4000
开闭原则支持不够，增加新产品是需要修改工厂类

         4、组成：   1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。 

                              2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。 

                              3) 具体产品角色：继承抽象产品角色，工厂类所创建的对象就是此角色的实例。

      5、实例

          抽象产品角色：

package simplefactory;

public interface Animal {

void print();

}

     具体产品角色：

        

package simplefactory;

public class Dog implements Animal{

@Override
public void print() {
// TODO Auto-generated method stub
System.out.println("i am dog");
}

}

<pre name="code" class="java">package simplefactory;

public class Cat implements Animal {

@Override
public void print() {
// TODO Auto-generated method stub
System.out.println("i am cat");
}

}

   工厂类角色：

      

package simplefactory;

public class AnimalFactory {

public  static Animal product(String s)
{
if(s.equals("dog"))
return new Dog();
else if(s.equals("cat"))
return new Cat();
else
{
System.out.println("can product this animal");
return null;
}

}

}

       测试类：

package simplefactory;

public class SimpleTest {

public static void main(String[] args) {
// TODO Auto-generated method stub
AnimalFactory.product("dog").print();//产生具体对象
AnimalFactory.product("cat").print();
AnimalFactory.product("bird").print();//产生异常
}

}

三、工厂方法模式

      1、定义：定义一个用于创建对象的接口，让子类决定实例化那个类。使一个类的实例化延时到其子类。

      2、组成

              a、抽象工厂角色：工厂方法的核心，任何创建对象的工厂类都必须实现这个接口

              b、具体工厂角色：实现抽象工厂角色，含有与应用密切相关的逻辑，受应用程序的调用以创建对象

             c、抽象产品角色：如简单工厂模式

             D、具体产品角色：如简单工厂模式

       3、应用

         抽象产品角色和具体产品角色不变，为工厂类改为接口变为抽象工厂角色，具体工厂角色实现该接口，要拓展新产品时不需改变抽象工厂角色和客户端，增加新产品类和相应具体工厂类即可。

      抽象工厂角色：

package factorymethod;

import simplefactory.Animal;

public interface AnimalFactory {

Animal factory();
}

      具体工厂角色：

      

package factorymethod;

import simplefactory.Animal;
import simplefactory.Cat;

public class CatFactory implements AnimalFactory{

@Override
public Animal factory() {
// TODO Auto-generated method stub
return new Cat();
}

}

package factorymethod;

import simplefactory.Animal;
import simplefactory.Dog;

public class DogFactory implements AnimalFactory{

@Override
public Animal factory() {
// TODO Auto-generated method stub
return new Dog();
}

}

   测试类：

   

package factorymethod;

public class Test {

public static void main(String[] args) {
// TODO Auto-generated method stub
AnimalFactory factorydog=new DogFactory();
AnimalFactory factorycat=new CatFactory();
factorydog.factory().print();
factorycat.factory().print();
}

}

运行结果：

i am dog

i am cat

四、抽象工厂模式

   1、定义：为创建相关会相互依赖的对象提供一个接口，而且无需指定他们的具体类。

    2、组成：如工厂方法模式；（具体工厂类需要处理选择实例化的对象）

3、优点：  抽象工厂模式除了具有工厂方法模式的优点外，最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族，一般或多或少的都存在一定的关联，抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述，而不必专门引入一个新的类来进行管理。

   4、缺点：产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。

   5、应用场景：具有多种产品和存在产品等级

    6、例子

       抽象工厂：

package abstractfactory;

import simplefactory.Animal;

public interface AbstractFactory {

Animal product1();

Fruit product2();

}


    实体工厂：
   package abstractfactory;

import simplefactory.Animal;
import simplefactory.Dog;

public class Factory1 implements AbstractFactory{

@Override
public Animal product1() {
// TODO Auto-generated method stub
return new Dog();
}

@Override
public Fruit product2() {
// TODO Auto-generated method stub
return new Apple();
}
}

package abstractfactory;

import simplefactory.Animal;
import simplefactory.Cat;

public class Factory2 implements AbstractFactory{

@Override
public Animal product1() {
// TODO Auto-generated method stub
return new Cat();
}

@Override
public Fruit product2() {
// TODO Auto-generated method stub
return new Banana();
}

}

抽象产品类：

package abstractfactory;

public interface Fruit {
void print();
}

package simplefactory; public interface Animal { void print(); }


具体产品

package abstractfactory;

public class Apple implements Fruit{

@Override
public void print() {
// TODO Auto-generated method stub
System.out.println("i am apple");
}

}

package abstractfactory;

public class Banana implements Fruit {

@Override
public void print() {
// TODO Auto-generated method stub
System.out.println("i am banana");
}

}

package simplefactory;

public class Dog implements Animal{

@Override
public void print() {
// TODO Auto-generated method stub
System.out.println("i am dog");
}

}

package simplefactory;

public class Cat implements Animal {

@Override
public void print() {
// TODO Auto-generated method stub
System.out.println("i am cat");
}

}

   测试类：

package abstractfactory;

public class Test {

public static void main(String[] args) {
// TODO Auto-generated method stub
AbstractFactory factory1=new Factory1();
factory1.product1().print();
factory1.product2().print();
AbstractFactory factory2=new Factory2();
factory2.product1().print();
factory2.product2().print();
}

}