工厂模式

发表于 | 分类于 ，

什么是工厂设计模式？

　　工厂设计模式就是用来生产对象的，它使用一个单独的类来生产对象，而不是让调用者直接使用new来创建对象。

优缺点

　　工厂设计模式使得创建对象的逻辑不会暴露，并且其最大的优点便是使得程序员与对象进行解耦。
　　其主要缺点为没增加一个产品，就要增加对应的实现类和对象实现工厂，增加了系统复杂度。

分类

　　1.简单工厂
　　2.抽象工厂

简单工厂

创建产品接口：

1
2
3
public interface Shape {
	void draw();
}

创建产品实现类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Rectangle implements Shape{
	@Override
	public void draw() {
		System.out.println("draw Rectangle");
	}
}
public class Square implements Shape{
	@Override
	public void draw() {
		System.out.println("draw square");
	}
}
public class Circle implements Shape{
	@Override
	public void draw() {
		System.out.println("draw Circle");
	}
}

创建工厂类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ShapeFactory {
	public Shape getShape(String shapeType) {
		if (shapeType == null) {
			return null;
		}else if (shapeType.equalsIgnoreCase("rectangle")) {
			return new Rectangle();
		}else if (shapeType.equalsIgnoreCase("square")) {
			return new Square();
		}else if (shapeType.equalsIgnoreCase("circle")) {
			return new Circle();
		}
		return null;
	}
}

测试：

1
2
3
4
5
6
7
public class Test {
	public static void main(String[] args) {
		ShapeFactory shapeFactory = new ShapeFactory();
		Shape rect = shapeFactory.getShape("rectangle");
		rect.draw();
	}
}

应用场景

抽象工厂

　　与简单工厂模式不同的是，抽象工厂模式多出了一个超级工厂（工厂接口），围绕超级工厂类，创建其他工厂类，再围绕工厂类，创建实体类。
　　抽象工厂可以生产一组相关（不止一类）的产品。
创建产品1接口及实现类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public interface Cpu {
	void run();
	class Cpu6 implements Cpu{
		@Override
		public void run() {
			System.out.println("Cpu6");
		}
	}
	class Cpu8 implements Cpu{
		@Override
		public void run() {
			System.out.println("Cpu8");
		}
	}
}

创建产品2接口及实现类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public interface Screen {
	void size();
	class Screen5 implements Screen{
		@Override
		public void size() {
			System.out.println("5寸");
		}
	}
	class Screen6 implements Screen{
		@Override
		public void size() {
			System.out.println("6寸");
		}
	}
}

超级工厂：

1
2
3
4
public interface PhoneFactory {
	Cpu getCpu();
	Screen getScreen();
}

A工厂：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class APhoneFactory implements PhoneFactory{

	@Override
	public Cpu getCpu() {
		return new Cpu.Cpu6();
	}

	@Override
	public Screen getScreen() {
		// TODO Auto-generated method stub
		return new Screen.Screen5();
	}
	
}

B工厂

1
2
3
4
5
6
7
8
9
10
11
12
13
public class BPhoneFactory implements PhoneFactory{

	@Override
	public Cpu getCpu() {
		return new Cpu.Cpu8();
	}

	@Override
	public Screen getScreen() {
		return new Screen.Screen6();
	}

}

参考：

https://www.runoob.com/design-pattern/factory-pattern.html
https://www.jianshu.com/p/38493eb4ffbd
https://xin-tan.com