Java之工厂设计模式

工厂设计模式

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

简单工厂模式-Spring-beanfactory

• 简单工厂模式：专门定义一个类用来创建其他类的实例，被创建的实例通常拥有共同的父类。
• 组成：

1. 一个抽象产品类
2. 具体产品类
3. 一个工厂

• 代码：

import java.util.Scanner;
interface Computer{
   void printComputer();
}

class MacbookComputer implements Computer{
@Override
public void printComputer() {
    System.out.println("This is a mac");
    }
}

class SurfacebookComputer implements >Computer{
   @Override
  public void printComputer() {
       System.out.println("This is a surface");
   }
}

class ComputerFactory{
   public static Computer getInstance(String type){
       Computer computer = null;
       if (type.equals("macbook")){
           computer = new MacbookComputer();
       } else if (type.equals("surface")){
          computer = new SurfacebookComputer();
       }
       return computer;
   }
}

public class Client {
    public static void main(String[] args) {
       Client client = new Client();
       Scanner scanner = new Scanner(System.in);
       System.out.println("请输入电脑型号");
       String type = scanner.nextLine();
       Computer computer = ComputerFactory.getInstance(type);
       client.buyComputer(computer);
   }
   public void buyComputer(Computer computer){
       computer.printComputer();
   }
}

• 优点：

1. 简单易于实现
2. 把类的实例化交给工厂，易于解耦

• 缺点：

1. 添加具体产品需要修改工厂违反OCP开放封闭原则

工厂方法模式-产品族

• 工厂方法模式：定义一个用来创建对象的接口，让子类决定实例化哪个工厂
• 组成：

1. 一个抽象产品类
2. 多个具体产品类
3. 一个抽象工厂
4. 多个具体工厂(每个产品对应一个具体工厂)

• 代码：

interface Computer{
   void printComputer();
}

class MacbookComputer implements Computer{
   @Override
   public void printComputer() {
       System.out.println("This is a mac");
   }
}

class SurfacebookComputer implements Computer{
   @Override
   public void printComputer() {
       System.out.println("This is a surface");
   }
}

interface ComputerFactory{
   Computer createComputer();
}

class AppleFactory implements ComputerFactory{
   @Override
   public Computer createComputer() {
       return new MacbookComputer();
   }
}

class MsFactory implements ComputerFactory{
   @Override
   public Computer createComputer() {
       return new SurfacebookComputer();
   }
}

public class Client {
   public static void main(String[] args) {
       Client client = new Client();
       ComputerFactory factory = new AppleFactory();
       client.buyComputer(factory.createComputer());
   }
   public void buyComputer(Computer computer){
       computer.printComputer();
   }
}

• 优点：

1. 降低了代码的耦合度，对象的生成交给子类去完成
2. 实现了开放封闭原则，每次添加子产品，不需要修改原代码

• 缺点：

1. 增加了代码量，每一个具体产品都需要一个具体工厂
2. 当增加抽象产品也就是添加一个其他产品族，需要修改工厂，违背了OPC

抽象工厂模式

• 抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类
• 组成：

1. 多个抽象产品类
2. 具体产品类
3. 抽象工厂类-声明(一组)返回抽象产品的方法
4. 具体工厂类-生产(一组)具体产品

• 代码：

interface Computer{
   void printComputer();
}

class MacbookComputer implements Computer{
   @Override
   public void printComputer() {
       System.out.println("This is a mac");
   }
}

class SurfacebookComputer implements Computer{
   @Override
   public void printComputer() {
       System.out.println("This is a surface");
   }
}

interface OperatingSystem{
   void printSystem();
}

class MacOsSystem implements OperatingSystem{
   @Override
   public void printSystem() {
       System.out.println("This is a mac os");
   }
}

class WindowsSystem implements OperatingSystem{
   @Override
   public void printSystem() {
       System.out.println("This is a window 8");
   }
}

interface ProductionFactory{
   Computer createComputer();
   OperatingSystem createSystem();
}

class AppleFactory implements ProductionFactory{
   @Override
   public Computer createComputer() {
       return new MacbookComputer();
   }

   @Override
   public OperatingSystem createSystem() {
       return new MacOsSystem();
   }
}

class MsFactory implements ProductionFactory{
   @Override
   public Computer createComputer() {
       return new SurfacebookComputer();
   }

   @Override
   public OperatingSystem createSystem() {
       return new WindowsSystem();
   }
}

public class Client {
   public static void main(String[] args) {
       Client client = new Client();
       ProductionFactory factory = new AppleFactory();
       Computer computer = factory.createComputer();
       OperatingSystem system = factory.createSystem();
       client.buyComputer(computer);
       client.use(system);
   }
   public void buyComputer(Computer computer){
       computer.printComputer();
   }
   public void use(OperatingSystem s){
       s.printSystem();
   }
}

• 优点：

1. 代码解耦
2. 实现多个产品族(相关联产品组成的家族)，而工厂方法模式的单个产品，可以满足更多的生成需求
3. 很好的满足OPC开放封闭原则
4. 抽象工厂模式中我们可以实现不止一个接口，一个工厂也可以生成不止一个产品类，对于复杂对象的生产相当灵活易扩展

• 缺点：

1. 扩展产品族相当麻烦，而且扩展产品族会违反OPC，因为要修改所有的工厂
2. 由于抽象工厂模式是工厂方法模式的扩展，总体来说很笨重

• 总结：

• 简单工厂模式最大的优点就是工厂内有具体的逻辑去判断生成什么产品，将类的实例化交给了工厂，这样当我们需要什么产品只需要修改工厂的调用而不需要去修改客户端，对于客户端来说降低了与具体产品的依赖
• 工厂方法模式是简单工厂的扩展，工厂方法模式把原先简单工厂中的实现那个类的逻辑判断交给了客户端，如果像添加功能只需要修改客户和添加具体的功能，不用去修改之前的类。
• 抽象工厂模式进一步扩展了工厂方法模式，它把原先的工厂方法模式中只能有一个抽象产品不能添加产品族的缺点克服了，抽象工厂模式不仅仅遵循了OCP原则，而且可以添加更多产品(抽象产品),具体工厂也不仅仅可以生成单一产品，而是生成一组产品，抽象工厂也是声明一组产品，对应扩展更加灵活，但是要是扩展族系就会很笨重

反射与简单工厂模式

• 对比：传统简单工厂模式，每次添加一个接口的子类都需要修改工厂类(即需要new新的子类对象)。而通过反射的方式可以使用newInstance()实例化对象，同时Class.forName()可以接收类名称。

• 代码

interface IFurit{
   void eat();
}

class Apple implements IFurit{
   @Override
   public void eat() {
       System.out.println("eat apple");
   }
}

class Orange implements IFurit{
   @Override
   public void eat() {
       System.out.println("eat orange");
   }
}

class FuritFactory{
  private FuritFactory(){

   }
   public static IFurit getInstance(String name){
       IFurit furit = null;
       try {
          furit = (IFurit) Class.forName(name).newInstance();
       } catch (InstantiationException e) {
           e.printStackTrace();
       } catch (IllegalAccessException e) {
           e.printStackTrace();
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       }
       return furit;
   }
}

public class testFactory {
   public static void main(String[] args) {
       IFurit furit = FuritFactory.getInstance("Orange");
       furit.eat();
   }
}