java设计模式3种工厂模式
工厂模式分为三种：
Simple Factory模式
专门定义一个类来负责创建其它类的实例，被创建的实例通常都具有共同的父类。
Factory Method模式
将对象的创建交由父类中定义的一个标准方法来完成，而不是其构造函数，究竟应该创建何种对象由具体的子类负责决定。
Abstract Factory模式
提供一个共同的接口来创建相互关联的多个对象。
一、Simple Factory模式：
水果接口：Fruit.java
package designpattern.factory.simplefactory;
public interface Fruit {
void plant();
void enableEat();
}苹果类实现水果接口：Apple.java
package designpattern.factory.simplefactory;
public class Apple implements Fruit{
@Override
public void enableEat() {
System.out.println("Eat Apple");
}
@Override
public void plant() {
System.out.println("Plan Apple");
}
}葡萄类实现水果接口：Grape.java
package designpattern.factory.simplefactory;
public class Grape implements Fruit{
@Override
public void enableEat() {
System.out.println("Eat Grape");
}
@Override
public void plant() {
System.out.println("Plant Grape");
}
}买水果工厂类，可根据不同的参数类型返回对应的实例：FruitFactory .java
package designpattern.factory.simplefactory;
public class FruitFactory {
public static Fruit getFruitFactory(String fruitType){
if (fruitType.equals("Apple")){
return new Apple();
}
if (fruitType.equals("Grape")){
return new Grape();
}
return null;
/*Fruit fruit = null;
try {
fruit = (Fruit)Class.forName("designpattern.factory.simplefactory." + fruitType).newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return fruit;*/
}
}测试类，根椐不同的输入参数从工厂类中得到对应的实例并调用相应实例的方法：FruitTest.java
package designpattern.factory.simplefactory;
public class FruitTest {
/**
* @param args
*/
public static void main(String[] args) {
Fruit fruit = FruitFactory.getFruitFactory("Apple");
fruit.plant();
fruit.enableEat();
}
}
A：我要需要苹果，只需向工厂角色（FruitFactory）请求即可。而工厂角色在接到请求后，会自行判断创建和提供哪一个产品。
B：但是对于工厂角色（FruitFactory）来说，增加新的产品（比如说增加草莓）就是一个痛苦的过程。工厂角色必须知道每一种产品，如何创建它们，以及何时向客户端提供它们。换言之，接纳新的产品意味着修改这个工厂。
C：因此Simple Factory模式的开放性比较差。
有什么办法可以解决这个问题吗？那就需要Factory Method模式来为我们服务了。
二、Factory Method 模式：
把水果工厂定义成接口再用各种水果去实现自己的实例，这样做的好处就是如果再增加一种水果，只要增加它的对象和实现工厂就可以了，而不必修改任何代码。
水果接口：
Fruit.java
package designpattern.factory.simplefactory;
public interface Fruit {
void plant();
void enableEat();
}苹果类实现水果接口：Apple.java
package designpattern.factory.simplefactory;
public class Apple implements Fruit{
@Override
public void enableEat() {
System.out.println("Eat Apple");
}
@Override
public void plant() {
System.out.println("Plan Apple");
}
}葡萄类实现水果接口：
Grape.java
package designpattern.factory.simplefactory;
public class Grape implements Fruit{
@Override
public void enableEat() {
System.out.println("Eat Grape");
}
@Override
public void plant() {
System.out.println("Plant Grape");
}
}苹果工厂类
：AppleFactory.java
package designpattern.factory.factorymodel;
public class AppleFactory implements FruitFactory {
@Override
public Fruit getFruitFactory() {
return new Pear();
}
}葡萄工厂类：
GrapeFactory.java
package designpattern.factory.factorymodel;
public class GrapeFactory implements FruitFactory {
@Override
public Fruit getFruitFactory() {
return new Grape();
}
}水果工厂类：
FruitFactory .java
package designpattern.factory.factorymodel;
public interface FruitFactory {
public Fruit getFruitFactory();
}测试类：
FruitTest.java
package designpattern.factory.factorymodel;
public class FruitTest {
/**
* @param args
*/
public static void main(String[] args) {
//Apple
AppleFactory appleFactory = new AppleFactory();
appleFactory.getFruitFactory().plant();
appleFactory.getFruitFactory().enableEat();
//So if you want add pear, you shall add pear and pear factory class.
//and not need modify anything.
//Pear
PearFactory pearFactory = new PearFactory();
pearFactory.getFruitFactory().plant();
pearFactory.getFruitFactory().enableEat();
}
}上面加了一个梨的水果，所以只要添加对应的代码即可。
A：工厂方法模式和简单工厂模式在结构上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。工厂方法模式可以允许很多具体工厂类从抽象工厂类中将创建行为继承下来，从而可以成为多个简单工厂模式的综合，进而推广了简单工厂模式。
B：工厂方法模式退化后可以变得很像简单工厂模式。设想如果非常确定一个系统只需要一个具体工厂类，那么就不妨把抽象工厂类合并到具体的工厂类中去。由于反正只有一个具体工厂类，所以不妨将工厂方法改成为静态方法，这时候就得到了简单工厂模式。C：如果需要加入一个新的水果，那么只需要加入一个新的水果类以及它所对应的工厂类。没有必要修改客户端，也没有必要修改抽象工厂角色或者其他已有的具体工厂角色。对于增加新的水果类而言，这个系统完全支持"开-闭"原则。
D：对Factory Method模式而言，它只是针对一种类别（如本例中的水果类Fruit），但如果我们还想买肉，那就不行了，这是就必须要Abstract Method模式帮忙了。
三、Abstract Method 模式：
A：抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，创建多个产品族中的产品对象。这就是抽象工厂模式的用意。
B：抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。
C：抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品（Fruit）等级结构；而抽象工厂模式则需要面对多个产品等级结构(Fruit、Meat)。
Fruit.java
package designpattern.factory.abstractfactory;
public interface Fruit {
void plant();
void enableEat();
}
Fruit.java
package designpattern.factory.abstractfactory;
public class Apple implements Fruit{
@Override
public void enableEat() {
System.out.println("Eat Apple");
}
@Override
public void plant() {
System.out.println("Plan Apple");
}
}
Grape.java
package designpattern.factory.abstractfactory;
public class Grape implements Fruit{
@Override
public void enableEat() {
System.out.println("Eat Grape");
}
@Override
public void plant() {
System.out.println("Plant Grape");
}
}
Pear.java
package designpattern.factory.abstractfactory;
public class Pear implements Fruit{
@Override
public void enableEat() {
System.out.println("Eat Pear");
}
@Override
public void plant() {
System.out.println("Plan Pear");
}
}
Apple.java
package designpattern.factory.abstractfactory;
public class Apple implements Fruit{
@Override
public void enableEat() {
System.out.println("Eat Apple");
}
@Override
public void plant() {
System.out.println("Plan Apple");
}
}
Meat.java
package designpattern.factory.abstractfactory;
public interface Meat {
void feed();
void enableEat();
}
Cow.java
package designpattern.factory.abstractfactory;
public class Cow implements Meat {
@Override
public void enableEat() {
System.out.println("Eat Cow");
}
@Override
public void feed() {
System.out.println("Feed Cow");
}
}
Pig.java
package designpattern.factory.abstractfactory;
public class Pig implements Meat {
@Override
public void enableEat() {
System.out.println("Eat Pig");
}
@Override
public void feed() {
System.out.println("Feed Pig");
}
}
IFactory.java
package designpattern.factory.abstractfactory;
public interface IFactory {
public Fruit getFruitFactory(Fruit whichFruit);
public Meat getMeatFactory(Meat whichMeat);
}
MyFactory.java
package designpattern.factory.abstractfactory;
public class MyFactory implements IFactory {
@Override
public Fruit getFruitFactory(Fruit whichFruit) {
// TODO Auto-generated method stub
return whichFruit;
}
@Override
public Meat getMeatFactory(Meat whichMeat) {
// TODO Auto-generated method stub
return whichMeat;
}
}
FruitTest .java
package designpattern.factory.abstractfactory;
public class FruitTest {
/**
* @param args
*/
public static void main(String[] args) {
Fruit apple = new Apple();
Meat pig = new Pig();
MyFactory my = new MyFactory();
my.getFruitFactory(apple).plant();
my.getFruitFactory(apple).enableEat();
System.out.println("---------------------------");
my.getMeatFactory(pig).feed();
my.getMeatFactory(pig).enableEat();
}
}
