- 定义
定义一个用于创建对象的接口，让子类决定实例化哪个类。
- 使用场景
在任何需要生成复杂对象的地方，都可以使用工厂方法模式。复杂对象适合使用工厂模式。
public interface Car {
public void make();
public void buy();
}
public class BMW implements Car{
@Override
public void make() {
System.out.println("生产宝马跑车");
}
@Override
public void buy() {
System.out.println("购买宝马跑车");
}
}
public class Ben implements Car{
@Override
public void make() {
System.out.println("生产奔驰跑车");
}
@Override
public void buy() {
System.out.println("购买奔驰跑车");
}
}
public interface CarFactory {
public Car product();
}
public class BWMFactory implements CarFactory{
@Override
public Car product() {
return new BMW();
}
}
public class BenFactory implements CarFactory{
@Override
public Car product() {
return new Ben();
}
}
public class JavaApplication10 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
CarFactory factory = new BenFactory();
Car car = factory.product();
car.make();
car.buy();
factory = new BWMFactory();
factory.product().make();
factory.product().buy();
}
}
这种方式比较常见，需要哪一个产品就创建相应的工厂生产相应的产品，有时候也可以利用反射的方式更简洁地来生产具体产品对象，此时，需要在工厂方法的参数列表中传入一个Class类来决定是哪一个产品类。
public interface Car {
public void make();
public void buy();
}
public class BMW implements Car{
@Override
public void make() {
System.out.println("生产宝马跑车");
}
@Override
public void buy() {
System.out.println("购买宝马跑车");
}
}
public class Ben implements Car{
@Override
public void make() {
System.out.println("生产奔驰跑车");
}
@Override
public void buy() {
System.out.println("购买奔驰跑车");
}
}
public interface CarFactory {
public <T extends Car> T product(Class<T> clz);
}
public class FactoryImpl implements CarFactory{
@Override
public <T extends Car> T product(Class<T> clz) {
Car car = null;
try {
car = (Car) Class.forName(clz.getName()).newInstance();
} catch (ClassNotFoundException ex) {
Logger.getLogger(FactoryImpl.class.getName()).log(Level.SEVERE, null, ex);
} catch (InstantiationException ex) {
Logger.getLogger(FactoryImpl.class.getName()).log(Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
Logger.getLogger(FactoryImpl.class.getName()).log(Level.SEVERE, null, ex);
}
return (T) car;
}
}
public class JavaApplication10 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
CarFactory factory = new FactoryImpl();
Car car = factory.product(BMW.class);
car.make();
car.buy();
factory.product(Ben.class).make();
factory.product(Ben.class).buy();
}
}
当我们的工厂生产的不只是一种产品的时候，就i要考虑将工厂也提取出一个抽象类——抽象工厂模式。例如，BenFactory在生产奔驰车的时候，还要考虑到轮胎的型号(假设有a和b两种型号的轮胎)，那就要将BenFactory提升为抽象类，派生出两种不同的工厂类，一种工厂类专门生产a型号轮胎的奔驰车，一种工厂类专门生产b型号轮胎的奔驰车。
public interface ITire {
void tire();
}
public interface IEngine {
void engine();
}
public class NormalTire implements ITire{
@Override
public void tire() {
System.out.println("普通轮胎");
}
}
public class SUVTire implements ITire{
@Override
public void tire() {
System.out.println("越野轮胎");
}
}
public class AEngine implements IEngine{
@Override
public void engine() {
System.out.println("A型发动机");
}
}
public class BEngine implements IEngine{
@Override
public void engine() {
System.out.println("B型发动机");
}
}
public interface CarFactory {
public ITire createTire();//工厂类就是来生产对象的，因此工厂类的方法里面大都是new一个对象，然后返回。
public IEngine createEngine();
}
public class AFactory implements CarFactory{
@Override
public ITire createTire() {
return new NormalTire();
}
@Override
public IEngine createEngine() {
return new AEngine();
}
}
public class BFactory implements CarFactory{
@Override
public ITire createTire() {
return new SUVTire();
}
@Override
public IEngine createEngine() {
return new BEngine();
}
}
