云海鹰影


我独自度过的无数个晨昏，用来交换你身边一瞬

面向对象设计模式之工厂模式

2019-05-12 分类 编程基础, 设计模式 作者 云海鹰影 ~3.32K 字

工厂模式有三类：简单工厂，工厂方法，抽象工厂。复杂度依次递增。

我们先假设有一组产品：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//抽象产品：偶像明星
public interface Idol {
	public void hello();
}
public class BoyIdol implements Idol {
	@Override
    public void hello() {
        System.out.println("I'm a boy!");
    }
}
public class GirlIdol implements Idol {
	@Override
    public void hello() {
        System.out.println("I'm a girl!");
    }
}

1. 简单工厂模式（Simple Factory）

简单工厂不属于23种设计模式之一，只是简单地提供一个类，提供创建函数，根据产品类型创建产品对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//简单工厂
public class IdolFactory {
    public static Idol produce(String type) {
        if ("boy".equals(type)) {
            return new BoyIdol();
        } else if ("girl".equals(type)) {
            return new GirlIdol();
        } else {
            System.out.println("请输入正确的类型!");
            return null;
        }
    }
}
// 测试类
public class Test {
    public static void main(String[] args) {
        Idol idol = IdolFactory.produce('boy'); //client调用
        if(idol) {
            idol.hello();
        }
    }
}

2. 工厂方法模式（Factory Method）

简单工厂模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了开闭原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到工厂方法模式，创建一个工厂接口，每增加一个具体产品类时，增加对应的具体工厂类，不需要修改之前的代码。但是由于每新增一个新产品时就需要增加两个类，这样势必会导致系统的复杂度增加。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public interface IdolFactory {
	public Idol produce();
}
public interface BoyIdolFactory implements IdolFactory{
	@Override
	public Idol produce() {
		return new BoyIdol();
	}
}
public interface GirlIdolFactory implements IdolFactory{
	@Override
	public Idol produce() {
		return new GirlIdol();
	}
}
1
2
3
4
5
6
7
8
// 测试类
public class Test {
    public static void main(String[] args) {
        IdolFactory fac = new GirlIdolFactory(); //client调用
        Idol idol = fac.produce();
        idol.hello();
    }
}

3. 抽象工厂模式（Abstract Factory）

抽象工厂模式是针对多种不同的抽象产品，创建一个工厂接口，根据需要实例化不同的具体工厂类，每种具体工厂类都可以生产一组组合方式不同的具体产品。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//另一类抽象产品: 偶像经纪人
public interface IdolAgent {
	public void hello();
}
public class BoyAgent implements IdolAgent {
	@Override
    public void hello() {
        System.out.println("I can help a boy!");
    }
}
public class GirlAgent implements IdolAgent {
	@Override
    public void hello() {
        System.out.println("I can help a girl!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//我们的抽象工厂
public interface Factory {
	public Idol produceIdol();
	public IdolAgent produceAgent();
}
public class BoyFactory implements Factory {
	@Override
	public Idol produceIdol() {
		return new BoyIdol();
	}
	@Override
	public IdolAgent produceAgent() {
		return new BoyAgent();
	}
}
public class GirlFactory implements Factory {
	@Override
	public Idol produceIdol() {
		return new GirlIdol();
	}
	@Override
	public IdolAgent produceAgent() {
		return new GirlAgent();
	}
}
1
2
3
4
5
6
7
8
9
10
// 测试类
public class Test {
    public static void main(String[] args) {
        Factory fac = new GirlFactory();  //client调用
        Idol idol = fac.produceIdol();
		Idol agent = fac.produceAgent();
        idol.hello();
		agent.hello();
    }
}
本作品采用 知识共享署名-相同方式共享 4.0 国际许可协议 进行许可
, , ,
最后编辑：2021-03-11