设计模式---简单工厂模式

转载：https://baijiahao.baidu.com/s?id=1759516373678860969&wfr=spider&for=pc

首先，我们定义一个抽象产品类 Product，它包含一个抽象方法 use()，表示产品的使用方法。

/**
 * 建档工厂模式
 * 首先，我们定义一个抽象产品类 Product，它包含一个抽象方法 use()，表示产品的使用方法。
 */
public abstract class Product {
    public abstract void use();
}

然后，我们定义两个具体产品类 ProductA 、ProductB和ProductC，它们都继承自抽象产品类 Product，并实现了 use() 方法。

/**
 * 产品A
 * 然后，我们定义两个具体产品类 ProductA，它们都继承自抽象产品类 Product，并实现了 use() 方法
 */
public class ProductA extends Product{
    @Override
    public void use() {
      System.out.println("正在使用A产品~");
    }
}

/**
 * 产品B
 * 然后，我们定义两个具体产品类 ProductB，它们都继承自抽象产品类 Product，并实现了 use() 方法
 */
public class ProductB extends Product{
    @Override
    public void use() {
        System.out.println("正在使用B产品~");
    }
}

/**
 * 产品c
 * 然后，我们定义两个具体产品类 ProductC，它们都继承自抽象产品类 Product，并实现了 use() 方法
 */
public class ProductC extends Product{
    @Override
    public void use() {
        System.out.println("正在使用c产品~");
    }
}

接下来，我们定义一个简单工厂类 ProductFactory，它包含一个静态方法 createProduct(String type)，根据传入的参数 type 来创建对应的产品实例。如果传入的参数不是 “A” 、 "B"或 “C”，则返回 null。

/**
 * 产品工厂
 * 接下来，我们定义一个简单工厂类 ProductFactory，它包含一个静态方法 createProduct(String type)，
 * 根据传入的参数 type 来创建对应的产品实例。如果传入的参数不是 "A" 或 "B"或 "C"
 */
public class ProductFactory {
   public static Product createProduct(String type){
       if("A".equals(type)){
           return new ProductA();
       }else if("B".equals(type)){
           return new ProductB();
       }else if("C".equals(type)){
           return new ProductC();
       }else{
           return null;
       }
   }
}

最后，我们可以在客户端代码中使用简单工厂来创建产品实例。

/**
 * 最后，我们可以在客户端代码中使用简单工厂来创建产品实例
 */
public class Client {
    public static void main(String[] args) {
        Product productA =ProductFactory.createProduct("A");
        productA.use();
        Product productB =ProductFactory.createProduct("B");
        productB.use();
        Product productC =ProductFactory.createProduct("C");
        productC.use();
    }
}

运行结果：

正在使用A产品~
正在使用B产品~
正在使用c产品~

应用示例（一）：

public abstract  class AutoDoor {
    /*闸机开门*/
    public abstract void openDoor();
    /*闸机关门*/
    public abstract void closeDoor();
    /*闸机锁门*/
    public abstract void lockDoor();
}

/**
 * 大华闸机
 */
public class Dahua extends AutoDoor{
    @Override
    public void openDoor() {
        System.out.println("大华闸机开门");
    }
    @Override
    public void closeDoor() {
        System.out.println("大华闸机关门");
    }
    @Override
    public void lockDoor() {
        System.out.println("大华闸机锁门");
    }
}

/**
 * 海康闸机
 */
public class Hikvision extends AutoDoor{
    @Override
    public void openDoor() {
        System.out.println("海康闸机开门");
    }
    @Override
    public void closeDoor() {
        System.out.println("海康闸机关门");
    }
    @Override
    public void lockDoor() {
        System.out.println("海康闸机锁门");
    }
}

/*云天励飞*/
public class intellif extends AutoDoor{
    @Override
    public void openDoor() {
        System.out.println("云天闸机开门");
    }
    @Override
    public void closeDoor() {
        System.out.println("云天闸机关门");
    }
    @Override
    public void lockDoor() {
        System.out.println("云天闸机锁门");
    }
}

public class DoorOperateFactory {
    public static AutoDoor operateDoor(String type){
        if("Dahua".equals(type)){
            return new Dahua();
        }else if("Hikvision".equals(type)){
            return new Hikvision();
        }else if("intellif".equals(type)){
            return new intellif();
        }else{
            return null;
        }
    }
}

public class Company {
    public static void main(String[] args) {
      AutoDoor dahua = DoorOperateFactory.operateDoor("Dahua");
      dahua.openDoor();
      dahua.closeDoor();
      dahua.lockDoor();

      AutoDoor hikvision = DoorOperateFactory.operateDoor("Hikvision");
      hikvision.openDoor();
      hikvision.closeDoor();
      hikvision.lockDoor();

      AutoDoor intellif = DoorOperateFactory.operateDoor("intellif");
      intellif.openDoor();
      intellif.closeDoor();
      intellif.lockDoor();
    }
}

运行结果：

大华闸机开门
大华闸机关门
大华闸机锁门
海康闸机开门
海康闸机关门
海康闸机锁门
云天闸机开门
云天闸机关门
云天闸机锁门

应用示例（二）：

package com.jm.depart;
public interface Phone {
    public void charge();
}

package com.jm.depart;
public class Hawei implements Phone{
    @Override
    public void charge() {
        System.out.println("华为手机正在充电~");
    }
}

package com.jm.depart;
public class Oppo implements Phone{
    @Override
    public void charge() {
        System.out.println("欧普手机正在充电~");
    }
}

package com.jm.depart;
public class ZhongXin implements Phone{
    @Override
    public void charge() {
        System.out.println("中兴手机正在充电~");
    }
}

package com.jm.depart;
public class PhoneFactory {
    public Phone phoneCharge(String phoneName){
      if("Huawei".equals(phoneName)){
            return new Hawei();
      } else if ("Oppo".equals(phoneName)) {
            return new Oppo();
      }else if ("ZhongXin".equals(phoneName)) {
            return new ZhongXin();
      }else{
          return null;
      }
    }

    public static void main(String[] args) {
        PhoneFactory phoneFactory = new PhoneFactory();

        Phone hw = phoneFactory.phoneCharge("Huawei");
        hw.charge();

        Phone oppo = phoneFactory.phoneCharge("Oppo");
        oppo.charge();

        Phone zhongXin = phoneFactory.phoneCharge("ZhongXin");
        zhongXin.charge();
    }
}

运行结果：

华为手机正在充电~
欧普手机正在充电~
中兴手机正在充电~

总结：此时当我们想要添加其他厂商的时候，我们也需要创建一个类，去继承接口，此时我们的工厂类需要修改匹配厂商类型方法代码了，违反了开闭原则（扩展开放、修改关闭），我们应该扩展，不应该修改。