• java设计模式之-工厂模式


    java设计模式之-工厂模式

    工厂模式分为:简单工厂、工厂方法模式、抽象工厂。实际上简单工厂并不属于设计模式。但是简单工厂提出来了工厂的概念。

    一、简单工厂

     1 //咖啡的父类,所有的咖啡都要继承该类。我把他定义成抽象方法。
     2 public abstract class Coffee {
     3     public abstract void creatCoffee();
     4 }
     5 
     6 //以下是咖啡的几个子类
     7 public class Coffee01 extends Coffee{
     8     public void creatCoffee() {
     9         System.out.println("创建Coffee01");
    10     }
    11 }
    12 
    13 
    14 public class Coffee02 extends Coffee{
    15     public void creatCoffee() {
    16         System.out.println("创建Coffee02");
    17     }
    18 }
    19 
    20 
    21 public class Coffee03 extends Coffee{
    22     public void creatCoffee() {
    23         System.out.println("创建Coffee03");
    24     }
    25 }

    既然是工厂模式,那么我们还需要定义一个工厂他的作用就是实例化我们需要的类。

     1 public class CoffeeFactory {
     2     
     3     public Coffee createCoffee(String coffee) {
     4         if(coffee.equals("coffee01")) {
     5             return new Coffee01();
     6         }else if(coffee.equals("coffee02")) {
     7             return new Coffee02();
     8         }else {
     9             return new Coffee03();
    10         }
    11     }
    12     
    13     public static void main(String[] args) {
    14         new CoffeeFactory().createCoffee("coffee01").creatCoffee();
    15     }
    16     
    17 }

    他是通过简单的入参判断需要实例化哪个类,写法也是比较简单,实用性也不强。

    二、工厂方法模式

    工厂方法模式主要是在工厂上做文章,每一个产品可以对应一个工厂,至于消费者要什么工厂由子类来确定。但是也有缺点,如果产品太多的话,那就要对应很多工厂,那么类将会异常的庞大

     1 //工厂父类,所有工厂都需要继承该类
     2 public abstract class CoffeeFactory {
     3     public abstract Coffee createFactory();
     4 }
     5 
     6 
     7 public class CoffeeFactory01 extends CoffeeFactory{
     8     @Override
     9     public Coffee createFactory() {
    10         // TODO Auto-generated method stub
    11         return new Coffee01();
    12     }
    13 }
    14 
    15 
    16 public class CoffeeFactory02 extends CoffeeFactory{
    17     @Override
    18     public Coffee createFactory() {
    19         // TODO Auto-generated method stub
    20         return new Coffee02();
    21     }
    22 }
    23 
    24 public class CoffeeFactory03 extends CoffeeFactory{
    25     @Override
    26     public Coffee createFactory() {
    27         // TODO Auto-generated method stub
    28         return new Coffee03();
    29     }
    30 }
    31 
    32 
    33 public class CoffeeFactory04 extends CoffeeFactory{
    34     @Override
    35     public Coffee createFactory() {
    36         // TODO Auto-generated method stub
    37         return new Coffee04();
    38     }
    39 }

    三、抽象工厂模式

    抽象工厂是工厂方法的模式的升级版。现在是这么个情况,上边的例子不是都是生产咖啡的吗?现在呢,我想在引进茶,那你该怎么办?是修改上诉代码,还是再添加一个和上边工厂方法模式结构一样的一些类呢?不管是用哪种方法都是不利于维护以及后续拓展,于是就有了抽象工厂模式诞生,他用一个超级工厂做所有工厂的父类,那么我们后期如果有新的需求,我们可以直接添加就可以,而不用去修改以前的代码了。

     1 public abstract class CFactory {
     2     public abstract Coffee createCoffee();
     3     public abstract Tea createTea();
     4 }
     5 
     6 
     7 public abstract class CoffeeFactory extends CFactory {
     8     public abstract Coffee createCoffee();
     9 }
    10 public class Coffee01Factory extends CoffeeFactory {
    11 
    12     @Override
    13     public Coffee createCoffee() {
    14         // TODO Auto-generated method stub
    15         return new Coffee01();
    16     }
    17     @Override
    18     public Tea createTea() {
    19         // TODO Auto-generated method stub
    20         return null;
    21     }
    22 }
    23 public class Coffee02Factory extends CoffeeFactory {
    24     @Override
    25     public Coffee createCoffee() {
    26         // TODO Auto-generated method stub
    27         return new Coffee02();
    28     }
    29 
    30     @Override
    31     public Tea createTea() {
    32         // TODO Auto-generated method stub
    33         return null;
    34     }
    35 }
    36 
    37 
    38 
    39 public abstract class TeaFactory extends CFactory {
    40     public abstract Tea createTea();
    41 }
    42 public class RedTeaFactory extends TeaFactory {
    43     @Override
    44     public Tea createTea() {
    45         // TODO Auto-generated method stub
    46         return new GreenTea();
    47     }
    48     @Override
    49     public Coffee createCoffee() {
    50         // TODO Auto-generated method stub
    51         return null;
    52     }
    53 }
    54 public class GreenTeaFactory extends TeaFactory {
    55     @Override
    56     public Tea createTea() {
    57         // TODO Auto-generated method stub
    58         return new RedTea();
    59     }
    60     @Override
    61     public Coffee createCoffee() {
    62         // TODO Auto-generated method stub
    63         return null;
    64     }
    65 }

    结构还是比较简单的,容易上手。说实在的23中设计模式我熟练的也就3种。还有20种不会的,以后有时间一定要学习一下

  • 相关阅读:
    Android系统四层架构分享
    tracebace用法
    Hadoop生态系统入门进阶之一
    Eclipse无法显示Android设计界面解决方案
    va_start和va_end使用详解
    Android实现左右滑动效果
    Android实现网络多线程断点续传下载
    基于TCP Socket的简单网络通信
    Android通过手势实现图像拖拽功能
    SHELLEXECUTEINFO 结构详解
  • 原文地址:https://www.cnblogs.com/Tiandaochouqin1/p/10972453.html
Copyright © 2020-2023  润新知