设计模式-工厂模式

一、定义

  实例化对象，用工厂方法代替new操作。

  将选择实现类、创建对象统一管理和控制。从而将调用者跟实现类分离。

二、实现

• 简单工厂：用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已 有代码）

//抽象产品
public interface Car {
	public void run();
}

//具体产品1
public class BMW implements Car {
	@Override
	public void run() {
		System.out.println("BMW run...");
	}
}

//具体产品2
public class Audi implements Car{
	@Override
	public void run() {
		System.out.println("Audi run...");
	}
}


//工厂
public class CarFactory {
	public static Car createCar(String type) {
		if("奥迪".equals(type)) {
			return new Audi();
		}else if("宝马".equals(type)) {
			return new BMW();
		}
		return null;
	}
}

//工厂
public class CarFactory1 {
	public static Car createAudi() {
		return new Audi();
	}
	public static Car createBMW() {
		return new BMW();
	}
}


public class Client {
	public static void main(String[] args) {
		Car c1=CarFactory.createCar("奥迪");
		Car c2=CarFactory.createCar("宝马");
		c1.run();
		c2.run();
		
		c1=CarFactory1.createBMW();
		c2=CarFactory1.createAudi();
		c1.run();
		c2.run();
	}
}

• 工厂方法：用来生产同一等级结构中的固定产品。（支持增加任意产品） 

public interface Car {
	public void run();
}

public class BMW implements Car {
	@Override
	public void run() {
		System.out.println("BMW run...");
	}
}

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


public interface CarFactory {
	Car createCar();
}

public class BMWFactory implements CarFactory{
	@Override
	public Car createCar() {
		return new BMW();
	}
}

public class AudiFactory implements CarFactory{
	@Override
	public Car createCar() {
		return new Audi();
	}
}


public class Client {
	public static void main(String[] args) {
		Car c1=new AudiFactory().createCar();
		Car c2=new BMWFactory().createCar();
		
		c1.run();
		c2.run();
	}
}

• 抽象工厂：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持 增加产品族）

public interface Engine {
	void start();
}

public class EngineLow implements Engine{
	@Override
	public void start() {
		System.out.println("启动慢。。。。。。");
	}
}

public class EngineLuxury implements Engine{
	@Override
	public void start() {
		System.out.println("启动快。。。。。。");
	}
}


public interface Seat {
	void message();
}

public class SeatLow implements Seat {
	@Override
	public void message() {
		System.out.println("布。。。。");
	}
}

public class SeatLuxury implements Seat {
	@Override
	public void message() {
		System.out.println("真皮。。。。。。");
	}
}


public interface CarFactory {
	Engine creatEngine();
	Seat creatSeat();
}

public class CarLow implements CarFactory {
	@Override
	public Engine creatEngine() {
		return new EngineLow();
	}
	@Override
	public Seat creatSeat() {
		return new SeatLow();
	}
}

public class CarLuxury implements CarFactory{
	@Override
	public Engine creatEngine() {
		return new EngineLuxury();
	}
	@Override
	public Seat creatSeat() {
		return new SeatLuxury();
	}
}


public class Client {
	public static void main(String[] args) {
		CarFactory factory=new CarLow();
		Engine e=factory.creatEngine();
		e.start();
		Seat s=factory.creatSeat();
		s.message();
	}
}

三、应用场景

工厂方法模式通常适用于以下场景。

• 客户只知道创建产品的工厂名，而不知道具体的产品名。
• 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
• 客户不关心创建产品的细节，只关心产品的品牌。