设计模式(3)：工厂模式

一.工厂模式

• 实现了创建者和调用者的分离。

二.分类

• 简单工厂模式

  • 用来生产同一等级结构中的任意产品。(对于新增产品，需要修改已有代码。用的最多）

  • 要点: 简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。

• 工厂方法模式

  • 用来生产同一等级结构中的固定产品。(支持增加任意产品)

  • 要点：

    • 为了避免简单工厂模式的缺点，不完全满足OCP原则。
    • 工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个(对于一个项目或一个独立模块而言)工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

• 抽象工厂模式

  • 用来生产不同产品族的全部产品。(对于增加新的产品，无能为力；支持增加产品族)
    
    

三.要点:

• $理论上工厂方法模式更优，但实际上，我们一般都使用简单工厂模式。$
  
  

四.核心本质

• 实例化对象，用工厂方法代替new操作；
• 将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。
  
  

五.具体实现

• 1.简单工厂模式

• • 代码实现

• • • 类和接口

/**
 * 车运行的接口
 */
public interface Car {
	void run();
}
/**
 * 奥迪车运行实现类 
 */
public class Audi implements Car {
	@Override
	public void run() {
		System.out.println("奥迪在跑。。。");
	}
}
/**
 * 比亚迪车运行实现类 
 */
public class Byd implements Car {
	@Override
	public void run() {
		System.out.println("比亚迪在跑。。。");
	}
}

• • • 简单工厂类1(也称静态工厂)

/**
 * 简单工厂类1(也称静态工厂)
 * @author Administrator
 *
 */
public class CarFactory {
	public static Car createCar(String type){
		if("奥迪".equals(type)){
			return new Audi();
		}else if("比亚迪".equals(type)){
			return new Byd();
		}else{
			return null;
		}
	}
}
/**
 *  简单工厂类调用
 * @author admin
 */
public static void main(String[] args) {
	Car c1= CarFactory.createCar("奥迪");
	Car c2= CarFactory.createCar("比亚迪");
	c1.run();
	c2.run();
}

• • • 简单工厂类2(也称静态工厂)

/**
 * 简单工厂类2(也称静态工厂)
 * @author Administrator
 *
 */
public class CarFactory {
	public static Car createAudi(){
		return new Audi();	
	}
	public static Car createByd(){
		return new Byd();	
	}
}
/**
 *  简单工厂类实现
 * @author admin
 */
public static void main(String[] args) {
	Car c1= CarFactory.createAudi();
	Car c2= CarFactory.createByd();
	c1.run();
	c2.run();
}

• 2.工厂方法模式

• • 代码实现

• • • 类和接口

/**
 * 车运行的接口
 */
public interface Car {
	void run();
}
/**
 * 奥迪车运行实现类 
 */
public class Audi implements Car {
	@Override
	public void run() {
		System.out.println("奥迪在跑。。。");
	}
}
/**
 * 比亚迪车运行实现类 
 */
public class Byd implements Car {
	@Override
	public void run() {
		System.out.println("比亚迪在跑。。。");
	}
}

• • • 工厂方法模式接口

/**
 * 工厂方法模式接口
 */
public interface CarFactory {
	Car CreateCar();
}
/**
 * 工厂方法模式接口实现类
 */
public class BydFactory implements CarFactory {
	@Override
	public Car CreateCar() {
		return new Byd();
	}
}
/**
 * 工厂方法模式接口方法的重写
 */
public class AudiFactory implements CarFactory {
	@Override
	public Car CreateCar() {
		return new Audi();
	}
}

• • • 工厂方法模式调用

/**
 * 方法工厂模式实现类
 */
public static void main(String[] args) {
	//new AudiFactory().CreateCar().run();
	Car c=new AudiFactory().CreateCar();
	c.run();		
}

• 3.抽象工厂模式

• • 代码实现

• • • 类和接口

/**
 * 座椅接口
 */
public interface Seat {
	void massage();
}
/**
 * 高端座椅
 */
class LuxurySeat implements Seat{
	@Override
	public void massage() {
		System.out.println("高端座椅可以按摩。。。。。");
	}
}
/**
 * 低端座椅
 */
class LowySeat implements Seat{
	@Override
	public void massage() {
		System.out.println("低端座椅不能按摩。。。。。");
	}
}

/**
 * 轮胎接口
 */
public interface Tyre {
	void revolve();
}
/**
 * 高端轮胎
 */
class LuxuryTyre implements Tyre{
	@Override
	public void revolve() {
		System.out.println("不会磨损。。。。");
	}
}
/**
 * 低端轮胎
 */
class LowTyre implements Tyre{
	@Override
	public void revolve() {
		System.out.println("磨损快。。。。。");
	}
}

/**
 * 引擎接口
 */
public interface Engine {
	void run();
	void start();
}
/**
 * 高端引擎
 */
class LuxuryEngine implements Engine{
	@Override
	public void run() {
		System.out.println("速度快。。。。。。");
	}
	@Override
	public void start() {
		System.out.println("启动快，。。。。。。");
	}
}
/**
 * 低端引擎
 */
class LowyEngine implements Engine{
	@Override
	public void run() {
		System.out.println("速度慢。。。。。。");
	}
	@Override
	public void start() {
		System.out.println("启动慢，。。。。。。");
	}
}

• • • 抽象工厂接口和实现类

/**
 * 汽车工厂
 */
public interface CarFactory {
	Engine createEngine();  //创建引擎
	Seat createSeat();		//座椅
	Tyre createTyre();		//轮胎
}
/**
 * 低端汽车
 */
public class LowCarFactory implements CarFactory {
	@Override
	public Engine createEngine() {
		return new LowyEngine();
	}
	@Override
	public Seat createSeat() {
		return new LowySeat();
	}
	@Override
	public Tyre createTyre() {
		return new LowTyre();
	}
}
/**
 * 高端汽车
 */
public class LuxuryCarFactory implements CarFactory{
	@Override
	public Engine createEngine() {
		return new LuxuryEngine();
	}
	@Override
	public Seat createSeat() {
		return new  LuxurySeat();
	}
	@Override
	public Tyre createTyre() {
		return new LuxuryTyre() ;
	}
}

• • • 抽象工厂调用

/**
 * 抽象工厂模式测试类
 */
public static void main(String[] args) {
	CarFactory c =new LowCarFactory();		
	Engine e=c.createEngine();
	e.run();
	e.start();
	
	CarFactory c1 =new LuxuryCarFactory();
	Engine e1=c.createEngine();
	e1.run();
	e1.start();
}

更多设计模式学习：

          设计模式(1)：介绍
          设计模式(2)：单例模式
          设计模式(4)：建造者模式
          设计模式(5)：原型模式
          设计模式(6)：桥接模式
          设计模式(7)：装饰器模式
          设计模式持续更新中…