Java设计模式(二)之工厂模式(Factory)

目录

简单工厂

静态工厂

抽象工厂


简单工厂

先创建两个类Car和Bike,看成是工厂要生成的两类产品,代码如下:

/**
 * Created by leboop on 2020/5/23.
 */
public interface Movable {
    void go();
}
/**
 * Created by leboop on 2020/5/23.
 */
public class Car implements Movable{
    @Override
    public void go() {
        System.out.println("Car going!");
    }
}
/**
 * Created by leboop on 2020/5/23.
 */
public class Bike implements Movable {
    @Override
    public void go() {
        System.out.println("Bike going!");
    }
}

 通常做法是在客户端直接通过new方式创建各类产品对象,但是很多时候需要在创建对象前后做一些其他操作,比如权限管理等,这些代码如果暴露在客户端是不合适的,所以可以将这些代码整合到单独的一个简单工厂类中实现:

/**
 * Created by leboop on 2020/5/23.
 */
public class SimpleFactory {
    public  Car createCar() {
        /*
         * 创建对象前的一些预处理
         */
        Car car = new Car();
        /*
         * 创建对象后的一些预处理
         */

        return car;
    }

    public Bike createBike() {
        /*
         * 创建对象前的一些预处理
         */
        Bike bike = new Bike();
        /*
         * 创建对象后的一些预处理
         */
        return bike;
    }
}

简单工厂类中可以做很多复杂操作。客户端就可以如下简单调用了:

/**
 * Created by leboop on 2020/5/23.
 */
public class Main {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Movable car = factory.createCar();
        car.go();
        Movable bike = factory.createBike();
        bike.go();
    }
}

这样对使用的客户来说非常友好。

 

静态工厂

        所谓静态工厂,指的是工厂类中创建实例的方法是静态的,这样的话就可以直接通过工厂类调用创建实例了,而不需要先实例化工厂类了,代码如下:

/**
 * Created by leboop on 2020/5/23.
 */
public class StaticFactory {
    public static Car createCar() {
        /*
         * 创建对象前的一些预处理
         */
        Car car = new Car();
        /*
         * 创建对象后的一些预处理
         */

        return car;
    }

    public static Bike createBike() {
        /*
         * 创建对象前的一些预处理
         */
        Bike bike = new Bike();
        /*
         * 创建对象后的一些预处理
         */
        return bike;
    }
}

客户端代码如下:

/**
 * Created by leboop on 2020/5/23.
 */
public class StaticFactoryMain {
    public static void main(String[] args) {
        Movable car=StaticFactory.createCar();
        car.go();
        Movable bike=StaticFactory.createBike();
        bike.go();
    }
}

现在就不用如下创建工厂类了:

StaticFactoryfactory = new StaticFactory();

简单工厂存在的一个弊端是每次新增一个产品,比如现在要新增火车,就需要修改原来的工厂类StaticFactory,能不能不修改原来的工厂类呢?可以的。可以通过抽象工厂实现,为每类产品创建一个单独工厂,该工厂仅生产对应类别产品。

 

抽象工厂

        先创建一个抽象工厂(也可以使用接口),含有一个可以创建所有产品的抽象方法,代码如下:

/**
 * Created by leboop on 2020/5/23.
 */
public abstract class AbstractFactory {
    abstract Movable create();
}

 为每个产品创建一个具体的抽象类,只生产对应的产品,比如CarFactory只生产Car,代码如下:

/**
 * Created by leboop on 2020/5/23.
 */
public class CarFactory extends  AbstractFactory{
    @Override
    Movable create() {
        /*
         * 创建对象前的一些预处理
         */
        Car car = new Car();
        /*
         * 创建对象后的一些预处理
         */

        return car;
    }
}
/**
 * Created by leboop on 2020/5/23.
 */
public class BikeFactory extends AbstractFactory{
    @Override
    Movable create() {
        /*
         * 创建对象前的一些预处理
         */
        Bike bike = new Bike();
        /*
         * 创建对象后的一些预处理
         */

        return bike;
    }
}

 客户端代码如下:

/**
 * Created by leboop on 2020/5/23.
 */
public class AbstractFactoryMain {
    public static void main(String[] args) {
        CarFactory carFactory=new CarFactory();
        Movable car=carFactory.create();
        car.go();

        BikeFactory bikeFactory=new BikeFactory();
        Movable bike=bikeFactory.create();
        bike.go();
    }
}

现在如有新增产品火车的时候,就不需要修改原来的工厂类代码。具体如下:

创建产品Train的类

/**
 * Created by leboop on 2020/5/23.
 */
public class Train implements Movable {
    @Override
    public void go() {
        System.out.println("train going!");
    }
}

创建该产品的工厂类

/**
 * Created by leboop on 2020/5/23.
 */
public class TrainFactory extends AbstractFactory {
    @Override
    Movable create() {

        /*
         * 创建对象前的一些预处理
         */
        Train train = new Train();
        /*
         * 创建对象后的一些预处理
         */
        return train;
    }
}

在客户端代码中添加创建train的代码,如下:

/**
 * Created by leboop on 2020/5/23.
 */
public class AbstractFactoryMain {
    public static void main(String[] args) {
        CarFactory carFactory=new CarFactory();
        Movable car=carFactory.create();
        car.go();

        BikeFactory bikeFactory=new BikeFactory();
        Movable bike=bikeFactory.create();
        bike.go();
        
        TrainFactory trainFactory=new TrainFactory();
        Movable train=trainFactory.create();
        train.go();
    }
}

从上面我们能看到,使用了抽象工厂模式之后,新增产品时只需要修改客户端少量代码,新增两个类即可,总体来看,新增的代码有所增加,但是不要修改原先的工厂类代码,隔离性非常好。

 

展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客
应支付0元
点击重新获取
扫码支付

支付成功即可阅读