工厂设计模式好处
工厂模式是为了解耦：就是 Class A 想调用 Class B ，那么A只是调用B的方法，而至于B的实例化，就交给工厂类。
工厂模式可以降低代码重复：如果创建对象 B 的过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。我们可以将这些创建对象 B 的代码放到工厂里统一管理。既减少了重复代码，也方便以后对 B 的创建过程的修改维护。
因为工厂管理了对象的创建逻辑，使用者并不需要知道具体的创建过程，只管使用即可，减少了使用者因为创建逻辑导致的错误
简单工厂设计模式
定义一个接口
1
2
3
| public interface Fruit {
void show();
}
|
定义两个水果类
1
2
3
4
5
6
| public class Apple implements Fruit {
@Override
public void show() {
System.out.println("苹果");
}
}
|
1
2
3
4
5
6
| public class Pear implements Fruit {
@Override
public void show() {
System.out.println("梨");
}
}
|
创建工厂
1
2
3
4
5
6
7
8
9
10
11
| public class FruitFactory {
public Fruit createFruit(String type) {
if (type.equals("apple")) {
return new Apple();
} else if (type.equals("pear")) {
return new Pear();
} else {
return null;
}
}
}
|
1
2
3
4
5
6
7
| public static void main(String[] args) {
FruitFactory fruitFactory = new FruitFactory();
Apple apple = (Apple)fruitFactory.createFruit("apple");
apple.show();
Pear pear = (Pear)fruitFactory.createFruit("pear");
pear.show();
}
|
工厂方法设计模式
定义一个接口
1
2
3
| public interface Fruit {
void show();
}
|
定义两个水果类
1
2
3
4
5
6
| public class Apple implements Fruit {
@Override
public void show() {
System.out.println("苹果");
}
}
|
1
2
3
4
5
6
| public class Pear implements Fruit {
@Override
public void show() {
System.out.println("梨");
}
}
|
创建FruitFactory接口
1
2
3
| public interface FruitFactory {
Fruit createFruit();
}
|
用到什么类, 写什么工厂
AppleFactory
1
2
3
4
5
6
| public class AppleFactory implements FruitFactory{
@Override
public Fruit createFruit() {
return new Apple();
}
}
|
PearFactory
1
2
3
4
5
6
| public class PearFactory implements FruitFactory{
@Override
public Fruit createFruit() {
return new Pear();
}
}
|
使用
1
2
3
4
5
6
7
8
9
10
| public class Test {
public static void main(String[] args) {
AppleFactory appleFactory = new AppleFactory();
PearFactory pearFactory = new PearFactory();
Apple apple = (Apple) appleFactory.createFruit();
apple.show();
Pear pear = (Pear) pearFactory.createFruit();
pear.show();
}
}
|
抽象工厂设计模式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| public interface FruitFactory {
void show();
class Apple implements FruitFactory {
@Override
public void show() {
System.out.println("苹果");
}
}
class Pear implements FruitFactory {
@Override
public void show() {
System.out.println("梨");
}
}
}
|
1
2
3
4
5
6
7
8
9
10
| public class Test {
public static void main(String[] args) {
FruitFactory.Apple apple = new FruitFactory.Apple();
apple.show();
FruitFactory.Pear pear = new FruitFactory.Pear();
pear.show();
}
}
|
cpu
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| public interface Cpu {
void run();
class Cpu600 implements Cpu{
@Override
public void run() {
System.out.println("Cpu600---run");
}
}
class Cpu800 implements Cpu{
@Override
public void run() {
System.out.println("Cpu800----run");
}
}
}
|
screen
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("Screen5----size");
}
}
class Screen8 implements Screen {
@Override
public void size() {
System.out.println("Screen8---size");
}
}
}
|
PhoneFactory
1
2
3
4
| public interface PhoneFactory {
Cpu getCpu();
Screen getScreen();
}
|
HongMiFactory
1
2
3
4
5
6
7
8
9
10
| public class HongMiFactory implements PhoneFactory{
@Override
public Cpu getCpu() {
return new Cpu.Cpu800();
}
@Override
public Screen getScreen() {
return new Screen.Screen8();
}
}
|
使用
选择
对于简单工厂和工厂方法来说，两者的使用方式实际上是一样的，如果对于产品的分类和名称是确定的，数量是相对固定的，推荐使用简单工厂模式，抽象工厂用来解决相对复杂的问题，适用于一系列、大批量的对象生产；
