工厂方法模式

工厂方法模式就是父类不知道具体子类的情况下实现自己的功能。
这个模式跟IOC有异曲同工之处。IOC的接口也是不知道其实现，然后直接使用其功能。IOC的子类是通过反射来获取的。而且工厂方法子类是后面NEW出来的的。
先看具体的实现
1、接口

public interface Phone {

	public void call();

}

2、3个实现

public class Nokia implements Phone {

	@Override
	public void call() {
		System.out.println("This is nokia");
	}

}

public class Iphone implements Phone {

	@Override
	public void call() {
		System.out.println("This is iphone");
	}

}

public class HTC implements Phone {

	@Override
	public void call() {
		System.out.println("This is HTC");
	}

}

3、工厂方法

public abstract class Factory {

	protected abstract Phone createPhone();

	public void call() {
		Phone phone = createPhone();
		phone.call();
	}
}

4、工厂方法的实现

public class IphoneFactory extends Factory {

	@Override
	protected Phone createPhone() {

		return new Iphone();
	}

}

public class NokiaFactory extends Factory {

	@Override
	protected Phone createPhone() {
		return new Nokia();
	}

}

5、Main方法

public class Main {
	public static void main(String[] args) {
		Factory factory = new IphoneFactory();
		factory.call();
	}
}

这样就是一个工厂方法的简单实现。为什么HTC类没有工厂方法的实现，这个类是为了表示工厂方法的另外一种模式（后面会说到）。
其实这里大家就可以看出工厂方法的优缺点。
最大的优点就是延迟了子类的实现，父类可以在不知道具体子类的情况下完成功能。IOC模式也是类似的
最大的缺点就是工厂方法的实现类与产品的实现类严重耦合。比如诺基亚的工厂方法就必须跟诺基亚的产品耦合，这样大大提高了代码间的耦合度。而且还有一个缺点就是如果有大量的子类，那么工厂方法实现类也会有许多。

下面介绍工厂方法的另外一种模式 带参数的工厂方法

1与2 不变
3、工厂方法

public class FactoryOther {

	protected Phone createPhone(int money) {
		Phone phone = null;
		if (money > 4000) {
			phone = new Iphone();
		} else if (money < 2000) {
			phone = new Nokia();
		}
		return phone;
	}

	public void call(int money) {
		Phone phone = createPhone(money);
		phone.call();
	}
}

public class FactoryOtherChild extends FactoryOther {
	@Override
	protected Phone createPhone(int money) {
		Phone phone = null;
		if (money < 4000 && money > 2000) {
			phone = new HTC();
		} else {
			phone = super.createPhone(money);
		}
		return phone;
	}

}

4、Main方法

public class MainOther {
	public static void main(String[] args) {
		FactoryOther factory = new FactoryOtherChild();
		factory.call(3500);
	}
}

这样能过参数来实现一个简单工厂，这样可以屏蔽掉工厂方法的实现类，减少类的生成。当然缺点跟简单工厂一样。