JAVA语言之工厂设计模式

1.简单工厂模式:专门定义一个类用来创建其他类的实例,被创建的实例通常有共同的父亲

对应代码介绍如下:

import java.util.Scanner;

interface Computer{
    public void printComputer();
}
class MacbookComputer implements Computer{
    public void printComputer(){
        System.out.println("这是MAC");
    }
}
class SurfbookComputer implements Computer{
    public void printComputer(){
        System.out.println("这是Surf");
    }
}
class ComputerFactory{
    public static Computer getInstance(String type){
       Computer computer = null;
       if(type.equals("mac")){
           computer = new MacbookComputer();
       }else if(type.equals("surf")){
           computer = new SurfbookComputer();
       }
       return computer;
    }
}
public class Test {
    public void buyComputer(Computer computer){
        computer.printComputer();
    }
    public static  void  main(String[] args) {
       Test test = new Test();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要的电脑型号:");
        String type = sc.nextLine();
        Computer computer = ComputerFactory.getInstance(type);
        test.buyComputer(computer);
    }
}

优点:易于实现;把实例化交给工厂,易于解耦

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

2.工厂方法模式:定义一个用来创建对象的接口,让子类决定实例化哪一个类,让子类决定实例化延迟子类

对应代码介绍如下:

interface Computer{
    public void printComputer();
}
class MacbookComputer implements Computer{
    public void printComputer(){
        System.out.println("这是MAC");
    }
}
class SurfbookComputer implements Computer{
    public void printComputer(){
        System.out.println("这是Surf");
    }
}
interface  ComputerFactory{
    Computer createComputer();
}
class MsFactory implements ComputerFactory{
    public Computer  createComputer(){
        return new MacbookComputer();
    }
}
class AppFactory implements ComputerFactory{
    public Computer createComputer(){
        return new SurfbookComputer();
    }
}
public class Test {
    public void buyComputer(Computer computer){
        computer.printComputer();
    }
    public static  void  main(String[] args) {
       Test test = new Test();
       ComputerFactory factory = new MsFactory();
       test.buyComputer(factory.createComputer());
    }
}

优点:降低了代码的耦合度,对象的生成交给子类完成;实现了开放封闭原则,每次增加子类不需要修改原来代码.

缺点:增加了代码量, 每个具体产品都需要一个具体工厂;增加抽象产品时,需要修改工厂,违背ocp

3.抽象工厂模式:提供一个创建一系列相关或相互依赖的对象的接口,无需指定具体的类

对应代码介绍如下:

interface Computer{
    public void printComputer();
}
class MacbookComputer implements Computer{
    public void printComputer(){
        System.out.println("这是MAC");
    }
}
class SurfbookComputer implements Computer{
    public void printComputer(){
        System.out.println("这是Surf");
    }
}
interface OperatingSystem{
    void printSystem();
}
class MacSystem implements OperatingSystem{
    public void printSystem(){
        System.out.println("这是 MAC OS");
    }
}
class WindowsSystem implements OperatingSystem{
    @Override
    public void printSystem() {
        System.out.println("这是 Windows8 ");
    }
}
interface  ProduceFactory{
    Computer createComputer();
    OperatingSystem  createSystem();
}
class MsFactory implements ProduceFactory{
    public Computer createComputer(){
        return new MacbookComputer();
    }
    public OperatingSystem createSystem(){
        return new MacSystem();
    }
}
class AppFactory implements ProduceFactory{
    public Computer createComputer(){
        return new SurfbookComputer();
    }
    public OperatingSystem createSystem(){
        return new WindowsSystem();
    }
}
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();
       ProduceFactory factory = new AppFactory();
       Computer computer = factory.createComputer();
       OperatingSystem system = factory.createSystem();
       test.buyComputer(computer);
       test.use(system);
    }
}

优点:代码解耦;实现多个产品族;满足OCP开放封闭原则;

缺点:扩展产品族相当麻烦,违反OCP;笨重