这个模式跟IOC有异曲同工之处。IOC的接口也是不知道其实现，然后直接使用其功能。IOC的子类是通过反射来获取的。而且工厂方法子类是后面NEW出来的的。
先看具体的实现
1、接口
Java代码
public interface Phone {
public void call();
}
2、3个实现
Java代码
public class Nokia implements Phone {
@Override
public void call() {
System.out.println("This is nokia");
}
}
Java代码
public class Iphone implements Phone {
@Override
public void call() {
System.out.println("This is iphone");
}
}
Java代码
public class HTC implements Phone {
@Override
public void call() {
System.out.println("This is HTC");
}
}
3、工厂方法
Java代码
public abstract class Factory {
protected abstract Phone createPhone();
public void call() {
Phone phone = createPhone();
phone.call();
}
}
4、工厂方法的实现
Java代码
public class IphoneFactory extends Factory {
@Override
protected Phone createPhone() {
return new Iphone();
}
}
Java代码
public class NokiaFactory extends Factory {
@Override
protected Phone createPhone() {
return new Nokia();
}
}
5、Main方法
Java代码
public class Main {
public static void main(String[] args) {
Factory factory = new IphoneFactory();
factory.call();
}
}
这样就是一个工厂方法的简单实现。为什么HTC类没有工厂方法的实现，这个类是为了表示工厂方法的另外一种模式（后面会说到）。
其实这里大家就可以看出工厂方法的优缺点。
最大的优点就是延迟了子类的实现，父类可以在不知道具体子类的情况下完成功能。IOC模式也是类似的
最大的缺点就是工厂方法的实现类与产品的实现类严重耦合。比如诺基亚的工厂方法就必须跟诺基亚的产品耦合，这样大大提高了代码间的耦合度。而且还有一个缺点就是如果有大量的子类，那么工厂方法实现类也会有许多。
下面介绍工厂方法的另外一种模式 带参数的工厂方法
1与2 不变
3、工厂方法
Java代码
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();
}
}
Java代码
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方法
Java代码
public class MainOther {
public static void main(String[] args) {
FactoryOther factory = new FactoryOtherChild();
factory.call(3500);
}
}
这样能过参数来实现一个简单工厂，这样可以屏蔽掉工厂方法的实现类，减少类的生成。当然缺点跟简单工厂一样。
================================引用理论东东=========================如下摘自:爪哇老妖
一、引子
话说十年前，有一个用户，他家有三辆汽车——Benz奔驰、Bmw宝马、Audi奥迪，还雇了司机为他开车。不过，用户坐车时总是怪怪的：上 Benz车后跟司机说“开奔驰车！”，
坐上Bmw后他说“开宝马车！”，坐上Audi说“开奥迪车！”。你一定说：这人有病！直接说开车不就行了？！ 而当把这个用户的行为放到我们程序设计中来时，会发现这是一个
普遍存在的现象。幸运的是，这种有病的现象在OO（面向对象）语言中可以避免了。下面就以Java语言为基础来引入我们本文的主题：工厂模式。
二、工厂模式分为：
工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
1、简单工厂模式（Simple Factory） ：又称静态工厂方法模式，重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。 但不利于产生系列产品。
在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化, 如同一个交通警察站在来往的车辆流中,决定放行那一个方向的车辆向那一个方向流动一样。
Simple Factory 模式角色组成：
1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
下面我们从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式：
当用户增加了一辆车的时候，只要符合抽象产品制定的合同，那么只要通知工厂 类知道就可以被客户使用了。所以对产品部分来说，它是符合开闭原则的；但是工厂部分好像不太理想，
因为每增加一辆车，都要在工厂类中增加相应的业务逻辑或 者判断逻辑，这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类（在我们的例子
中是为CarFactory），我们称它为全能类或者上帝类。
我们举的例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中