工厂模式

简单工厂模式

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

public interface Car {
    public void run();
    public void stop();
}
// 具体实现类
public class Benz implements Cars {
    public void run() {
        System.out.println("Benz开始启动了。。。。。");
    }
    public void stop() {
       System.out.println("Benz停车了。。。。。");
   }
}
public class Ford implements Cars {
   public void run() {
       System.out.println("Ford开始启动了。。。");
   }
   public void stop() {
       System.out.println("Ford停车了。。。。");
   }
}
// 工厂类
public class Factory {
    public static Car getCarInstance(String type) {
        Car car = null;
        if("Benz".equals(type)) {
            car = new Benz();
        }
        if("Ford".equals(type)) {
            car = new Ford();
        }
        return car;
    }
}
public class Test {
    public static void main(String[] args) {
        Car car = Factory.getCarInstance("Benz");
        if(car != null) {
            car.run();
            car.stop();
        } else {
            System.out.println("造不了这种汽车。。。");
        }
    }
}

工厂方法模式

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

// 抽象产品角色
public interface Moveable {
    void run();
}
// 具体产品角色
public class Plane implements Moveable {
    @Override
    public void run() {
        System.out.println("plane....");
    }
}
public class Broom implements Moveable {
       @Override
       public void run() {
           System.out.println("broom.....");
       }
}
// 抽象工厂
public abstract class VehicleFactory {
    abstract Moveable create();
}
// 具体工厂
public class PlaneFactory extends VehicleFactory {
    public Moveable create() {
        return new Plane();
    }
}
public class BroomFactory extends VehicleFactory {
    public Moveable create() {
        return new Broom();
    }
}
public class Test {
    public static void main(String[] args) {
        VehicleFactory factory = new BroomFactory();
        Moveable m = factory.create();
        m.run();
    }
}

抽象工厂模式

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

//抽象工厂类
public abstract class AbstractFactory {
   public abstract Vehicle createVehicle();
   public abstract Weapon createWeapon();
   public abstract Food createFood();
}
//具体工厂类，其中Food,Vehicle，Weapon是抽象类，
public class DefaultFactory extends AbstractFactory{
   @Override
   public Food createFood() {
       return new Apple();
   }
   @Override
   public Vehicle createVehicle() {
       return new Car();
   }
   @Override
   public Weapon createWeapon() {
       return new AK47();
   }
}
//测试类
public class Test {
   public static void main(String[] args) {
       AbstractFactory f = new DefaultFactory();
       Vehicle v = f.createVehicle();
       v.run();
       Weapon w = f.createWeapon();
       w.shoot();
       Food a = f.createFood();
       a.printName();
   }

三种工厂模式的特点

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