工厂方法模式

产品由某一具体工厂的同一方法生产， 工厂只需被告知具体产品的类型就可以了。 适用单一系列多产品的场景。

废话少说， 上代码：

产品的抽象

public interface Car {
	void showDesc();

	void start();

	void showCurrentSpeed();

	void stop();
}

具体的产品1

public class Benz implements Car {

	@Override
	public void showCurrentSpeed() {
		System.out.println("210");
	}

	@Override
	public void showDesc() {
		System.out.println("I'm Benz");
	}

	@Override
	public void start() {
		System.out.println("Benz started...");
	}

	@Override
	public void stop() {
		System.out.println("Benz stoped...");
	}
}

具体的产品2

public class BMW implements Car {

	@Override
	public void showCurrentSpeed() {
		System.out.println("200");
	}

	@Override
	public void showDesc() {
		System.out.println("I'm BMW");
	}

	@Override
	public void start() {
		System.out.println("BMW started...");
	}

	@Override
	public void stop() {
		System.out.println("BMW stoped...");
	}
}

具体的产品3

public class Audi implements Car {

	@Override
	public void showCurrentSpeed() {
		System.out.println("180");
	}

	@Override
	public void showDesc() {
		System.out.println("I'm Audi");
	}

	@Override
	public void start() {
		System.out.println("Audi started...");
	}

	@Override
	public void stop() {
		System.out.println("Audi stoped...");
	}
}

工厂的抽象

public abstract class AbstractCarFactory {
	public abstract <T extends Car> T createCar(Class<T> c);
}

具体的工厂

public class CarFactory extends AbstractCarFactory {

	@Override
	public <T extends Car> T createCar(Class<T> c) {
		Car car = null;

		try {
			car = (Car) Class.forName(c.getName()).newInstance();
		} catch (Exception e) {
			// Handle exception...
		}

		return (T) car;
	}
}

客户端代码

private static void testFactory() {
	AbstractCarFactory carFactory = new CarFactory();

	Car audi = carFactory.createCar(Audi.class);
	audi.showDesc();
	audi.start();
	audi.showCurrentSpeed();
	audi.stop();

	Car bmw = carFactory.createCar(BMW.class);
	bmw.showDesc();
	bmw.start();
	bmw.showCurrentSpeed();
	bmw.stop();

	Car benz = carFactory.createCar(Benz.class);
	benz.showDesc();
	benz.start();
	benz.showCurrentSpeed();
	benz.stop();
}

运行结果：

引用

I'm Audi
Audi started...
180
Audi stoped...
I'm BMW
BMW started...
200
BMW stoped...
I'm Benz
Benz started...
210
Benz stoped...

评论

2 楼 huhu_long 2011-10-17  

而针对于 抽象工厂方法 则侧重在 多产品 多系列 的情况下

这样，

对于多产品 则可以形成 工厂的抽象
对于多系列 则可以形成 产品的抽象

比如产品， AbstractCarFactory - BMWFactory, AudiFactory

而对系列， AbstractCar - BMWSerial5, BMWSerial6, BMWSerial7; AudiA4, AudiA6, AudiA8.

比如：

// 场景类
public static void main(String[] args) {
	AbstractCarFactory bmwFactory = new BMWFactory();
	BMWSerial7 bmwSerial7 = bmwFactory.createCar(BMWSerial7.class);
	bmwSerial7.run();

	AbstractCarFactory audiFactory = new AudiFactory();
	AudiA8 audiA8 = audiFactory.createCar(AudiA8.class);
	audiA8.run();
}

// 抽象工厂
public abstract class AbstractCarFactory {
	public abstract <T extends AbstractCar> T createCar(Class<T> c);
}

// BMW工厂
public class BMWFactory extends AbstractCarFactory {

	@Override
	public <AbstractBMW extends AbstractCar> AbstractBMW createCar(Class<AbstractBMW> c) {
		AbstractBMW t = null;

		try {
			t = (AbstractBMW) Class.forName(c.getName()).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}

		return t;
	}

}

// Audi工厂
public class AudiFactory extends AbstractCarFactory {

	@Override
	public <AbstractAudi extends AbstractCar> AbstractAudi createCar(Class<AbstractAudi> c) {
		AbstractAudi t = null;

		try {
			t = (AbstractAudi) Class.forName(c.getName()).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}

		return t;
	}

}

// 抽象Car
public abstract class AbstractCar {
	public abstract void run();
}

// 抽象BMW
public abstract class AbstractBMW extends AbstractCar {

	@Override
	public void run() {
		System.out.println("BMW is running.");
	}

}

// 抽象Audi
public abstract class AbstractAudi extends AbstractCar {

	@Override
	public void run() {
		System.out.println("Audi is running.");
	}

}

// 具体 BMWSerial7
public class BMWSerial7 extends AbstractBMW {

	@Override
	public void run() {
		System.out.println("BMW Serial 7...");
	}

}

// 具体 AudiA8
public class AudiA8 extends AbstractAudi {

	@Override
	public void run() {
		System.out.println("Audi A8...");
	}

}

这样的话，如果需要新加 AudiA6, AudiA4, BMWSerial6 等等只需要添加一个类就可以了。

1 楼 huhu_long 2011-10-17  

工厂方法 和 简单工厂方法 的区别在于 简单工厂不需要抽象， 而工厂方法则提供了抽象的可能， 可以在上面进行进一步的扩充。

pubic class SampleFactory {
    public static <T extends Car> T createCar(Class<T> c) {
        return (Car) Class.forName(c.getName()).newInstance();
    }
}

而 工厂方法
public class CarFactory extends AbstractFactory {
    @Override
    public <T extends Car> T createCar(Class<T> c) {
        return (Car) Class.forName(c.getName()).newInstance();
    }
}

在使用上
SimpleCarFactory.createCar(Audi.class);

以及
AbstractCarFactory carFactory = new CarFactory();
carFactory.createCar(Audi.class);