抽象工厂模式

抽象工厂模式

定义:抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

产品族与产品等级结构

比如,餐馆新推出的套餐,炸鸡加可乐为一个组合的套餐 这个套餐 就是一个产品族。炸鸡、可乐分别是这个套餐中不同的产品等级。

适用场景

  • 客户端不依赖产品类如何实现创建的细节
  • 强调一系列相关产品对象(同一产品族)一起使用创建对象需要大量的代码
  • 提供一个产品类的库,所有的产品均以相同的接口出现,从而使客户端不依赖具体的实现

优点

  • 具体产品在代码层隔离,无需关心实现的细节
  • 将一个系列的产品族统一到一起创建

缺点

  • 规定了所有可能被创建产品的集合,产品族中扩展新的产品较为困难,需要修改抽象工程的接口
  • 增加了系统的抽象性和理解难度

场景例子

现在视频与手记组成一个课程,课程又分为java和Python两种课程,以后可能会添加更多课程

添加产品族较为容易,但是添加产品等级较为困难,这个例子中 如果再把源代码作为课程的一部分的话就需要修改大量的接口

UML图

#####代码
Article 产品抽象类

1
2
3
4
5
6
7
8
9
10
package com.anthony.design.pattern.creational.abstractfactory;

/**
* @ Description:
* @ Date: Created in 18:12 2018-11-26
* @ Author: Anthony_Duan
*/
public abstract class Article {
public abstract void produce();
}

Video产品抽象类

1
2
3
4
5
6
7
8
9
10
package com.anthony.design.pattern.creational.abstractfactory;

/**
* @ Description:
* @ Date: Created in 18:12 2018-11-26
* @ Author: Anthony_Duan
*/
public abstract class Video {
public abstract void produce();
}

JavaVideo JavaArticle PythonVideo PythonArticle 产品具体类

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.anthony.design.pattern.creational.abstractfactory;

/**
* @ Description:
* @ Date: Created in 18:14 2018-11-26
* @ Author: Anthony_Duan
*/
public class JavaArticle extends Article {
@Override
public void produce() {
System.out.println("编写Java课程手记");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
package com.anthony.design.pattern.creational.abstractfactory;

/**
* @ Description:
* @ Date: Created in 18:16 2018-11-26
* @ Author: Anthony_Duan
*/
public class JavaVideo extends Video {
@Override
public void produce() {
System.out.println("录制Java视频");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
package com.anthony.design.pattern.creational.abstractfactory;

/**
* @ Description:
* @ Date: Created in 18:15 2018-11-26
* @ Author: Anthony_Duan
*/
public class PythonArticle extends Article {
@Override
public void produce() {
System.out.println("编写Python课程手记");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
package com.anthony.design.pattern.creational.abstractfactory;

/**
* @ Description:
* @ Date: Created in 18:17 2018-11-26
* @ Author: Anthony_Duan
*/
public class PythonVideo extends Video {
@Override
public void produce() {
System.out.println("录制Python视频");
}
}

抽象工厂类

1
2
3
4
5
6
7
8
9
10
11
12
package com.anthony.design.pattern.creational.abstractfactory;

/**
* @ Description:
* @ Date: Created in 18:18 2018-11-26
* @ Author: Anthony_Duan
*/
public interface CourseFactory {
Video getVideo();

Article getArticle();
}

java 与Python 两个产品族的工厂类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.anthony.design.pattern.creational.abstractfactory;

/**
* @ Description:
* @ Date: Created in 18:19 2018-11-26
* @ Author: Anthony_Duan
*/
public class JavaCourseFactory implements CourseFactory {
public Video getVideo() {
return new JavaVideo();
}

public Article getArticle() {
return new JavaArticle();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.anthony.design.pattern.creational.abstractfactory;

/**
* @ Description:
* @ Date: Created in 18:23 2018-11-26
* @ Author: Anthony_Duan
*/
public class PythonCourseFactory implements CourseFactory {
public Video getVideo() {
return new PythonVideo();
}

public Article getArticle() {
return new PythonArticle();
}
}

test类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.anthony.design.pattern.creational.abstractfactory;


/**
* @ Description: 抽象工厂模式
* @ Date: Created in 18:23 2018-11-26
* @ Author: Anthony_Duan
*/
public class test {
public static void main(String[] args) {
CourseFactory courseFactory = new JavaCourseFactory();
Video video = courseFactory.getVideo();
Article article = courseFactory.getArticle();
video.produce();
article.produce();

}
}

-------------End Of This ArticleThank You For Reading-------------