zoukankan      html  css  js  c++  java
  • 设计模式-工厂模式

    一、简单工厂模式     又叫静态工厂方法模式

    是通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。 

    缺点:
    拓展性差,额外增加一个具体产品类时,需要修改工厂。

    一个例子: 
    我喜欢吃面条,抽象一个面条基类,(接口也可以),这是产品的抽象类。

    public abstract class Noodles {
        //描述每种面条啥样的
        public abstract void desc();
    }
    

    先来一份兰州拉面(具体的产品类):

    程序员加班必备也要吃泡面(具体的产品类):

    还有我最爱吃的家乡的干扣面(具体的产品类):

    public class LzNoodles extends Noodles{
    	@Override
    	public void desc() {
    		System.out.println("兰州拉面 上海的好贵");
    	}
    }
    
    
    public class PaoNoodles extends Noodles{
    	@Override
    	public void desc() {
    		 System.out.println("泡面-程序员加班必备");
    	}
    }
    
    public class GankouNoodles extends Noodles {
    	@Override
    	public void desc() {
    		System.out.println("还是家里的干扣面好吃 6块一碗");
    	}
    }

    准备工作做完了,我们来到一家“简单面馆”(简单工厂类)

    public class NoodlesFactory {
    	 public static Noodles createNoodles(String name){
    		 if(name == "兰州拉面"){
    			 return new LzNoodles();
    		 }else if(name == "泡面"){
    			 return new PaoNoodles();
    		 }else if(name == "干扣面"){
    			 return new GankouNoodles();
    		 }
    		 return null;
    	 }
    }
    

    简单面馆就提供三种面条(产品),你说你要啥,他就给你啥。这里我点了一份干扣面:

    Noodles noodles = NoodlesFactory.createNoodles("干扣面");
    noodles.desc();
    

    输出:

    还是家里的干扣面好吃 6块一碗
    

      

     

    二.   工厂方法模式

    通过定义工厂父类负责定义创建对象的公共接口,而子类则负责生成具体的对象。

    优点:提高了程序拓展性,降低了程序间耦合度,
    缺点:当具体产品种类非常多时,会出现大量的与之对应的具体子工厂对象,程序变得

    使用步

    步骤1: 创建抽象工厂类,定义具体工厂的公共接口

    abstract class Factory{
        public abstract Product Manufacture();
    }
    

    步骤2: 创建抽象产品类 ,定义具体产品的公共接口;

    abstract class Product{
        public abstract void Show();
    }
    

    步骤3: 创建具体产品类(继承抽象产品类), 定义生产的具体产品;

    //具体产品A类
    class  ProductA extends  Product{
        @Override
        public void Show() {
            System.out.println("生产出了产品A");
        }
    }
    
    //具体产品B类
    class  ProductB extends  Product{
    
        @Override
        public void Show() {
            System.out.println("生产出了产品B");
        }
    }
    

    步骤4:创建具体工厂类(继承抽象工厂类),定义创建对应具体产品实例的方法;

    //工厂A类 - 生产A类产品
    class  FactoryA extends Factory{
        @Override
        public Product Manufacture() {
            return new ProductA();
        }
    }
    
    //工厂B类 - 生产B类产品
    class  FactoryB extends Factory{
        @Override
        public Product Manufacture() {
            return new ProductB();
        }
    }
    

    步骤5:外界通过调用具体工厂类的方法,从而创建不同具体产品类的实例

    /生产工作流程
    public class FactoryPattern {
        public static void main(String[] args){
            //客户要产品A
            FactoryA mFactoryA = new FactoryA();
            mFactoryA.Manufacture().Show();
    
            //客户要产品B
            FactoryB mFactoryB = new FactoryB();
            mFactoryB.Manufacture().Show();
        }
    }

    结果:

    生产出了产品A
    生产出了产品C

    三.  抽象工厂模式

    实现的条件:
      1.将产品工厂抽象化,为每一个具体产品类提供一个具体产品子工厂
      2.对应在子工厂中提供去获取该具体产品对象的方法
      3.在设计程序时要严格划分产品的等级关系
    优点:限制了程序自由拓展
    缺点:程序的拓展性变差,耦合度增加
    使用场景:1.解决工厂方法模式带来的弊端

    Nike和Adidas公司在生产鞋的同时,都还在生产衣服,那么,这种情况用工厂模式就不能做到了,因此产生了抽象工厂模式。 
    抽象工厂模式的适用范围比工厂模式更加广泛,它与工厂模式最大的区别在于: 
    工厂模式中一个工厂只能生产一种产品,而抽象工厂可以生产多个。

    Shoes

    public interface Shoes {
      public void wear();
    }

    AdidasShoes

    public class AdidasShoes implements Shoes{
      @Override
      public void wear() {
        System.out.println("Wear Adidas Shoes");
      }
    }

    NikeShoes

    public class NikeShoes implements Shoes{
        @Override
        public void wear() {
            System.out.println("Wear Nike Shoes");
        }
    }

    Clothes

    public interface Clothes {
        public void wear();
    }


    NikeClothes

    public class NikeClothes implements Clothes{
        @Override
        public void wear() {
            System.out.println("Wear Nike Clothes");
        }
    }

    AdidasClothes

    public class AdidasClothes implements Clothes{
        @Override
        public void wear() {
            System.out.println("Wear Adidas Clothes");
        }
    } 

    LabourFactory

    public interface LabourFactory {
        Shoes produceShoes();
        Clothes produceClothes();
    }

    NikeFactory

    public class NikeFactory implements LabourFactory{
    
        @Override
        public Shoes produceShoes() {
            System.out.println("Produce Nike Shoes");
            return new NikeShoes();
        }
    
        @Override
        public Clothes produceClothes() {
            System.out.println("Produce Nike Clothes");
            return new NikeClothes();
        }
    
    }

    AdidasFactory

    public class AdidasFactory implements LabourFactory{
    
        @Override
        public Shoes produceShoes() {
            System.out.println("Produce Adidas Shoes");
            return new AdidasShoes();
        }
    
        @Override
        public Clothes produceClothes() {
            System.out.println("Produce Adidas Clothes");
            return new AdidasClothes();
        }
    
    }
    

      

    链接:https://www.jianshu.com/p/d0c444275827
     
  • 相关阅读:
    常见的web漏洞
    WEB前端性能优化常见方法
    前端多终端浏览器兼容
    vue中computer与watch区别
    Vue父子组件生命周期执行顺序
    Git配置文件的妙用
    Git的基本概念和操作
    对AUC计算公式和几何意义的理解(详细版)
    如何看文献
    Python函数 range()和arange()的区分
  • 原文地址:https://www.cnblogs.com/gshao/p/10211956.html
Copyright © 2011-2022 走看看