简单工厂模式

一个抽象接口，多个抽象接口实现类，一个工厂类，用来实例化抽象接口

  1. public interface Car {
  2.     public void run();
  4.     public void stop();
  5. }
  7. // 具体实现类
  8. public class Benz implements Cars {
  9.     public void run() {
  10.         System.out.println("Benz开始启动了。。。。。");
  11.     }
  13.     public void stop() {
  14.        System.out.println("Benz停车了。。。。。");
  15.    }
  16. }
  18. public class Ford implements Cars {
  19.    public void run() {
  20.        System.out.println("Ford开始启动了。。。");
  21.    }
  23.    public void stop() {
  24.        System.out.println("Ford停车了。。。。");
  25.    }
  26. }
  28. // 工厂类
  29. public class Factory {
  30.     public static Car getCarInstance(String type) {
  31.         Car car = null;
  32.         if("Benz".equals(type)) {
  33.             car = new Benz();
  34.         }
  35.         if("Ford".equals(type)) {
  36.             car = new Ford();
  37.         }
  38.         return car;
  39.     }
  40. }
  42. public class Test {
  43.     public static void main(String[] args) {
  44.         Car car = Factory.getCarInstance("Benz");
  45.         if(car != null) {
  46.             car.run();
  47.             car.stop();
  48.         } else {
  49.             System.out.println("造不了这种汽车。。。");
  50.         }
  51.     }
  52. }

工厂方法模式

有四个角色，抽象工厂模式，具体工厂模式，抽象产品模式，具体产品模式。不再是由一个工厂类去实例化具体的产品，而是由抽象工厂的子类去实例化产品。
一个工厂只生产单一的产品。

  1. // 抽象产品角色
  2. public interface Moveable {
  3.     void run();
  4. }
  6. // 具体产品角色
  7. public class Plane implements Moveable {
  8.     @Override
  9.     public void run() {
  10.         System.out.println("plane....");
  11.     }
  12. }
  14. public class Broom implements Moveable {
  15.        @Override
  16.        public void run() {
  17.            System.out.println("broom.....");
  18.        }
  19. }
  21. // 抽象工厂
  22. public abstract class VehicleFactory {
  23.     abstract Moveable create();
  24. }
  26. // 具体工厂
  27. public class PlaneFactory extends VehicleFactory {
  28.     public Moveable create() {
  29.         return new Plane();
  30.     }
  31. }
  33. public class BroomFactory extends VehicleFactory {
  34.     public Moveable create() {
  35.         return new Broom();
  36.     }
  37. }
  39. public class Test {
  40.     public static void main(String[] args) {
  41.         VehicleFactory factory = new BroomFactory();
  42.         Moveable m = factory.create();
  43.         m.run();
  44.     }
  45. }

抽象工厂模式

与工厂方法模式不同，抽象工厂模式中的工厂生产多个产品。

  1. //抽象工厂类
  2. public abstract class AbstractFactory {
  3.    public abstract Vehicle createVehicle();
  4.    public abstract Weapon createWeapon();
  5.    public abstract Food createFood();
  6. }
  7. //具体工厂类，其中Food,Vehicle，Weapon是抽象类，
  8. public class DefaultFactory extends AbstractFactory{
  9.    @Override
  10.    public Food createFood() {
  11.        return new Apple();
  12.    }
  13.    @Override
  14.    public Vehicle createVehicle() {
  15.        return new Car();
  16.    }
  17.    @Override
  18.    public Weapon createWeapon() {
  19.        return new AK47();
  20.    }
  21. }
  22. //测试类
  23. public class Test {
  24.    public static void main(String[] args) {
  25.        AbstractFactory f = new DefaultFactory();
  26.        Vehicle v = f.createVehicle();
  27.        v.run();
  28.        Weapon w = f.createWeapon();
  29.        w.shoot();
  30.        Food a = f.createFood();
  31.        a.printName();
  32.    }

三种工厂模式的特点

  • 简单工厂模式：每次扩展时，需要新增一个类，并修改工厂内部代码，添加新的if分支。
  • 工厂方法模式：与简单工厂的区别就在于有多个工厂，每个工厂只专注生产一种产品，当需要修改获取的产品时，著需要修改所访问的工厂就行。
  • 抽象工厂模式：每次扩展时，只需要添加一个类，并添加一个对应工厂。扩展灵活，不需要修改旧的类，但是需要编写新的工厂类。