工厂模式、抽象工厂模式——java

工厂模式

作用：

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

详细分类：

• 简单工厂模式
  • 用来生产同一等级结构中的任意产品（对于增加新的产品，需要覆盖已有代码）
• 工厂模式方法
  • 用来生产同一等级结构的固定产品（支持增加任意）
• 抽象工厂模式
  • 围绕一个超级工厂创建其他工厂。该超级工厂又称其他工厂的工厂

OOP七大原则

• 开闭原则：一个软件的实体应当对扩展开放，对修改关闭
• 依赖倒转原则：要针对接口编程，不要针对实现编程
• 迪米特法则：只与你直接的朋友通信，而避免和陌生人通信

核心本质：

• 实例对象不能用new，用工厂模式代替
• 将选择实现类，创建对象统一管理和控制。而将调用者跟我们的实现类解耦

代码演示：

简单工厂模式（静态工厂模式）：
tip：虽然某种程度上不符合设计原则，但是实际使用最多

public interface Car {
	public void name();
}

public class WuLingHongGuang implements Car{
	@Override
	public void name() {
		System.out.println("我是五菱宏光");
	}
}

public class WuLingHongGuang implements Car{
	@Override
	public void name() {
		System.out.println("我是五菱宏光");
	}
}

//另一种叫法：静态工厂模式（简单工厂模式）
//弊端：增加一个新的产品，如果你不修改代码，做不到
//开闭原则
public class CarFactory {
	//方法一
	//第三方 拿车，只需要传入String car
	public static Car getCar(String car){
		if (car.equals("五菱宏光")) {
			return new WuLingHongGuang();
		}else if (car.equals("比亚迪")) {
			return new Byd();
		}else {
			return null;
		}	
	}
	 //方法二
	public static Car getWuLingHongGuang(){
		return new WuLingHongGuang();
	}
	public static Car getByd(){
		return new Byd();
	}
	//方法三
	public static Object factory(Class clazz) throws InstantiationException,IllegalAccessException,ClassNotFoundException,ClassCastException {
		Object object = clazz.newInstance();
		return object;
	}
}

public class Consumer {

	public static void main(String[] args) 
			throws InstantiationException,IllegalAccessException,ClassNotFoundException,ClassCastException{
		// 1.原始写法
		// 必须知道接口，所有的实现类
		// Car car = new WuLingHongGuang();
		// Car car2 = new Byd();

		// 2.使用工厂创建
		// Car car = CarFactory.getCar("五菱宏光");
		// Car car2 = CarFactory.getCar("比亚迪");
		// car.name();
		// car2.name();

		// 3
		try {
			Byd byd = (Byd) CarFactory.factory(Byd.class);
			byd.name();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (ClassCastException e) {
			e.printStackTrace();
		}
	}
}

工厂模式方法：
tip：不修改已有类的前提下，通过增加新的工厂类实现扩展

public interface Car {
	public void name();
}

//工厂方法模式
public interface CarFactory {
	Car getCar();
}

public class Byd implements Car{
	@Override
	public void name() {
		System.out.println("我是比亚迪");
	}
}

public class BydFactory implements CarFactory{
	@Override
	public Car getCar() {
		return new Byd();
	}
}

public class WuLingHongGuang implements Car{
	@Override
	public void name() {
		System.out.println("我是五菱宏光");
	}
}

public class WuLingHongGuangFactory implements CarFactory{
	@Override
	public Car getCar() {
		return new WuLingHongGuang();
	}
}

public class MoBai implements Car{
	@Override
	public void name() {
		System.out.println("摩拜单车");		
	}
}

public class MoBaiFactory implements CarFactory{
	@Override
	public Car getCar() {
		return new MoBai();
	}
}

public class Consumer {
	public static void main(String[] args) {
		Car car = new WuLingHongGuangFactory().getCar();
		Car car2 = new BydFactory().getCar();
		car.name();
		car2.name();
		Car car3 = new MoBaiFactory().getCar();
		car3.name();
	}
}

小总结：

简单工厂模式和工厂方法模式对比：

1. 结构复杂度：简单工厂模式
2. 代码复杂度：简单工厂模式
3. 编程复杂度：简单工厂模式
4. 管理上的复杂度：简单工厂模式
5. 根据设计原则：工厂方法模式（不会扰乱程序）
6. 根据实际业务：简单工厂模式（大多数软件一般使用的都是简单工厂模式）

抽象工厂模式（本质和工厂模式有区别）：
定义：抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定他们具体类
tip：不可以增加产品，可以增加产品族
适用场景：

• 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节
• 强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码
• 提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体实现

优点：

• 具体产品在应用层的代码隔离，无需关心创建的细节
• 将一个系列的产品统一到一起创建

缺点：

• 规定了所有可能被创建的产品集合，产品族中扩展新的产品困难
• 增加了系统的抽象性和理解难度

代码演示：

//手机产品接口
public interface IphoneProduct {
	public void start();
	public void shutdown();
	public void callup();
	public void sendSMS();
}

//路由器产品接口
public interface IRouterProduct {
	public void start();
	public void shutdown();
	public void openWife();
	public void setting();
}

//抽象产品工厂
public interface IProductFactory {
	//生产手机
	IphoneProduct iphoneProduct();
	//生产路由器 
	IRouterProduct iRouterProduct();
}

//华为手机
public class HuaweiPhone implements IphoneProduct{

	@Override
	public void start() {
		System.out.println("开启华为手机");
		
	}

	@Override
	public void shutdown() {
		System.out.println("关闭华为手机");
		
	}

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

	@Override
	public void sendSMS() {
		System.out.println("华为发短信");
		
	}

}

//华为路由器
public class HuaweiRouter implements IRouterProduct{

	@Override
	public void start() {
		System.out.println("启动华为路由器");
		
	}

	@Override
	public void shutdown() {
		System.out.println("关闭华为路由器");
		
	}

	@Override
	public void openWife() {
		System.out.println("打来华为的WiFi");
		
	}

	@Override
	public void setting() {
		System.out.println("关闭华为设置");
		
	}

}

public class HuaweiFactory implements IProductFactory{

	@Override
	public IphoneProduct iphoneProduct() {
		return new HuaweiPhone();
	}

	@Override
	public IRouterProduct iRouterProduct() {
		return new HuaweiRouter();
	}

}

//小米手机
public class XiaomiPhine implements IphoneProduct{

	@Override
	public void start() {
		System.out.println("开启小米手机");
		
	}

	@Override
	public void shutdown() {
		System.out.println("关闭小米手机");
		
	}

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

	@Override
	public void sendSMS() {
		System.out.println("小米发短信");
		
	}

}

//小米路由器
public class XiaomiRouter implements IRouterProduct{

	@Override
	public void start() {
		System.out.println("启动小米路由器");
		
	}

	@Override
	public void shutdown() {
		System.out.println("关闭小米路由器");
		
	}

	@Override
	public void openWife() {
		System.out.println("打来小米的WiFi");
		
	}

	@Override
	public void setting() {
		System.out.println("关闭小米设置");
		
	}

}

public class XiaomiFactory implements IProductFactory{

	@Override
	public IphoneProduct iphoneProduct() {
		return new XiaomiPhine();
	}

	@Override
	public IRouterProduct iRouterProduct() {
		return new XiaomiRouter();
	}

}

//客户端调用
public class Client {
	public static void main(String[] args) {
		System.out.println("=======小米系列产品======");
		//小米工厂
		XiaomiFactory xiaomiFactory = new XiaomiFactory();
		IphoneProduct iphoneProduct=xiaomiFactory.iphoneProduct();//生产小米手机
		iphoneProduct.callup();
		iphoneProduct.sendSMS();
		iphoneProduct.start();
		iphoneProduct.shutdown();
		IRouterProduct iRouterProduct=xiaomiFactory.iRouterProduct();//生产小米路由器
		iRouterProduct.openWife();
		iRouterProduct.shutdown();
		System.out.println("======华为系列产品======");
		HuaweiFactory huaweiFactory = new HuaweiFactory();
		IphoneProduct iphoneProduct2=huaweiFactory.iphoneProduct();//生产华为手机
		iphoneProduct2.sendSMS();
		iphoneProduct2.shutdown();
		iphoneProduct2.shutdown();
		iphoneProduct2.start();
		IRouterProduct iRouterProduct2 = huaweiFactory.iRouterProduct();//生产华为路由器
		iRouterProduct2.openWife();
		iRouterProduct2.shutdown();
		iRouterProduct2.setting();
		
	}
}

输出结果：

抽象工厂模式逻辑总结：