精华内容
下载资源
问答
  • NULL 博文链接:https://1193355343.iteye.com/blog/2370838
  • 简单工厂和抽象工厂有什么区别?

    万次阅读 2019-07-09 09:40:09
    简单工厂和抽象工厂有什么区别? 简单工厂模式 是由一个工厂对象创建产品实例,简单工厂模式的工厂类一般是使用静态方法,通过不同的参数的创建不同的对象实例 可以生产结构中的任意产品,不能增加新的产品 ...

    简单工厂和抽象工厂有什么区别?

    • 简单工厂模式

    是由一个工厂对象创建产品实例,简单工厂模式的工厂类一般是使用静态方法,通过不同的参数的创建不同的对象实例
    可以生产结构中的任意产品,不能增加新的产品

     

    • 抽象工厂模式

    提供一个创建一系列相关或相互依赖对象的接口,而无需制定他们具体的类,生产多个系列产品
    生产不同产品族的全部产品,不能新增产品,可以新增产品族
     

     


    【Java面试题与答案】整理推荐

     

    展开全文
  • 分为简单工厂和抽象工厂 两种设计模式的区别: 区别在于产品,如果产品单一,最合适用工厂模式,但是如果有多个业务品种、业务分类时,通过抽象工厂模式产生需要的对象是一种非常好的解决方式。再通俗深化理解下:...

    //此总结为个人原创,有任何问题欢迎指出并改正,谢谢支持

    使用场景:计划在不同的场景下创建不同的产品;分为简单工厂和抽象工厂 

    两种设计模式的区别:

           区别在于产品,如果产品单一,最合适用工厂模式,但是如果有多个业务品种、业务分类时,通过抽象工厂模式产生需要的对象是一种非常好的解决方式。再通俗深化理解下:工厂模式针对的是一个产品等级结构抽象工厂模式针对的是面向多个产品等级结构的。

    简单工厂方法模式Demo

    抽象产品接口

    public interface Operation{

        public double getResult(double numberA,double numberB)throws Exception;

    }

     

    具体产品接口

    public class Add implements Operation{   // 加法计算   
    public double getResult(double numberA, double numberB){       return numberA + numberB;  }}
    public class Sub implements Operation{   // 减法计算       public double getResult(double numberA, double numberB){               return  numberA-numberB;   }}
    public class Mul implements Operation{// 乘法计算
        public double getResult(double numberA, double numberB){      
         return numberA * numberB;
        }
    }
    public class Div implements Operation{// 除法计算  
       public double getResult(double numberA, double numberB)throws Exception {       
        if(numberB == 0) {               throw  new  Exception("除数不能为0");    }           return  numberA / numberB; }} 

    简单工厂类

    public class EasyFactory // 简单工厂,根据字符串创建相应的对象    

    publicstatic Operation createOperation(String name){
            Operation operationObj = null;
            switch(name) {            
                case"+":
                    operationObj = new Add();
                    break;
                case"-":
                    operationObj = new Sub();
                    break;
                case"*":
                    operationObj = new Mul();
                    break;
                case"/":
                    operationObj = new Div();
                    break;
            }
            return operationObj;
        }
    }

    客户端调用

    public class Client{  
    public static void main(String[] args) throws Exception {
      Operation add = EasyFactory.createOperation("+");
      Operation sub = EasyFactory.createOperation("-");
      Operation mul = EasyFactory.createOperation("*");
      Operation div = EasyFactory.createOperation("/");
      System.out.println(add.getResult(1, 1));
      System.out.println(sub.getResult(1, 1));
      System.out.println(mul.getResult(1, 1));
      System.out.println(div.getResult(1, 1));
        }
    }

    *****************

     可以对简单工厂进行改良

     

    public class EasyFactory
    private static Operation operationObj = null;    
    private static Operation add(){
            System.out.println("加法运算");        return new Add();
    }
        privatestatic Operation sub(){
            System.out.println("减法运算");                return new Sub();
        }
        private static Operation mul(){
             System.out.println("乘法运算");
            return new Mul();
    }    
    private static Operation div(){
            System.out.println("除法运算");        return new Div();}    
    // 简单工厂,根据字符串创建相应的对象   
    publicstatic Operation createOperation(String name){      
    switch (name) {
                case"+":
                    operationObj = add();
                    break;
                case"-":
                    operationObj = sub();
                    break;
                case"*":
                    operationObj = mul();
                    break;
                case"/":
                    operationObj = div();
                    break;
            }
            return operationObj;
        }
    }

    抽象工厂方法模式Demo

     

    产品类不变,只抽象工厂类

     

    抽象工厂类

     

    public interface Factory{    
    public Operation createOperation();
    }

     

    具体工厂类

     

    // 加法类工厂
    public class AddFactory implements Factory{   
    public Operation createOperation(){
            System.out.println("加法运算");
            return new Add();
        }
    }

     

    // 减法类工厂
    public class SubFactory implements Factory{   public Operation createOperation(){        System.out.println("减法运算");        return new Sub();
      }}

       // 乘法类工厂

    public class MulFactory implements Factory{
     public Operation createOperation(){
            System.out.println("乘法运算");               return new Mul();
        }
    }
    // 除法类工厂
    public class DivFactory implements Factory 
    public Operation createOperation(){
            System.out.println("除法运算");        
             return new Div();
        }
    }

     

     

    客户端代码:

     

    public class Client{  
    public static void main(String[] args)throws Exception {       
    // 使用反射机制实例化工厂对象,因为字符串是可以通过变量改变的
            Factory addFactory = (Factory) Class.forName("org.zero01.factory.AddFactory").newInstance();
            Factory subFactory=(Factory) Class.forName("org.zero01.factory.SubFactory").newInstance();
            Factory mulFactory=(Factory) Class.forName("org.zero01.factory.MulFactory").newInstance();
            Factory divFactory=(Factory) Class.forName("org.zero01.factory.DivFactory").newInstance();       
    // 通过工厂对象创建相应的实例对象
            Operation add = addFactory.createOperation();
            Operation sub = subFactory.createOperation();
            Operation mul = mulFactory.createOperation();
            Operation div = divFactory.createOperation();
     
            System.out.println(add.getResult(1, 1));
            System.out.println(sub.getResult(1, 1));
            System.out.println(mul.getResult(1, 1));
            System.out.println(div.getResult(1, 1));
        }
    }

    *******************************

     抽象工厂类可以改良(代码中常用)如下:

    public abstract class Factroy{
        public abstract<T extends Operation > T create(Class<T> clz);
    }
    public class BaseFactory extends Factroy{
      @override
        public <T extends Operation > T create(Class<T> clz){
          Operation shape=null;
          try{
    
              shape=(Operation)Class.forName(clz.getName()).newInstance();
          } catch(Exception e){
              e.printStackTrace();
          }
          return (T)shape;
      }
    }

    客户端调用

    public class Client{    
    public static void main(String[] args)throws Exception {
            Factory factory=new BaseFactory();
            Factory addFactory =factory.create(AddFactory.class);
            Factory subFactory =factory.create(SubFactory.class);
            Factory mulFactory =factory.create(MulFactory.class);
            Factory divFactory =factory.create(DivFactory.class);        
             // 通过工厂对象创建相应的实例对象
            Operation add = addFactory.createOperation();
            Operation sub = subFactory.createOperation();
            Operation mul = mulFactory.createOperation();
            Operation div = divFactory.createOperation();
     
            System.out.println(add.getResult(1, 1));
            System.out.println(sub.getResult(1, 1));
            System.out.println(mul.getResult(1, 1));
            System.out.println(div.getResult(1, 1));
        }
    }

     



    展开全文
  • 看了网络上很多关于设计模式的方法,有的模式看起来相似,但本质还是区别很大的.像简单工厂,工厂方法和抽象工厂就有很明显的区别.
  • C++ 工厂模式 (简单工厂、工厂和抽象工厂
  • 原文链接:...第一次写有什么不对的望指教 1.简单工厂 using System; public interface ICar { void run(); } public class BMWCar : ICar { public void run() { Console.WriteLine...

    原文链接:https://www.cnblogs.com/aivdesign/articles/3240869.html
    第一次写有什么不对的望指教
    1.简单工厂

    using System;
    public interface ICar
    {
    void run();
    }
    public class BMWCar : ICar
    {
    public void run()
    {
    Console.WriteLine(“BMWCar run”);
    }
    }

    public class BenzCar : ICar
    {
    public void run()
    {
    Console.WriteLine(“BenzCar run”);
    }
    }

    public class Driver
    {
    public static ICar DriverCar(string carType)
    {
    switch (carType)
    {
    case “BMWCar”: return new BMWCar();
    case “BenzCar”: return new BenzCar();
    default: throw new Exception();
    }
    }
    }

    public class Client
    {
    public static void Main()
    {
    ICar myCar = Driver.DriverCar(“BenzCar”);
    myCar.run();
    Console.Read();
    }
    }
    个人心得:简单工厂是一个工厂生产一类的产品,面对的事具体的类
    优点:只要实现共有的接口就可以实现不同的方式。

    2.抽象工厂
    using System;
    public interface IBusinessCar
    {
    void run();
    }

    public interface ISportCar
    {
    void run();
    }

    public class BMWBusinessCar : IBusinessCar
    {
    public void run()
    {
    Console.WriteLine(“BMWCar run”);
    }

    }

    public class BenzBusinessCar : IBusinessCar
    {
    public void run()
    {
    Console.WriteLine(“BenzBusinessCar run”);
    }
    }

    public class BMWSportCar:ISportCar
    {
    public void run()
    {
    Console.WriteLine(“BMWSportCar run”);
    }
    }

    public class BenzSportCar:ISportCar
    {
    public void run()
    {

    Console.WriteLine(“BenzSportCar run”);
    }
    }

    public interface IDriver
    {
    IBusinessCar BusinessCarDriver();
    ISportCar SportCarDriver();
    }

    public class BMWDriver:IDriver
    {
    public IBusinessCar BusinessCarDriver()
    {
    return new BMWBusinessCar();
    }
    public ISportCar SportCarDriver()
    {
    return new BMWSportCar();
    }
    }

    public class BenzDriver:IDriver
    {
    public IBusinessCar BusinessCarDriver()
    {
    return new BenzBusinessCar();
    }

    public ISportCar SportCarDriver()
    {
    return new BenzSportCar();
    }
    }

    class Client
    {
    public static void Main()
    {
    IDriver myDriver =new BenzDriver();
    ISportCar myCar = myDriver.SportCarDriver();
    myCar.run();
    Console.Read();
    }

    }

    心得:抽象工厂是把产品划出共同的东西,把相互依赖 的对象抽象出来,只要实现接口就可以得到不同的产品。

    展开全文
  • 简单工厂: 1、理解spring bean工厂基本上就理解了spring ioc了。 2、学东西先理脉络,再研究细节。 3、在实际工作中要把设计模式综合运用。 4、车的产生过程由自己确定,不由师父创建。 5、工厂就是生产产品,是靠...

    简单工厂:

    1、理解spring bean工厂基本上就理解了spring ioc了。
    2、学东西先理脉络,再研究细节。
    3、在实际工作中要把设计模式综合运用。
    4、车的产生过程由自己确定,不由师父创建。
    5、工厂就是生产产品,是靠自己生产产品,不是靠new;在里面可以做各种判断后再new车。
    6、工厂里面用单利还是多例可以自己选择。
    7、要替换方便就必须用多态,就要用父类和子类。
    8、控制生成类型和生成过程

    抽象工厂:

    1、在jdk里面有很多getInstance()基本上都是静态的工厂方法。
    2、在jdk里面有很多各种各样的Factory就是产生factory的工厂。
    3、这个人不单开车,还拿的武器,还吃着苹果,这个人手里控制的产品很多。
    4、问题是:控制系列产品的替换。
    4、如果把1系列产品换车2系列产品,只需要换1系列产品的工厂换成2系列产品的工厂就可以,没必要替换所以的。
    5、东西都new一遍,可以在配置文件里面修改一个地方就可以,换皮肤的功能类似抽象工厂,抽象工厂生产了。
    6、一系列产品,可以批量换掉一系列产品,只需要换掉工厂。

    抽象工厂和简单点工厂对比:

    1、简单工厂来说是可以在产品这个维度扩展,在普通工厂里面产生产品系列,会很麻烦,产生不同的产品就要产生对应的工厂,导致工厂泛滥问题。
    2、抽象工厂的问题:能换产品系列,但是能产生新的产品品种吗?修改的地方太多。
    3、既能在产品系列和产品品种方面有好的解决方案:
    比如:
    spring bean工厂,new什么东西由配置文件来决定。

    学习方法:

    应用驱动学习

    展开全文
  • 简单工厂模式(女娲造人),工厂(不同厂家生产不同空调),抽象工厂抽象工厂生产一类CPU)
  • 1 简单工厂(Simple Factory) 1.1 问题引出 假如有一个披萨店,Pizza的种类有很多,如CheesePizza、VeggiePizza、PepperPizza等。披萨店根据收到的订单制作Pizza,披萨的制作流程有材料的准备材料、烤、切、包装几步...
  • 主要介绍了Java设计模式编程中简单工厂与抽象工厂模式的使用实例,简单工厂与抽象工厂都可以归类于设计模式中的创建型模式,需要的朋友可以参考下
  • 工厂方法模式和抽象工厂模式的区别,对工厂方法模式和抽象工厂模式做了简单的比较
  • 4.简单工厂-工厂方法-抽象工厂 对比总结
  • 设计模式之工厂方法、简单工厂、抽象工厂
  • 1、抽象工厂模式+反射技术 2、抽象工厂模式+简单工厂模式 3、仅仅是抽象工厂模式
  • 这是代码,介绍请查看以下博客地址: http://www.cnblogs.com/homg/p/3548110.html代码乱码请使用utf-8编码。
  • 工厂模式在一些设计模式的书中分为简单工厂模式,工厂方法模式和抽象工厂模式三类。也有把工厂方法模式划分到抽象工厂模式的,认为工厂方法是抽象工厂模式的特例的一种,就是只有一个要实现的产品接口。
  • 简单工厂、工厂方法、抽象工厂区别

    万次阅读 多人点赞 2018-08-17 11:38:19
    结合简单示例UML图,讲解工厂模式简单原理。 一、引子 话说十年前,有一个爆发户,他家有三辆汽车(Benz(奔驰)、Bmw(宝马)、Audi(奥迪)),还雇了司机为他开车。不过,爆发户坐车时总是这样:上Benz车后跟...
  • 使用简单工厂模式模拟女娲(Nvwa)造人(Person),如果传入参数M,则返回一个Man对象,如果传入参数W,则返回一个Woman对象,请实现该场景。现需要增加一个新的Robot类,如果传入参数R,则返回一个Robot对象,对...
  • 为什么会出现简单工厂,工厂方法与简单工厂还有抽象工厂到底有啥区别,什么时候能用到这些呢,如果你对于这些不是很清晰,那么你可以看看小编的这篇博客,透析式挖掘三者的区别!不要错过哟! 这里所有的类图均用...
  • // 创建Reader对象的工厂 public class ReaderFactory { public static Reader getReader() throws FileNotFoundException { File file = new File("aa.txt"); FileReader fileReader = new FileReader(file); ...
  • 介绍的是工厂模式 包括简单工厂模式、工厂方法模式、抽象工厂模式 包括PPT代码
  • C++编写简单工厂和抽象工厂

    千次阅读 2018-05-07 23:55:59
    简单工厂模式包含三个角色:工厂角色Factory,抽象产品角色(Product)具体产品角色(ConcreteProduct)先做个实例来全面诠释我们的工厂模式 有一个销售管理系统支持多种支付方式,如现金支付,信用卡支付,代金券支付...
  • 简单工厂 简单工厂模式又 叫静态工厂方法模式(Static FactoryMethod Pattern),是通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。 简单工厂定义一个Factory类,可以根据参数的...
  • 简单工厂模式,工厂模式负责创建业务类的不同实现,本身使用接口解耦对具体工厂实例的依赖,并且一个工厂只负责生产一个类的实现,而抽象工厂则可看作是用来成产一组接口实现实例的的工厂。...
  • 一般用简单工厂+抽象工厂 1:工厂生成产品方法是static: 1-1简单(静态)工厂: 1-2简单(反射)工厂:方法中里用反射生成产品 1-3多方法工厂:生成产品的方法不一样 2:普通工厂:抽象工厂层+具...
  • 对于简单工厂,工厂方法,抽象工厂比较容易混淆,在这很有必要总结一下这三种设计模式的特点、相同之处不同之处。 1 本质:  这三种设计模式的名字中都含有“工厂”二字,其含义是使用工厂(一个或一系列方法)...
  • 一个抽象工厂类,可以派生出多个具体工厂类。每个具体工厂类只能创建一个具体产品类的实例。 抽象工厂模式: 多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。一个抽象工厂类,可以派生出多个具体工厂类...
  • 抽象工厂模式使用迭代模式创建对象 定义变量不同。简单工厂模式使用参数或者配置文件等事先定义好的变量,然后利用分支判断初始化具体产品类并返回;工厂方法模式不用事先定义变量,使用时随时引用便可;抽象工厂...
  • 主要介绍了Java设计模式之工厂模式,结合实例形式分析了简单工厂、工厂方法、抽象工厂等相关功能、实现与使用方法,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 138,314
精华内容 55,325
关键字:

简单工厂和抽象工厂