教你如何一篇博客读懂设计模式之—--工厂模式

一篇博客读懂设计模式之—工厂模式

工厂模式在我们日常开发的时候经常用到，相信大家都有了一定的了解，工厂模式是一种创建对象的设计模式，它提供一种创建对象的最佳方式。

主要过程是： 定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

工厂模式主要有常见的三种类型：简单工厂模式，工厂方法模式，抽象工厂模式。下面我们分别用代码来介绍一下这三种模式的演化过程：

简单工厂模式

1. 添加一个接口

public interface Car {
    
    
	String getBrand();
}

2. 添加几个实现类实现接口

public class Bmw implements Car {
    
    
	@Override
	public String getBrand() {
    
    
		return "BMW";
	}
}

public class Benz implements Car {
    
    
	@Override
	public String getBrand() {
    
    
		return "Benz";
	}
}

public class Audi implements Car{
    
    
	@Override
	public String getBrand() {
    
    
		return "Audi";
	}
}

3. 添加一个方法来选择创建的对象

//todo:1 简单工厂模式，虽然代码很简单，但是一个工厂怎么可能生产这么多不同的产品，不太符合规律，所以有了工厂方法模式
public class SimpleFactory {
    
    
	public Car getCar(String name){
    
    
		if("BMW".equalsIgnoreCase(name)){
    
    
			return new Bmw();
		}else if("Benz".equalsIgnoreCase(name)){
    
    
			return new Benz();
		}else if("audi".equalsIgnoreCase(name)){
    
    
			return new Audi();
		}else{
    
    
			return null;
		}
	}
}

4. 添加测试类：

public class TestSimpleFactory {
    
    
	public static void main(String[] args) {
    
    
		SimpleFactory simpleFactory = new SimpleFactory();
		Car car = simpleFactory.getCar("");
		System.out.println(car.getBrand());
	}
}

工厂方法模式：

1. 添加一个工厂的接口

//todo:2 工厂方法模式，通过接口来实现，不过这有个不足，我们消费者得自己知道用哪个工厂来进行生产
public interface Factory {
    
    
	Car getCar();
}

2. 实现接口的工厂类

public class AudiFactory implements Factory {
    
    
	@Override
	public Car getCar() {
    
    
		return new Audi();
	}
}

public class BenzFactory implements Factory {
    
    
	@Override
	public Car getCar() {
    
    
		return new Benz();
	}
}

public class BmwFactory implements Factory{
    
    
	@Override
	public Car getCar() {
    
    
		return new Bmw();
	}
}

3. 测试类：

public class TestFuncFactory {
    
    
	//这种模式也有点问题，工厂模式的好处是让使用者更加方便，但是这种模式还要我们知道是要用哪个工厂来创建，这也太不智能了吧，所以就有了抽象工厂
	public static void main(String[] args) {
    
    
		System.out.println(new BenzFactory().getCar());

		System.out.println(new BmwFactory().getCar());
		
		System.out.println(new AudiFactory().getCar());

	}
}

抽象工厂方法： 整合了前面两种模式

1. 添加一个抽象工厂

//todo:3. 抽象工厂方法模式，利用抽象类来实现，综合了工厂方法和简单工厂方法两种模式的优缺点
public abstract  class AbstractFactory {
    
    
	abstract Car getCar();
	public Car getCar(String name){
    
    
		if("BMW".equalsIgnoreCase(name)){
    
    
			return new BmwFactory().getCar();
		}else if("Benz".equalsIgnoreCase(name)){
    
    
			return new BenzFactory().getCar();
		}else if("audi".equalsIgnoreCase(name)){
    
    
			return new AudiFactory().getCar();
		}else{
    
    
			return null;
		}
	}
}

2. 添加一个默认实现类

//因为抽象类不能直接实例化，所以这里添加了一个默认类来实现抽象类的其他方法
public class DefaultFactory extends AbstractFactory {
    
    
	@Override
	Car getCar() {
    
    
		return new BenzFactory().getCar();
	}
}

3. 测试类

public class TestAbstrFactory {
    
    
	public static void main(String[] args) {
    
    
		DefaultFactory defaultFactory = new DefaultFactory();
		System.out.println(defaultFactory.getCar("bmw"));
	}
}

**

后期会继续完善 欢迎留言点赞！！

**