单例模式

设计模式总分类

创建型模式( 5种 )

单例模式
工厂模式
抽象工厂模式
建造者模式
原型模式

结构型模式( 7种 )

适配器模式
桥接模式
装饰模式
组合模式
外观模式
享元模式
代理模式

行为型模式( 11种 )

模版方法模式
命令模式
迭代器模式
观察者模式
中介者模式
备忘录模式
解释器模式
状态模式
策略模式
职责链模式
访问者模式

工厂模式

应用场景

作用

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

本质

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

教你区别内聚与耦合

补充面向对象设计的基本原则

项目	Value
OCP（开闭原则，Open-Closed Principle）	一个软件的实体应当对扩展开放，对修改关闭。
DIP（依赖倒转原则，Dependence Inversion Principle）	要针对接口编程，不要针对实现编程。
LoD（迪米特法则，Law of Demeter )	只与你直接的朋友通信，而避免和陌生人通信。

分类

简单工厂模式

用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码 )

基础类

package ah.szxy.simplefactory;

public interface car {
  void run();
}

package ah.szxy.simplefactory;

public class BenChi implements car{

	@Override
	public void run() {
			
		System.out.println("奔驰在跑");
	}

}

package ah.szxy.simplefactory;

public class BaoMa implements car{

	@Override
	public void run() {
		
		System.out.println("宝马在跑");
	}

}

工厂类以及测试类

package ah.szxy.simplefactory;
/**
 * 简单工厂模式一
 * @author chy
 *
 */
public class CarFactory {

	public static car createCar(String type) {
		
		if ("BaoMa".equals(type)) {
			return new BaoMa();
		}else if ("BenChi".equals(type)) {
			return new BenChi();
		}else {
			return null;	
		}
	}
}

package ah.szxy.simplefactory;
/**
 * 简单工厂模式二
 * @author chy
 *
 */
public class CarFactory2 {

	public static car createBenChi() {

		return new BenChi();
	}

	public static car createBaoMa() {

		return new BaoMa();
	}
}


package ah.szxy.simplefactory;
/**
 * 测试简单工厂模式
 * @author chy
 *
 */
public class Client2 {
	public static void main(String[] args) {
	
		CarFactory carFactory = new CarFactory();
		//car bc = carFactory.createCar("BenChi");
		//car bm = carFactory.createCar("BaoMa");
		car bm = CarFactory2.createBaoMa();
		car bc = CarFactory2.createBenChi();
		
		bc.run();
		bm.run();
	}
}

uml图

工厂方法模式

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

package ah.szxy.simplefactory;

public interface car {
  void run();
}

package ah.szxy.simplefactory;

public class BenChi implements car{

	@Override
	public void run() {
			
		System.out.println("奔驰在跑");
	}

}

package ah.szxy.simplefactory;

public class BaoMa implements car{

	@Override
	public void run() {
		
		System.out.println("宝马在跑");
	}

}

package ah.szxy.factorymethod;

public interface Factory {
	public Car createCar();
}

package ah.szxy.factorymethod;

public class BenChiFactory  implements Factory{

	@Override
	public Car createCar() {
		
		return new BenChi();
	}

	
}

package ah.szxy.factorymethod;

public class BaoMaFactory  implements Factory{

	@Override
	public Car createCar() {
		
		return new BaoMa();
	}

	
}

package ah.szxy.factorymethod;
/**
 * 测试工厂方法模式
 * @author 曹海洋
 *
 */
public class Client{

	public static void main(String[] args) {
		
		Car bc =  new BenChiFactory().createCar();
		Car bm =  new BaoMaFactory().createCar();
		
		bc.run();
		bm.run();
	}
	
}

测试结果

uml图

简单工厂模式和抽象工厂模式比较

根据设计理论建议：工厂方法模式。但实际上，我们一般都用简单工厂模式

抽象工厂模式

用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

package ah.szxy.abstractfactory;
/**
 * 引擎
 * @author chy
 *
 */
public interface Engine {
	void run();
	
}

class luxuryEngine implements Engine{

	@Override
	public void run() {
		System.out.println("跑的快");
	}
	
	
}
class lowEngine implements Engine{
	
	@Override
	public void run() {
		System.out.println("跑的慢");
	}
	
	
}


package ah.szxy.abstractfactory;
/**
 * 座位
 * @author chy
 *
 */
public interface Seat {
	void feel();
}

class luxurySeat implements Seat{

	@Override
	public void feel() {
		System.out.println("坐着爽");
		
	}
}
class lowSeat implements Seat{
	
	@Override
	public void feel() {
		System.out.println("坐着不爽");
		
	}
}
	
	

package ah.szxy.abstractfactory;
/**
 * 轮胎
 * @author chy
 *
 */
public interface Tyre {
	void moSun();
}

class luxuryTyre implements Tyre{

	@Override
	public void moSun() {
		
		System.out.println("耐磨损");
	}
	
}
class lowTyre implements Tyre{
	
	@Override
	public void moSun() {
		
		System.out.println("不耐磨损");
	}
	
}

package ah.szxy.abstractfactory;

public interface CarFactory {
	Engine engine();
	Seat seat();
	Tyre tyre();
}


package ah.szxy.abstractfactory;

public class lowCar implements CarFactory{

	@Override
	public Engine engine() {

		return new lowEngine();
	}

	@Override
	public Seat seat() {

		return new lowSeat();
	}

	@Override
	public Tyre tyre() {

		return new lowTyre();
	}

}

package ah.szxy.abstractfactory;

public class LuxuryCar implements CarFactory {

	@Override
	public Engine engine() {
		
		return new luxuryEngine();
	}

	@Override
	public Seat seat() {

		return new luxurySeat();
	}

	@Override
	public Tyre tyre() {

		return new luxuryTyre() ;
	}

}

package ah.szxy.abstractfactory;
/**
 * 测试抽象方法模式
 * @author chy
 *
 */
public class Client {
	public static void main(String[] args) {
		
		CarFactory luxuryCar = new LuxuryCar();
		CarFactory lowCar = new lowCar();
		
		luxuryCar.engine().run();
		lowCar.engine().run();
	}
}

运行结果

uml类图

工厂模式总结

分类	区别
简单工厂模式(静态工厂模式)	虽然某种程度不符合设计原则，但实际使用最多。
工厂方法模式	不修改已有类的前提下，通过增加新的工厂类实现扩展。
抽象工厂模式	不可以增加产品，可以增加产品族

设计模式之工厂模式

单例模式

设计模式总分类

创建型模式( 5种 )

结构型模式( 7种 )

行为型模式( 11种 )

工厂模式

应用场景

作用

本质

补充 面向对象设计的基本原则

分类

简单工厂模式

工厂方法模式

简单工厂模式和抽象工厂模式比较

抽象工厂模式

工厂模式总结

补充面向对象设计的基本原则