学习之路---java设计模式--简单工厂、工厂方法和抽象工厂

最新推荐文章于 2023-02-21 21:29:34 发布
最新推荐文章于 2023-02-21 21:29:34 发布
阅读量213 收藏
点赞数
分类专栏： Java 文章标签： 学习 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luojiawen208/article/details/123357886
版权

 

 

 简单工厂和工厂方法一起

 

package org.example.ms.factory.factorymethod;

/**
 * @author Gavin.luo
 * @title: Moveable
 * @projectName MyData
 * @description:
 * @date 2022/3/10 9:18
 */
public interface Moveable {
    void go();
}


package org.example.ms.factory.factorymethod;

/**
 * @author Gavin.luo
 * @title: Car
 * @projectName MyData
 * @description:
 * @date 2022/3/8 16:58
 */
public class Car implements Moveable {


    public void go(){
        System.out.println("car go------------------->");
    }
}


package org.example.ms.factory.factorymethod;

/**
 * @author Gavin.luo
 * @title: CarFactory
 * @projectName MyData
 * @description:
 * @date 2022/3/10 9:58
 */
public class CarFactory {

    public Moveable create(){
        System.out.println("a car create-------------------------->");
        return new Car();
    }
}

package org.example.ms.factory.factorymethod;

/**
 * @author Gavin.luo
 * @title: Plane
 * @projectName MyData
 * @description:
 * @date 2022/3/10 9:15
 */
public class Plane implements Moveable{

    public void go(){
        System.out.println("plane fly------------------->");
    }
}


package org.example.ms.factory.factorymethod;

/**
 * @author Gavin.luo
 * @title: PlaneFactory
 * @projectName MyData
 * @description:
 * @date 2022/3/10 9:59
 */
public class PlaneFactory {

    public Moveable create(){
        System.out.println("a plane create --------------->");
        return new Plane();
    }
}

package org.example.ms.factory.factorymethod;

/**
 * @author Gavin.luo
 * @title: VehicleFactory
 * @projectName MyData
 * @description:  简单工厂的扩展性不好
 * @date 2022/3/10 9:33
 */
public class SimpleVehicleFactory {

    public Car createCar(){
        //before processing    可以在创建之前做一些操作  比如加权限
        return new Car();
    }

    public Plane createPlane(){
        //before processing    可以在创建之前做一些操作  比如加权限
        return new Plane();
    }

    public Broom createBroom(){
        //before processing    可以在创建之前做一些操作  比如加权限
        return new Broom();
    }
}


package org.example.ms.factory.factorymethod;

/**
 * @author Gavin.luo
 * @title: Test
 * @projectName MyData
 * @description:
 * @date 2022/3/8 16:57
 */
public class Test {
    public static void main(String[] args) {
//        Car car=new Car();
//        car.go();
//        Plane plane=new Plane();
//        plane.go();

        Moveable moveable=new Car();
        moveable.go();

        //简单工厂使用
        SimpleVehicleFactory vehicleFactory=new SimpleVehicleFactory();
        vehicleFactory.createCar().go();

        Moveable m=new CarFactory().create();
        m.go();

        Moveable mf=new PlaneFactory().create();
        mf.go();
    }
}

 

抽象工厂

在未使用抽象工厂前的代码

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: Ak47
 * @projectName MyData
 * @description:
 * @date 2022/3/10 10:19
 */
public class Ak47 {
    public void shoot(){
        System.out.println("tu tutututu----------->");
    }
}

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: Bread
 * @projectName MyData
 * @description:
 * @date 2022/3/10 10:20
 */
public class Bread {

    public void printName(){
        System.out.println("味多美---------->");
    }
}

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: Car
 * @projectName MyData
 * @description:
 * @date 2022/3/10 10:19
 */
public class Car {

    public void go(){
        System.out.println("car go---------------->");
    }
}

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: Broom
 * @projectName MyData
 * @description:
 * @date 2022/3/10 10:26
 */
public class Broom {
    public void go(){
        System.out.println("骑着扫把飞-------》");
    }
}

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: MagicStick
 * @projectName MyData
 * @description:
 * @date 2022/3/10 10:25
 */
public class MagicStick {

    public void shoot(){
        System.out.println("电击-----》");
    }
}

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: MushRoom
 * @projectName MyData
 * @description:
 * @date 2022/3/10 10:26
 */
public class MushRoom {

    public void printName(){
        System.out.println("吃毒蘑菇------》");
    }
}

调用是这样子的，每当我要增加某一种品类的时候就要加很多代码，比如再加外星人呢？

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: Test
 * @projectName MyData
 * @description:
 * @date 2022/3/10 10:21
 */
public class Test {

    public static void main(String[] args) {
        //现代人
        //一个司机开着车  吃着面包  开着枪
        System.out.println("现代人");
        Car c=new Car();
        c.go();
        Bread b=new Bread();
        b.printName();
        Ak47 a=new Ak47();
        a.shoot();
        //魔法世界的人
        //一个法师骑着扫把，吃着毒蘑菇，使用魔法棒
        System.out.println("魔法世界的人");
        Broom broom=new Broom();
        broom.go();
        MushRoom mushRoom=new MushRoom();
        mushRoom.printName();
        MagicStick magicStick=new MagicStick();
        magicStick.shoot();
    }

}

使用抽象工厂后的代码如下

 

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: AbstractFactory
 * @projectName MyData
 * @description:
 * @date 2022/3/10 10:35
 */
public abstract class AbstractFactory {

    //交通工具
    abstract  Vehicle createVhicel();
    //食物
    abstract Food createFood();
    //武器
    abstract Weapon crateWeapon();
}

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: ModernFactory
 * @projectName MyData
 * @description: 魔法世界的工厂
 * @date 2022/3/10 11:24
 */
public class MagicFactory extends AbstractFactory{
    @Override
    Vehicle createVhicel() {
        return new Broom();
    }

    @Override
    Food createFood() {
        return new MushRoom();
    }

    @Override
    Weapon crateWeapon() {
        return new MagicStick();
    }
}

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: FoodFactory
 * @projectName MyData
 * @description: 食物
 * @date 2022/3/10 10:36
 */
public abstract class Food {
    abstract void printName();
}

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: Vehicle
 * @projectName MyData
 * @description:交通工具
 * @date 2022/3/10 10:39
 */
public abstract class Vehicle {
    abstract void go();
}

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: Weapon
 * @projectName MyData
 * @description: 武器射击
 * @date 2022/3/10 10:37
 */
public abstract class Weapon {
    abstract void shoot();
}

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: Ak47
 * @projectName MyData
 * @description:
 * @date 2022/3/10 10:19
 */
public class Ak47  extends Weapon{
    public void shoot(){
        System.out.println("tu tutututu----------->");
    }
}


package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: Bread
 * @projectName MyData
 * @description:
 * @date 2022/3/10 10:20
 */
public class Bread extends Food{

    public void printName(){
        System.out.println("味多美---------->");
    }
}

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: Broom
 * @projectName MyData
 * @description:
 * @date 2022/3/10 10:26
 */
public class Broom extends Vehicle{
    public void go(){
        System.out.println("骑着扫把飞-------》");
    }
}

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: Car
 * @projectName MyData
 * @description:
 * @date 2022/3/10 10:19
 */
public class Car extends Vehicle{

    public void go(){
        System.out.println("car go---------------->");
    }
}

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: MagicStick
 * @projectName MyData
 * @description:
 * @date 2022/3/10 10:25
 */
public class MagicStick extends Weapon{

    public void shoot(){
        System.out.println("电击-----》");
    }
}

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: MushRoom
 * @projectName MyData
 * @description:
 * @date 2022/3/10 10:26
 */
public class MushRoom extends Food{

    public void printName(){
        System.out.println("吃毒蘑菇------》");
    }
}

package org.example.ms.factory.abstractfactory;

/**
 * @author Gavin.luo
 * @title: Test
 * @projectName MyData
 * @description:
 * @date 2022/3/10 10:21
 */
public class Test {

    public static void main(String[] args) {
        //现代人
        //一个司机开着车  吃着面包  开着枪
        System.out.println("现代人");
        Car c=new Car();
        c.go();
        Bread b=new Bread();
        b.printName();
        Ak47 a=new Ak47();
        a.shoot();
        //魔法世界的人
        //一个法师骑着扫把，吃着毒蘑菇，使用魔法棒
        System.out.println("魔法世界的人");
        Broom broom=new Broom();
        broom.go();
        MushRoom mushRoom=new MushRoom();
        mushRoom.printName();
        MagicStick magicStick=new MagicStick();
        magicStick.shoot();

        System.out.println("------------------------------");

        //使用了抽象工厂后的代码
        //人类
        System.out.println("现代人");
        AbstractFactory modernFactory=new ModernFactory();
        modernFactory.createVhicel().go();
        modernFactory.createFood().printName();
        modernFactory.crateWeapon().shoot();
        //魔法世界的人
        System.out.println("魔法世界的人");
        AbstractFactory magicFactory=new MagicFactory();
        magicFactory.createVhicel().go();
        magicFactory.createFood().printName();
        magicFactory.crateWeapon().shoot();

        //就算以后要增加外星人、底下人、宇宙人  只需要增加抽象工厂和具体的实现，可随意扩展
    }

}

那么问题来了

我们进行优化

那就是SpringBean工厂

 

<黑科技T_T
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java常用设计模式-抽象工厂模式
08-26
java常用设计模式-抽象工厂模式 抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它通过定义一个创建对象的接口来创建对象，但将具体实现的决定留给子类来决定。在抽象工厂模式中，接口是负责创建...
设计模式-抽象工厂-Java 源码
05-02
抽象工厂模式是设计模式中的一种创建型模式，它提供了一个创建对象族的接口，而具体的对象族由子类决定。这种模式允许系统在不指定具体产品的前提下，能够创建一系列相关或相互依赖的对象，同时避免了硬编码所造成的...
【java_设计模式】简单工厂、工厂方法、抽象工厂
chenghan_yang的博客
05-19 344
学习路径：https://coding.imooc.com/class/270.html 【简单工厂】不属于设计模式，是一种【编码风格】 【工厂方法】、【抽象工厂】属于【创建型】的设计模式 // 基础简单工厂 FruitFactory fruitFactory = new FruitFactory(); // 约定一个标识让工厂去生成，这里可以用反射的方式演进得更合理 Fruit fruit ...
java web简单工厂模式_简单工厂和工厂方法模式Java示例
weixin_36282765的博客
02-26 131
版权声明：此文章转载自_infocool原文链接：http://www.infocool.net/kb/Java/201610/204014.html如需转载请联系听云College团队成员小尹 邮箱：yinhy#tingyun.com简单工厂和工厂方法模式都是将对象的创建交由工厂处理，运用了工厂方法模式，我们代码中的if else被不同类型的具体工厂类所取代，这样在增加新的产品的时候不用修改原来...
工厂 java_【Java】简单工厂和抽象工厂代码
weixin_34082139的博客
02-15 140
Java简单工厂和抽象工厂简单工厂模式packagecn.wingfly.bean;interfaceFruit{voideat();}classOrangeimplementsFruit{@Overridepublicvoideat(){System.out.println("吃橘子");}}classAppleimplementsFruit{@Overri...
Spring学习笔记（四）
m0_53737524的博客
06-04 404
aop
Hbase Java API操作
m0_72168501的博客
11-27 2091
Hbase Java API操作，对于创建项目和操作表，表数据的方法
Java设计模式之工厂模式分析【简单工厂、工厂方法、抽象工厂】
08-27
Java设计模式之工厂模式分析【简单工厂、工厂方法、抽象工厂】 Java设计模式之工厂模式是Java设计模式中的一种非常重要的模式，它通过将对象的创建过程与对象的调用者分离，以提高系统的可维护性、可扩展性。工厂...
Java设计模式编程中的工厂方法模式和抽象工厂模式
09-02
在Java设计模式编程中，工厂方法模式和抽象工厂模式是两种重要的创建型设计模式，它们主要解决了对象创建过程中的灵活性和可扩展性问题。 工厂方法模式的核心思想是将对象的实例化过程延迟到子类中进行，从而实现对...
3.设计模式-抽象工厂模式1
08-03
抽象工厂模式是一种设计模式，属于创建型模式，它提供了一个创建一系列相关或相互依赖对象的接口，而无需指定...在实际开发中，尤其是在需要支持多种类似产品或服务的场景下，抽象工厂模式是非常重要的设计模式之一。
javaSE基础入门知识笔记2
最新发布
wwl193206126的博客
02-21 99
javaSe基础内容和案例
Java获取resources下配置文件信息
someInNeed的博客
09-06 630
用配置文件获取信息 （通过new property） package org.example; import java.io.IOException; import java.io.InputStream; import java.util.Properties; public class TestProperty { public static void main(String[] args) { Properties properties = new Properties()
《设计模式详解》创建型模式 - 工厂模式
萌宅鹿的技术小屋
01-05 1770
《设计模式详解》4.2 工厂模式4.2.1 概述4.2.2 简单工厂模式4.2.2.1 结构4.2.2.2 实现4.2.2.3 优缺点4.2.2.4 扩展 - 静态工厂4.2.3 工厂方法模式4.2.3.1 概念4.2.3.2 结构4.2.3.3 实现4.2.3.4 优缺点4.2.4 抽象工厂模式4.2.4.1 概念4.2.4.2 结构4.2.4.2 实现4.2.4.3 优缺点4.2.4.4 使用场景4.2.5 扩展：简单工厂 + 配置文件4.2.6 JDK源码 - Collection.iterator
Java面向对象编程
澄白易的博客
11-19 170
目录 包 导入包中的类 静态导入 常见的系统包 继承 语法规则 protected 关键字 final 关键字 多态 向上转型 方法重写 动态绑定 理解多态 向下转型 抽象类 语法规则： 抽象类的作用 接口 语法规则 Comparable和Clonable 接口 Comparable Clonable 包 文件夹，包(package) 是组织类的一种方式，使用包的主要目的是保证类的唯一性. 导入包中的类 导入一个类：import 包名...
子类构造器默认调用父类的无参构造器
m0_37996243的博客
08-20 854
如果子类没有显式调用父类的构造器，将调用父类的无参构造器，以下代码编译不通过 package org.example; public class A { public A(String s) { } } package org.example; public class B extends A { public B() { } } 在A类中加入无参构造器，或B类的构造器中调用A类有参构造器，编译就可以通过。 ...
Java（封装、继承、多态、接口）组成一个继承树，表示游戏中的角色练习题
Mr_Czhenhai的博客
07-15 570
一，创建Role接口，包含两个方法： 1）int attack(); 表示攻击，返回值表示对敌人的伤害 2）void practise(); 表示练习。练习之后对敌人的伤害会增加 二，创建NamedRole类，该类为一个抽象类，实现了Role 接口，并有两个属性： 1）name：角色的名字 2）age：角色的年龄 三，增加MagicStick接口。该接口表示法师使用的法杖。接口中包含一个方法： 1）int fire() 四，为MagicStick类增加两个实现类，分别为GreenStick和BlackSti
bean的四种实例化方法
m0_52228992的博客
07-18 3975
这里是我对视频学习做的笔记，仅供学习刚刚开始学习，可能有很多地方都没有理解到位，努力大家有兴趣的话，可以去黑马程序员2022最新SSM框架教程_Spring+SpringMVC+Maven高级+SpringBoot+MyBatisPlus企业实用开发技术_哔哩哔哩_bilibili老师讲的非常好。httpshttpshttpshttpshttpshttpshttpshttps。...
2022-15-Java 设计模式-抽象工厂模式
zzhangwa的博客
05-11 3342
在工厂方法模式中，我们使用一个工厂创建一个产品，一个具体工厂对应一个具体产品，但有时候我们需要一个工厂能够提供多个产品对象，而不是单一的对象，这个时候我们就需要使用抽象工厂模式。 在介绍抽象工厂模式前，我们先厘清两个概念： 产品等级结构：产品等级结构指的是产品的继承结构，例如一个空调抽象类，它有海尔空调、格力空调、美的空调等一系列的子类，那么这个空调抽象类和他的子类就构成了一个产品等级结构。 产品族：产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如，海尔工厂生产海尔空调、海尔冰
java 三种工厂模式(简单工厂+工厂方法+抽象工厂)
热门推荐
java小菜鸡成长之路
06-04 1万+
一、简单工厂模式 概述   简单工厂模式：定义一个工厂类，它可以根据参数的不同返回不同类的 实例，被创建的实例通常都具有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态(static)方法，因此简单工厂模式又被称为静态工厂方法模式，它属于类创建型模式。 工厂模式结构图 简单工厂模式角色   在简单工厂模式结构图中包含如下几个角色： Factory（工厂角色）：工厂角色即工厂类，它是简单...
"深度解读JAVA与J2EE设计模式：抽象工厂、建造模式等详细介绍
在JAVA设计模式中，创建型模式是一类常见的设计模式，主要用于对象的创建过程，包括Abstract Factory（抽象工厂模式）和Builder（建造模式）等。抽象工厂模式将客户类和工厂类分离，客户只需向工厂请求即可获取所需...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值