设计模式——工厂模式

工厂设计模式

在面向对象编程，工厂设计模式是常用的设计模式之一，体现了面向对象的抽象性，工厂设计模式可以分为三种：
1、简单工厂模式
2、普通工厂模式
3、抽象工厂模式

引入:
    想一下，加入我们现在需要生产一台计算机，因为计算机有很多的类型，可以有A，B，C三种，而这个时候，一个用户可以需要这三种的任意一种，所以我们的类可能是这么写的：

class People{
    private Computer computer = null;

    public People(){}
    ppublic Computer createComputerA(){
        //生产ComputerA代码
    }
    ppublic Computer createComputerB(){
        //生产ComputerB代码
    }
}

这样的话计算机和用户的耦合性比较高，不是很符合低耦合高内聚的思想。于是需要有一种更好的方式去处理，使得代码的作用更加独立，更有利于大批量生产对象，于是就有了工厂设计模式。

一、简单工厂设计模式。
简单工厂模式可以分为以下三个组成：
抽象工具类：具体类的父类，用于抽象具体类特征，一般是接口或抽象类。
具体工具类：就是具体产品的类，可以直接实现出来使用。
工厂类：用于生产具体的工具的。

话不多说，直接上代码：

//抽象工具类
class abstract Computer{
    //Computer共有属性及方法
}
//具体实现类
class ComputerA extends Computer{
    //ComputerA属性及方法
}
class ComputerB extends Computer{
    //ComputerB属性及方法
}

//工厂类
class ComputerFactory{
    public static Computer createComputer(String type){
        switch(type){
            case "A":
                return new ComputerA();
            break;
            case "B":
                return new ComputerB();
            break;

        }
    }
}
//使用类

class people{
    private Computer computer;
    public void createComputer(String type){
        computer = ComputerFactory.createComputer(type);
    }
}

这样使得用户类与产品类更加的独立，耦合性明显降低了。

二、普通工厂模式
    普通工厂模式实在简单工厂模式的基础上进一步抽象获得，多定义了一个抽象工厂，可写代码如下：

/* 产品类跟简单设计模式一样，于是不重复代码 一下是对工厂类的修改 */

//抽象工厂类
class interface ComputerFactory{
    public void createCoputer();
}
//具体工厂类
class ComputerAFactory implements ComputerFactory{
    public Computer createComputer(){
        return new ComputerA();
    }
}
class ComputerBFactory implements ComputerFactory{
    public Computer createComputer(){
        return new ComputerB();
    }
}

//引用
class People(){
    public static void main(String[] args){
    Computer computer;
        ComputerFactory factory;
        //创建电脑A
        factory = new ComputerAFactory();
        computer = factory.createFactory();
        //创建电脑B
        factory = new ComputerBFactory();
        computer = factory.createFactory();
    }
}

三、抽象工厂模式

虽然看似已经很好的对类进行了抽象,可是如果说要给Computer配一个打印机，这样的话又要对代码进行较大的改动，可见抽象性还不够。

抽象工厂模式与普通工厂模式的区别在于，抽象工厂模式可以有多个产品类。一下是代码：

class abstract Computer{
    //Computer共有属性及方法
}
class abstract Printer{
    //Printer共有属性及方法
}
class ComputerA extends Computer{
    //ComputerA属性及方法
}
class ComputerB extends Computer{
    //ComputerB属性及方法
}
class PrinterA extends Printer{
    //PrinterA属性及方法
}
class PrinterB extends Printer{
    //PrinterB属性及方法
}
class interface IComputerAFactory{
    public Computer createComputerA();
    public Printer createPrinterA();
}
class interface IComputerBFactory{
    public Computer createComputerB();
    public Printer createPrinterB();
}
class ComputerAFactory implements IComputerAFactory{
    public Computer createComputerA(){
        return new ComputerA();
    }
    public Printer createPrinterA(){
        return new PrinterA();
    }
}
class ComputerBFactory implements IComputerBFactory{
    public Computer createComputerB(){
        return new ComputerB();
    }
    public Printer createPrinterB(){
        return new PrinterB();
    }
}

或用编程设计模式可是使自己的代码更加灵活，有利于后期的维护。

因为本人的经验也不足，如有不对的地方，请见谅，望指正。

• 编程没有捷径，脚踏实地的打代码才是王道，希望大家好好的学习。