轻松学会设计模式——工厂模式

引子

众所周知，在我们java中，万物都是对象，所有的对象都需要创建，如果创建的时候直接去new一个对象，就会对此对象耦合严重，当我们需要要更换对象的时候，所有new对象的地方都需要重新修改一遍，这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦。

一、工厂模式是什么

工厂模式是用来创建对象的一种最常用的设计模式，不暴露创建对象的具体逻辑，而是将将逻辑封装在一个函数中，那么这个函数就可以被视为一个工厂

其就像工厂一样重复的产生类似的产品，工厂模式只需要我们传入正确的参数，就能生产类似的产品

打个比方：

• 编程中，在一个 A 类中通过 new 的方式实例化了类 B，那么 A 类和 B 类之间就存在关联（耦合）
• 后期因为需要修改了 B 类的代码和使用方式，比如构造函数中传入参数，那么 A 类也要跟着修改，一个类的依赖可能影响不大，但若有多个类依赖了 B 类，那么这个工作量将会相当的大，容易出现修改错误，也会产生很多的重复代码，这无疑是件非常痛苦的事；
• 这种情况下，就需要将创建实例的工作从调用方（A类）中分离，与调用方解耦，也就是使用工厂方法创建实例的工作封装起来，减少代码重复，由工厂管理对象的创建逻辑，调用方不需要知道具体的创建过程，只管使用，而降低调用者因为创建逻辑导致的错误；

二、工厂模式的类型

工厂模式目前分三种类型

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

简单工厂模式

实现一个手机接口

public interface Phone {
    void build();
}

每个品牌的手机都要有一个继承了手机接口的实现类

public class HuaWeiPhone implements Phone {
    @Override
    public void build() {
        System.out.println("创建华为手机");
    }
}

public class Iphone implements Phone {
    @Override
    public void build() {
        System.out.println("创建苹果手机");
    }
}

public class MiPhone implements Phone {
    @Override
    public void build() {
        System.out.println("创建小米手机");
    }
}

用工厂判断用哪个厂家的接口造手机

public class PhoneFactory {

    public static Phone getphone(String phonename){
        if (phonename.equals("huawei")){
            return new HuaWeiPhone();
        }else if (phonename.equals("xiaomi")){
            return new MiPhone();
        }else {
            return new Iphone();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Phone xiaomi= PhoneFactory.getphone("xiaomi");
        Phone huawei= PhoneFactory.getphone("huawei");
        Phone iphone= PhoneFactory.getphone("iphone");
        huawei.build();
        xiaomi.build();
        iphone.build();
    }
}

结果

工厂方法模式

一个手机接口

public interface Phone {
    void build();
}

工厂接口，用来造出手机接口

public interface PhoneFactory {
    Phone getphone();
}

华为手机厂家的接口，继承手机接口

public class HuaWeiPhone implements Phone {
    @Override
    public void build() {
        System.out.println("创建华为手机");
    }
}

华为手机工厂接口，继承手机工厂接口，下面也是同理

public class HuaWeiPhoneFavtory implements PhoneFactory {
    @Override
    public Phone getphone() {
        return new HuaWeiPhone();
    }
}

public class Iphone implements Phone {
    @Override
    public void build() {
        System.out.println("创建苹果手机");
    }
}

public class IphonePhoneFavtory implements PhoneFactory {
    @Override
    public Phone getphone() {
        return new Iphone();
    }
}

public class MiPhone implements Phone {
    @Override
    public void build() {
        System.out.println("创建小米手机");
    }
}

public class MiPhoneFavtory implements PhoneFactory {
    @Override
    public Phone getphone() {
        return new MiPhone();
    }
}

public class Main {
    public static void main(String[] args) {
        PhoneFactory mifactory=new MiPhoneFavtory();
        Phone miphone=mifactory.getphone();
        miphone.build();

        PhoneFactory huaweifactory=new HuaWeiPhoneFavtory();
        Phone huaweiphone=huaweifactory.getphone();
        huaweiphone.build();


        PhoneFactory Ifactory=new IphonePhoneFavtory();
        Phone Iphone=Ifactory.getphone();
        Iphone.build();
    }
}

结果

抽象工厂模式

手机接口

public interface Phone {
    void start();
    void sms();
    void playPhoneGame();
}

电脑接口

public interface Pc {
    void start();
    void playPcGame();
}

平板接口

public interface Pad {
    void start();
    void playPadGame();
}

抽象工厂接口，用来创建电脑，手机平板

public interface AbstractFactory {
    Phone buildPhone();
    Pad buildPad();
    Pc buildPc();
}

华为工厂，用来创建手机，平板，电脑

public class HuaWeiFactory implements AbstractFactory {
    @Override
    public Phone buildPhone() {
        return new HuaWeiPhone();
    }

    @Override
    public Pad buildPad() {
        return new HuaWeiPad();
    }

    @Override
    public Pc buildPc() {
        return new HuaWeiPc();
    }
}

public class HuaWeiPad implements Pad {
    @Override
    public void start() {
        System.out.println("华为pad开机");
    }

    @Override
    public void playPadGame() {
        System.out.println("华为玩pad游戏");
    }


}

public class HuaWeiPc implements Pc {
    @Override
    public void start() {
        System.out.println("华为电脑开机");
    }

    @Override
    public void playPcGame() {
        System.out.println("华为电脑玩游戏");
    }
}

public class HuaWeiPhone implements Phone {
    @Override
    public void start() {
        System.out.println("华为手机开机");
    }

    @Override
    public void sms() {
        System.out.println("华为手机发信息");
    }

    @Override
    public void playPhoneGame() {
        System.out.println("华为手机玩游戏");
    }
}

public class IFactory implements AbstractFactory {
    @Override
    public Phone buildPhone() {
        return new Iphone();
    }

    @Override
    public Pad buildPad() {
        return new IPad();
    }

    @Override
    public Pc buildPc() {
        return new IMAC();
    }


}

public class IMAC implements Pc {
    @Override
    public void start() {
        System.out.println("苹果电脑开机");
    }

    @Override
    public void playPcGame() {
        System.out.println("苹果电脑玩游戏");
    }
}

public class IPad implements Pad {
    @Override
    public void start() {
        System.out.println("ipad开机");
    }

    @Override
    public void playPadGame() {
        System.out.println("ipad玩游戏");
    }
}

public class Iphone implements Phone {
    @Override
    public void start() {
        System.out.println("苹果手机开机");
    }

    @Override
    public void sms() {
        System.out.println("苹果手机发信息");
    }

    @Override
    public void playPhoneGame() {
        System.out.println("苹果手机玩游戏");
    }
}

public class MiFactory implements AbstractFactory {
    @Override
    public Phone buildPhone() {
        return new MiPhone();
    }

    @Override
    public Pad buildPad() {
        return new MiPad();
    }

    @Override
    public Pc buildPc() {
        return new MiPc();
    }
}

public class MiPad implements Pad {
    @Override
    public void start() {
        System.out.println("小米pad开机");
    }

    @Override
    public void playPadGame() {
        System.out.println("小米pad玩游戏");
    }
}

public class MiPc  implements Pc {
    @Override
    public void start() {
        System.out.println("小米电脑开机");
    }

    @Override
    public void playPcGame() {
        System.out.println("小米电脑玩游戏");
    }
}

public class MiPhone implements Phone {
    @Override
    public void start() {
        System.out.println("小米手机开机");
    }

    @Override
    public void sms() {
        System.out.println("小米手机发信息");
    }

    @Override
    public void playPhoneGame() {
        System.out.println("小米手机玩游戏");
    }
}

public class Main {
    public static void main(String[] args) {
        AbstractFactory huawei=new HuaWeiFactory();
        Pad huaweipad = huawei.buildPad();
        Pc huaweipc = huawei.buildPc();
        Phone huaweiphone = huawei.buildPhone();

        huaweipad.playPadGame();
        huaweipc.playPcGame();
        huaweiphone.sms();
    }
}

结果

总的来说，工厂模式是一个很好理解的设计模式，只要大家多加学习，自己实现一遍，就可以理解了