java 设计模式

OOP七大原则

1、单例模式

核心作用：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点

饿汉模式

// 饿汉式单例
public class Hungry{
	// 可能会浪费空间
	private Hungry(){}
	
	private final static Hungry HUNGRY = new Hungry();
	
	public static Hungry getInstance(){
		return HUNGRY;
	}
}

懒汉模式

// 懒汉式单例
public class LazyMan{
	
	private LazyMan(){}
	
	private volatile static LazyMan lazyMan;
	
	// 双重检测锁模式的懒汉式单例  DCL 懒汉式
	public static LazyMan getInstance(){
		if(lazyMan==null){
			synchronized (LazyMan.class){
				if(lazyMan==null){
					lazyMan = new LazyMan();
				}
			}
		}
		return lazyMan;
	}
}

静态内部类单例

// 静态内部类单例
public class Holder{
	
	private Holder(){}
	
	public static Holder getInstace(){
		return InnerClass.HOLDER;
	}
	
	public static class InnerClass{
		private static final Holder HOLDER = new Holder();
	}
}

枚举单例

// enum 本身也是一个Class类
public enum EnumSingle{
	
	INSTANCE;
	
	public EnumSingle getInstance(){
		return INSTANCE;
	}
}

2、工厂模式

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

详细分类：简单工厂模式、工厂方法模式、抽象工厂模式

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

简单工厂模式

public interface Car{
	void name();
}

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

public class Tesla implements Car{
	@Override
	public void name(){
		System.out.println("特斯拉");
	}
}

// 简单工厂，静态工厂模式
// 增加一个新的产品，如果你不修改代码，做不到
// 没有满足开闭原则
public class CarFactory{
	public static Car getCar(String car){
		if(car.equals("五菱")){
			return new WuLing();
		}else if(car.equals("特斯拉")){
			return new Tesla();
		}else{
			return null;
		}
	}
}

工厂方法模式

public interface Car{
	void name();
}

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

public class Tesla implements Car{
	@Override
	public void name(){
		System.out.println("特斯拉");
	}
}

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

public class WuLingFactory implements CarFactory{
	@Override
	public Car getCar(){
		return new WuLing();
	}
}

public class TeslaFactory implements CarFactory{
	@Override
	public Car getCar(){
		return new Tesla();
	}
}

根据设计原则：工厂方法模式
根据实际业务：简单工厂模式

抽象工厂模式

定义：抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们具体的类

// 手机产品接口
public interface IphoneProduct{
	void start();
	void shutdown();
	void callup();
	void sendSMS();
}
// 路由器产品接口
public interface IRouterProduct{
	void start();
	void shutdown();
	void openWifi();
	void setting();
}
// 小米手机
public class XiaomiPhone 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 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 XiaomiRouter implements IRouterProduct{
	@Override
	public void start(){
		System.out.println("启动小米路由器");
	}
	@Override
	public void shutdown(){
		system.out.println("关闭小米路由器");
	}
	@Override
	public void openWifi(){
		System.out.println("打开小米wifi");
	}
	@Override
	public void setting(){
		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 openWifi(){
		System.out.println("打开华为wifi");
	}
	@Override
	public void setting(){
		System.out.println("华为设置");
	}
}
// 抽象产品工厂
public interface IProductFactory{
	// 生产手机
	IphoneProduct iphoneProduct();
	
	// 生产路由器
	IRouterProduct routerProduct();
}
// 小米工厂
public class XiaomiFactory implements IProductFactory{
	@Override
	public IphoneProduct iphoneProduct(){
		return new XiaomiPhone();
	}
	@Override
	public IRouterProduct routerProduct(){
		return new XiaomiRouter();
	}
}
// 华为工厂
public class HuaweiFactory implements IProductFactory{
	@Override
	public IphoneProduct iphoneProduct(){
		return new HuaweiPhone();
	}
	@Override
	public IRouterProduct routerProduct(){
		return new HuaweiRouter();
	}
}
// 测试
public class Test{
	public static void main(String[] args){
		//创建小米工厂
		XiaomiFactory xiaomiFactory = new XiaomiFactory();
		IphoneProduct iphoneProduct = xiaomiFactory.iphoneProduct();
		iphoneProduct.callup();
		iphoneProduct.sendSMS();
		IRouteProduct iRouterProduct = xiaomiFactory.routerProduct();
		iRouterProduct.openWifi();
	}
}

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

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