Java设计模式[03]-工厂模式

1.简单工厂模式

2.工厂方法模式

3.抽象工厂模式

---

一.简单工厂模式

package com.jensenlee.designPatterns;

public class Factry {

	public static void main(String[] args) {
		Phone hw = PhoneFactry.createPhone("hw");
		hw.call();
		Phone go = PhoneFactry.createPhone("go");
		go.call();
	}

}

class PhoneFactry {
	
	public static Phone createPhone(String phoneType) {
		
		switch (phoneType) {
			case "hw": return new HuaWeiPhone();
			case "go": return new GooglePhone();
		}
		return null;
		
	}
	
}

interface Phone {

	public void call();

}

class HuaWeiPhone implements Phone {

	@Override
	public void call() {
		System.out.println("华为手机打电话");
	}
	
}

class GooglePhone implements Phone {

	@Override
	public void call() {
		System.out.println("谷歌手机打电话");
	}
	
}

简单工厂模式基本介绍：

1. 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。
2. 简单工厂 模式:定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)。
3. 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。

简单工厂模式的三种写法：

// 懒汉模式
class LazySingleton {

	private volatile static LazySingleton lazySingleton;

	private LazySingleton() {

	}

	public LazySingleton getInstance() {
		if (lazySingleton == null) {
			synchronized (LazySingleton.class) {
				if (lazySingleton == null) {
					lazySingleton = new LazySingleton();
				}
			}
		}
		return lazySingleton;
	}
	// 1.延迟加载，只有在真正使用的时候才初始化。
	// 2.通过加锁和双重检查进行优化
	// 3.编译器（JIT），CPU有可能对指令进行重排序，导致使用了尚未初始化的实例，对于volatile修饰的字段，可以防止指令重排。
}

// 饿汉模式
class HungrySingleton {

	private static HungrySingleton hungrySingleton = new HungrySingleton();

	private HungrySingleton() {

	}

	public HungrySingleton getInstance() {
		return hungrySingleton;
	}

}

// 静态内部类模式
class InnerClassSingleton {

	private static class InnerClassHolder {
		private static InnerClassSingleton innerClassSingleton = new InnerClassSingleton();
	}

	private InnerClassSingleton() {

	}

	public InnerClassSingleton getInstance() {
		return InnerClassHolder.innerClassSingleton;
	}

}

二.工厂方法模式

package com.jensenlee.designPatterns;

public class FactryMethod {
	
	public static void main(String[] args) {
		Tea mj = new MaoJianTea();
		mj.drink();
		
		Tea blc = new BiLuoChunTea();
		blc.drink();
	}

}

interface Tea {
	
	void drink();
	
}

class MaoJianTea implements Tea {

	@Override
	public void drink() {
		System.out.println("品尝毛尖");
	}
	
}

class BiLuoChunTea implements Tea {

	@Override
	public void drink() {
		System.out.println("品尝碧螺春");
	}
	
}

工厂方法使用场景：

1. 创建对象需要大量重复的代码。
2. 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节。
3. 一个类通过其子类来指定创建哪个对象。

工厂方法也有缺点：

1. 类的个数容易过多，增加复杂度。
2. 增加了系统的抽象性和理解难度。

三.抽象工厂模式

package com.jensenlee.designPatterns;

public class AbstractFactory {
	/**
	 * 1.两个品牌（族）：华为、小米
	 * 2.两个产品（类）：手机、音响
	 */
	public static void main(String[] args) {
		IDigitalShopFactory factory = new HuaWeiDigitalShopFactory();
		factory.createCellPhone().call();
		factory.createAudio().play();
	}

}

// 手机接口
interface CellPhone {
	
	void call();
	
}

// 音响接口
interface Audio {
	
	void play();
	
}

// 华为手机
class HuaWeiCellPhone implements CellPhone {

	@Override
	public void call() {
		System.out.println("华为手机打电话");
	}
	
}

// 华为音响
class HuaWeiAudio implements Audio {

	@Override
	public void play() {
		System.out.println("华为音响播放音乐");
	}
	
}

// 小米手机
class XiaoMiCellPhone implements CellPhone {

	@Override
	public void call() {
		System.out.println("小米手机打电话");
	}
	
}

// 小米音响
class XiaoMiAudio implements Audio {

	@Override
	public void play() {
		System.out.println("小米音响播放音乐");
	}
	
}

// 数码产品体验店接口
interface IDigitalShopFactory {
	
	CellPhone createCellPhone();
	
	Audio createAudio();
	
}

// 华为数码产品体验店
class HuaWeiDigitalShopFactory implements IDigitalShopFactory {

	@Override
	public CellPhone createCellPhone() {
		return new HuaWeiCellPhone();
	}

	@Override
	public Audio createAudio() {
		return new HuaWeiAudio();
	}
	
}

// 小米数码产品体验店
class XiaoMiDigitalShopFactory implements IDigitalShopFactory {

	@Override
	public CellPhone createCellPhone() {
		return new XiaoMiCellPhone();
	}

	@Override
	public Audio createAudio() {
		return new XiaoMiAudio();
	}
	
}

1. 意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
2. 主要解决：主要解决接口选择的问题。
3. 何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
4. 如何解决：在一个产品族里面，定义多个产品。
5. 关键代码：在一个工厂里聚合多个同类产品。
6. 注意事项：产品族难扩展，产品等级易扩展。