设计模式抽象工厂的代码讲解

最新推荐文章于 2023-10-12 00:22:43 发布
最新推荐文章于 2023-10-12 00:22:43 发布
阅读量373 收藏 3
点赞数
分类专栏： 抽象工厂 文章标签： 设计模式 java 经验分享 程序人生
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42764997/article/details/105833693
版权

文章目录

代码背景

工厂生产小球和对应的盒子，材质有两种，皮质的和钢制的

先写两种材质的小球

框架结构1

MagicPipe是管理工厂的类

package abstractMethod;
public abstract class AbstractFactory {
 public abstract Ball MakeBallFactoryMethod();
}
package abstractMethod;
//管理工厂
public  class MagicPipe {
// uml聚集 包含抽象工厂对象
 public AbstractFactory abstractFactory;
// 传入某一个具体工厂 得到的是产品系列
 public void setAbstractFactory(AbstractFactory abstractFactory) {
  this.abstractFactory = abstractFactory;
 }
// 公有接口
 public Ball pop(){
  System.out.println("准备创建中……");
  return abstractFactory.MakeBallFactoryMethod();
 }
}

package abstractMethod;
public class RubberBallFactory extends AbstractFactory{
 public Ball MakeBallFactoryMethod() {
  return new RubberBall();
 }
}
package abstractMethod;
public class SteelBallFactory extends AbstractFactory{
 public Ball MakeBallFactoryMethod() {
  return new SteelBall();
 }
}
package abstractMethod;
public abstract class Ball {
 public abstract void prtInfo();
}
package abstractMethod;
public class SteelBall extends Ball{
 public SteelBall() {
  System.out.println("创建了钢球");
 }
 public void prtInfo(){
  System.out.println("我是钢球");
 }
}
package abstractMethod;
public class RubberBall extends Ball{
 public RubberBall() {
  System.out.println("创建了皮球");
 }
 public void prtInfo(){
  System.out.println("我是皮球");
 }
}
package abstractMethod;
public class Application {
public static void main(String[] args) {
 System.out.println("欢迎进入坦克，请按下F键");
 //创建皮球
 MagicPipe mp = new MagicPipe();
 mp.setAbstractFactory(new RubberBallFactory());
 Ball b = mp.pop();
 b.prtInfo();
}
}

添加盒子的元素

框架结构2

上面的代码时建立一个抽象工厂，可以创建两种材质的小球
接下来加入盒子的元素：

	有一个抽象工厂生产小球和盒子
	分别被 皮质厂 和 钢质厂 继承
	皮质厂负责生产皮盒子和皮球
	钢质厂负责生产钢盒子和钢球

package abstractMethod_Series;
public abstract class AbstractFactory {
 public abstract Ball MakeBallFactoryMethod();
 public abstract Box MakeBoxFactoryMethod();
}
package abstractMethod_Series;
public class RubberStyleFactory extends AbstractFactory{ 
 public Ball MakeBallFactoryMethod() {
  return new RubberBall();
 }
 public Box MakeBoxFactoryMethod() {
  return new RubberBox();
 }
}
package abstractMethod_Series;
public class SteelStyleFactory extends AbstractFactory{
 public Ball MakeBallFactoryMethod() {
  return new SteelBall();
 }
 @Override
 public Box MakeBoxFactoryMethod() {
  // TODO Auto-generated method stub
  return new SteelBox();
 }
}

MagicPipe是管理工厂的类

package abstractMethod_Series;
//管理工厂
public  class MagicPipe {
// uml聚集 包含抽象工厂对象
 public AbstractFactory abstractFactory;
// 传入某一个具体工厂 得到的是产品系列
 public void setAbstractFactory(AbstractFactory abstractFactory) {
  this.abstractFactory = abstractFactory;
 }
// 公有接口
 public Ball pop(){
  System.out.println("准备创建中……");
  return abstractFactory.MakeBallFactoryMethod();
 }
 public Box popBox(){
  System.out.println("准备创建中……");
  return abstractFactory.MakeBoxFactoryMethod();
 }
}
package abstractMethod_Series;
public abstract class Ball {
 public abstract void prtInfo();
}
package abstractMethod_Series;
public abstract class Box {
 public abstract void prtInfo();
}
package abstractMethod_Series;
public class RubberBall extends Ball{
 public RubberBall() {
  System.out.println("创建了皮球");
 }
 public void prtInfo(){
  System.out.println("我是皮球");
 }
}
package abstractMethod_Series;
public class RubberBox extends Box {
 public RubberBox() {
  System.out.println("创建了皮盒子");
 }
 public void prtInfo(){
  System.out.println("我是皮盒子");
 }
}
package abstractMethod_Series;
public class SteelBall extends Ball{
 public SteelBall() {
  System.out.println("创建了钢球");
 }
 public void prtInfo(){
  System.out.println("我是钢球");
 }
}
package abstractMethod_Series;
public class SteelBox extends Box {
 public SteelBox() {
  System.out.println("创建了钢盒子");
 }
 public void prtInfo(){
  System.out.println("我是钢盒子");
 }
}
package abstractMethod_Series;
public class Application {
public static void main(String[] args) {
 System.out.println("欢迎进入坦克，请按下F键");
 
 //创建皮球 /皮盒子
 MagicPipe mp = new MagicPipe();
 mp.setAbstractFactory(new RubberStyleFactory());
 Ball ball;
 Box box;
 ball = mp.pop();
 ball.prtInfo();
 box = mp.popBox();
 box.prtInfo();
 
 //创建钢球 /钢盒子
 mp.setAbstractFactory(new SteelStyleFactory());
 ball = mp.pop();
 ball.prtInfo();
 box = mp.popBox();
 box.prtInfo();
}
}

再将耦合到一起的工厂分开，建立子工厂

框架结构3

建立抽象的盒子工厂和小球工厂

小球工厂被皮球工厂和钢球工厂继承

盒子工厂被皮盒子工厂和钢盒子工厂继承

每个工厂生产一个产品，可以有更灵活的组合搭配

package abstractMethod_Series_level4;
// 小球的抽象工厂
public abstract class AbstractFactory1 {
 public abstract Ball MakeBallFactoryMethod();
}
package abstractMethod_Series_level4;
public class RubberBallFactory extends AbstractFactory1{
 public Ball MakeBallFactoryMethod() {
  return new RubberBall();
 }
}
package abstractMethod_Series_level4;
public class SteelBallFactory extends AbstractFactory1{
 public Ball MakeBallFactoryMethod() {
  return new SteelBall();
 }
}
package abstractMethod_Series_level4;
// 盒子的抽象工厂
public abstract class AbstractFactory2 {
 public abstract Box MakeBoxFactoryMethod();
}
package abstractMethod_Series_level4;
public class RubberBoxFactory extends AbstractFactory2{
 @Override
 public Box MakeBoxFactoryMethod() {
  // TODO Auto-generated method stub
  return new RubberBox();
 }
}
package abstractMethod_Series_level4;
public class SteelBoxFactory extends AbstractFactory2{
 @Override
 public Box MakeBoxFactoryMethod() {
  // TODO Auto-generated method stub
  return new SteelBox();
 }
}
package abstractMethod_Series_level4;
//管理工厂
public  class MagicPipe {
// uml聚集 包含抽象工厂对象
 public AbstractFactory1 abstractFactory1;
 public AbstractFactory2 abstractFactory2;
// 传入某一个具体工厂 得到的是产品系列
 public void setAbstractFactory1(AbstractFactory1 abstractFactory1) {
  this.abstractFactory1 = abstractFactory1;
 }
 public void setAbstractFactory2(AbstractFactory2 abstractFactory2) {
  this.abstractFactory2 = abstractFactory2;
 }
// 公有接口
 public Ball pop(){
  System.out.println("准备创建中……");
  return abstractFactory1.MakeBallFactoryMethod();
 }
 public Box popBox(){
  System.out.println("准备创建中……");
  return abstractFactory2.MakeBoxFactoryMethod();
 }
}
package abstractMethod_Series_level4;
public abstract class Ball {
 public abstract void prtInfo();
}
package abstractMethod_Series_level4;
public class RubberBall extends Ball{
 public RubberBall() {
  System.out.println("创建了皮球");
 }
 public void prtInfo(){
  System.out.println("我是皮球");
 }
}
package abstractMethod_Series_level4;
public class SteelBall extends Ball{
 public SteelBall() {
  System.out.println("创建了钢球");
 }
 public void prtInfo(){
  System.out.println("我是钢球");
 }
}
package abstractMethod_Series_level4;
public abstract class Box {
 public abstract void prtInfo();
}
package abstractMethod_Series_level4;
public class RubberBox extends Box {
 public RubberBox() {
  System.out.println("创建了皮盒子");
 }
 public void prtInfo(){
  System.out.println("我是皮盒子");
 }
}
package abstractMethod_Series_level4;
public class SteelBox extends Box {
 public SteelBox() {
  System.out.println("创建了钢盒子");
 }
 public void prtInfo(){
  System.out.println("我是钢盒子");
 }
}
package abstractMethod_Series_level4;
public class Application {
public static void main(String[] args) {
 System.out.println("工厂1：a1 a2 \n" + "工厂2：b1 b2");
 System.out.println("欢迎进入坦克，请按下F键");
 //创建皮球 /皮盒子
 MagicPipe mp = new MagicPipe();
 AbstractFactory1 f1 = new RubberBallFactory();
 AbstractFactory1 f2 = new SteelBallFactory();
 AbstractFactory2 fbox1 = new RubberBoxFactory();
 AbstractFactory2 fbox2 = new SteelBoxFactory();
 
 mp.setAbstractFactory1(f1);
 mp.setAbstractFactory2(fbox1);
 Ball ball;
 Box box;
 ball = mp.pop();
 ball.prtInfo();
 box = mp.popBox();
 box.prtInfo(); 
}
}
bin~ibn
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【简单工厂和抽象工厂的区别以及Java代码实例】
学无止境
03-29 235
简单工厂和抽象工厂是两种常见的设计模式，它们都属于工厂模式的变体。它们的区别在于，简单工厂只有一个工厂类，负责创建所有产品，而抽象工厂则有多个工厂类，每个工厂类负责创建一组相关的产品。
代码详解设计模式--抽象工厂模式
热门推荐
博学de叫兽
01-04 1万+
简单工厂模式   实例：创建一个形状接口和实现该接口的圆形和方形，然后定义形状工厂。Demo演示类使用工厂来获取不同的形状对象。 优点： 屏蔽产品的具体实现，调用者只关心产品的接口。 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 缺点： 每增加一个形状，都需要增加一个具体类和工厂的 if / else 分支。 在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。...
创建者模式之抽象工厂模式（附带代码详解）
am的博客
09-14 569
一、开发环境 1. JDK 1.8 2. Idea + Maven ⼆、抽象⼯工⼚厂模式介绍 抽象工厂模式与工厂方法模式虽然主要意图都是为了解决，接口选择问题。但在实现上，抽象工厂是一 个中心工厂，创建其他工厂的模式。 可能在平常的业务开发中很少关注这样的设计模式或者类似的代码结构，但是这种场景确一直在我们身 边，例如； 不同系统内的回车换行 1. Unix系统里，每行结尾只有 <换行>，即 \n ； 2. Windows系统里面，每行结尾是 <换行><
设计模式：抽象工厂模式（java实现）
maligebilaowang的博客
03-13 1287
工厂方法模式和抽象工厂模式对比工厂方法模式是一种极端情况的抽象工厂模式，而抽象工厂模式可以看成是工厂方法模式的推广。工厂方法模式用来创建一个产品的等级结构，而抽象工厂模式是用来创建多个产品的等级结构。工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个抽象产品类。工厂方法模式中具体工厂类只有一个创建方法，而抽象工厂模式中具体工厂类有多个创建方法。到此，工厂模式中3种模式都学完了，那到底工厂模式的实现帮了我们什么？系统可以在不修改具体工厂角色的情况下引进新的产品。
抽象工厂（代码实现）
weixin_43379487的博客
03-15 724
图解产品族，产品等级 如上图所示，华为手机和华为电脑都是出自华为公司，因此他们是同一产品族。苹果手机和苹果电脑都出自苹果公司，那么他们也是同一产品族。 华为电脑和苹果电脑都属于“电脑”这个产品，那么他们是同一产品等级。华为手机和苹果手机也是同一产品等级。 代码实现 1.我们这里有两个产品等级（手机和电脑），我们为这两个产品创建抽象接口。 package DesignalPattern_Abstra...
Java设计模式之抽象工厂模式实例详解
08-29
Java设计模式之抽象工厂模式实例详解 Java设计模式之抽象工厂模式实例详解是指在软件设计中，通过提供一个创建一系列相关或相互依赖对象的接口，且无需指定它们具体的类别的方式来生成这些对象的模式。抽象工厂模式...
Android编程设计模式之抽象工厂模式详解
08-28
【抽象工厂模式详解】 在Android编程中，设计模式是一种重要的软件设计原则，它提供了一种在不断变化的需求中保持代码可维护性和可扩展性的方法。其中，抽象工厂模式（Abstract Factory Pattern）是一种创建型设计...
PHP实现设计模式中的抽象工厂模式详解
10-25
抽象工厂模式是设计模式中的一种常见类型，主要目的是为了隔离具体类的创建，使得系统能够独立于这些类的实现细节，同时提供一个统一的接口来创建相关联的对象族。在PHP中，我们可以利用抽象工厂模式来创建一系列...
设计模式-抽象工厂模式（讲解及其实现代码）
06-23
抽象工厂模式是设计模式中的一种创建型模式，它提供了一种创建对象集合的接口，而无需指定具体的类。这种模式允许系统独立于如何创建、组合和表示产品对象的细节进行设计，为产品族（一组相关或相互依赖的对象）提供...
详解iOS应用开发中使用设计模式中的抽象工厂模式
09-02
主要介绍了iOS应用开发中使用设计模式中的抽象工厂模式,示例代码为传统的Objective-C,需要的朋友可以参考下
抽象工厂模式 - 代码(Java)
05-26
抽象工厂模式的代码(java), 详细描述了抽象工厂模式的代码架构.
抽象工厂模式代码
12-17
抽象工厂模式代码，基本入门。。。。Java语言。。。。。。。。。。。。。。。。。。。
抽象工厂模式实例代码
01-15
通过抽象工厂搜提供的接口，可以创建产品的家族，利用这个接口书写代码，我们的代码将从实际工厂解耦，以便在不同上下文中实现各种各样的工厂，制造出各种不同的产品。这是与博客《抽象工厂模式--GOF的23个之一》配套实例源代码，具体说明欢迎阅读。 如有好的建议，可留言或发至笔者邮箱：fzb_xxzy@163.com
抽象工厂模式--演示代码
11-01
JAVA抽象工厂模式--演示代码，抽象工厂模式，也称为工厂的工厂，有一个工厂创建其他工厂
Java设计模式-抽象工厂模式
我的小幸运呢
07-11 249
抽象工厂模式是将工厂与产品都抽象化，这样在实例化工厂的时候，对具体对象的依赖就会变得很小，比如IFactory factory = new MysqlFactory();，当需要切换数据库到postgresql的时候，直接修改为IFactory factory = new PostgresqlFactory();即可，下面的User相关的代码全部不需要改动，因为它们都是接口依赖，而接口又不会改变，所以只需要改变很少的地方即可实现比较大的需求变动。
设计模式之抽象工厂模式
最新发布
lidaoping12345的博客
10-12 112
设计模式之抽象工厂模式
抽象工厂模式 （流程图） + 代码
奋斗
10-10 722
如下 ![抽象工厂模式](https://img-blog.csdnimg.cn/20191010142738115.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4MzkwMDky,size_16,color_FFFFFF,t...
抽象工厂模式 Idea
太阳上的雨天
03-15 717
抽象工厂模式 AbstractFactory 抽象工厂模式其实就是多个工厂方法模式 AbstractFactory抽象工厂类 下述代码是一个抽象工厂类，它的职责是定义每个工厂要实现的功能，有n个产品族，在抽象工厂类中就应该有n个创建方法。这里按上述类图，给出A、B两个产品族，即构造两个方法 package com.learn.Factory.AbstractFactory; abstract class AbstractFactory { public abstract ProductA cre
设计模式-抽象工厂模式
贾欣晓的博客
01-30 511
工厂方法模式：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。
深入浅出设计模式(非常详细通俗易懂).docx
09-28
"深入浅出设计模式的文档详细介绍了设计模式中的工厂模式，包括静态工厂模式、工厂方法模式和抽象工厂模式。文档通过一个生动的故事引入，讲述了如何在程序设计中避免类似故事中暴发户的怪异行为，即通过工厂模式来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值