浅谈工厂设计模式

1.简单工厂模式（买电脑问题）
简单工厂模式：专门定义一个类用来创建其它类的实例，
被创建的实例通常都具有共同的父类。
概要：
一个抽象产品类；
具体产品类；
一个工厂；
一个客户端；
代码如下：

public interface Computer {//抽象的电脑接口
    void printComputer();
}

public class MacbookProComputer implements Computer {
    @Override
    public void printComputer() {
        System.out.println("MacbookProComputer");
    }
}

public class SurfaceBookComputer implements Computer {
    @Override
    public void printComputer() {
        System.out.println("SurfaceBookComputer");
    }
}

public class AlienComputer implements Computer {
    @Override
    public void printComputer() {
        System.out.println("AlienComputer");
    }
}

public class ComputerFactory {
    public static Computer getInstance(String type) {//一个返回电脑型号的方法
        Computer computer = null;
        switch (type) {
            case "MAC":
                computer = new MacbookProComputer();
                break;
            case "SUR":
                computer = new SurfaceBookComputer();
                break;
            case "ALI":
                computer = new AlienComputer();
                break;
            default:
                System.out.println("请输入正确的电脑型号");
                break;
        }
        return computer;
    }
}

import java.util.Scanner;

public class Client {
    public void buyComputer(Computer computer) {//一个含有电脑型号的形参且无返回值的方法
        computer.printComputer();
    }
    public static void main(String[] args) {
        Client client = new Client();
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你想要的电脑型号");
        String type = scanner.nextLine();
        client.buyComputer(ComputerFactory.getInstance(type));
    }
}

此类模式的优点有：简单易于实现；把类的实例化交给工厂，易于解耦。
此类模式的缺点有：添加具体产品需要修改工厂违反OCP开放封闭原则。
2.工厂方法模式（买电脑问题）
工厂方法模式：定义一个用来创建对象的接口，让子类决定实例化哪一个类，
让子类决定实例化延迟到子类。
概要：
一个抽象产品类；
多个具体产品类；
一个抽象工厂；
多个具体工厂，每一个具体产品对应一个具体工厂；
一个客户端；
代码如下：

public interface Computer {//抽象的电脑接口
    void printComputer();
}

public class MacbookProComputer implements Computer {
    @Override
    public void printComputer() {
        System.out.println("MacbookProComputer");
    }
}

public class SurfaceBookComputer implements Computer {
    @Override
    public void printComputer() {
        System.out.println("SurfaceBookComputer");
    }
}

public interface ComputerFactory {//抽象的工厂接口
    Computer createComputer();
}

public class MsFactor implements ComputerFactory {
    @Override
    public Computer createComputer() {
        return new SurfaceBookComputer();
    }
}

public class AppleFactory implements ComputerFactory {
    @Override
    public Computer createComputer() {
        return new MacbookProComputer();
    }
}

public class Client {
    public void buyComputer(Computer computer) {//一个含有电脑型号的形参且无返回值的方法
        computer.printComputer();
    }
    public static void main(String[] args) {
        Client client = new Client();
        ComputerFactory factory = new AppleFactory();
        ComputerFactory factory1 = new MsFactor();
        client.buyComputer(factory.createComputer());
        client.buyComputer(factory1.createComputer());
    }
}

此类模式的优点有：降低了代码耦合度，对象的生成交给子类去完成；
实现了开放封闭原则，每次添加子产品不需要修改原有代码。
此类模式的缺点有：增加了代码量，每个具体产品都需要一个具体工厂；
当增加抽象产品，也就是添加一个其他产品族，需要修改工厂违背OCP。
3.抽象工厂模式（买电脑问题）
抽象工厂模式：提供一个创建一系列相关互相依赖对象的接口，
而无需指定它们具体的类。
概要：
多个抽象产品类；
具体产品类；
抽象工厂类，声明（一组）返回抽象产品的方法；
具体工厂类，生产（一组）具体产品；
一个客户端；
代码如下：

 public interface Computer {//抽象的电脑接口
    void printComputer();
}

public class MacbookProComputer implements Computer {
    @Override
    public void printComputer() {
        System.out.println("MacbookProComputer");
    }
}

public class SurfaceBookComputer implements Computer {
    @Override
    public void printComputer() {
        System.out.println("SurfaceBookComputer");
    }
}

public interface OpeartSystem {//抽象的操作系统接口
    void printSystem();
}

public class MacOsSystem implements OpeartSystem {
    @Override
    public void printSystem() {
        System.out.println("MacOsSystem");
    }
}

public class Windows10System implements OpeartSystem {
    @Override
    public void printSystem() {
        System.out.println("Windows10System");
    }
}

public interface ComputerFactory {//抽象的工厂接口，包含了两个抽象方法
    Computer createComputer();
    OpeartSystem createSystem();
}

public class AppleFactory implements ComputerFactory {
    @Override
    public Computer createComputer() {
        return new MacbookProComputer();
    }

    @Override
    public OpeartSystem createSystem() {
        return new MacOsSystem();
    }
}

public class MsFactor implements ComputerFactory {
    @Override
    public OpeartSystem createSystem() {
        return new Windows10System();
    }

    @Override
    public Computer createComputer() {
        return new SurfaceBookComputer();

    }
}

public class Client {
    public void buyComputer(Computer computer) {//一个含有电脑型号的形参且无返回值的方法
        computer.printComputer();
    }
    public void use(OpeartSystem system) {//一个含有操作系统类型的形参且无返回值的方法
        system.printSystem();
    }
    public static void main(String[] args) {
        Client client = new Client();
        ComputerFactory factory = new AppleFactory();
        ComputerFactory factory1 = new MsFactor();
        client.buyComputer(factory.createComputer());
        client.use(factory.createSystem());
        client.buyComputer(factory1.createComputer());
        client.use(factory1.createSystem());
    }
}

此类模式的优点有：代码解耦；实现多个产品族；很好的满足OCP开放封闭原则；
抽象工厂模式中我们可以定义实现不止一个接口，
一个工厂也可以生成不止一个产品类，对于复杂对象的生产相当灵活易扩展。
此类模式的缺点有：扩展产品族相当麻烦而且扩展产品族会违反OCP，
因为要修改所有的工厂；
由于抽象工厂模式是工厂方法模式的扩展，总体来说很笨重。

最后再总结一下抽象类和接口的区别：
1.结构组成：抽象类可以包含普通方法、抽象方法（必有）、构造器以及代码块；
而接口只能包含抽象方法和全局静态常量。
2.权限：抽象类可以使用各种权限；而接口只能用public权限。
3.子类使用：抽象类使用extends关键字继承抽象类；
而接口使用implements关键字实现接口。
4.关系：一个抽象类可以实现若干个接口；
而接口不能继承抽象类（因为接口不含有普通方法），
但是接口可以使用extends关键字继承多个父接口。
5.子类限制：一个子类只能继承一个抽象类；而一个子类可以实现多个接口。