2.工厂模式(简单工厂模式,工厂方法模式,抽象工厂模式)(设计模式笔记)

àì夳堔傛蜴生んèń 2022-08-03 18:58 209阅读 0赞

分类:  
1：创建型模式：  
单例模式，工厂模式，抽象工厂模式，建造者模式，原型模式；  
2：结构型模式：  
适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式  
3：行为型模式：  
模板方法模式，命令模式，迭代器模式，观察者模式，中介者模式，备忘录模式，  
解释器模式，状态模式，策略模式，职责链模式，访问者模式。

应用场景:  
jdk中Calendar的getInstance方法  
jdbc中Connection对象的获取  
hibernate中Sessionfactory创建session  
spring中ioc容器创建管理bean对象  
xml解析时的DocumentBuilderFactory创建解析器对象  
反射中class对象的newInstance()

面向对象的基本原则  
ocp(开闭原则，open-closed principle):一个软件的实体应该对扩展开放，对修改关闭  
dip(依赖倒转原则, dependence inversion principle):要针对接口编程，不要针对实现编程  
lod(迪米特法则，law of derneter):只与你直接的朋友通信，而避免和陌生人通信  
isp(接口隔离原则):接口口隔离原则认为："使用多个专门的接口比使用单一的总接口要好"。  
因为接口如果能够保持粒度够小，就能保证它足够稳定，正如单一职责原则所标榜的那样  
srp(单一职责原则，Single Responsibility Principle SRP):所谓单一职责原则就是一个类只负责一个职责,只有一个引起变化的原因.  
如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化会削弱或抑制这个类完成其他职责的能力，  
这个耦合会导致脆弱的设计。  
lsp(里氏替换原则,Liskov Substitution Principle）:任何基类可以出现的地方，  
子类一定可以出现。LSP是继承复用的基石，只有当子类可以替换基类，软件单位的功能不受影响时，  
基类才能真正的被复用，而子类也可以在基类的基础上增加新的行为。

(1)简单工厂模式:

public class Audi implements Car {
    
    	@Override
    	public void run() {
    		System.out.println("奥迪跑的快");
    	}
    
    }

public class BaoMa implements Car {
    
    	@Override
    	public void run() {
    		System.out.println("宝马跑的更快");
    	}
    
    }

public interface Car {
    
    	public void run();
    }

public class CarFactory {
    	
    	public static Car createCar(String type) {
    		//添加车的时候是否会更改代码违背开闭原则
    		if("奥迪".equals(type)) {
    			return new Audi();
    		} else if("宝马".equals(type)) {
    			return new BaoMa();
    		} else {
    			return null;
    		}
    	}
    }

public class Test {
    
    	@org.junit.Test
    	public void test1() {
    		Car audi = new Audi();
    		Car baoma = new BaoMa();
    		
    		audi.run();
    		baoma.run();
    	}
    	
    	@org.junit.Test
    	public void test2() {
    		//调用者和创建者已分离
    		Car audi = CarFactory.createCar("奥迪");
    		audi.run();
    	}
    }

可以利用泛型和反射方式构建简单工厂(从而在产生新对象的时候，满足开闭原则)

@SuppressWarnings("unchecked")
    public class CarFactory2 {
    	//利用泛型和反射的方式构造简单工厂，满足开闭原则
    	public static <T> T createCar(String className)  {
    		try {
    			return (T) Class.forName(className).newInstance();
    		} catch (InstantiationException | IllegalAccessException
    				| ClassNotFoundException e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
    	
    	@Test
    	public void test() {
    		Car audi = CarFactory2.createCar("com.designpattern.simplefactory.Audi");
    		Car baoma = CarFactory2.createCar("com.designpattern.simplefactory.BaoMa");
    		audi.run();
    		baoma.run();
    	}
    }

(2)工厂方法模式(符合开闭原则，但是创建类和接口较多)

public interface Car {
    
    	public void run();
    }

public class Audi implements Car {
    
    	@Override
    	public void run() {
    		System.out.println("奥迪跑的快");
    	}
    
    }

public class BaoMa implements Car {
    
    	@Override
    	public void run() {
    		System.out.println("宝马跑的更快");
    	}
    
    }

public interface CarFactory {
    	public Car createCar();
    }

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

public class BaoMaFactory implements CarFactory {
    
    	//扩展的时候创建新的具体工厂，符合开闭原则
    	@Override
    	public Car createCar() {
    		return new BaoMa();
    	}
    
    }

(3)抽象工厂模式

用来生产不同产品族的全部产品(对于增加新的产品，无能为力;支持增加产品族)  
抽象共产模式是工厂方法模式的升级版本，在有多高业务品种，业务分类时，通过  
抽象工厂模式产生需哟啊的对象是一种非常友好的解决方式。  
产品族举例(发动机，座椅，轮胎)，三者构成一个产品族

public interface Seat {
    	void releax();
    }
    
    class LuxurySeat implements Seat {
    
    	@Override
    	public void releax() {
    		System.out.println("休息时很舒适");
    	}
    	
    }
    
    class LowSeat implements Seat {
    
    	@Override
    	public void releax() {
    		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 LowEngine implements Engine {
    
    	@Override
    	public void run() {
    		System.out.println("转的慢");
    	}
    
    	@Override
    	public void start() {
    		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 CarFactory {
    
    	Engine createEngine();
    	Seat createSeat();
    	Tyre createTyre();
    
    }

//低级car生产工厂
    public class LowCarFactory implements CarFactory {
    
    	@Override
    	public Engine createEngine() {
    		return new LowEngine();
    	}
    
    	@Override
    	public Seat createSeat() {
    		return new LowSeat();
    	}
    
    	@Override
    	public Tyre createTyre() {
    		return new LowTyre();
    	}
    
    }

//高级car生产工厂
    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 class Test {
    	
    	@org.junit.Test
    	public void test() {
    		CarFactory factory = new LuxuryCarFactory();
    		Engine e = factory.createEngine();
    		e.run();
    		e.start();
    	}