工厂模式

目录

https://blog.csdn.net/dongganen/article/details/79688794

---

定义工厂方法模式

---

定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

案例分析

---

最近听说有个阿里程序员相亲穿特步被拒，苦逼单身码农小明同学这周也有个相亲，所以他得赶紧买双新鞋，而且要买Adidas或Nike(这样可能不会上来就被灭灯)。

代码实现

//工厂方法
public class Factory {

    public static void main(String[] args) {
        ShoeShop shoeShop = new ShoeShop();
        Shoes shoes = shoeShop.returnShoes("nike");
        System.out.println(shoes.name);
    }
}

//鞋店
class ShoeShop{

    public Shoes returnShoes(String type){
        Shoes shoes = null;
        if(type.equals("adidas")){
            shoes = new AdidasShoes();
        }else if(type.equals("nike")){
            shoes = new NikeShoes();
        }
        return shoes;
    }
}

//鞋子
abstract class Shoes{
    String name;
}


class NikeShoes extends Shoes{
    public NikeShoes(){
        name = "Nike";
    }
}

class AdidasShoes extends Shoes{
    public AdidasShoes(){
        name = "Adidas";
    }
}

分析

鞋店可能一开始只卖NIke和Adidas，后来生意越来越好开始卖Pumn，Lining等运动鞋，后来发现某些鞋子卖的不好就不卖了，这样returnShoes里面的逻辑经常变，所以我们打算打他抽取出来，用简单工厂实现。

代码实现

//工厂方法
public class Factory {

    public static void main(String[] args) {
        ShoeShop shoeShop = new ShoeShop();
        Shoes shoes = shoeShop.returnShoes("nike");
        System.out.println(shoes.name);
    }
}

class SimpleShoeShop{

    public static Shoes orderShoes(String type){
        Shoes shoes = null;
        if(type.equals("adidas")){
            shoes = new AdidasShoes();
        }else if(type.equals("nike")){
            shoes = new NikeShoes();
        }
        return shoes;
    }
}

//鞋店
class ShoeShop{

    public Shoes returnShoes(String type){
        Shoes shoes;
        shoes = SimpleShoeShop.orderShoes(type);
        shoes.tryOn();
        return shoes;
    }
}

//鞋子
abstract class Shoes{
    String name;
    //试穿
    void tryOn(){
        System.out.println("试穿");
    }
}


class NikeShoes extends Shoes{
    public NikeShoes(){
        name = "Nike";
    }
}

class AdidasShoes extends Shoes{
    public AdidasShoes(){
        name = "Adidas";
    }
}

分析

细心的同学发现这里只不过把相同的逻辑移到了简单工厂，这有什么好处呢？如果这家店还开了网店，订单来了可以直接问简单工厂获取鞋子。

定义简单工厂

简单工厂不是一个设计模式，反而比较像一种编程习惯。

分析

现在鞋店开大了，鞋店不混卖了，分成了专门卖Nike的NikeShoesShop和专门卖Adidas的AdidasShoesShop，到了店之后小明发现adidas和nike下面有好多的系类，adidas下面有yeezy boost和NMD humn等，Nike下面有Nike Air Foamposite和Air Jordan等
1. 我们分别为Nike和Adidas写两个简单工厂NikeSimpleFactory和AdidasSimpleFactory。
2. 希望建立一个框架，把分店和鞋子捆绑在一起同时具备一定的弹性，Nike分店专门卖Nike鞋，AD分店专门卖AD鞋，之后可能还有Pumn分店。

UML

分析

细心的同学可能已经发现上面的图我少画了一根线，对就是Creater里有Product的引用， 抽象类Creator定义抽象工厂方法，子类继承必须实现工厂方法创建系列具体实例，而且实例必须是Product的实现。

代码

//工厂方法
public class Factory {

    public static void main(String[] args) {
        ShoeShop shoeShop = new NikeShoesShop();
        shoeShop.returnShoes("NikeAirFoamposite");
        shoeShop = new AdidasShoesShop();
        shoeShop.returnShoes("YeezyBoost");
    }
}

//鞋店
abstract class ShoeShop{

    public Shoes returnShoes(String type){
        Shoes shoes;
        shoes = createShoes(type);
        shoes.tryOn();
        return shoes;
    }

    abstract Shoes createShoes(String type);
}

//Nike鞋店
class NikeShoesShop extends ShoeShop{

    @Override
    Shoes createShoes(String type) {
        Shoes shoes = null;
        if(type.equals("NikeAirFoamposite")){
            shoes = new NikeAirFoamposite();
        }else if(type.equals("AirJordan")){
            shoes = new AirJordan();
        }
        return shoes;
    }
}

//Adidas鞋店
class AdidasShoesShop extends ShoeShop{

    @Override
    Shoes createShoes(String type) {
        Shoes shoes = null;
        if(type.equals("YeezyBoost")){
            shoes = new YeezyBoost();
        }else if(type.equals("NMDHumn")){
            shoes = new NMDHumn();
        }
        return shoes;
    }
}

//鞋子
abstract class Shoes{
    String name;
    //试穿
    void tryOn(){
        System.out.println("试穿");
    }
}


class YeezyBoost extends Shoes{
    public YeezyBoost(){
        name = "YeezyBoost";
    }

    @Override
    void tryOn() {
        System.out.println("踩屎感 买买买");
    }
}

class NMDHumn extends Shoes{
    public NMDHumn(){
        name = "NMDHumn";
    }
}

class NikeAirFoamposite extends Shoes{
    public NikeAirFoamposite(){
        name = "NikeAirFoamposite";
    }

    @Override
    void tryOn() {
        System.out.println("内靴,不是很舒服！！！");
    }
}

class AirJordan extends Shoes{
    public AirJordan(){
        name = "AirJordan";
    }

    @Override
    void tryOn() {
        System.out.println("这鞋颜值真高");
    }
}

最后祝天下码农都找到心上人

---

工厂模式和简单工厂比较

---

NikeShoesShop看起来很像简单工厂。简单工厂把全部的事情，在一个地方都处理完了，然而工厂方法却是在创建一个框架，让子类来决定如何实现。当有的新的品牌鞋店时，只要继承抽象鞋店，然后创建具体的鞋子就可以。简单工厂的做法，可以将创建对象封装起来，但是简单工厂不具备工厂方法的弹性，因为简单工厂不能变更正在创建的产品。

参考《Head First设计模式》

---