工厂模式

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

一、分类

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

       2、工厂方法模式

       3、抽象工厂模式

二、简单工厂模式

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

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

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

         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();
	}


}