• 设计模式之工厂模式(简单工厂+工厂模式+抽象工厂)


    参考博文:https://www.cnblogs.com/toutou/p/4899388.html   侵权必删

    什么是工厂模式:通过“对象创建”模式绕开new,来避免对象创建(new)过程中所导致的紧耦合(依赖具体类)。

    适用性:使用new创建对象且导致紧耦合的场景。

    思考:面向对象编程要以动态的思维去看待代码。换句话说,在看代码时需要时间概念,发现代码在未来的稳定之处和变化之处。一般接口和抽象类是稳定的,而具体实现是变化的,这也是面向接口/抽象编程的原因,可以使代码更加稳定。

    先思考如下场景:目前只有一种ProductA,需要productA时,使用代码 ProductA pa = new ProductA()。如果未来需求变化,添加ProductB、ProductC等,会导致上述代码是不稳定。因为ProductA pa = new ProductA() 这俩部分都依赖了具体实现。

    将ProductA、ProductB、ProductC抽象出Product,改写代码Product pa = new ProductA(),目前依然依赖nProductA,工厂问题就是为了解决这种new依赖的问题。

    一、简单工厂模式

    基本代码:

    package simpleFactory;
    
    public abstract class Produce {
        public abstract void readme();
    }
    package simpleFactory;
    
    public class ProductA extends Produce{
        @Override
        public void readme() {
            System.out.println("AAAAAAA");
        }
    }
    package simpleFactory;
    
    public class ProduvtB extends Produce {
        @Override
        public void readme() {
            System.out.println("BBBBBBBBBB");
        }
    }
    package simpleFactory;
    
    public class SimpleFacory {
        public Produce getProduce(String type){
            if(type.equals("A")) {
                return new ProductA();
            }else if(type.equals("B")){
                return new ProduvtB();
            }else {
                System.out.println("typr error");
            }
            return null;
        }
    }
        public static void main(String[] args) {
    ////---------------简单工厂模式---------------------
    ////        通过向工厂传递参数而获取期望的对象,单工厂模式能够根据外界给定的信息,决定究竟应该创建哪个具体类的对象。
    ////          明确区分了各自的职责和权力,有利于整个软件体系结构的优化。
    ////          但是工厂类集中了所有实例的创建逻辑,容易违反GRASPR的高内聚的责任分配原则
    //
    //        SimpleFacory sf = new SimpleFacory();
    //        Produce p = sf.getProduce("A");
    //        p.readme();
    //    }
    }

    二、工厂模式

    package FactoryMethod;
    
    import simpleFactory.Produce;
    
    public abstract class Factory {
        public abstract Produce getProduce();
    
    }
    package FactoryMethod;
    
    import simpleFactory.Produce;
    import simpleFactory.ProductA;
    
    public class FactoryA extends Factory{
        @Override
        public Produce getProduce() {
            return new ProductA();
        }
    }
    package FactoryMethod;
    
    import simpleFactory.Produce;
    import simpleFactory.ProduvtB;
    
    public class FactoryB extends Factory {
        @Override
        public Produce getProduce() {
            return new ProduvtB();
        }
    }
    ////------------------工厂模式------------------------
            Factory f = new FactoryA(); //这里使用new的方式代替,实际情况下应该根据需要传入具体的工厂
            Produce p = f.getProduce(); //均依赖抽象
            p.readme();

    三、抽象工厂模式(可以认为抽象工厂模式是工厂模式的一般形式)

    package AbstractFactory;
    
    public abstract class ProduceNumber {
        public abstract void readme();
    }
    package AbstractFactory;
    
    /**
     * 只能与产品A配套
     */
    public class Produce1 extends ProduceNumber {
        public void readme(){
            System.out.println("111111111");
        }
    }
    package AbstractFactory;
    /**
     * 只能与产品B配套
     */
    public class Produce2 extends ProduceNumber {
        public void readme() {
            System.out.println("222222");
        }
    }
    package AbstractFactory;
    
    import simpleFactory.Produce;
    
    public abstract class AbstractFactory {
        public abstract Produce getProduce();
        public abstract ProduceNumber getProduceNumber();
    }
    package AbstractFactory;
    
    import simpleFactory.Produce;
    import simpleFactory.ProductA;
    
    public class FactoryA1 extends AbstractFactory {
        @Override
        public Produce getProduce() {
            return new ProductA();
        }
    
        @Override
        public ProduceNumber getProduceNumber() {
            return new Produce1();
        }
    }
    package AbstractFactory;
    
    
    import simpleFactory.Produce;
    import simpleFactory.ProduvtB;
    
    public class FactoryB2 extends AbstractFactory{
        @Override
        public Produce getProduce() {
            return new ProduvtB();
        }
    
        @Override
        public ProduceNumber getProduceNumber() {
            return new Produce2();
        }
    }
    //--------------------抽象工厂模式-----------------------
    //        有产品A和产品1配套,产品B和产品2配套。如果只用工厂模式需要4个具体工厂,且有可能出现产品不匹配的问题。
    //        抽象工厂模式为创建一组相关或相互依赖的对象提供一个接口,保证产品的配套问题,使得上述问题只要两个工厂。
    // 适用场合:多个需要配套的产品
    AbstractFactory f = new FactoryA1();//这里使用new的方式代替,实际情况下应该根据需要传入具体的工厂 Produce p = f.getProduce(); ProduceNumber pn = f.getProduceNumber(); p.readme(); pn.readme();
  • 相关阅读:
    2018.8.5 复习笔记
    C#抽象类与接口的区别【转】
    double转整数问题
    C++学习笔记
    BCG使用
    C++设计模式之工厂方法模式
    静态成员函数
    CTreeCtrl 控件使用总结
    WinAPI: ShellExecute
    C++ STL map使用
  • 原文地址:https://www.cnblogs.com/youzoulalala/p/11050489.html
Copyright © 2020-2023  润新知