欢迎观临
路漫漫其修远兮,吾将上下而求索

面向对象设计模式之工厂模式

工厂模式有三类:简单工厂,工厂方法,抽象工厂。复杂度依次递增。

我们先假设有一组产品:

//抽象产品:偶像明星
public interface Idol {
    public void hello();
}
public class BoyIdol implements Idol {
    @Override
    public void hello() {
        System.out.println("I'm a boy!");
    }
}
public class GirlIdol implements Idol {
    @Override
    public void hello() {
        System.out.println("I'm a girl!");
    }
}

1. 简单工厂模式(Simple Factory)

简单工厂不属于23种设计模式之一,只是简单地提供一个类,提供创建函数,根据产品类型创建产品对象。

//简单工厂
public class IdolFactory {
    public static Idol produce(String type) {
        if ("boy".equals(type)) {
            return new BoyIdol();
        } else if ("girl".equals(type)) {
            return new GirlIdol();
        } else {
            System.out.println("请输入正确的类型!");
            return null;
        }
    }
}
// 测试类
public class Test {
    public static void main(String[] args) {
        Idol idol = IdolFactory.produce('boy'); //client调用
        if(idol) {
            idol.hello();
        }
    }
}

2. 工厂方法模式(Factory Method)

简单工厂模式有一个问题就是,类的创建依赖工厂类,也就是说,如果想要拓展程序,必须对工厂类进行修改,这违背了开闭原则,所以,从设计角度考虑,有一定的问题,如何解决?就用到工厂方法模式,创建一个工厂接口,每增加一个具体产品类时,增加对应的具体工厂类,不需要修改之前的代码。但是由于每新增一个新产品时就需要增加两个类,这样势必会导致系统的复杂度增加。

public interface IdolFactory {
    public Idol produce();
}
public interface BoyIdolFactory implements IdolFactory{
    @Override
    public Idol produce() {
        return new BoyIdol();
    }
}
public interface GirlIdolFactory implements IdolFactory{
    @Override
    public Idol produce() {
        return new GirlIdol();
    }
}
// 测试类
public class Test {
    public static void main(String[] args) {
        IdolFactory fac = new GirlIdolFactory(); //client调用
        Idol idol = fac.produce();
        idol.hello();
    }
}

3. 抽象工厂模式(Abstract Factory)

抽象工厂模式是针对多种不同的抽象产品,创建一个工厂接口,根据需要实例化不同的具体工厂类,每种具体工厂类都可以生产一组组合方式不同的具体产品。

//另一类抽象产品: 偶像经纪人
public interface IdolAgent {
    public void hello();
}
public class BoyAgent implements IdolAgent {
    @Override
    public void hello() {
        System.out.println("I can help a boy!");
    }
}
public class GirlAgent implements IdolAgent {
    @Override
    public void hello() {
        System.out.println("I can help a girl!");
    }
}
//我们的抽象工厂
public interface Factory {
    public Idol produceIdol();
    public IdolAgent produceAgent();
}
public class BoyFactory implements Factory {
    @Override
    public Idol produceIdol() {
        return new BoyIdol();
    }
    @Override
    public IdolAgent produceAgent() {
        return new BoyAgent();
    }
}
public class GirlFactory implements Factory {
    @Override
    public Idol produceIdol() {
        return new GirlIdol();
    }
    @Override
    public IdolAgent produceAgent() {
        return new GirlAgent();
    }
}
// 测试类
public class Test {
    public static void main(String[] args) {
        Factory fac = new GirlFactory();  //client调用
        Idol idol = fac.produceIdol();
        Idol agent = fac.produceAgent();
        idol.hello();
        agent.hello();
    }
}
赞(0) 打赏
未经允许不得转载:云海鹰影博客 » 面向对象设计模式之工厂模式
分享到: 更多 (0)

欢迎留言 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏