简单工厂，工厂模式，抽象工厂

学习了一下关于工厂的设计模式，写个例子整理一下，例子是生产不同厂商的鼠标，可能不太合适，记录一下想法。

1.简单工厂

这个模式在factory里面动态选择使用哪个类

public class Factory {
  public static Made getMade(String o) {
    Made made = null;
    switch (o) {
      case "logutech":
        made = new LogitechMade();
        break;
      case "lenovo":
        made = new LenovoMade();
        break;
      default:
        made = new LogitechMade();
    }
    return made;
  }
}

Made类是一个抽象类，规定了制作的方法。

public abstract class Made {
  public abstract void made();
}

在工厂中通过客户端传入的需求，实例化不同的made对象。两个厂商的made类继承自Made类。另一个相同，重写抽象类的生产方法

public class LogitechMade extends Made {
  @Override
  public void made() {
    System.out.println("logutech made mouse");
  }
}

接下来是main客户端

public class Main {

  public static void main(String[] args) {
    Made made = Factory.getMade("lenovo");
    made.made();
  }
}

首先声明一个Made的实例对象，从factory里面获得，根据用户数需求实例化不同的厂商made对象，然后实例对象执行made制造方法，就制造了相应厂商的鼠标。
这就是简单工厂模式。
项目结构截图

2.工厂模式

通过观察，简单工厂扩展性很差，每次增加厂商都要修改工厂类factory。工厂模式来解决，工厂模式只是增强了可扩展性，为每个生产类增加了一个工厂，类的数量增多，工厂类factory负担减少。

---

首先是工厂类，这里做成抽象类，减轻负担，只规定了一个获得生产方法的方法。

public abstract class AbstractFactory {
  public abstract Made getMade();
}

然后每个厂商都有一个工厂类，继承自这个抽象的工厂类。重写获取制造方法的方法，这里由于就是罗技的工厂，所以在获取制造方法的方法里直接返回与简单工厂相同的类LogitechMade。这个类也是继承自Made类，这里与简单工厂相同。

public class LogutechFactory extends AbstractFactory {
  @Override
  public Made getMade() {
    return new LogitechMade();
  }
}

剩下的类基本与简单工厂一样，接下来是mian。声明一个AbstractFactory的引用，申请为LogitechFactory，这样factory就是LogitechFactory的factory。然后从这个factory里面获得made制造方法，然后调用made.made方法。就是调用的LogitechMade的制造方法，制造出的就是Logitech的鼠标。

public class Main {

  public static void main(String[] args) {
    AbstractFactory factory = new LogitechFactory();
    Made made = factory.getMade();
    made.made();
  }
}

工厂模式就是为每个执行方法的类做一个工厂，这样达到了便于扩展的目的。
项目的截图：

---

3.抽象工厂

然后是每个厂商不只是生产鼠标，还要生产键盘，涉及到产品族的问题，就要用到抽象工厂。
这里想放上项目的结构的截图：

---

Mouse类：类似于之前的Made类，为抽象类，有一个制作鼠标的方法，Keyboard与这个相同。

public abstract class Mouse {
  public abstract void MouseMade();
}

LogitechMouseMade为具体的生产类，继承Mouse类，重写mousemade方法，made包下的制造类分贝继承device包下的类。

public class LogitechMouseMade extends Mouse {
  @Override
  public void MouseMade() {
    System.out.println("LogitechMouse");
  }
}

这里的工厂增加了获取制造键盘的的方法的抽象方法。

public abstract class AbstractFactory {
  public abstract Mouse madeMouse();
  public abstract Keyboard madeKeyboard();
}

具体厂商的工厂继承抽象工厂，重写方法：在方法中调用相应的类。

public class LogitechFactory extends AbstractFactory {
  @Override
  public Mouse madeMouse() {
    return new LogitechMouseMade();
  }

  @Override
  public Keyboard madeKeyboard() {
    return new LogitechKeyboardMade();
  }
}

main：还是获得一个罗技的工厂，调用罗技工厂的做鼠标方法和做键盘方法，就制作出来了。

public class Main {

  public static void main(String[] args) {
    AbstractFactory factory = new LogitechFactory();
    Mouse mouse = factory.madeMouse();
    Keyboard keyboard = factory.madeKeyboard();
    mouse.MouseMade();
    keyboard.KeyboardMade();
  }
}

---

3种模式各有利弊，在不同的情况用不同的方式，使代码易维护，可扩展。