简单的工厂模式和工厂方法模式

1,简单的工厂模式

简单的说就是通过一个工厂类，对接口和类进行统一的管理。
我们先通过一个例题来说明一问题。

例子：我要买手机。

1，定义接口，用来买手机。

public interface OnPhone {
	/**
	 * 要购买的手机.
	 */
 void payPhone();
 
}

2，创建各种品牌的手机，实现上面的接口。

//小米
public class Mi implements OnPhone {
	@Override
	public void payPhone() {
		System.out.println("我是小米，万物基于MIUI,便宜又实惠，买了");
	}
}

//华为
public class Huawei implements OnPhone {

	@Override
	public void payPhone() {
		System.out.println("有点贵哈,但是没有啥大问题，买了");
	}
}

//苹果
public class Pingguo implements OnPhone {

	@Override
	public void payPhone() {
		System.out.println("这个更贵,不过有钱，任性，买了");
	}
}

接着就是我们的测试类

//买了两部手机
public class Text {
	
	public static void main(String[] args) {
		OnPhone mi = new Mi();
		mi.payPhone();
		
		OnPhone pingguo = new Pingguo();
		pingguo.payPhone();
	}
}

结果如下，

我是小米，万物基于MIUI,便宜又实惠，买了
这个更贵,不过有钱，任性，买了

我们观察上面的代码，其实是很好的完成了任务，但是我们的实现类和接口紧密的连接在了一起，耦合很高，在想一下，你要买手机，直接去找厂家买吗？，肯定是找一个代理人，或者是一个官方的软件呀，所以就引出了工厂模式。

我门在添加一个类Fragory，用它来管理手机，你要买什么只要找它就行。

public class Fragory {
	
	public static final int TYPE_MI = 1;//小米
	public static final int TYPE_HUA= 2;//华为
	public static final int TYPE_pingguo = 3;//苹果
	
	public static OnPhone createPhone(int type){
		switch(type){
		case TYPE_MI:
			return new Mi();
		case TYPE_HUA:
			return new Huawei();
		case TYPE_pingguo:
			return new Pingguo();
		default:
			System.out.println("没有这种手机");
			return null; 
		}
	}
	
}

只要调用这个类的静态工厂的方法里传入你需要购买的手机，然后就好了。如下所示：

public class Text {
	
	public static void main(String[] args) {
		OnPhone phone = Fragory.createPhone(Fragory.TYPE_MI);
		phone.payPhone();
	}
}

下面我们看一下这个模式的优点和缺点：

优点：

• 通过一个静态的方法。就可以拿到所需要的东西，降低了耦合度。
• 简单的工厂模式包含必要的判断逻辑，简单工厂实现了对象的创建和使用的分离。
• 在不修改任何客户端代码的情况下更换和怎家新的具体产品类，在一定程度上提高了系统的灵活性。

缺点：

• 扩展性很差，如果有很多部手机的话，就好定义很多的类，每一个类对应着一部手机。而且还要修改静态工厂，这样就违反了封闭原则，而且会变得非常麻烦。
• 工厂类的职责过重，如果静态工厂出现了问题，则整个系统都会出现问题。
• 简单工厂的静态方法，使得工厂角色无法形成基于继承的等级结构。

---

工厂方法：

工厂方法则避免了 违反开放封闭原则，其实他的实现方法也非常简单，就是每个产品都对应着一个工厂。

如上面简单工厂，简单的说就是多个产品对应着一个静态的工厂方法。而工厂方法则是多个产品对应着多个工厂。下面我们看一下实现；

1,定义产品抽象类：

//产品抽象类
public abstract class Product {
	//显示产品
	public abstract void show();
	
}

2，定义产品实现类：

public class ProductMi extends Product{
	public void show() {
		System.out.println("生产小米手机");
	}
}


public class ProdcutHuaWei extends Product{
	public void show() {
		System.out.println("生产华为手机");
	}
}

public class ProductPingGuo extends Product{
	public void show() {
		System.out.println("生产苹果手机");
	}
}

3，定义工厂抽象类。

public abstract class Fractory {

	String name;
	
	//工厂名字
	public Fractory(String name){
		this.name = name;
		print();
	}
	public void print(){
		System.out.println(name);
	}
	//生产东西
	public abstract Product setProduct();
	
}

4，定义工厂的实现类，每个产品对应一个工厂实现类。

public class FractoryMi extends Fractory {

	public FractoryMi() {
		super("我是小米工厂");
	}
	@Override
	public Product setProduct() {
		// TODO Auto-generated method stub
		return new ProductMi();
	}
}

public class FractoryHuaWei extends Fractory{

	public FractoryHuaWei() {
		super("我是华为工厂");
	}

	@Override
	public Product setProduct() {
		return new ProdcutHuaWei();
	}
}

public class FractoryPingguo extends Fractory{

	public FractoryPingguo() {
		super("我是苹果工厂");
	}

	@Override
	public Product setProduct() {
		return new ProductPingGuo();
	}
}

每个工厂里面都有自己的名字，并且创建一个对应的产品对象，通过向上转型返回了出去。

5，使用：

public class Go {
	
	public static void main(String[] args) {
		FractoryMi mi = new FractoryMi();
		mi.setProduct().show();
	}
}

结果如下：

我是小米工厂
生产小米手机

通过创建对应的产品工厂，就可以拿到对应的产品对象，然后调用他的shou方法。

优点：

• 通过常见对应的产品工厂，就能拿到对应的产品对象，同时隐藏了产品被实例化的细节。用户只需要关注工厂，就可以了，不需要知道产品实现的细节。
• 在创建新产品的时候，只需要增加工厂和创建的产品分别实现对应的抽象类就好了，完全符合 封闭性原则。
• 创建对象的细节完全封装在具体的工厂内部，而且有了抽象的工厂类，所有的工厂都继承了自己的父类！完美的体现了多态。

缺点；

• 在增加新的产品时，也必须增加细心地工厂类，会造成额外的开销。
• 抽象层的加入使得理解起来变得有点困难。