【设计模式】工厂模式的实现

内容

工厂模式是一种创建型的设计模式，旨在提供一种创建对象的接口，可以分为三种模式：

简单工厂模式

简单工厂模式通过一个工厂类封装创建对象的逻辑，客户端通过工厂类提供的方法获取对象实例，扩展性较差。

工厂方法模式

工厂方法模式定义一个创建对象的接口，并让子类决定实例化哪一个类，通过一个抽象工厂类和多个具体子类实现，这样可以把创建实例的时机延迟到子类。

抽象工厂模式

抽象工厂模式提供了一个接口，用于创建相关的或者依赖对象的家族，而不需要指定具体的类，通过定义一个工厂接口和多个工厂实现类实现，每个工厂实现类负责创建相关的一组对象

代码示例

实验环境：jdk17

简单工厂模式

public interface Sight {
    /**
     * 获取景点门票数量
     * @return
     */
    Integer getTicketNum();

    /**
     * 获取景点门票价格
     * @return
     */
    Integer getTicketMoney();

}

public class Park implements Sight{
    @Override
    public Integer getTicketNum() {
        return 100;
    }

    @Override
    public Integer getTicketMoney() {
        return 25;
    }
}

public class Square implements Sight{
    @Override
    public Integer getTicketNum() {
        return 200;
    }

    @Override
    public Integer getTicketMoney() {
        return 10;
    }
}

public class SightFactory {
    public static Sight getSight(Integer type) {
        return switch (type) {
            case 0 -> new Park();
            case 1 -> new Square();
            default -> null;
        };
    }
}

public class Client {
    public static void main(String[] args) {
        Sight sight = SightFactory.getSight(1);
        if (sight == null) {
            System.out.println("没有该景点");
        } else {
            System.out.println("票价 = " + sight.getTicketMoney());
            System.out.println("余票 = " + sight.getTicketNum());
        }
    }
}

工厂方法模式

例子为用不同国家的语言打招呼

public interface Language {
    void sayHello();
}

public class English implements Language{
    private final String hello = "hello";


    @Override
    public void sayHello() {
        System.out.println(hello);
    }
}

public class Chinese implements Language {
    private final String hello = "你好";

    @Override
    public void sayHello() {
        System.out.println(hello);
    }
}

public abstract class LanguageFactory {
    public abstract Language createLanguage();

    public void sayHello() {
        Language language = createLanguage();
        System.out.println(language.getClass());
        language.sayHello();
    }
}

public class ChineseFactory extends LanguageFactory {
    @Override
    public Language createLanguage() {
        return new Chinese();
    }
}

public class EnglishFactory extends LanguageFactory {
    @Override
    public Language createLanguage() {
        return new English();
    }
}

public class Client {
    public static void main(String[] args) {
        LanguageFactory factory = new EnglishFactory();
        factory.sayHello();
    }
}

抽象工厂模式

语言翻译，同时输出译文和原文，其中Product类同工厂方法模式

public interface AbstractFactory {
    Language createSrcLanguage();
    Language createTransLanguage();
}

public class CNTOEnFactory implements AbstractFactory{
    @Override
    public Language createSrcLanguage() {
        return new Chinese();
    }

    @Override
    public Language createTransLanguage() {
        return new English();
    }
}

public class EnToCNFactory implements AbstractFactory {
    @Override
    public Language createSrcLanguage() {
        return new English();
    }

    @Override
    public Language createTransLanguage() {
        return new Chinese();
    }
}

public class Client {
    public static void main(String[] args) {
        AbstractFactory factory = new EnToCNFactory();
        Language srcLang = factory.createSrcLanguage();
        Language transLang = factory.createTransLanguage();
        System.out.println("原文：");
        srcLang.sayHello();
        System.out.println("译文：");
        transLang.sayHello();
    }
}

总结

工厂模式的目标是使对象的创建和使用分离，提高系统的灵活性、可维护性、可扩展性。