设计模式-工厂模式

核心：

帮助我们实例化对象，用工厂实例化对象。将选择实现类、创建对象统一控制和管理。从而将调用者跟我们的实现类解耦。

简单工厂模式：

用来生产同一等级结构中的任意产品。

如果增加新的产品，则要修改已有的代码。

不符合开放封闭原则，但是使用较多。

UML图：

通过简单工厂类，可以使客户端只依赖于car接口和car工厂 

代码实现：

car

public interface Car {
	void run();
}

car的两个实现类

public class Audi implements Car{

	@Override
	public void run() {
		System.out.println("奥迪");
	}
	
}

public class Byd implements Car{

	@Override
	public void run() {
		System.out.println("比亚迪");
	}
	
}

car工厂

public class CarFactory {
	public static Car creatCar(String car) {
		if(car.equals("奥迪")) {
			return new Audi();
		}else if(car.equals("比亚迪")) {
			return new Byd();
		}else {
			return null;
		}
		
	}
}

客户端

public class Clien {

	public static void main(String[] args) {
		Car c1 = CarFactory.creatCar("奥迪");
		c1.run();
	}
}

结果为:奥迪

工厂方法模式：

与简单工厂模式最大的区别在于，简单工厂只有一个工厂类，而工厂方法有一组实现相同接口的工厂类。

不修改已有类的前提下，可以通过添加新的工厂类实现扩展。

UML图： 

客户端依赖于car接口和car工厂的实现类

代码实现：

car接口与实现类不变

Car工厂改为接口

public interface CarFactory {
	Car creatCar();
}

可以通过添加任意多的实现类，来扩展业务

Audi工厂

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

Byd工厂

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

客户端

public class Clien {

	public static void main(String[] args) {
		Car c1 =new BydFactory().creatCar();
		c1.run();
	}
}

 

抽象工厂模式：

用来生产不同产品族的全部产品。

不可以增加产品，可以增加产品族。

UML图：

 代码实现： 

Cpu及其实现类 

public interface Cpu {
	void Scoring();
}
class I implements Cpu{
	@Override
	public void Scoring() {
		System.out.println("I跑1000000分");
	}
}
class A implements Cpu{
	@Override
	public void Scoring() {
		System.out.println("A跑2000000分");
	}
}

Gpu及其实现类

public interface Gpu {
	void Scoring();
}
class N implements Gpu{
	@Override
	public void Scoring() {
		System.out.println("N跑100分");
	}
}
class R implements Gpu{
	@Override
	public void Scoring() {
		System.out.println("A跑100分");
	}
}

工厂

public interface ComputerFactory {
	Cpu creatCpu();
	Gpu creatGpu();
}
class LFactory implements ComputerFactory{
	@Override
	public Cpu creatCpu() {
		return new I();
	}
	@Override
	public Gpu creatGpu() {
		return new N();
	}
}
class XFactory implements ComputerFactory{
	@Override
	public Cpu creatCpu() {
		return new A();
	}
	@Override
	public Gpu creatGpu() {
		return new R();
	}
}

客户端

public class Clent {

	public static void main(String[] args) {
		ComputerFactory c = new LFactory();
		c.creatCpu().Scoring();
		c.creatGpu().Scoring();
	}

}

输出结果：

I跑1000000分
N跑100分

工厂模式要点：

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

工厂方法模式：可以在不修改已有类的前提下，通过新的工厂类实现扩展。

抽象工厂模式：不可以增加产品，但是可以增加产品族。

工厂模式往往会和其他模式结合起来使用。

---

                                                                                                                                          感谢高淇java300集