Java简单工厂类

简单工厂模式

简单工厂模式：专门定义一个类用来创建其它类的实例，被创建的实例通常都具有共同的父类。

这里我们相当于是创建生产电脑的工厂，客户需要购买什么样的电脑，只要输入类型编号就可以获取该电脑。将类的实例化交给工厂易于解耦。

package a.b.c;

import java.util.Scanner;
interface Computer{
    void printComputer();
}

class Macbook implements Computer{
    @Override
    public void printComputer() {
        System.out.println("This is a Macbook");
    }
}
class Surface implements  Computer{
    @Override
    public void printComputer() {
        System.out.println("This is a Surfacebook");
    }
}

class Computerfactory{
    public static Computer getInstance(String type){
        Computer computer = null ;
        if(type.equals("macbook")){
            computer = new Macbook();
        }
        else if(type.equals("Surface")){
            computer = new Surface();
        }
        return computer;
    }
}
class Test{
    public void BuyComputer(Computer computer){
        computer.printComputer();
        }
    public static void main(String[] args) {
        Test t1 =new Test();
        Scanner scanner =new Scanner(System.in);
        System.out.println("请输入您想要的电脑型号...");
        String type =scanner.nextLine();
        Computer computer = Computerfactory.getInstance(type);
        t1.BuyComputer(computer);

    }
}

以上就是简单工厂模式

概要:

• 1.一个抽象产品类
• 2.具体产品类
• 3.一个工厂

优点:
1.简单易于实现
2.把类的实例化对象交给工厂,易于解耦

缺点
添加具体产品需要修改工厂违反OCP开放封闭原则

工厂方法模式

工厂方法模式：定义一个用来创建对象的接口，让子类决定实例化哪一个类，让子类决定实例化延迟到子类。
工厂方法模式是针对每个产品提供一个工厂类，在客户端中判断使用哪个工厂类去创建对象。

package a.b.c;

import java.util.Scanner;
interface Computer{
    void printComputer();
}

class Macbook implements Computer{
    @Override
    public void printComputer() {
        System.out.println("This is a Macbook");
    }
}
class Surface implements  Computer{
    @Override
    public void printComputer() {
        System.out.println("This is a Surfacebook");
    }
}

interface Computerfactory{
   Computer createComputer();
}
class MsFactory implements Computerfactory{
    @Override
    public Computer createComputer() {
        return new Surface();
    }
}
class AppleFactory implements Computerfactory{
    @Override
    public Computer createComputer() {
        return new Macbook();
    }
}
class Test{
    public void BuyComputer(Computer computer){
        computer.printComputer();
        }
    public static void main(String[] args) {
        Test t = new Test();
        Computerfactory factory = new AppleFactory();
        t.BuyComputer(factory.createComputer());

    }
}

简单工厂模式 VS 工厂方法模式：

对于简单工厂模式而言，创建对象的逻辑判断放在了工厂类中，客户不感知具体的类，但是其违背了开闭原则，如果要增加新的具体类，就必须修改工厂类。
对于工厂方法模式而言，是通过扩展来新增具体类的，符合开闭原则，但是在客户端就必须要感知到具体的工厂类，也就是将判断逻辑由简单工厂的工厂类挪到客户端。
工厂方法横向扩展很方便，假如该工厂又有新的产品 Macbook Air 要生产，那么只需要创建相应的工厂类和产品类去实现抽象工厂接口和抽象产品接口即可，而不用去修改原有已经存在的代码。

优点：
降低了代码耦合度，对象的生成交给子类去完成

实现了开放封闭原则 - 每次添加子产品 不需要修改原有代码

缺点：
增加了代码量，每个具体产品都需要一个具体工厂

当增加抽象产品 也就是添加一个其他产品族 需要修改工厂 违背OCP

抽象工厂模式

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

工厂方法模式和抽象工厂模式基本类似，可以这么理解：当工厂只生产一个产品的时候，即为工厂方法模式，而工厂如果生产两个或以上的商品即变为抽象工厂模式。

package a.b.c;

import java.util.Scanner;
interface Computer {
    void printComputer();
}
class MacbookProComputer implements Computer {
    public void printComputer() {
        System.out.println("This is a MacbookPro");
    }
}
class SurfaceBookComputer implements Computer {
    public void printComputer() {
        System.out.println("This is a SurfaceBook");
    }
}
interface OperatingSystem {
    void printSystem();
}
class MacOsSystem implements OperatingSystem {
    public void printSystem() {
        System.out.println("This is a mac os");
    }
}
class Windows8System implements OperatingSystem {
    public void printSystem() {
        System.out.println("This is a windows10");
    }
}
interface ProductionFactory {
    Computer createComputer();
    OperatingSystem createSystem();
}
class AppleFactory implements ProductionFactory {
    public Computer createComputer() {
        return new MacbookProComputer();
    }
    public OperatingSystem createSystem() {
        return new MacOsSystem();
    }
}
class MsFactory implements ProductionFactory {
    public Computer createComputer() {
        return new SurfaceBookComputer();
    }
    public OperatingSystem createSystem() {
        return new Windows8System();
    }
}
public class Test {
    public void buyComputer(Computer computer) {
        computer.printComputer();
    }
    public void use(OperatingSystem s) {
        s.printSystem();
    }
    public static void main(String[] args) {
        Test test = new Test();
        ProductionFactory factory = new AppleFactory();
        Computer computer = factory.createComputer();
        OperatingSystem system = factory.createSystem();
        test.buyComputer(computer);
        test.use(system);
    }
}

概要

1. 多个抽象产品类
2. 具体产品类
3. 抽象工厂类 - 声明(一组)返回抽象产品的方法
4. 具体工厂类 - 生成(一组)具体产品

优点：
代码解耦
实现多个产品族(相关联产品组成的家族)，而工厂方法模式的单个产品,可以满足更多的生产需求
很好的满足OCP开放封闭原则
抽象工厂模式中我们可以定义实现不止一个接口，一个工厂也可以生成不止一个产品类 对于复杂对象的生产
相当灵活易扩展

缺点：
扩展产品族相当麻烦 而且扩展产品族会违反OCP,因为要修改所有的工厂
由于抽象工厂模式是工厂方法模式的扩展 总体的来说 很笨重

总结:

简单工厂模式最大的优点就是工厂内有具体的逻辑去判断生成什么产品，将类的实例化交给了工厂，这样当我们需要什么产品只需要修改工厂的调用而不需要去修改客户端，对于客户端来说降低了与具体产品的依赖

工厂方法模式是简单工厂的扩展，工厂方法模式把原先简单工厂中的实现那个类的逻辑判断交给了客户端，如果像添加功能只需要修改客户和添加具体的功能，不用去修改之前的类。

抽象工厂模式进一步扩展了工厂方法模式，它把原先的工厂方法模式中只能有一个抽象产品不能添加产品族的缺点克服了，抽象工厂模式不仅仅遵循了OCP原则，而且可以添加更多产品(抽象产品),具体工厂也不仅仅可以生成单一产品，而是生成一组产品，抽象工厂也是声明一组产品，对应扩展更加灵活，但是要是扩展族系就会很笨重。