设计模式——工厂模式

概念：

假如直接使用new的方式来创建对象，会存在耦合性高的问题，可以新建对象的工厂类，通过工厂类来获取对象，可以降低耦合性。

工厂模式分为三种，分别是

• 简单工厂模式：允许接口创建对象，但不会暴露对象的创建逻辑。
• 工厂方法模式：允许接口创建对象，但使用哪个类来创建对象，则是交由子类决定的。
• 抽象工厂模式：抽象工厂是一个能够创建一系列相关的对象而无需指定/公开其具体类的接口。该模式能够提供其他工厂的对象，在其内部创建其他对象。

1、简单工厂模式

创建接口：

public interface Car {
    public void name();
}

创建接口的实现类：

public class Baoma implements Car{
    @Override
    public void name() {
        System.out.println("宝马！！！");
    }
}

public class Benci implements Car{
    @Override
    public void name() {
        System.out.println("奔驰！！！");
    }
}

创建工厂：

public class CarFactory {

    public static Car getCar(String name){
        Car car=null;
        if (name=="baoma"){
            car=new Baoma();
        }else if(name=="benci"){
            car=new Benci();
        }
        return car;
    }

}

这样就可以通过工厂类去创建对象了

public class client {
    public static void main(String[] args) {
        Car car=CarFactory.getCar("baoma");
        car.name();
        Car car1=CarFactory.getCar("benci");
        car1.name();
    }
}

2、工厂方法模式

上述简单工厂模式虽然降低了耦合，但是当需要新增车辆时，就需要修改工厂类，违反了设计模式中的开闭原则（对修改关闭，对拓展开放）。

创建接口：

public interface Car {
    public void name();
}

创建接口的实现类：

public class Baoma implements Car{
    @Override
    public void name() {
        System.out.println("宝马！！！");
    }
}

public class Benci implements Car{
    @Override
    public void name() {
        System.out.println("奔驰！！！");
    }
}

创建工厂接口：

public interface CarFactory {
    public Car getCar();
}

创建工厂接口实现类：

public class BaomaFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Baoma();
    }
}

public class BenciFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Benci();
    }
}

编写测试类：

public class client {
    public static void main(String[] args) {
        Car car=new BaomaFactory().getCar();
        car.name();
        Car car1=new BenciFactory().getCar();
        car1.name();
    }
}

 工厂方法模式符合开闭原则，当需要新增车辆时，不需要改动代码，只需要在其基础上新增车辆的实现类和工厂实现类。但每次都需要去新建实现类，就容易发生类爆炸。

3、抽象工厂模式

新建接口：

public interface iphone {
     public void call();
}

public interface router {
    public void openWifi();
}

创建接口实现类：

public class huaweiPhone implements iphone{
    @Override
    public void call() {
        System.out.println("华为手机打电话！！");
    }
}

public class xiaomiPhone implements iphone{
    @Override
    public void call() {
        System.out.println("小米手机打电话！！");
    }
}

public class huaweiRouter implements router{
    @Override
    public void openWifi() {
        System.out.println("华为路由器开wifi");
    }
}

public class xiaomiRouter implements router{
    @Override
    public void openWifi() {
        System.out.println("小米路由器开wifi");
    }
}

新建工厂接口：

public interface factory {
    public iphone createPhone();

    public router createRouter();
}

创建工厂实现类：

public class huaweiFactory implements factory{
    @Override
    public iphone createPhone() {
        return new huaweiPhone();
    }

    @Override
    public router createRouter() {
        return new huaweiRouter();
    }
}

public class xiaomiFactory implements factory{
    @Override
    public iphone createPhone() {
        return new xiaomiPhone();
    }

    @Override
    public router createRouter() {
        return new xiaomiRouter();
    }
}

新建测试类：

public class client {
    public static void main(String[] args) {
        iphone iphone = new xiaomiFactory().createPhone();
        iphone.call();

        iphone iphone1=new huaweiFactory().createPhone();
        iphone1.call();

        router router=new xiaomiFactory().createRouter();
        router.openWifi();

        router router1=new huaweiFactory().createRouter();
        router1.openWifi();


    }
}

 类图

抽象工厂模式也不符合设计模式中的开闭原则，当需要添加一个新产品时，比如说添加一个笔记本，则需要去修改工厂接口和产品接口。