精华内容
下载资源
问答
  • 主要介绍了JS中创建自定义类型的常用模式,结合实例形式总结分析了工厂模式,构造函数模式,原型模式,动态原型模式等javascript创建自定义类型的常用模式与相关操作注意事项,需要的朋友可以参考下
  • 工厂方法模式、简单工厂模式、抽象工程模式

    千次阅读 多人点赞 2018-04-07 22:11:06
    工厂设计模式是一种创建型模式,它提供了一种创建对象的最佳方式。在工厂模式中,我们创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。 针对的问题:在面向对象编程中,最...

    1.概述

    工厂设计模式是一种创建型模式,它提供了一种创建对象的最佳方式。在工厂模式中,我们创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象

    1.1. 针对的问题

    在面向对象编程中,最常用的方法是new一个操作符产生一个对象实例,new对象操作符就是用来构造对象实例的,但是在一些情况下,new操作符直接生成对象会带来一些问题,举例说,许多类型对象的创建都需要一系列的步骤,可能需要计算或取得对象的初始设置,选择生成哪个子对象实例,或者在生成需要的对象之前必须先生成一些辅助功能的对象,这些情况下,对象的建立就是一个过程,不仅是一个操作。

    1.2. 分析

    这里写图片描述
    上图就是没有工厂模式时,用户需要自己new一辆车,这样,车和人就耦合在了一起。
    那么怎么能够方便的构建对象实例,而不关心构造对象实例的细节和复杂过程呢,那就是建立一个工厂来创建对象。把创建的过程封装到工厂里。

    1.3. 工厂模式类型

    工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到灵活性的目的。
    工厂模式一共三类

    1. 简单工厂模式
    2. 工厂方法模式
    3. 抽象工厂模式

    一般将简单工厂模式看为工厂方法模式的一种特例,二者归为一类。

    2. 三种工厂模式特征及实现

    2.1 简单工厂模式

    2.1.1. 角色组成

    这里写图片描述

    1. 工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑,用来创建产品

    2. 抽象产品角色:它一般是具体产品继承的父类或者实现的接口。

    3. 具体产品角色:工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

    2.1.2. 实现
    //产品类
    abstract class BMW{
    	public BMW(){}
    }
    
    //具体产品类
    public class BMW100 extends BMW{
    	public BMW100(){
    	    System.out.println("this is BMW100");
    	}
    }
    public class BMW200 extends BMW{	
    	public BMW200(){
    		System.out.println("this is BMW200");
       }
    }
    
    //工厂类
    public class Factory{
    	public BMW CreateBMW(int type){
    		if(type ==100) return new BMW100();
    		if(type ==200) return new BMW200();
    		else return null;
        }
    }
    
    
    2.1.3. 分析

    在简单工厂中,当客户不再满足现有的车型号时,想要一种更快的车,只要这种车满足抽象产品指定的规则,只要通知工厂类增加相应的逻辑就好了,但是每增加一种车,都要在工厂类中增加相应的逻辑,工厂类十分被动,这样的工厂类成为全能类或者上帝类。

    2.2 工厂方法模式

    2.2.1. 角色构成

    1)抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

    2)具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

    3)抽象产品角色:它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

    4)具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

    工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的上帝类,分担了对象承受的压力。

    2.2.2. 实现
    //抽象产品类
    abstract class BMW()
    {
        public BMW();
    }
    
    // 具体产品类 四种车,宝马1系,(两种),2系(两种)
    public class BMW100 extends BMW
    {
    	public BMW100()
    	{
    		System.out.println("this is BMW100");
    	}
    }
    public class BMW109 extends BMW
    {
    	public BMW109()
    	{
    		System.out.println("this is BMW100");
    	}
    }
    public class BMW200 extends BMW
    {
    	public BMW200()
    	{
    		System.out.println("this is BMW200");
    	}
    }
    public class BMW209 extends BMW
    {
    	public BMW209()
    	{
    		System.out.println("this is BMW209");
    	}
    }
    
    
    //抽象工厂角色
    interface Factory
    {
        BMW createBMW();
    }
    
    //具体工厂角色
    public class FactoryBMW1 implements FactoryBMW{  
      
        @Override  
        public BMW100 createBMW() {  
            return new BMW100();  
        }  
      
    }  
    public class FactoryBMW2 implements FactoryBMW {  
        @Override  
        public BMW200 createBMW() {  
      
            return new BMW200();  
        }  
    }   //分为100的工厂和200的工厂(省略了两个工厂)。都实现了工厂的接口
    
    
    2.2.3. 分析

    想加一辆车,就单独加车的类,这个车的工厂,然后只修改客户端的代码即可。工厂方法模式实现时,客户端需要决定实例化哪一个工厂来创建对象,工厂方法把简单工厂的内部逻辑移到了客户端代码来执行。

    2.3. 抽象工厂模式

    抽象工厂模式是工厂方法模式的升级版本,它用来创建一组相关或者相互依赖的对象。

    抽象工厂模式提供一个创建一系列相关或者相互依赖对象的接口,而无需指定他们具体的类。就是一个工厂里放一些相关的类,使工厂数减少

    最大的好处便是易于交换产品系列,其次是让具体的创建实例过程与客户端分离,客户端通过他们的抽象接口操纵实例,产品的具体类名也被具体工厂的实现分离。不会出现在客户代码中

    2.3.1. 角色

    这里写图片描述

    2.3.2. 实现

    抽象工厂方法就是一个工厂里生产不同等级结构中的一个(其中一种车)中的不同的配件(不同的车的属性)

    //抽象产品类1 发动机以及型号    
    public interface Engine {    
      
    }    
    //抽象产品类2 空调以及型号    
    public interface Aircondition {    
      
    }
    
    //具体产品类
    public class EngineA extends Engine{    
        public EngineA(){    
            System.out.println("制造-->EngineA");    
        }    
    }    
    public class EngineB extends Engine{    
        public EngineB(){    
            System.out.println("制造-->EngineB");    
        }    
    }  
        
    public class AirconditionA extends Aircondition{    
        public AirconditionA(){    
            System.out.println("制造-->AirconditionA");    
        }    
    }    
    public class AirconditionB extends Aircondition{    
        public AirconditionB(){    
            System.out.println("制造-->AirconditionB");    
        }    
    }
    
    //抽象工厂    
    public interface AbstractFactory {    
        //制造发动机  
        public Engine createEngine();  
        //制造空调   
        public Aircondition createAircondition();   
    }    
    
    
    //具体工厂类  
    public class 奔驰工厂 implements AbstractFactory{    
            
        @Override    
        public Engine createEngine() {      
            return new EngineA();    
        }    
        @Override    
        public Aircondition createAircondition() {    
            return new AirconditionA();    
        }    
    }    
    //为宝马车生产配件
    public class 宝马工厂 implements AbstractFactory {    
        
         @Override    
        public Engine createEngine() {      
            return new EngineB();    
        }    
        @Override    
        public Aircondition createAircondition() {    
            return new AirconditionB();    
        }    
    }
    
    2.3.3. 分析

    抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式则是针对的多个产品等级结构。在编程中,通常一个产品结构,表现为一个接口或者抽象类,也就是说,工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类,而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

    展开全文
  • listview不同类型的item实现,采用工厂模式实现item的复用,以及更方便的扩展更多类型的item
  • 设计模式类型

    2018-05-14 00:00:55
    设计模式主要分三个类型:创建型、结构型和行为型。  其中创建型有: Singleton,单例模式:保证一个类只有一个实例,并提供一个访问它的全局访问点  Abstract Factory,抽象工厂:提供一个创建一系列相关或相互...
  • 简单工厂模式工厂模式和抽象工厂模式 1. 简单工厂模式 简单工厂模式属于创建型模式,是工厂模式的一种。简单工厂模式定义了一个创建对象的类,由这个类来封装实例化对象的行为。它是由一个工厂对象决定创建出哪一...

    简单工厂模式、工厂模式和抽象工厂模式

    1. 简单工厂模式

    简单工厂模式属于创建型模式,是工厂模式的一种。简单工厂模式定义了一个创建对象的类,由这个类来封装实例化对象的行为。它是由一个工厂对象决定创建出哪一种产品类的实例。

    简单工厂模式是工厂模式中最简单使用的模式。

    简单工厂模式的三个角色

    • Factory(工厂角色) :简单工厂模式的核心,它负责实现创建所有实例的内部逻辑,根据调用时传入的参数,从而创建不同的对象。

    • Product(抽象产品角色) :简单工厂模式中所创建所有对象的父类,负责描述所以产品的实例行为。

    • Concrete Product(具体产品角色):简单工厂模式的创建目标,所有从工厂中创建的对象都是充当这个角色的某个具体类的实例。

    image-20201025215225999

    举一个栗子

    创建一个可以绘制不同图形的工具,可以绘制圆形、矩形等。

    Shape:抽象产品形状

    package cn.personalweb.factory.simplefactory;
    
    public abstract class Shape {
        /**
         * 画图形的方法
         */
        abstract void draw();
    }
    
    

    Circle:具体产品圆形

    实现了Shape中的画方法。

    package cn.personalweb.factory.simplefactory;
    
    public class Circle extends Shape{
        @Override
        void draw() {
            System.out.println("draw Circle");
        }
    }
    
    

    Rectangle:具体产品矩形

    实现了Shape中的画方法。

    package cn.personalweb.factory.simplefactory;
    
    public class Rectangle extends Shape {
    
    
        @Override
        void draw() {
            System.out.println("draw Rectangle");
        }
    }
    
    

    SimpleFactory:简单工厂

    内部定义了一个创建产品的方法getShape,此方法根据传入的参数来创建不同的产品。

    package cn.personalweb.factory.simplefactory;
    
    public class SimpleFactory {
        public Shape getShape(String shapeType) {
            if (shapeType == null) {
                return null;
            }
            if (shapeType.equals("Circle")) {
                return new Circle();
            } else if (shapeType.equals("Rectangle")) {
                return new Rectangle();
            }
            return null;
        }
    }
    
    

    Client:客户端

    package cn.personalweb.factory.simplefactory;
    
    public class Client {
        public static void main(String[] args) {
            SimpleFactory simpleFactory = new SimpleFactory();
            Shape rectangle = simpleFactory.getShape("Rectangle");
            rectangle.draw();
    
            Shape circle = simpleFactory.getShape("Circle");
            circle.draw();
        }
    }
    
    

    输出结果

    draw Rectangle
    draw Circle
    

    2. 工厂方法模式

    工厂方法模式是简单工厂的仅一步深化, 在工厂方法模式中,我们不再提供一个统一的工厂类来创建所有的对象,而是针对不同的对象提供不同的工厂。也就是说 每个对象都有一个与之对应的工厂

    工厂模式定义了一个创建对象的抽象方法,由子工厂类决定要实例化的类。工厂方法模式将对象的实例化推迟到子工厂类。

    工厂方法模式的四个角色

    • Abstract Factory(抽象工厂角色):是工厂方法模式的核心,与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。

    • Concrete Factory(具体工厂角色) :这是实现抽象工厂接口的具体工厂类,包含与应用程序密切相关的逻辑,并且受到应用程序调用以创建某一种产品对象。

    • AbstractProduct(抽象产品角色) :工厂方法模式所创建的对象的超类型,也就是产品对象的共同父类或共同拥有的接口。

    • Concrete Product(具体产品角色) :这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建,它们之间往往一一对应

    image-20201028225355710

    举一个栗子

    同上创建一个可以绘制不同图形的工具,可以绘制圆形、矩形等。

    Shape:抽象产品形状

    package cn.personalweb.factory.factory;
    
    public abstract class Shape {
        /**
         * 画图形的方法
         */
        abstract void draw();
    }
    
    

    Circle:具体产品圆形

    package cn.personalweb.factory.factory;
    
    public class Circle extends Shape {
        @Override
        void draw() {
            System.out.println("draw Circle");
        }
    }
    
    

    Rectangle:具体产品矩形

    package cn.personalweb.factory.factory;
    
    public class Rectangle extends Shape {
    
    
        @Override
        void draw() {
            System.out.println("draw Rectangle");
        }
    }
    
    

    Factory:抽象工厂

    package cn.personalweb.factory.factory;
    
    public interface Factory {
        public Shape getShape();
    }
    
    

    CircleFactory:具体圆形工厂

    package cn.personalweb.factory.factory;
    
    public class CircleFactory implements Factory{
        @Override
        public Shape getShape() {
            return new Circle();
        }
    }
    
    

    RectangleFactory:具体矩形工厂

    package cn.personalweb.factory.factory;
    
    public class RectangleFactory implements Factory{
        @Override
        public Shape getShape() {
            return new Rectangle();
        }
    }
    
    

    Client:客户端

    package cn.personalweb.factory.factory;
    
    public class Client {
        public static void main(String[] args) {
            CircleFactory circleFactory = new CircleFactory();
            Shape circle = circleFactory.getShape();
            circle.draw();
    
            RectangleFactory rectangleFactory = new RectangleFactory();
            Shape rectangle = rectangleFactory.getShape();
            rectangle.draw();
    
        }
    }
    
    

    输出结果

    draw Circle
    draw Rectangle
    

    3. 抽象工厂

    在前面的工厂模式中我们生产的都是同一类产品,而抽象工厂模式是工厂方法的仅一步深化,在这个模式中的工厂类不单单可以创建一种产品,而是可以创建一组产品。

    基本介绍

    1. 抽象工厂模式:定义了一个**interface用于创建相关或有依赖关系的对象簇**,而无需指明具体的类
    2. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合
    3. 从设计层面上看,抽象工厂模式就是对简单工厂模式的改进(或者称为进一步抽象)
    4. 将工厂抽象成两层,ABSFactor(抽象工厂)和具体实现的子类。程序员可以根据创建对象类型使用对应的工程子类。这样将单个的简单工厂类编程了工厂簇,更利于代码的维护和扩展

    在抽象工厂模式中,有一个产品族的概念:所谓的产品族,是指位于不同产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品就组成一个产品族;而工厂方法提供的一系列产品称为一个等级结构。

    抽象工厂的工厂和工厂方法中的工厂有什么区别呢?

    抽象工厂是生产一整套有产品的(至少要生产两个产品),这些产品必须相互是有关系或有依赖的,而工厂方法中的工厂是生产单一产品的工厂。

    抽象工厂方法模式角色分配:

    • AbstractFactory(抽象工厂角色) :是工厂方法模式的核心,与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。

    • ConreteFactory(具体工厂类角色) :这是实现抽象工厂接口的具体工厂类,包含与应用程序密切相关的逻辑,并且受到应用程序调用以创建某一种产品对象。

    • Abstract Product(抽象产品角色) :工厂方法模式所创建的对象的超类型,也就是产品对象的共同父类或共同拥有的接口。

    • Concrete Product(具体产品角色) :抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。在抽象工厂中创建的产品属于同一产品族,这不同于工厂模式中的工厂只创建单一产品。

    image-20201028232842979

    举一个栗子

    创建 ShapeColor 接口和实现这些接口的实体类。

    Shape:抽象形状

    package cn.personalweb.factory.Abstractfactor;
    
    public interface Shape {
        void draw();
    }
    
    

    具体形状

    package cn.personalweb.factory.Abstractfactor;
    
    // 圆形
    public class Circle implements Shape{
        @Override
        public void draw() {
            System.out.println("draw Circle");
        }
    }
    
    // 正方形
    public class Square implements Shape{
        @Override
        public void draw() {
            System.out.println("draw Square");
        }
    }
    
    // 矩形
    public class Rectangle implements Shape {
        @Override
        public void draw() {
            System.out.println("draw Rectangle");
        }
    }
    
    
    

    Color:抽象颜色

    package cn.personalweb.factory.Abstractfactor;
    
    public interface Color {
        void fill();
    }
    
    

    具体颜色

    package cn.personalweb.factory.Abstractfactor;
    
    // 红色
    public class Red implements Color{
        @Override
        public void fill() {
            System.out.println("fill red");
        }
    }
    
    // 绿色
    public class Green implements Color{
        @Override
        public void fill() {
            System.out.println("fill green");
        }
    }
    
    // 蓝色
    public class Blue implements Color {
        @Override
        public void fill() {
            System.out.println("fill blue");
        }
    }
    
    
    

    AbstracFactory:抽象工厂

    package cn.personalweb.factory.Abstractfactor;
    
    public abstract class AbstracFactory {
        public abstract Shape getShape(String shape);
        public abstract Color getColor(String color);
    }
    
    

    ColorFactory:具体颜色工厂

    package cn.personalweb.factory.Abstractfactor;
    
    public class ColorFactory extends AbstracFactory {
        @Override
        public Shape getShape(String shape) {
            return null;
        }
    
        @Override
        public Color getColor(String color) {
            if (color == null) {
                return null;
            }
            if (color.equalsIgnoreCase("RED")) {
                return new Red();
            } else if (color.equalsIgnoreCase("BLUE")) {
                return new Blue();
            } else if (color.equalsIgnoreCase("GREEN")) {
                return new Green();
            }
            return null;
        }
    }
    
    

    ShapeFactory:具体形状工厂

    package cn.personalweb.factory.Abstractfactor;
    
    public class ShapeFactory extends AbstracFactory {
        @Override
        public Shape getShape(String shape) {
            if (shape == null) {
                return null;
            }
            if (shape.equalsIgnoreCase("RECTANGLE")) {
                return new Rectangle();
            } else if (shape.equalsIgnoreCase("CIRCLE")) {
                return new Circle();
            } else if (shape.equalsIgnoreCase("SQUARE")) {
                return new Square();
            }
            return null;
        }
    
        @Override
        public Color getColor(String color) {
            return null;
        }
    }
    
    

    FactoryProducer:工厂制造者

    用于生成工厂

    package cn.personalweb.factory.Abstractfactor;
    
    public class FactoryProducer {
        public static AbstracFactory getFactory(String factory) {
            if (factory == null) {
                return null;
            }
            if (factory.equalsIgnoreCase("SHAPE")) {
                return new ShapeFactory();
            } else if (factory.equalsIgnoreCase("COLOR")) {
                return new ColorFactory();
            }
            return null;
        }
    }
    
    

    Client:客户端

    package cn.personalweb.factory.Abstractfactor;
    
    public class Client {
        public static void main(String[] args) {
            // 获取形状工厂
            AbstracFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
    
            // 通过形状工厂获取 circle
            Shape circle = shapeFactory.getShape("CIRCLE");
            circle.draw();
    
            // 通过形状工厂获取 Rectangle
            Shape rectangle = shapeFactory.getShape("RECTANGLE");
            rectangle.draw();
    
            // 获取颜色工厂
            AbstracFactory colorFactory = FactoryProducer.getFactory("COLOR");
            Color red = colorFactory.getColor("RED");
            red.fill();
    
            Color green = colorFactory.getColor("GREEN");
            green.fill();
    
            Map<Integer, Integer> map = new HashMap<>();
            Set<Integer> integers = map.keySet();
    
        }
    }
    
    

    输出结果

    draw Circle
    draw Rectangle
    fill red
    fill green
    

    参考资料:
    工厂模式

    展开全文
  • 一、简单工厂 从设计模式类型上来说,简单工厂模式是属于创建型模式,又叫做静态工厂方法(StaticFactory Method)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的...

         一、简单工厂

            从设计模式的类型上来说,简单工厂模式是属于创建型模式,又叫做静态工厂方法(StaticFactory Method)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。

          其包括三个角色:


    1.  工厂(Creator)角色 :简单工厂模式的核心,它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用,创建所需的产品对象。
    2.  抽象产品(Product)角色:简单工厂模式所创建的所有对象的父类,它负责描述所有实例所共有的公共接口。
    3.  具体产品(Concrete Product)角色:是简单工厂模式的创建目标,所有创建的对象都是充当这个角色的某个具体类的实例。

    其UML图如下所示:



    看一下写的小例子:假如一家航空公司需要购买飞机:

    先定义飞机接口:

    public interface IPlane {
    	void name();
    }
    

    在得到Product:

    波音:

    public class Boeing777 implements IPlane{
    	private String name = "Boeing777";
    	@Override
    	public void name() {
    		// TODO Auto-generated method stub
    		System.out.println("My name is:" + name);
    	}
    
    }
    

    空客:

    public class Boeing737 implements IPlane {
    	private String name = "Boeing737";
    	@Override
    	public void name() {
    		// TODO Auto-generated method stub
    		System.out.println("My name is :" + name);
    	}
    
    }
    

    再看飞机工厂:

    Create:

    public class PlaneFactory {
    	public static IPlant getPlane(String name) throws Exception {
    		if (name.equalsIgnoreCase("boeing777")){
    			return new Boeing777();
    		} else if (name.equalsIgnoreCase("boeing737")){
    			return new Boeing737();
    		}else
    		{
    			throw new Exception("The type $type don't exists" );
    		}		
    	}
    }
    

    当我们在客户端想要得到飞机的时候:

    public class PlaneTest {
    
    	/**
    	 * @param args
    	 * @throws Exception 
    	 */
    	public static void main(String[] args) throws Exception {
    		// TODO Auto-generated method stub
    		//获取波音飞机
    		IPlane boeing777 = PlaneFactory.getPlane("boeing777");
    		//获得名字
    		boeing777.name();
    		//获取空客飞机
    		IPlane boeing737= PlaneFactory.getPlane("airbus");
    		//获得名字
    		boeing737.name();
    	}
    
    }

    运行结果:

    My name is:Boeing777
    My name is :Boeing737


    优点:

      工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的.明确了各自的职责和权利,有利于整个 软件体系结构 的优化。
    缺点:
      由于工厂类集中了所有实例的创建逻辑,违反了 高内聚 责任分配原则,将全部创建逻辑集中到了一个工厂类中;它所能创建的类只能是事先考虑到的,如果需要添加新的类,则就需要改变工厂类了。
      当系统中的具体产品类不断增多时候,可能会出现要求工厂类根据不同条件创建不同实例的需求.这种对条件的判断和对具体产品类型的判断交错在一起,很难避免模块功能的蔓延,对系统的维护和扩展非常不利;
      这些缺点在 工厂方法模式 中得到了一定的克服。
    使用场景
      工厂类负责创建的对象比较少;
      客户只知道传入工厂类的参数,对于如何创建对象(逻辑)不关心;

      由于简单工厂很容易违反高内聚责任分配原则,因此一般只在很简单的情况下应用。

     说明:

            以上文字概念部分,均来自百度百科。自己没有那么好的归纳能力。


    二、工厂模式




    5月23号修改工厂模式代码,把工厂类修改成抽象类:

    public abstract class PlaneFactory {
    	public void letPlaneFly(String name){
    		IPlane iPlane = getPlane(name);
    		iPlane.fly();
    	}
    	abstract IPlane getPlane(String name) ;
    }
    

    不但能获取飞机,而且能让它飞!

    具体工厂类,有boeing工厂和airbus工厂。

    public class AirbusFactory extends PlaneFactory {
    
    	@Override
    	IPlane getPlane(String name) {
    		// TODO Auto-generated method stub
    		if (name.equalsIgnoreCase("airbus320")){
    			return new Airbus320();
    		} else if (name.equalsIgnoreCase("airbus380")){
    			return new Airbus380();
    		}else {
    			return null;
    		}
    	}
    
    }
    

    public class BoeingPlaneFactory extends PlaneFactory{
    
    	@Override
    	IPlane getPlane(String name) {
    		// TODO Auto-generated method stub
    		if (name.equalsIgnoreCase("boeing777")){
    			return new Boeing777();
    		} else if (name.equalsIgnoreCase("boeing737")){
    			return new Boeing737();
    		}else {
    			return null;
    		}		
    	}
    
    	
    }
    

    产品抽象类:plane

    public abstract class IPlane {
    	abstract void name();
    	public void fly() {
    		name();
    		System.out.println("i fly in the sky");
    	}
    }
    

    分别继承,获得的四个飞机类:

    public class Boeing777 extends IPlane {
    
    	@Override
    	public void name() {
    		// TODO Auto-generated method stub
    		System.out.println("i am boeing 777");
    	}
    
    }

    public class Boeing737 extends IPlane {
    
    	@Override
    	public void name() {
    		// TODO Auto-generated method stub
    		System.out.println("i am boeing 737");
    	}
    
    }


    public class Airbus320 extends IPlane {
    
    	@Override
    	public void name() {
    		// TODO Auto-generated method stub
    		System.out.println("i am airbus320");
    	}
    
    }
    

    public class Airbus380 extends IPlane {
    
    	@Override
    	public void name() {
    		// TODO Auto-generated method stub
    		System.out.println("i am Airbus380");
    	}
    
    }
    

    测试类:

    public static void main(String[] args) throws Exception {
    		PlaneFactory airBus = new AirbusFactory();
    		//看空客飞机飞
    		airBus.letPlaneFly("airbus320");
    		airBus.letPlaneFly("airbus380");
    		PlaneFactory boeing = new BoeingPlaneFactory();
    		boeing.letPlaneFly("boeing777");
    		boeing.letPlaneFly("boeing737");
    		
    	}

    测试结果:

    i am airbus320
    i fly in the sky
    i am Airbus380
    i fly in the sky
    i am boeing 777
    i fly in the sky
    i am boeing 737
    i fly in the sky


    三、抽象工厂模式

            当我们发现,我们不仅需要民航飞机,我们还需要战斗机,该如何办呢?大家都知道,波音不仅生产民用飞机,还有著名的B-52,而空客也有它的军用运输机A400M。

    我们生产飞机时,就需要两个接口了,军用飞机一个接口,民用飞机一个接口。看下图:


    军用飞机是一个产品等级,民用飞机又是一个产品等级,而波音和空客生产两个不同的产品族。


    先看看民用飞机接口:

    public interface ICivilaircraft {
    	String getName();
    	//运输旅客
    	void passengers();
    }

    民用飞机:

    public class Boeing777 implements ICivilaircraft{
    	private String name ="Boeing 777";
    	private String personNumber ="350";
    
    	@Override
    	public String getName() {
    		return name;
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void passengers() {
    		// TODO Auto-generated method stub
    		System.out.println(getName()+"can passengers "+personNumber+" person");
    	}
    }
    

    空客的空客340

    public class Airbus340 implements ICivilaircraft{
    	private String name ="Airbus340";
    	private String personNumber ="380";
    
    	@Override
    	public String getName() {
    		return name;
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public void passengers() {
    		// TODO Auto-generated method stub
    		System.out.println(getName()+"can passengers "+personNumber+" person");
    	}
    }


    军用飞机接口:

    public interface IWarplane  {
    	String getName();
    	//运输武器
    	void Transportarms();
    }
    

    军用飞机:

    public class A400M implements IWarplane {
    	private String name ="A400M";
    	private String armweight="30吨";
    	@Override
    	public String getName() {
    		// TODO Auto-generated method stub
    		return name;
    	}
    
    	@Override
    	public void Transportarms() {
    		// TODO Auto-generated method stub
    		System.out.println(getName()+"can transport "+ armweight+" arms");
    	}
    
    }

    B52:

    public class B52 implements IWarplane {
    	private String name ="B52";
    	private String armweight="27吨";
    	@Override
    	public String getName() {
    		// TODO Auto-generated method stub
    		return name;
    	}
    
    	@Override
    	public void Transportarms() {
    		// TODO Auto-generated method stub
    		System.out.println(getName()+"can transport "+ armweight+" arms");
    	}
    
    }
    

    在看看飞机工厂,波音公司和空客公司,先看他们的父类:

    public abstract class AbstractFactory {
        abstract ICivilaircraft getCivilair();
        abstract IWarplane getWarplane();
    }
    

    波音:

    public class BoeingFactory extends AbstractFactory{
    
    	@Override
    	ICivilaircraft getCivilair() {
    		// TODO Auto-generated method stub
    		return new Boeing777();
    	}
    
    	@Override
    	IWarplane getWarplane() {
    		// TODO Auto-generated method stub
    		return new B52();
    	}
    	
    
    }
    

    空客:

    public class AirBus extends AbstractFactory {
    
    	@Override
    	ICivilaircraft getCivilair() {
    		// TODO Auto-generated method stub
    		return new Airbus340();
    	}
    
    	@Override
    	IWarplane getWarplane() {
    		// TODO Auto-generated method stub
    		return new A400M();
    	}
    
    }
    

    测试类:

    public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		AbstractFactory boeing = new BoeingFactory();
    		AbstractFactory airbus = new AirBus();
    		//查看波音的民用飞机
    		boeing.getCivilair().passengers();
    		//查看波音的军用飞机
    		boeing.getWarplane().Transportarms();
    		//查看空客的民用飞机
    		airbus.getCivilair().passengers();
    		//查看空客的军用飞机
    		airbus.getWarplane().Transportarms();
    	}

    测试结果:

    Boeing 777  can passengers 350 person
    B52  can transport 27吨 arms
    Airbus340  can passengers 380 person
    A400M  can transport 30吨 arms


    区别和联系:

    抽象工厂和工厂模式有什么区别呢?他们俩又在具体什么情况下使用呢?请看下面从网上找到的不错的回答:


          其实这两者的区别,GOF的书上说得很清楚。工厂方法采用的是类继承机制(生成一个子类,重写该工厂方法,在该方法中生产一个对象)。而抽象工厂采用的是对象组合机制,专门定义“工厂”对象来负责对象的创建。对象组合的方式就是把“工厂”对象作为参数传递。


    工厂方法模式:
    一个抽象产品类,可以派生出多个具体产品类。   
    一个抽象工厂类,可以派生出多个具体工厂类。   
    每个具体工厂类只能创建一个具体产品类的实例。
    
    抽象工厂模式:
    多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。   
    一个抽象工厂类,可以派生出多个具体工厂类。   
    每个具体工厂类可以创建多个具体产品类的实例。   
        
    区别:
    工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。   
    工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。


    工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。工厂方法:说白了就是一个方法,这个方法是创建具体的产品的,它要求所有的工厂都具有同一个签名的方法,必要时重写该方法;抽象工厂:不能直接创建产品,只能创建工厂,即抽象工厂创建的产品是工厂。虽然它也定义了创建产品的方法,但需要创建出来的具体的工厂实现,即:抽象工厂创建出的工厂创建产品。工厂方法采用的是类继承机制(生成一个子类,重写该工厂方法,在该方法中生产一个对象);而抽象工厂采用的是对象组合机制,专门定义“工厂”对象来负责对象的创建。对象组合的方式就是把“工厂”对象作为参数传递。


    可以这么去理解,“抽象工厂模式”这个称呼中的“抽象”是一个动词,即对工厂方法模式进行了抽象,就变成了抽象工厂模式,这么理解后,就不难看出它们的区别: 工厂方法模式:每个抽象产品派生多个具体产品类,每个抽象工厂类派生多个具体工厂类,每个具体工厂类负责一个具体产品的实例创建; 抽象工厂模式:每个抽象产品派生多个具体产品类,每个抽象工厂派生多个具体工厂类,每个具体工厂负责多个(一系列)具体产品的实例创建。

    
    




    展开全文
  • 工厂模式

    千次阅读 2019-09-25 20:18:24
    这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。 介绍 意图:定义一个创建对象...

    工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

    在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。

    介绍

    意图:定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。

    主要解决:主要解决接口选择的问题。

    何时使用:我们明确地计划不同条件下创建不同实例时。

    如何解决:让其子类实现工厂接口,返回的也是一个抽象的产品。

    关键代码:创建过程在其子类执行。

    应用实例 :1、您需要一辆汽车,可以直接从工厂里面提货,而不用去管这辆汽车是怎么做出来的,以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。

    优点 :1、一个调用者想创建一个对象,只要知道其名称就可以了。 2、扩展性高,如果想增加一个产品,只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现,调用者只关心产品的接口。

    缺点:每次增加一个产品时,都需要增加一个具体类和对象实现工厂,使得系统中类的个数成倍增加,在一定程度上增加了系统的复杂度,同时也增加了系统具体类的依赖。这并不是什么好事。

    使用场景 :1、日志记录器:记录可能记录到本地硬盘、系统事件、远程服务器等,用户可以选择记录日志到什么地方。 2、数据库访问,当用户不知道最后系统采用哪一类数据库,以及数据库可能有变化时。 3、设计一个连接服务器的框架,需要三个协议,“POP3”、“IMAP”、“HTTP”,可以把这三个作为产品类,共同实现一个接口。

    注意事项:作为一种创建类模式,在任何需要生成复杂对象的地方,都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式,而简单对象,特别是只需要通过 new 就可以完成创建的对象,无需使用工厂模式。如果使用工厂模式,就需要引入一个工厂类,会增加系统的复杂度。

    实现

    我们将创建一个 Shape 接口和实现 Shape 接口的实体类。下一步是定义工厂类 ShapeFactory

    FactoryPatternDemo,我们的演示类使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息(CIRCLE / RECTANGLE / SQUARE),以便获取它所需对象的类型。

    工厂模式

    步骤 1

    创建一个接口。

    Shape.java

    public interface Shape {
        void draw();
    }
    

    步骤 2

    创建实现接口的实体类。

    Rectangle.java

    public class Rectangle implements Shape {
        @Override
        public void draw() {
            System.out.println("Inside Rectangle::draw() method.");
        }
    }
    

    Square.java

    public class Square implements Shape {
        @Override
        public void draw() {
            System.out.println("Inside Square::draw() method.");
        }
    }
    

    Circle.java

    public class Circle implements Shape {
        @Override
        public void draw() {
            System.out.println("Inside Circle::draw() method.");
        }
    }
    

    步骤 3

    创建一个工厂,生成基于给定信息的实体类的对象。

    ShapeFactory.java

    public class ShapeFactory {
    
        //使用 getShape 方法获取形状类型的对象
        public Shape getShape(String shapeType) {
            if (shapeType == null) {
                return null;
            }
            shapeType = shapeType.toLowerCase();
    
            switch (shapeType) {
                case "circle":
                    return new Circle();
                case "rectangle":
                    return new Rectangle();
                case "square":
                    return new Square();
                default:
                    return null;
            }
    
        }
    
    }
    

    步骤 4

    使用该工厂,通过传递类型信息来获取实体类的对象。

    FactoryPatternDemo.java

    public class FactoryPatternDemo {
    
        public static void main(String[] args) {
            ShapeFactory shapeFactory = new ShapeFactory();
    
            //获取 Circle 的对象,并调用它的 draw 方法
            Shape shape1 = shapeFactory.getShape("CIRCLE");
            //调用 Circle 的 draw 方法
            shape1.draw();
    
            //获取 Rectangle 的对象,并调用它的 draw 方法
            Shape shape2 = shapeFactory.getShape("RECTANGLE");
            //调用 Rectangle 的 draw 方法
            shape2.draw();
    
            //获取 Square 的对象,并调用它的 draw 方法
            Shape shape3 = shapeFactory.getShape("SQUARE");
            //调用 Square 的 draw 方法
            shape3.draw();
        }
    
    }
    

    步骤 5

    验证输出。

    Inside Circle::draw() method.
    Inside Rectangle::draw() method.
    Inside Square::draw() method.
    
    展开全文
  • 通过工厂模式来实现支持不同数据库类型。根据实际情况从解决方案中移除不需要的DAL. 通过修改Web.config 的实现加载不同的DAL程序集.
  • 工厂模式与抽象工厂模式

    万次阅读 2020-12-25 21:34:30
    工厂模式 模式定义: 定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟到子类 作用:实现了创建者和调用者的分离 详细分类:  简单工厂模式工厂方法模式  抽象工厂...
  • 设计模式——工厂模式

    千次阅读 多人点赞 2020-10-12 17:19:53
    这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。 2. 作用 通过工厂模式,将...
  • 1、简单工厂模式简单工厂模式是属于创建型模式,又叫做静态工厂方法(static Factory Method)模式,简单工厂模式是由一个工厂对象决定创建出来哪一种产品类的实例.简单工厂模式的实质是由一个工厂类根据传入的参数,...
  • 我用工厂模式做的一个简单的客房类型管理 很简单 突出的是工厂模式
  • 直到前些时候才去了解工厂模式,其实工厂模式还是很常用的,参考大话设计模式和网上的若干博客,初步整理出四种版本的,简单工厂模式工厂模式、改进的反射工厂模式、抽象工厂模式。  首先先大概了解下实际运用...
  • 工厂模式 所谓工厂,就是将零件组装成产品的地方。 建一个对象常常需要复杂的过程,所以不适合包含在一个复合...例如,在《设计模式》一书中,像工厂方法模式、抽象工厂模式、生成器模式,甚至是单例模式都应用了工厂
  • 设计模式——抽象工厂模式及与工厂模式的区别

    万次阅读 热门讨论 2017-12-21 11:08:25
    这两种设计模式主要的区别在于产品,工厂模式是用来创建同一个产品的不同类型的(详情请看上一篇博客中卖包子的案例,大肉包和牛肉包它们都是包子的不同类型展示),但是抽象工厂模式是用来创建不同类的产品
  • 抽象工厂模式工厂模式更为复杂,就像上面提到的缺点一样,工厂模式和简单工厂模式要求产品子类必须要是同一类型的,拥有共同的方法,这就限制了产品子类的扩展。于是为了更加方便的扩展,抽象工厂模式就将同一类的...
  • 抽象工厂模式的区别及优缺点及使用场景简单工厂普通简单工厂多方法简单工厂静态方法简单工厂工厂方法模式抽象工厂模式 工厂模式是java设计模式中比较简单的一个设计模式,但很多地方都用到了工厂模式,(如解析xml...
  • 抽象工厂模式

    千次阅读 2019-09-25 20:07:55
    这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。 介绍 意图:提供...
  • Java设计模式工厂方法模式&抽象工厂模式

    万次阅读 多人点赞 2016-09-11 15:07:17
    工厂方法模式: 通用类图如下: 抽象产品类: 具体产品类 抽象工厂类 具体的工厂类 场景类: 工厂方法模式的优点: 使用场景: 工厂方法模式的扩展: (1)简单工厂模式 (2)多工厂模式 抽象工厂模式.....
  • 这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。 介绍 意图:定义一个创建...
  • 实例化对象,用工厂方法替代new操作,避免你辛苦的准备构造方法的参数工厂模式包括工厂方法模式和抽象工厂模式抽象工厂模式工厂方法模式的拓展工厂对象可以被传递 工厂模式的意义: 在面向对象编程中, 最...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 462,651
精华内容 185,060
关键字:

工厂模式类型