设计模式---工厂模式

Posted 2021-02-20 chongcheng

如果文章中哪里有问题，希望各位大哥大姐指出，小弟十分感激。

 

正文

什么是工厂模式？

　　工厂模式就是将原来我们手动一个个分散new的对象，整合到一个类/方法中进行创建，我们只需调用不同获取方法，或者传入不同的参数，就可以获取不同的目标对象。

 

为什么我们要用工厂模式呢？

　　首先当我们需要某个对象的时候，我们肯定是随用随new是吧，如果我们很多地方都用到这个对象，那就肯定new的代码很分散了。如果某天产品经理跟你说，我们这个东东要加个什么功能，你需要改下这个对象的创建过程。当然，如果你就几个地方使用的这个对象那没啥，但要是你几百个地方都用到了呢。想想看，你是不是会吐。

　　另外如果哪天，产品经理又说要增加一个类似的新产品，功能一样，但是他更炫酷，那是不是又要到处改啊改。

　　但如果我们用工厂模式，将这个对象的创建统一抽取出来放在工厂方法/工厂类里面，我们就传入不同的参数，让工厂方法自己判断需要生成什么类对象进行返回。那我们碰到这样的需求，岂不是只需要改一下工厂方法里面的创建对象的地方就行了。

怎样用工厂模式？

　　工厂模式需要满足两个条件：
　　　　1：工厂生产的对象必须有公共操作，也就是公共方法/功能、
　　　　2：工厂生产的对象必须实现同一个接口或继承同一个父类

　　我们最小需要的东西：
　　　　1：通用产品类的接口，IProduct
　　　　2：具体产品类实现类，ProductA
　　　　3：工厂类，Factory

　　工厂模式可以划分成3中：简单工厂、工厂模式、抽象工厂。一个比一个复杂

• 简单工厂：只有一个工厂类，将对象的创建放在同一个工厂类中，根据参数的不同去创建不同的对象并返回。
• 工厂模式：有多个工厂，一个工厂对应一种产品，也就是一个工厂只能生产一种产品，应用自己去获取不同的工厂，然后生产产品。
• 抽象工厂：有多个工厂，一种类型的工厂可以生产多种不同样的产品，但是所有工厂生产的产品又是类似的。用户自己去根据需求获取不同的工厂，然后自己获取各种不同的产品。例如说文具店有晨光、得力，这就相当于工厂。他们都生产笔，笔记本。但是晨光生产铅笔，得力生产圆珠笔；晨光生产牛皮本，得力生产车线本。（注意，并不是给工厂类加了abstract就算抽象工厂啊，这是掩耳盗铃，自欺欺人而已）

 

简单工厂：

 

 

/**
 *     简单工厂
 * */
public class time{
    public static void main(String[] args) {
        IProduct product = Factory.createProduct(ProductType.ProductB);
        product.operation();
    }
}

abstract class Factory{
    public static IProduct createProduct(ProductType productType) {
        IProduct product = null;
        switch (productType) {
        case ProductA:
            product = new ProductA();
            /** 可以进行些初始化 */
            break;
        case ProductB:
            product = new ProductB();
            /** 可以进行些初始化 */
            break;
        default:
            break;
        }
        return product;
    }
}
interface IProduct{
    void operation();
}

class ProductA implements IProduct{
    public void operation() {
        System.err.println(this.getClass());
    }
}
class ProductB implements IProduct{
    public void operation() {
        System.err.println(this.getClass());
    }
}
enum ProductType{
    ProductA,ProductB;
}

 

 

工厂模式：

 

 

 

 

/**
 *     工厂模式
 * */
public class test1 {
    static ProductType type = ProductType.ProductB;
    static IFactory factory = null;
    static IProduct product = null;
    public static void main(String[] args) {
        if(type == ProductType.ProductA) {
            factory = new FactoryA();
        }else {
            factory = new FactoryB();
        }
        product = factory.createProduct();
        /** 业务 */
        product.operation();
    }
}
/**
 *     工厂接口
 * */
interface IFactory{
    IProduct createProduct();
}
/***
 *     具体工厂A
 * */
class FactoryA implements IFactory{
    public IProduct createProduct() {
        ProductA productA = new ProductA();
        /** 可以进行初始化 */
        return productA;
    }
}
/***
 *     具体工厂B
 * */
class FactoryB implements IFactory{
    public IProduct createProduct() {
        ProductB productB = new ProductB();
        /** 可以进行初始化 */
        return productB;
    }
}
/**
 *     产品接口
 * */
interface IProduct{
    void operation();
}
/***
 *     产品实现
 * */
class ProductA implements IProduct{
    public void operation() {
        System.err.println(this.getClass());
    }
}
/***
 *     产品实现
 * */
class ProductB implements IProduct{
    public void operation() {
        System.err.println(this.getClass());
    }
}
enum ProductType{
    ProductA,ProductB;
}

 

 

抽象工厂：

 

/**
 *     抽象工厂
 * */
public class time3 {
    static IFactory factory = null;
    static IPen pen = null;
    static INote note = null;
    public static void init(String name) {
        if("得力".equals(name)) {
            factory = new DeLiFactory();
        }else {
            factory = new ChenGuangFactory();
        }
    }
    public static void main(String[] args) {
        init("晨光");
        note = factory.createNote();
        pen = factory.createPen();
        /** 业务 */
        note.operation();
        pen.operation();
    }
}
/**
 *     工厂接口
 * */
interface IFactory{
    IPen createPen();
    INote createNote();
}
/**
 *     得力工厂
 * */
class DeLiFactory implements IFactory{
    public IPen createPen() {
        BallPen pen = new BallPen();
        /** 进行一些初始化 */
        return pen;
    }
    public INote createNote() {
        CheXianNote note = new CheXianNote();
        /** 进行一些初始化 */
        return note;
    }
}
/**
 *     晨光工厂
 * */
class ChenGuangFactory implements IFactory{
    public IPen createPen() {
        Pencil pen = new Pencil();
        /** 进行一些初始化 */
        return pen;
    }
    public INote createNote() {
        NiuPiNote note = new NiuPiNote();
        /** 进行一些初始化 */
        return note;
    }
}
/**
 *     笔--产品接口
 * */
interface IPen{
    void operation();
}
/**
 *     笔记本--产品接口
 * */
interface INote{
    void operation();
}
/***
 *     铅笔--产品实现
 * */
class Pencil implements IPen{
    public void operation() {
        System.err.println(this.getClass());
    }
}
/***
 *     圆珠笔--产品实现
 * */
class BallPen implements IPen{
    public void operation() {
        System.err.println(this.getClass());
    }
}
/***
 *     车线本--产品实现
 * */
class CheXianNote implements INote{
    public void operation() {
        System.err.println(this.getClass());
    }
}
/***
 *     牛皮本--产品实现
 * */
class NiuPiNote implements INote{
    public void operation() {
        System.err.println(this.getClass());
    }
}