【java】Java中的工厂设计模式，

【java】Java中的工厂设计模式，

工厂设计模式一共有三种，简单工厂模式、工厂方法模式、抽象工厂模式。
我们都以用户买电脑作为例子。
首先说简单工厂模式。有一个抽象的产品的接口，需要具体的产品类去实现这个接口，然后
需要有一个工厂类去产生具体产品。最后用客户端去实现买电脑。
我们直接以代码来看看：

public interface Computer {//首先定义一个电脑接口
    void print();
}
class Macbook implements Computer{//具体产品类
    @Override
    public void print() {//MacBook去实现Computer接口
        System.out.println("MacBook");
    }
}
class SurfaceBook implements Computer{//具体产品类
    @Override
    public void print() {//SurfaceBook去实现Computer接口
        System.out.println("SurfaceBook");
    }
}
class ComputeFactory {//产品工厂类
    public static Computer getInstance(String type){//返回一种具体产品
        Computer computer=null;
        switch (type){
            case "Mac":
                computer=new Macbook();break;//生产Macbook
            case "Sur":
                computer=new SurfaceBook();break;//生产SurfaceBook
            default:
                System.out.println("请输入型号");break;//其他型号
        }
       return computer;//返回生产的电脑
    }
}
import java.util.Scanner;//导入Scanner类

public class Client {//客户端类
    public static void Buy(Computer computer){//接收电脑型号买电脑
        computer.print();
    }

    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        String type=scanner.nextLine();//用户输入需要购买的型号
        Computer computer=ComputeFactory.getInstance(type);//根据用户输入型号生产电脑
        Buy(computer);调用买电脑方法，传过去用户需要购买的型号买到电脑。
    }
}

简单工厂模式的优点顾名思义就是简单，缺点是，在工厂中添加其他型号电脑时违反了OCP封装原则。
然后是工厂方法模式。有一个产品接口，需要具体的产品实现产品接口，有一个工厂接口，需要具体的工厂实现工厂接口。同样用代码来详解。

public interface Computer {//产品接口
    void print();
}
public interface ComputerFactory {//工厂接口
    Computer CreatComputer();//生产一种具体产品
}
public class MacBook implements Computer{//具体产品类MacBook
    @Override
    public void print() {//实现产品接口
        System.out.println("MacBook");
    }
}
public class SurfaceBook implements Computer {//具体产品类SurfaceBook
    @Override
    public void print() {//实现产品接口
        System.out.println("SurfaceBook");
    }
}
public class MacFactory implements ComputerFactory {//具体工厂类MacFactory
    @Override
    public Computer CreatComputer() {//实现工厂接口
        return new MacBook();//生产MacBook
    }
}
public class SurfaceFactory implements  ComputerFactory {//具体工厂类SurfaceFactory
    @Override
    public Computer CreatComputer() {
        return new SurfaceBook();//生产SurfaceBook
    }
}
public class Client {//客户端类，实现购买电脑
    public void BuyComputer(Computer computer){//根据型号购买电脑
        computer.print();
    }

    public static void main(String[] args) {
        Client client=new Client();
        ComputerFactory computerFactory=new SurfaceFactory();//生产SurfaceBook
        client.BuyComputer(computerFactory.CreatComputer());//购买生产出的电脑
    }
}

工厂方法类的优点是降低了代码的耦合度，实现了开放封闭原则，添加新的产品类的时候不需要
修改原有的代码，缺点同样也很明显，代码量增多，并且在添加抽象产品的时候，比如Mac添加苹果手机，同样会违反OCP封装原则。
最后是抽象工厂模式，这种模式与工厂方法模式特别接近，不过就是在原有的基础上增加了抽象
产品接口，比如电脑的操作系统，在工厂中同时需要加入相应的操作系统。同样再看一段代码。

public interface Computer {//抽象产品接口电脑
    void print();
}
public interface OpreatSystem {//抽象产品接口操作系统
    void print();
}
public interface Factory {//抽象工厂接口
    Computer createComputer();//生产电脑
    OpreatSystem createOpreatSystem();//安装电脑操作系统
}
class MacBook implements Computer {//具体产品类MacBook
    @Override
    public void print() {
        System.out.println("MacBook");
    }
}
class SurfaceBook implements Computer {//具体产品类SurfaceBook
    @Override
    public void print() {
        System.out.println("SurfaceBook");
    }
}
class MacFactory implements Factory {//具体工厂类Mac工厂
    @Override
    public Computer createComputer() {
        return new MacBook();//生产MacBook
    }
    @Override
    public OpreatSystem createOpreatSystem() {
        return new MacOs();//安装MacOs系统
    }
}
class SurfaceFactory implements Factory {//具体工厂Surface工厂
    @Override
    public Computer createComputer() {
        return new SurfaceBook();//生产SurfaceBook
    }

    @Override
    public OpreatSystem createOpreatSystem() {
        return new Win10();//安装Win10系统
    }
}
public class Client {
    public void BuyComputer(Computer computer){
        computer.print();//购买电脑的型号
    }
    public void Os(OpreatSystem opreatSystem){
        opreatSystem.print();//购买电脑的操作系统
    }

    public static void main(String[] args) {
        Client client=new Client();
        Factory factory=new MacFactory();//使用MacFactory
        client.BuyComputer(factory.createComputer());//买MacFactory生产出的电脑
        client.Os(factory.createOpreatSystem());//购买的电脑操作系统是
    }
}

抽象工厂模式总体上和工厂方法模式差不多，是对工厂方法模式的扩充，抽象工厂接口可以灵活扩充，缺点也同工厂方法模式，并且代码量更大，在扩展具体产品时同样会违反OCP封装原则。