Java设计模式(工厂模式)

 

一.简单工厂模式

  简单工厂模式就是把对类的创建初始化全都交给一个工厂来执行,而用户不需要去关心创建的过程是什么样的,只用告诉工厂我想要什么就行了。而这种方法的缺点也很明显,违背了设计模式的开闭原则,因为如果你要增加工厂可以初始化的类的时候,你必须对工厂进行改建

代码如下:

package com.long88.ad.test;

interface  Car {
    public void getCar();
}
package com.long88.ad.test;

public class BMW implements Car{

    @Override
    public void getCar() {
        System.out.printf("来一辆BMW!");
    }
}
package com.long88.ad.test;

public class BYD implements Car {
    @Override
    public void getCar() {
        System.out.printf("来一辆BYD!");
    }
}
package com.long88.ad.test;

public class CarFactor {

    public static Car carFactor(Class<?> tClass){
        if (tClass.getName().equals(BMW.class.getName())){
            return new BMW();
        }
        if (tClass.getName().equals(BYD.class.getName())){
            return new BYD();
        }
        return null;
    }
}
package com.long88.ad.test;

public class testFactory {

    public static void main(String[] args) {
        Car car = CarFactor.carFactor(BYD.class);
        car.getCar();
    }
}

结果如图:

 

 二. 工厂方法模式

   设计一个工厂的接口,你想要什么东西,就写个类继承于这个工厂,这样就不用修改什么,直接添加就行了。就相当于,我这个工厂是用来生汽车的,而要什么品牌的汽车具体分到了每个车间,如果新多了一种品牌的汽车,直接新增一个车间就行了。那么问题又来了,如果想要生产大炮怎么办?

 代码如下:

package com.long88.ad.test;

interface  Car {
    public void getCar();
}
package com.long88.ad.test;

public class BMW implements Car{

    @Override
    public void getCar() {
        System.out.printf("来一辆BMW!");
    }
}
package com.long88.ad.test;

public class BYD implements Car {
    @Override
    public void getCar() {
        System.out.printf("来一辆BYD!");
    }
}
//抽象工厂
interface CarFactory{
    public Car getCarByFactory();
}
// BMW 具体工厂类
class BMWfactory implements CarFactory{
 
    @Override
    public Car getCarByFactory() {
        return new BMW();
    }
}
// BYD 具体工厂类
class BYD factory implements CarFactory{
 
    @Override
    public Car getCarByFactory() {
        return new BYD ();
    }
}
public class TestFactory {
    public static void main(String[] args) {
        Car bmw= new BMWfactory().getCarByFactory();
        bmw.getCar();
    }
}

 

三. 抽象工厂模式 

  定义:为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类。

  抽象工厂与工厂方法的区别,就在于产品簇的问题,多了一种产品,这时候怎么办呢,就是在接口类里面加上创建大炮的方法,然后每个车间就可以有两个子车间分别来生产汽车和大炮。这样的话缺点也很显然的冒了出来,如果我又想生产飞机,那么我要需要更改所有的工厂车间以及工厂接口。

  抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式则是针对的多个产品等级结构。在编程中,通常一个产品结构,表现为一个接口或者抽象类,也就是说,工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类,而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

 代码如下:

package com.long88.ad.test;

interface  Car {
    public void getCar();
}
package com.long88.ad.test;

public class BMW implements Car{

    @Override
    public void getCar() {
        System.out.printf("来一辆BMW!");
    }
}
package com.long88.ad.test;

public class BYD implements Car {
    @Override
    public void getCar() {
        System.out.printf("来一辆BYD!");
    }
}

 

package com.long88.ad.test;

interface  Plane{
    public void getPlane();
}
package com.long88.ad.test;

public class AirPlane implements Plane{

    @Override
    public void getPlane() {
        System.out.printf("来一架客机!");
    }
}
package com.long88.ad.test;

public class BattlePlane implements Plane{
    @Override
    public void getPlane() {
        System.out.printf("来一架战斗机!");
    }
}

 

//抽象工厂
interface Factory{
    public Car getCarByFactory();
public Plane getPlaneByFactory(); }

 

// 具体工厂类
class FactoryOne implements Factory{

    @Override
    public Car getCarByFactory() {
        return new BMW();
    }

    @Override
    public Plane getPlaneByFactory() {
        return new AirPlane();
    }
}
// 具体工厂类
class FactoryTwo implements Factory{

    @Override
    public Car getCarByFactory() {
        return new BYD();
    }

    @Override
    public Plane getPlaneByFactory() {
        return new BattlePlane ();
    }
}
public class TestFactory {
    public static void main(String[] args) {
        Car byd = new FactoryTwo().getCarByFactory();
        byd.getCar();
        Plane airPlane = new FactoryOne().getPlaneByFactory();
        airPlane.getPlane();
} 
}
/* 运行结果
来一辆BYD!
来一架客机!
*/

 

 

 使用场景

  当我们直接new一个对象比较麻烦时,比如构造方法传参数量太多;

  再比如创建一个类A要先创建类B,这种使用new比较麻烦时就可以交给工厂去做,还减少了代码的重复。

 

posted @ 2019-06-19 22:58  IT_longlong  阅读(10960)  评论(0编辑  收藏  举报