设计模式之工厂模式

静态工厂模式

静态工厂方法模式，属于创建型设计模式，但不属于 GOF 提出的 23 种设计模式之一
将创建具体类的过程交给工厂类来实现

1.定义产品接口

public interface Computer {
    void message();
}

2.定义实现接口的不同产品

public class Window  implements Computer{
    @Override
    public void message() {
        System.out.println("window");
    }
}


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

3.在工厂的静态方法中实现产品的创建

public class ComFactory {
    public static Computer getComputer() {
        Computer computer;
        if (System.getProperty("os.name").substring(0, 1).equalsIgnoreCase("w")) {
            computer = new Window();
        } else {
            computer = new Linux();
        }
        return computer;
    }

}

4.测试

public class TestJava {
    public static void main(String[] args) {
        Computer computer = ComFactory.getComputer();
        computer.message();//window
    }
}

工厂方法模式

工厂方法模式是一种创建型设计模式， 其在父类中提供一个创建功能对象的方法， 允许工厂子类决定实例化对象的类型

要素

一是抽象的工厂类，定义抽象的方法，在抽象方法中创建具体的功能对象

二是产品类的接口，根据实现类的不同从而创建不同的产品

抽象工厂类是用于子类继承的，子类继承后要重写其中的创建方法，不同的工厂子类可以生成不同的产品实例对象
产品类的接口是用于实现，不同实现类根据实际的需求编写不同的功能实现

Java示例

1.产品类的接口

public interface Computer {
    void message();
}

2.定义接口的实现类，实现接口方法

// 根据需求的不同的生产不同的产品
public class Window  implements Computer{
    @Override
    public void message() {
        System.out.println("window");
    }
}


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

3.定义抽象工厂类，定义抽象方法，在抽象方法中生成产品对象

public abstract class Factorys {
    public void render(){//调用产品的信息
        Computer computer = createComputer();
        computer.message();
    }
    public abstract Computer createComputer();//创建产品
}

4.定义具体的工厂子类继承工厂类，重写抽象方法，创建具体的产品类对象

public class WinFactory extends Factorys{
    @Override
    public Computer createComputer() {
        return new Window();
    }
}


public class LinFactory extends Factorys{
    @Override
    public Computer createComputer() {
        return new Linux();
    }
}

5.调用
在不同的条件下调用不同的工厂类生成特定的产品对象

public static void main(String[] args) {
        Factorys factorys;
        if (System.getProperty("os.name").substring(0, 1).equalsIgnoreCase("w")) {
            factorys = new WinFactory();
        } else {
            factorys = new LinFactory();
        }
        factorys.render();//window
    }

抽象工厂模式

抽象工厂模式是一种创建型设计模式， 它能创建一系列相关的对象， 而无需指定其具体类
在上述的工厂模式中，一个具体的工厂只能生产特定的某一个产品对象
如果想在一个工厂中生产多个不同的产品就需要使用抽象工厂模式
一个工厂只生产电脑，功能太单一，增加生产对应系统的软件功能

1.不同的产品接口及其产品类

public interface Computer {//第一个产品接口
    void message();
}

public class Window  implements Computer{
    @Override
    public void message() {
        System.out.println("window");
    }
}

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

public interface SoftWare {//第二个产品接口
    void applicable();
}

public class WinSoftWare implements SoftWare{
    @Override
    public void applicable() {
        System.out.println("只适用于Win的软件");
    }
}

public class LinSoftWare implements SoftWare{
    @Override
    public void applicable() {
        System.out.println("只适用于Linux的软件");
    }
}

2.工厂接口及其实现类工厂

public interface Factorys {

    public abstract Computer createComputer();//生产电脑
    public abstract SoftWare createSoftWare();//生产软件
}

public class WinFactory implements Factorys{//生产Win系列的工厂
    @Override
    public Computer createComputer() {
        return new Window();
    }

    @Override
    public SoftWare createSoftWare() {
        return new WinSoftWare();
    }
}

public class LinFactory implements Factorys{//生产Linux系列的工厂
    @Override
    public Computer createComputer() {
        return new Linux();
    }

    @Override
    public SoftWare createSoftWare() {
        return new LinSoftWare();
    }
}

3.测试类

public static void main(String[] args) {
        Factorys factorys;
        if (System.getProperty("os.name").substring(0, 1).equalsIgnoreCase("w")) {
            factorys = new WinFactory();
        } else {
            factorys = new LinFactory();
        }
        render(factorys);
    }

    public static void render(Factorys factorys){
        Computer computer = factorys.createComputer();
        computer.message();//window
        SoftWare softWare = factorys.createSoftWare();
        softWare.applicable();//只适用于Win的软件
        System.out.println("===");//===
    }