常用Java设计模式系列(5)- 简单工厂、工厂方法模式和抽象工厂模式
2017-05-04 17:07
851 查看
讲到设计模式,我想大家都会想到工厂模式,在之前的几篇文章中,我们没有探讨,在这篇文章中,我们就来简单的看一下。
说道工厂模式,其实并不是指一种设计模式,从标题看就知道,其实有好几种,下面我们对这几种都简单的看看。
我们假设现在我们需要生产一些产品,这些产品我们委托给工厂进行生产。
(1)简单工厂模式
简单工厂模式,简单的说就是从前有个工厂,因为规模比较小,所以在一个工厂里面有多个生产线,生产不同的产品,客户提交订单时根据订单的要求去生产不同的产品并提供给客户。
简单工厂模式涉及的角色有:
工厂角色:具体生产产品的类
抽象产品角色:具体产品需要实现的接口;
具体产品角色:具体产品,由工厂生产出来的实体对象;
下面我们通过简单的Java代码来简单实现一下:
抽象产品角色示例代码:
package com.majing.test.designpattern.factory.simplefactory;
public interface IProduct {
void display();
}
具体产品角色示例代码:
package com.majing.test.designpattern.factory.simplefactory;
public class ProductA implements IProduct{
@Override
public void display() {
System.out.println("我是ProductA.");
}
}
工厂角色示例代码:
package com.majing.test.designpattern.factory.simplefactory;
public class SimpleFactory {
public static IProduct produce(String type){
IProduct product = null;
if("A".equals(type)){
product = new ProductA();
}else if("B".equals(type)){
product = new ProductB();
}else{
return null;
}
return product;
}
}
测试用例示例代码:
package com.majing.test.designpattern.factory.simplefactory;
public class Client {
public static void main(String[] args) {
IProduct product = SimpleFactory.produce("A");
product.display();
product = SimpleFactory.produce("B");
product.display();
}
}
从上面的实现可以看到,工厂是一个集中生产产品的地方,根据客户的需求(这里是生产A产品,还是生产B产品),来生产出对应的产品。
这种设计模式的缺点是,如果需要这个工厂去生产新的产品,那么就需要修改工厂类,增加新产品生产逻辑,很明显,这违背了开闭原则。但是这种模式的优点是设计简单,实现方便。
但是随着科技的发展,原本的工厂需要生产的东西越来越多,这时候,工厂厂长决定将不同的产品生产线进行独立,同一类型产品生产线由单独一个工厂进行生产,这样不同的生产线之间就不会相互影响了,不用挤在一个拥挤的老工厂里了。于是就出现了工厂方法模式。
(2)工厂方法模式
工厂方法模式,是将不同的产品生产交由不同的工厂进行生产,这样的话,当我们把一个订单交给一个工厂生产时,我们就不需要去说给我生产什么产品了,毕竟这个工厂只会生产一种产品。
工厂方法模式涉及的角色大概有:
抽象产品角色:是具体产品角色的基类,包含所有具体产品共有的特性;
具体产品角色:具体产品角色,
抽象工厂角色:是具体工厂角色的基类,包含着所有具体工厂共有的特性,如生产产品;
具体工厂角色:负责生产具体产品的工厂类;
和前面一样,我们也给出相应的Java代码示例:
抽象产品角色示例代码:
package com.majing.test.designpattern.factory.factorymethod;
public interface IProduct {
void display();
}
具体产品角色示例代码:
package com.majing.test.designpattern.factory.factorymethod;
public class ProductA implements IProduct{
@Override
public void display() {
System.out.println("我是ProductA.");
}
}
抽象工厂角色示例代码:
package com.majing.test.designpattern.factory.factorymethod;
public interface IFactory {
IProduct produce();
}
具体工厂角色示例代码:
package com.majing.test.designpattern.factory.factorymethod;
public class ProductAFactory implements IFactory {
@Override
public IProduct produce() {
return new ProductA();
}
}
从上面的示例代码中,我们看到,每个工厂都只生产一类产品。这种设计模式的好处是符合开闭原则,即使后面需要生产新的产品,也不需要修改已有的工厂类,而是新建一个工厂类和新的产品。当然也存在缺点,那就是,每次有新产品时都要实现相应的产品和工厂类,类的数量会越来越多。
此时的厂长还想继续增加效益,所以做出了决定,那就是每个工厂不仅仅生产一类产品,而是生产多个产品,所有的工厂都生产多个相同种类的产品,这就引出了我们下面要说的另一种设计模式----抽象工厂模式
(3)抽象工厂模式
抽象工厂模式,是对工厂方法模式的进一步抽象,它让每个工厂都生产同一个产品簇,产品簇内包含多个产品类型。这里的示例是让每个工厂都生产ProductA和ProductB。
抽象工厂模式涉及的角色和工厂方法模式一样,这里就不赘述了。下面直接来看看抽象工厂模式的实现。
抽象产品角色示例代码:
package com.majing.test.designpattern.factory.abstractfactory;
public interface IProduct {
void display();
}
package com.majing.test.designpattern.factory.abstractfactory;
import com.majing.test.designpattern.factory.simplefactory.IProduct;
public abstract class AbstractProductA implements IProduct {
}
package com.majing.test.designpattern.factory.abstractfactory;
import com.majing.test.designpattern.factory.simplefactory.IProduct;
public abstract class AbstractProductB implements IProduct {
}
具体产品角色示例代码:
package com.majing.test.designpattern.factory.abstractfactory;
public class ProductA1 extends AbstractProductA {
@Override
public void display() {
System.out.println("我是工厂1生产的ProductA!");
}
}
抽象工厂角色示例代码:
package com.majing.test.designpattern.factory.abstractfactory;
public interface IFactory {
AbstractProductA produceA();
AbstractProductB produceB();
}
具体工厂角色示例代码:
package com.majing.test.designpattern.factory.abstractfactory;
public class Factory1 implements IFactory {
@Override
public AbstractProductA produceA() {
return new ProductA1();
}
@Override
public AbstractProductB produceB() {
return new ProductB1();
}
}
测试用例代码:
package com.majing.test.designpattern.factory.abstractfactory;
public class Client {
public static void main(String[] args) {
IFactory factory = new Factory1();
AbstractProductA productA = factory.produceA();
AbstractProductB productB = factory.produceB();
productA.display();
productB.display();
}
}
至此,一个简单的抽象工厂设计模式的演示代码便结束了。直观的感觉,那就是类的数量激增啊!!!大家看下每种模式的文件数(也就是类和接口数):
从上截图就可以看出来,一个模式比一个模式复杂,大家还是根据自己的需要选择合适的实现吧。
至此,关于工厂模式的相关说明已经全部讲述完毕,如果想了解我最新的博文,请关注我的博客,谢谢。如果您愿意打赏我,可扫描下方二维码,对您的打赏我表示感谢。
说道工厂模式,其实并不是指一种设计模式,从标题看就知道,其实有好几种,下面我们对这几种都简单的看看。
我们假设现在我们需要生产一些产品,这些产品我们委托给工厂进行生产。
(1)简单工厂模式
简单工厂模式,简单的说就是从前有个工厂,因为规模比较小,所以在一个工厂里面有多个生产线,生产不同的产品,客户提交订单时根据订单的要求去生产不同的产品并提供给客户。
简单工厂模式涉及的角色有:
工厂角色:具体生产产品的类
抽象产品角色:具体产品需要实现的接口;
具体产品角色:具体产品,由工厂生产出来的实体对象;
下面我们通过简单的Java代码来简单实现一下:
抽象产品角色示例代码:
package com.majing.test.designpattern.factory.simplefactory;
public interface IProduct {
void display();
}
具体产品角色示例代码:
package com.majing.test.designpattern.factory.simplefactory;
public class ProductA implements IProduct{
@Override
public void display() {
System.out.println("我是ProductA.");
}
}
package com.majing.test.designpattern.factory.simplefactory; public class ProductB implements IProduct { @Override public void display() { System.out.println("我是ProductB."); } }
工厂角色示例代码:
package com.majing.test.designpattern.factory.simplefactory;
public class SimpleFactory {
public static IProduct produce(String type){
IProduct product = null;
if("A".equals(type)){
product = new ProductA();
}else if("B".equals(type)){
product = new ProductB();
}else{
return null;
}
return product;
}
}
测试用例示例代码:
package com.majing.test.designpattern.factory.simplefactory;
public class Client {
public static void main(String[] args) {
IProduct product = SimpleFactory.produce("A");
product.display();
product = SimpleFactory.produce("B");
product.display();
}
}
从上面的实现可以看到,工厂是一个集中生产产品的地方,根据客户的需求(这里是生产A产品,还是生产B产品),来生产出对应的产品。
这种设计模式的缺点是,如果需要这个工厂去生产新的产品,那么就需要修改工厂类,增加新产品生产逻辑,很明显,这违背了开闭原则。但是这种模式的优点是设计简单,实现方便。
但是随着科技的发展,原本的工厂需要生产的东西越来越多,这时候,工厂厂长决定将不同的产品生产线进行独立,同一类型产品生产线由单独一个工厂进行生产,这样不同的生产线之间就不会相互影响了,不用挤在一个拥挤的老工厂里了。于是就出现了工厂方法模式。
(2)工厂方法模式
工厂方法模式,是将不同的产品生产交由不同的工厂进行生产,这样的话,当我们把一个订单交给一个工厂生产时,我们就不需要去说给我生产什么产品了,毕竟这个工厂只会生产一种产品。
工厂方法模式涉及的角色大概有:
抽象产品角色:是具体产品角色的基类,包含所有具体产品共有的特性;
具体产品角色:具体产品角色,
抽象工厂角色:是具体工厂角色的基类,包含着所有具体工厂共有的特性,如生产产品;
具体工厂角色:负责生产具体产品的工厂类;
和前面一样,我们也给出相应的Java代码示例:
抽象产品角色示例代码:
package com.majing.test.designpattern.factory.factorymethod;
public interface IProduct {
void display();
}
具体产品角色示例代码:
package com.majing.test.designpattern.factory.factorymethod;
public class ProductA implements IProduct{
@Override
public void display() {
System.out.println("我是ProductA.");
}
}
package com.majing.test.designpattern.factory.factorymethod; public class ProductB implements IProduct { @Override public void display() { System.out.println("我是ProductB."); } }
抽象工厂角色示例代码:
package com.majing.test.designpattern.factory.factorymethod;
public interface IFactory {
IProduct produce();
}
具体工厂角色示例代码:
package com.majing.test.designpattern.factory.factorymethod;
public class ProductAFactory implements IFactory {
@Override
public IProduct produce() {
return new ProductA();
}
}
package com.majing.test.designpattern.factory.factorymethod; public class ProductBFactory implements IFactory { @Override public IProduct produce() { return new ProductB(); } }
从上面的示例代码中,我们看到,每个工厂都只生产一类产品。这种设计模式的好处是符合开闭原则,即使后面需要生产新的产品,也不需要修改已有的工厂类,而是新建一个工厂类和新的产品。当然也存在缺点,那就是,每次有新产品时都要实现相应的产品和工厂类,类的数量会越来越多。
此时的厂长还想继续增加效益,所以做出了决定,那就是每个工厂不仅仅生产一类产品,而是生产多个产品,所有的工厂都生产多个相同种类的产品,这就引出了我们下面要说的另一种设计模式----抽象工厂模式
(3)抽象工厂模式
抽象工厂模式,是对工厂方法模式的进一步抽象,它让每个工厂都生产同一个产品簇,产品簇内包含多个产品类型。这里的示例是让每个工厂都生产ProductA和ProductB。
抽象工厂模式涉及的角色和工厂方法模式一样,这里就不赘述了。下面直接来看看抽象工厂模式的实现。
抽象产品角色示例代码:
package com.majing.test.designpattern.factory.abstractfactory;
public interface IProduct {
void display();
}
package com.majing.test.designpattern.factory.abstractfactory;
import com.majing.test.designpattern.factory.simplefactory.IProduct;
public abstract class AbstractProductA implements IProduct {
}
package com.majing.test.designpattern.factory.abstractfactory;
import com.majing.test.designpattern.factory.simplefactory.IProduct;
public abstract class AbstractProductB implements IProduct {
}
具体产品角色示例代码:
package com.majing.test.designpattern.factory.abstractfactory;
public class ProductA1 extends AbstractProductA {
@Override
public void display() {
System.out.println("我是工厂1生产的ProductA!");
}
}
package com.majing.test.designpattern.factory.abstractfactory; public class ProductA2 extends AbstractProductA { @Override public void display() { System.out.println("我是工厂2生产的ProductA!"); } }
package com.majing.test.designpattern.factory.abstractfactory; public class ProductB1 extends AbstractProductB { @Override public void display() { System.out.println("我是工厂1生产的ProductB!"); } }
package com.majing.test.designpattern.factory.abstractfactory; public class ProductB2 extends AbstractProductB { @Override public void display() { System.out.println("我是工厂2生产的ProductB!"); } }
抽象工厂角色示例代码:
package com.majing.test.designpattern.factory.abstractfactory;
public interface IFactory {
AbstractProductA produceA();
AbstractProductB produceB();
}
具体工厂角色示例代码:
package com.majing.test.designpattern.factory.abstractfactory;
public class Factory1 implements IFactory {
@Override
public AbstractProductA produceA() {
return new ProductA1();
}
@Override
public AbstractProductB produceB() {
return new ProductB1();
}
}
package com.majing.test.designpattern.factory.abstractfactory; public class Factory2 implements IFactory { @Override public AbstractProductA produceA() { return new ProductA2(); } @Override public AbstractProductB produceB() { return new ProductB2(); } }
测试用例代码:
package com.majing.test.designpattern.factory.abstractfactory;
public class Client {
public static void main(String[] args) {
IFactory factory = new Factory1();
AbstractProductA productA = factory.produceA();
AbstractProductB productB = factory.produceB();
productA.display();
productB.display();
}
}
至此,一个简单的抽象工厂设计模式的演示代码便结束了。直观的感觉,那就是类的数量激增啊!!!大家看下每种模式的文件数(也就是类和接口数):
从上截图就可以看出来,一个模式比一个模式复杂,大家还是根据自己的需要选择合适的实现吧。
至此,关于工厂模式的相关说明已经全部讲述完毕,如果想了解我最新的博文,请关注我的博客,谢谢。如果您愿意打赏我,可扫描下方二维码,对您的打赏我表示感谢。
相关文章推荐
- Java设计模式(三):工厂模式(简单工厂模式、工厂方法模式、抽象工厂模式)
- [Java] 设计模式之工厂系列 01 简单工厂 - 缺点 :产生产品系列的时候很麻烦,会工厂泛滥
- [Java] 设计模式之工厂系列 01 简单工厂 - 缺点 :产生产品系列的时候很麻烦,会工厂泛滥
- 设计模式- 简单工厂模式---->工厂方法模式---->抽象工厂模式
- java设计模式之工厂模式(简单工厂模式、工厂方法模式、抽象工厂模式)
- 设计模式之工厂模式系列(简单工厂,工厂模式,抽象工厂模式)
- Java设计模式编程中简单工厂与抽象工厂模式的使用实例
- java va中工厂模式( 静态工厂模式、工厂方法模式、抽象工厂模式)的介绍以及简单例子
- Java设计模式(2)创建型:工厂模式(工厂方法模式与抽象工厂模式)
- Head First 设计模式学习——简单工厂方法-工厂方法模式-抽象工厂模式
- 简单工厂模式、工厂方法模式和抽象工厂模式-设计模式学习
- Java设计模式--简单工厂、工厂、抽象工厂模式
- 设计模式之简单工厂、工厂方法模式、抽象工厂模式
- Java 可复用的面向对象的设计模式之 工厂模式Factory详解 :简单工厂模式 工厂方法模式 抽象工厂模式
- Java设计模式(一) 设计模式初探——简单工厂和工厂方法模式
- iOS常用设计模式——工厂方法(简单工厂模式,工厂方法模式, 抽象工厂模式)
- iOS常用设计模式——工厂方法(简单工厂模式,工厂方法模式, 抽象工厂模式)
- java设计模式系列--简单工厂模式
- 设计模式系列——三个工厂模式(简单工厂模式,工厂方法模式,抽象工厂模式)
- Java设计模式:工厂模式(一)简单工厂模式