设计模式之--工厂模式

春风霓裳

于 2021-09-30 17:03:31 发布

阅读量127

点赞数

分类专栏： 23种设计模式文章标签： java 工厂方法模式

本文链接：https://blog.csdn.net/qq_43470725/article/details/120569228

版权

23种设计模式专栏收录该内容

26 篇文章 0 订阅

订阅专栏

参考：https://blog.csdn.net/weixin_48052161/article/details/118092235
1、简单工厂模式
简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口；

组成：
1、物品的抽象
2、一个生产工厂的类
3、具体物品类
eg:
在这里插入图片描述

如图：物品抽象和工厂类以依赖连接；
代码实例：

物品抽象：车

public interface Car {

    void drive();

}

车具体类：宝马

package com.example.dtest.design23.factory.simpleFactory;

public class Bmw implements Car{
    @Override
    public void drive() {
        System.out.println("Driving Bmw");
    }
}

车具体类：奔驰

package com.example.dtest.design23.factory.simpleFactory;

public class Benz implements Car{
    @Override
    public void drive() {
        System.out.println("Driving Benz");
    }
}

工厂类：

package com.example.dtest.design23.factory.simpleFactory;

public class SimpleFactory {

    public static Car driverCar(String s)throws Exception{
//equals() 会判断大小写区别，equalsIgnoreCase() 不会判断大小写区别：
        if(s.equalsIgnoreCase("Benz")){
            return new Benz();
        }else if(s.equalsIgnoreCase("Bmw")){
            return new Bmw();
        }else {
            throw new Exception();
        }

    }

    public static void main(String[] args) {

        try {
            Car car = SimpleFactory.driverCar("benz");

            car.drive();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }


}

二、工厂方法模式
工厂方法模式是指定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个对象，工厂方法让类的实例化推迟到子类中进行，
在工厂方法模式中用户只需要关心所需产品对应的工厂，无须关心创建细节，而且加入新的产品符合开闭原则。

相比于简单工厂，多了工厂的抽象；
组成：
1、物品的抽象
2、具体物品类
3、一个生产工厂的抽象接口
4、生产工厂的类

eg:
在这里插入图片描述
这里工厂和产品以依赖形式连接，抽象也是，体现在代码中，实际是由于抽象间就已经是依赖关系了，所以实体间必然是；

代码实例：
车产品抽象接口：

package com.example.dtest.design23.factory.factory;
public interface CarFactory {
    Car driverCar();
}

奔驰工厂类

package com.example.dtest.design23.factory.factory;
public class BenzFactory implements CarFactory{

    @Override
    public Car driverCar() {
        return new Benz();
    }

}

宝马工厂类：

package com.example.dtest.design23.factory.factory;
public class BmwFactory implements CarFactory{
    @Override
    public Car driverCar() {
        return new Bmw();
    }
}

车产品抽象接口：

package com.example.dtest.design23.factory.factory;

public interface Car {

    void drive();

}

宝马车类：

package com.example.dtest.design23.factory.factory;



public class Bmw implements Car {
    @Override
    public void drive() {
        System.out.println("Driving Bmw");
    }
}

奔驰车类：

package com.example.dtest.design23.factory.factory;



public class Benz implements Car {
    @Override
    public void drive() {
        System.out.println("Driving Benz");
    }
}

测试：

package com.example.dtest.design23.factory.factory;

public class FactoryTest {

    public static void main(String[] args) {

        // Car car = SimpleFactory.driverCar("benz");
        CarFactory factory = new BmwFactory();
        Car car = factory.driverCar();
        car.drive();
        
    }

}

抽象工厂
产品族
产品族：位于不同产品等级结构中，功能相关联的产品组成的家族。
假设BmwFactory,BenzFactory不但造汽车,还制造飞机坦克.

那么Bmw厂家的car ,plane ,tank就是一族.
同样Benz厂家的car ,plane ,tank也是一族.
而BmwFactory 和BenzFactory 就是两个产品树（产品层次结构）；

相比于工厂，多了具体物品的种类；
组成：
1、物品的抽象
2、具体物品类1，具体物品类2…
3、一个生产工厂的抽象接口
4、生产工厂的类
eg:
在这里插入图片描述

代码实例：
车抽象：

package com.example.dtest.design23.factory.abstractFactory;

public interface Car {

    void driveCar();

}

飞机抽象：

package com.example.dtest.design23.factory.abstractFactory;

public interface Plane {

    void driverPlane();

}

坦克抽象：

package com.example.dtest.design23.factory.abstractFactory;

public interface Tank {

    void driverTank();

}

奔驰车实现：

package com.example.dtest.design23.factory.abstractFactory.bc;

import com.example.dtest.design23.factory.abstractFactory.Car;

public class BcCar implements Car {
    @Override
    public void driveCar() {
        System.out.println("Driving BcCar Car");
    }
}

奔驰飞机实现：

package com.example.dtest.design23.factory.abstractFactory.bc;

import com.example.dtest.design23.factory.abstractFactory.Plane;

public class BcPlane implements Plane {
    @Override
    public void driverPlane() {
        System.out.println("Driving BcPlane Plane");
    }
}

奔驰坦克实现：

package com.example.dtest.design23.factory.abstractFactory.bc;

import com.example.dtest.design23.factory.abstractFactory.Tank;

public class BcTank implements Tank {
    @Override
    public void driverTank() {
        System.out.println("Driving BcTank Tank");
    }
}

宝马车实现：

package com.example.dtest.design23.factory.abstractFactory.bm;

import com.example.dtest.design23.factory.abstractFactory.Car;

public class BmCar implements Car {
    @Override
    public void driveCar() {
        System.out.println("Driving BmCar Car");
    }
}

宝马飞机实现：

package com.example.dtest.design23.factory.abstractFactory.bm;

import com.example.dtest.design23.factory.abstractFactory.Plane;

public class BmPlane implements Plane {
    @Override
    public void driverPlane() {
        System.out.println("Driving BmPlane Plane");
    }
}

宝马坦克实现：

package com.example.dtest.design23.factory.abstractFactory.bm;

import com.example.dtest.design23.factory.abstractFactory.Tank;

public class BmTank implements Tank {
    @Override
    public void driverTank() {
        System.out.println("Driving BmTank Tank");
    }
}

工厂的抽象：

package com.example.dtest.design23.factory.abstractFactory;

public interface AbstractFactory {

    //制造汽车
    abstract Car driverCar();

    //制造飞机
    abstract Plane driverPlane();

    //制造坦克
    abstract Tank driverTank();

}

奔驰工厂的实现：

package com.example.dtest.design23.factory.abstractFactory.bc;

import com.example.dtest.design23.factory.abstractFactory.AbstractFactory;
import com.example.dtest.design23.factory.abstractFactory.Car;
import com.example.dtest.design23.factory.abstractFactory.Plane;
import com.example.dtest.design23.factory.abstractFactory.Tank;

public class BcFactory implements AbstractFactory {
    @Override
    public Car driverCar() {
        return new BcCar();
    }

    @Override
    public Plane driverPlane() {
        return new BcPlane();
    }

    @Override
    public Tank driverTank() {
        return new BcTank();
    }
}

宝马工厂的实现：

package com.example.dtest.design23.factory.abstractFactory.bm;

import com.example.dtest.design23.factory.abstractFactory.AbstractFactory;
import com.example.dtest.design23.factory.abstractFactory.Car;
import com.example.dtest.design23.factory.abstractFactory.Plane;
import com.example.dtest.design23.factory.abstractFactory.Tank;

public class BmFactory implements AbstractFactory{
    @Override
    public Car driverCar() {
        return new BmCar();
    }

    @Override
    public Plane driverPlane() {
        return new BmPlane();
    }

    @Override
    public Tank driverTank() {
        return new BmTank();
    }
}

测试：

package com.example.dtest.design23.factory.abstractFactory;

import com.example.dtest.design23.factory.abstractFactory.bm.BmFactory;

public class AbstractFactoryTest {

    public static void main(String[] args) {

        AbstractFactory factory = new BmFactory();

        Car car = factory.driverCar();
        Plane plane = factory.driverPlane();
        Tank tank = factory.driverTank();

        car.driveCar();
        plane.driverPlane();
        tank.driverTank();


    }

}