设计模式--工厂模式

冲击年薪50W，助你进阶Python工程师>>>

工厂模式是java设计模式中最常见的一种设计模式。这种类型的模式属于创建性设计模式。它提供了一种创建对象的最佳方式。

1、简单工厂

public interface Car {
    void run();
}

class BMW implements Car {
    @Override
    public void run() {
        System.out.println("宝马来了,快让开....");
    }
}

class Audi implements Car {
    @Override
    public void run() {
        System.out.println("奥迪来了,快闪开....");
    }
}

class Benz implements Car {
    @Override
    public void run() {
        System.out.println("奔驰来了,快滚开....");
    }
}

class CarFactory {
    private static final String BMW = "BMW";
    private static final String AUDI = "Audi";
    private static final String BENZ = "Benz";

    public static Car getCar(String carName) {
        switch (carName) {
            case BMW:
                return new BMW();
            case AUDI:
                return new Audi();
            case BENZ:
                return new Benz();
            default:
                return null;
        }
    }

    public static void main(String[] args) {
        CarFactory.getCar(CarFactory.BMW).run();
        CarFactory.getCar(CarFactory.AUDI).run();
        CarFactory.getCar(CarFactory.BENZ).run();
    }
}

getCar()方法是静态的，也可以称作是静态工厂。这样的扩展性比较差，如果我要新增一个车的话还要去修改工厂类，而且如果参数错误的话无法实现效果，

还有一种工厂方法：

class StaticCarFactory{
    public static <T extends Car>T getCar(Class<T> tClass){
        T tcar = null;
        try {
            tcar = (T) Class.forName(tClass.getName()).newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
        return tcar;
    }

    public static void main(String[] args) {
        StaticCarFactory.getCar(Benz.class).run();
        StaticCarFactory.getCar(Audi.class).run();
        StaticCarFactory.getCar(BMW.class).run();
    }
}

这种方式在新增加就不需要在新增加一个车时在改动工厂类的方法。

Class.forName(tClass.getName()).newInstance()调用的是无参构造函数生成对象，它和new Object()是一样的性质，而工厂方法应该用于复杂对象的初始化 ，当需要调用有参的构造函数时便无能为力了，这样像为了工厂而工厂

再次改造：

class MyCarFactory{
    public static Car getBMW(){
        return new BMW();
    }
    public static Car getAudi(){
        return new Audi();
    }
    public static Car getBenz(){
        return new Benz();
    }

    public static void main(String[] args) {
        MyCarFactory.getAudi().run();
        MyCarFactory.getBenz().run();
        MyCarFactory.getBMW().run();
    }
}

class Toyota implements Car {
    private String from;

    public Toyota(String from) {
        this.from = from;
    }
    @Override
    public void run() {
        System.out.println("我是大丰田...." + from);
    }
}

结果显示：

还有一种抽象工厂方法：

interface Food {
    void eat();
}

class Rice implements Food {
    @Override
    public void eat() {
        System.out.println("米饭一碗2块钱");
    }
}

class Noodles implements Food {
    @Override
    public void eat() {
        System.out.println("面条一碗10块钱");
    }
}

interface Drink {
    void drink();
}

class Water implements Drink {

    @Override
    public void drink() {
        System.out.println("开水免费");
    }
}

class Cole implements Drink {
    @Override
    public void drink() {
        System.out.println("可乐3块钱");
    }
}
//抽象工厂
interface Shop {
    Food saleFood();

    Drink saleDrink();
}
//实现类
class Shaxian implements Shop {
    @Override
    public Food saleFood() {
        return new Rice();
    }

    @Override
    public Drink saleDrink() {
        return new Water();
    }
}
//实现类
class LianHua implements Shop {

    @Override
    public Food saleFood() {
        return new Noodles();
    }

    @Override
    public Drink saleDrink() {
        return new Cole();
    }
}

class Test {
    public static void main(String[] args) {
        Shop shop = new LianHua();
        shop.saleDrink().drink();
        shop.saleFood().eat();
        Shop shop1 = new Shaxian();
        shop1.saleDrink().drink();
        shop1.saleFood().eat();
    }
}