简单工厂方法,工厂模式,抽象工厂模式

简要对比

  • 简单工厂方法是一种编程习惯,不是设计模式:一个电脑工厂,负责生产不同的电脑。
  • 工厂模式:联想工厂负责生产联想电脑,戴尔工厂负责生产戴尔电脑(实际的工厂类),它们都有生产电脑的方法(实现公共接口)。
  • 抽象工厂:联想工厂既要生产电脑,又要生产鼠标;戴尔工厂既要生产电脑,又要生产鼠标(实际的工厂类)。他们都有生产电脑和鼠标的方法(实现公共接口)。其中生产鼠标和电脑都是用工厂模式实现(包含多个工厂模式)。
  • 抽象工厂模式的优点是可以保证同一个工厂返回的同一个产品族,比如使用罗技的工厂就只会生产罗技的鼠标和键盘。缺点是扩展比较困难,接口标准里增加了一个方法,所有实现接口的子类都需要改变。

简单工厂方法:把生成对象集中到一个类里,严格来说不是设计模式,而是一种编程习惯。(创建方法通常定义为静态)

类图

示例

public interface Computer {
}

public class DellComputer implements Computer {
    public DellComputer(){
        System.out.println("戴尔");
    }
}

public class Lenovo implements Computer {
    public Lenovo(){
        System.out.println("联想");
    }
}

public class SimpleComputerFactory {
    static Computer createComputer(String type){
        Computer computer =null;
        if("dell".equalsIgnoreCase(type)){
            computer = new DellComputer();
        }else if("lenovo".equalsIgnoreCase(type)){
            computer = new Lenovo();
        }
        return  computer;
    }
}

运行

public class SimpleFactoryTestDemo {
    public static void main(String[] args){
        SimpleComputerFactory.createComputer("dell");
        SimpleComputerFactory.createComputer("lenovo");
    }
}

结果

工厂模式:定义了一个创建对象的接口,由子类决定要实例化的类,把实例化延迟到子类。

类图

示例

public interface Computer {
}

public class Lenovo implements Computer {
   public Lenovo(){
       System.out.println("联想");
   }
}

public class ThinkPad implements Computer {
    public ThinkPad(){
        System.out.println("ThinkPad");
    }
}

public interface  ComputerFactory {
     Computer createCompute(String type) ;
}

public class LenovoComputerFactory implements ComputerFactory{
    @Override
    public Computer createCompute(String type) {
        Computer computer = null;
        if("lenovo".equalsIgnoreCase(type)){
            computer = new Lenovo();
        }else  if("thinkpad".equalsIgnoreCase(type)){
            computer = new ThinkPad();
        }
        return computer;
    }
}

运行

public class ComputerFactoryTestDemo {
    public static void main(String[] args){
        ComputerFactory lenovoComputerFactory = new LenovoComputerFactory();
        lenovoComputerFactory.createCompute("lenovo");
        lenovoComputerFactory.createCompute("thinkpad");
    }
}

结果

抽象工厂模式:提供了一个接口,用来创建相关或依赖或依赖对象的家族,而不需要明确指定具体类。(常包含多个工厂模式,可以看做创建工厂的工厂)

类图

示例

//键盘接口
public interface KeyBoard {
}
public class LogitechKeyBoardA implements KeyBoard {
    public LogitechKeyBoardA(){
        System.out.println("罗技键盘A");
    }
}

public class LogitechKeyBoardB implements KeyBoard {
    public LogitechKeyBoardB(){
        System.out.println("罗技键盘B");
    }
}

public class RazerKeyBoardA implements KeyBoard {
    public RazerKeyBoardA(){
        System.out.println("雷蛇键盘A");
    }
}

public class RazerKeyBoardB implements KeyBoard {
    public RazerKeyBoardB(){
        System.out.println("雷蛇键盘B");
    }
}

//鼠标接口
public interface Mouse {
}

public class LogitechMouseA implements Mouse{
    public LogitechMouseA(){
        System.out.println("罗技鼠标A");
    }
}

public class LogitechMouseB implements Mouse{
    public LogitechMouseB(){
        System.out.println("罗技鼠标B");
    }
}

public class RazerMouseA implements Mouse{
    public RazerMouseA(){
        System.out.println("雷蛇鼠标A");
    }
}

public class RazerMouseB implements Mouse{
    public RazerMouseB(){
        System.out.println("雷蛇鼠标B");
    }
}

//外设工厂接口,负责生产键盘和鼠标
public interface PeripheralsFactory {
     Mouse createMouse(String type);
     KeyBoard createKeyBord(String type);
}

public class LogitechPeripheralsFactory implements PeripheralsFactory {
    @Override
    public Mouse createMouse(String type) {
        Mouse mouse = null;
        if ("A".equalsIgnoreCase(type)) {
            mouse = new LogitechMouseA();
        } else if ("B".equalsIgnoreCase(type)) {
            mouse = new LogitechMouseB();
        }
        return mouse;
    }

    @Override
    public KeyBoard createKeyBord(String type) {
        KeyBoard keyBoard = null;
        if ("A".equalsIgnoreCase(type)) {
            keyBoard = new LogitechKeyBoardA();
        } else if ("B".equalsIgnoreCase(type)) {
            keyBoard = new LogitechKeyBoardB();
        }
        return keyBoard;
    }
}

public class RazerPeripheralsFactory implements PeripheralsFactory {
    @Override
    public Mouse createMouse(String type) {
        Mouse mouse = null;
        if ("A".equalsIgnoreCase(type)) {
            mouse = new RazerMouseA();
        } else if ("B".equalsIgnoreCase(type)) {
            mouse = new RazerMouseB();
        }
        return mouse;
    }

    @Override
    public KeyBoard createKeyBord(String type) {
        KeyBoard keyBoard = null;
        if ("A".equalsIgnoreCase(type)) {
            keyBoard = new RazerKeyBoardA();
        } else if ("B".equalsIgnoreCase(type)) {
            keyBoard = new RazerKeyBoardB();
        }
        return keyBoard;
    }
}

运行

public class PeripheralsAbstractFactoryTestDemo {
    public static void main(String[] args){
        PeripheralsFactory razerFactory = new RazerPeripheralsFactory();
        razerFactory.createKeyBord("A");
        razerFactory.createKeyBord("B");
        razerFactory.createMouse("A");
        razerFactory.createMouse("B");
        PeripheralsFactory logitechFactory = new LogitechPeripheralsFactory();
        logitechFactory.createKeyBord("A");
        logitechFactory.createKeyBord("B");
        logitechFactory.createMouse("A");
        logitechFactory.createMouse("B");
    }
}

结果

原文地址:https://www.cnblogs.com/camcay/p/12355096.html

时间: 2024-10-14 04:12:10

简单工厂方法,工厂模式,抽象工厂模式的相关文章

大话设计模式之简单工厂模式&工厂方法模式&抽象工厂模式

创造类模式分为三种:简单工厂模式,工厂模式和抽象工厂模式. 定义: 简单工厂模式:用一个单独的类来做创造实例的过程. 工厂模式:一个用于创建对象的接口,让子类决定实例化哪一个类,讲一个类的实例化 延迟到其子类. 抽象工厂模式:为创建一组相关或相互依赖的对象的类,而不指定具体类. 结构图: 这是简单工厂的结构图,从图中就很好理解. 简单工厂的优点: 根据用户需要,new出需要的对象. 但是简单工厂弊端: 当新加入一个功能是,就要修改工厂.这个时候,就需要工厂模式了. 从图中我们可以看出: 工厂模式

Java设计模式—工厂方法模式&抽象工厂模式

工厂方法模式与抽象工厂模式都是设计模式中重要而且常见的模式.       工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类. 通用类图如下: 在工厂方法模式中,抽象产品类Product负责定义产品的共性,实现对事物最抽象的定义:Creator为抽象创建 类,也就是抽象工厂,具体如何创建产品类是由具体的实现工厂ConcreteCreator完成的. 工厂方法模式的扩展方式有很多种,下边是工厂方法模式一个比较实用的源代码: 抽象产品类: pub

.Net简单工厂模式,工厂模式,抽象工厂模式实例

1.定义   简单工厂模式:是由一个工厂对象决定创建出哪一种产品类的实例.简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现. 工厂模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类. 抽象工厂模式:为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类. 2.实例 用工人种蔬菜的例子来说明,蔬菜植物的产品器官有根.茎.叶.花.果等5类,因此按产品器官分类也分成5种,分别是根菜类,茎菜类,叶莱类,花菜类以及果菜类.我们以根菜类,茎菜类为例,

Java设计模式(创建型:工厂方法模式+抽象工厂模式)

设计模式根据目的准则可以分为三类: 创建型:creational 创建型的设计模式与对象的创建有关. 结构型:Structural 处理类和对象之间的组合. 行为型:behavioral 描述类和对象如何交互及如何分配职责. 工厂方法模式 站在使用者的角度,工厂方法模式是指使用者提出想要实现的具体功能或者说是想要生产的具体的东西的要求,在通过工厂制造之后就将该东西或功能交付给使用者.使用者并不知道实现的具体过程,只是做了要求提出以及实现的结果的使用. 严谨来说工厂方法模式(Factory Met

工厂方法(Factory Method)模式

一.工厂方法(Factory Method)模式 工厂方法(FactoryMethod)模式是类的创建模式,其用意是定义一个创建产品对象的工厂接口,将实际创建工作推迟的子类中. 工厂方法模式是简单工厂模式的进一步抽象和推广.由于使用了多态性,工厂方法模式保持了简单工厂模式的有点,而且客服了它的缺点. 在工厂方法模式中,核心的工厂类不再负责所有产品的创建,而是将具体创建工作交给予子类去做.这个核心类仅仅负责给出具体工厂必须实现的接口,而不接触哪一个产品类被实例化这种细节.这使得工厂方法模式可以允许

第5章 创建型模式—抽象工厂模式

1. 抽象工厂的定义 (1)提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类 ①只需各要知道创建一系列对象的接口,而无需知道具体使用的是哪一个实现 ②这一系列对象是相关或相互依赖的,也就是说既要创建对象,还要约束它们之间的关系. ③一系列对象是构建新对象所需要的组成部分,并且对象之间相互有约赖.如电脑由CPU和主板等组成,但CPU的针脚数和主板提供的插口必须是匹配的,否则无法组装. (2)产品族和产品等级 ①产品族:在抽象工厂模式中,产品族是指由同一个工厂生产的,位于不同产品等

工厂模式&抽象工厂——HeadFirst设计模式学习笔记

当使用new实例化一个类时,使用的是实现,而不是接口,代码捆绑着具体类会导致代码更脆弱缺乏弹性,使用松耦合的OO模式可以得到解脱. 工厂:封装对象的创建,处理创建对象的细节 静态工厂:利用静态方法定义一个简单的工厂.优点:不需要创建工厂类的实例化.缺点:不能通过继承改变创建方法行为. 简单工厂:简单工厂并不是一种设计模式,因为只是简单的把创建对象的代码封装起来 工厂模式:在父类定义了一个创建对象的接口,通过让子类决定创建的对象是什么,来达到让对象创建的过程封装的目的.工厂方法让类把实例化推迟到子

4、设计模式-创建型模式-抽象工厂模式

抽象工厂模式 产品等级结构和产品族 工厂方法模式中具体工厂负责生产具体的产品 每一个具体工厂对应一种具体的产品 工厂方法具有唯一性 一般情况下:一个具体工厂中只有一个或一组重载的工厂方法 有时候希望一个一个工厂可以提供多个产品对象 而不是单一的产品对象 产品等级结构: 产品等级结构即产品的继承结构,如一个抽象类是电视机 子类有海尔电视机.海信电视机等 抽象电视机与具体与具体品牌的电视机之间构成了一个产品等级结构 抽象电视机是父类,具体品牌的电视机是其子类 产品族: 在抽象工厂模式中 产品族是指由

23中设计模式----------抽象工厂模式

抽象工厂模式: 在上一篇中讲到通过各个具体球类(如:足球,篮球等)来继承总球类(Ball),来实现通过BallFactory对具体球类的生产. 不过,当时只是能造出不同球类,而在每种球类中肯定也有颜色,大小等不同的属性.所以,为了实现在工厂中添加属性.将抽象的Ball球类,修改成Bll接口,在该接口中添加所需要的方法: 这种模式是抽象工厂模式,抽象工厂模式是抽象方法模式的升级.在有多个业务品种,业务分级时,采用抽象工厂模式生产需要的对象是一种非常好的解决房还是.(比如,在生产球类的时候,不仅要分

创建型模式 抽象工厂

/** * 创建型模式 抽象工厂 * 抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的.抽象工厂模式可以向客户端提供一个接口,使得客户端在不必指定产品的具体类型的情况下,能够创建多个产品族的产品对象. * * 抽象工厂(Creator)角色 * 抽象工厂模式的核心,包含对多个产品结构的声明,任何工厂类都必须实现这个接口. * 具体工厂( Concrete Creator)角色 * 具体工厂类是抽象工厂的一个实现,负责实例化某个产品族中的产品对象. * 抽象(Product)角色 * 抽象