设计模式：工厂模式

无工厂模式：

每个类都要求有具体的产品实现细节，并返回该产品。
例如：买电脑

class LenovoComputer{
    LenovoComputer(){}
    public void work(){
        System.out.println("Lenovo working...");
    }
}
class DellComputer{
    DellComputer(){}
    public void work(){
        System.out.println("Dell working...");
    }
}
//客户类
class Client{
    public static void main(String args[]){
        LenovoComputer lenovoComputer = new LenovoComputer();
        lenovoComputer.work();
        DellComputer dellComputer = new DellComputer();
        dellComputer.work();
    }
}

我们能发现客户端需要知道怎么去创建一个电脑，客户和电脑紧紧耦合在了一起，若是电脑端出现了一些问题，那么客户端就会崩溃。

简单工厂模式：

创建一个工厂来创建新的对象，把操作细节都放到工厂类中去，用户只需要给出产品的名称就可以得到产品，而不需要知道产品创建的细节。
简单工厂模式需要以下几个类：
1、产品抽象类（或是接口）
2、产品具体类
3、工厂类
4、 客户类

例如：买电脑

//产品抽象类Computer，每一个产品都要继承这个产品抽象类（或者实现产品抽象的接口），并重写类中的方法。
abstract class Computer{
    public abstract void work();
}

//若干个产品具体类Dell 和 Lenovo（有几个产品就有几个产品具体类），每一个具体类都继承了抽象类并重写了work()方法。
class Lenovo extends Computer{
    public void work(){
        System.out.println("Lenovo working...");
    }
}
class Dell extends Computer{
    public void work(){
        System.out.println("Dell working...");
    }
}

//工厂类，封装着产品实现的细节。
class Factory{
    public Computer getComputer(String computer){
        if(computer.equals("Lenovo")){
            return new Lenovo();
        }else if(computer.equals("Dell")){
            return new Dell();
        }else{
            return null;
        }
    }
}
//客户类，只需要建立一个工厂类，把需要得到的产品名传递给工厂类，便可以不用考虑产品实现的细节，直接拿到产品。
public class Client{
    public static void main(String args[]){
        Factory factory = new Factory();
        Computer computer = factory.getComputer("Lenovo");
        computer.work();
    }
}

Running:
Output: Lenovo working…
简单工厂模式客户端不需要知道电脑细节，仅仅声明一个电脑类型，输入电脑型号，便可以得到心仪的电脑，复用性也比无工厂模式要高，我若是想得到Dell电脑，只需要把字符串“Lenovo”改为“Dell”即可。

工厂方法模式：

通过简单工厂模式我们降低了客户端与产品的耦合性，但是在简单工厂模式中，工厂承受的压力太大，我们如果需要增加，修改或者删除一个产品，就必须到工厂类中进行修改，不能很好的实现java的“开闭原则”，而且若是产品的属性不相同，由一个工厂也不能很好的控制产品间属性的差异，因此引入了一种工厂方法模式，每个产品对应他自己的一个工厂类。
工厂方法模式需要以下几个类：
1、抽象工厂类
2、具体工厂类
3、抽象产品类
4、具体产品类
5、客户类

例如：买电脑

//抽象工厂类，有一个制造产品方法，以下的工厂具体类需要重写这个方法。
abstract class Factory{
    public abstract Computer creatComputer();
}
//若干个产品工厂类，一个产品对应一个产品工厂类，这样降低了工厂的压力，每个工厂只负责创建属于他的产品。
class LenovoFactory extends Factory{
    @Override
    public Computer creatComputer(){
        return new Lenovo();
    }
}
class DellFactory extends Factory{
    @Override
    public Computer creatComputer()
    {
        return new Dell();
    }
}
//抽象产品类
abstract class Computer{
    public abstract void work();
}
//若干个具体产品类
class Lenovo extends Computer{
    public void work(){
        System.out.println("Lenovo working...");
    }
}
class Dell extends Computer{
    public void work(){
        System.out.println("Dell working...");
    }
}
//客户类
public class Client{
    public static void main(String args[]){

       Factory factory = new LenovoFactory();
        Computer computer = factory.creatComputer();
        computer.work();
    }
}

Running:
Output: Lenovo working…
Dell working…

工厂方法模式为每一个产品类创建一个产品工厂，以便工厂可以更好的实现各个产品不同的属性，也是得产品类得到了更好的封装。

ps：待更…