java设计模式之-工厂模式（静态工厂-工厂方法-抽象工厂）

最新推荐文章于 2024-08-31 18:16:35 发布

CarryBest

最新推荐文章于 2024-08-31 18:16:35 发布

阅读量620

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/CarryBest/article/details/112908519

版权

java 专栏收录该内容

13 篇文章

订阅专栏

静态工厂

用一个工厂类去封装具有相同属性的其他类的new的工厂。这个方法是静态的，称之为静态工厂。

简单例子：AnimalFactory 工厂，里面生产孵化各种动物，都在这一个大工厂里

public interface Animal {
    void getAnimal();
}
class Cat implements Animal {
    @Override
    public void getAnimal() {
        System.out.println("喵喵我是一只猫");
    }
}
class Dog implements Animal {

    @Override
    public void getAnimal() {
        System.out.println("汪汪我是一只狗");
    }
}
class AnimalFactory {
    public static Animal getCat() {
        return new Cat();
    }
    public static Animal getDog() {
        return new Dog();
    }
}
class TestClass {
    public static void main(String[] agrs) {
        Animal animal =AnimalFactory.getCat();
        animal.getAnimal();
        animal =AnimalFactory.getDog();
        animal.getAnimal();
    }
}

优势：

              1：和构造器不同的第一优势在于，它们有名字，更容易知道想要表达的是啥,比如代理模式中生成代理类就是用的静态工厂方法Proxy.newProxyInstance
                  构造器必须是类名：比如  Cat cat =new Cat("小猫")，而静态工厂则不用，一般都后缀instance,比如 MyFactory.newOldCatInstance(),MyFactory.newYoungCatInstance()
              2：不用每次被调用时都创建新对象，减少内存开销，单例的写法也大都是用静态工厂方法来实现的
              3：可以返回原返回类型的子类
              4：可以有多个参数相同但名称不同的工厂方法
              5：可以减少对外暴露的属性，比如上面的狗的年龄必须是1-3岁。

如果是传统的new的方法，很有可能传入一个不符合规则的年龄，无法控制调用方

public interface Animal {
    void getAnimal();
}
class Cat implements Animal {
    @Override
    public void getAnimal() {
        System.out.println("喵喵我是一只猫");
    }
}
class Dog implements Animal {
    String dogType;
    int dogAge;
    public Dog(int dogAge, String dogType) {
        this.dogAge = dogAge;
        this.dogType = dogType;
    }
    @Override
    public void getAnimal() {
        System.out.println("汪汪我是一只狗" + dogType);
    }
}
class AnimalFactory {
    private static final int ONE_YEARS_OLD = 1;
    private static final int TWO_YEARS_OLD = 2;
    private static final int THREE_YEARS_OLD = 3;
    public static Animal getCat() {
        return new Cat();
    }
    //#########对应上面的优点1、3、4 但无法保证调用方对age输入的限制  START###########
    public static Animal getDogHsq(int age) {
        return new Dog(age, "我是哈士奇");
    }
    public static Animal getDogHsq(String dogType) {
        return new Dog(ONE_YEARS_OLD, dogType);
    }
    //#########对应上面的优点1、3、4   END###########
    //#########对应上面的优点5  START###########
    public static Animal getDogYearsOld(String dogType) {
        return new Dog(ONE_YEARS_OLD, dogType);
    }
    public static Animal getDogYearsOld2(String dogType) {
        return new Dog(TWO_YEARS_OLD, dogType);
    }
    //#########对应上面的优点5   END###########
}

想要啥动物，就继承一下Animal，直接工厂获取就行

缺点：

类的创建依赖工厂类，想要拓展业务需要修改工厂类，比如你想在搞一个小鸟出来，得修改AnimalFactory.java

工厂方法模式：

设计一个工厂的接口，你想要什么东西，就写个类继承于这个工厂，就好比上面的动物工厂，此时这个工厂规范化了，生产狗的新建一个车间小工厂，生产猫的新建一个车间小工厂....................

//省略上面的相关代码
//省略上面的相关代码
interface AnimalFactory{
    Animal getAnimalByFactory();
}
class DogFactory implements AnimalFactory{
    @Override
    public Animal getAnimalByFactory() {
        return  new Dog();
    }
}
class CatFactory implements AnimalFactory{
    @Override
    public Animal getAnimalByFactory() {
        return  new Cat();
    }
}

class TestClass {
    public static void main(String[] agrs) {
        Animal animal =new CatFactory().getAnimalByFactory();
        animal.getAnimal();
        animal =new DogFactory().getAnimalByFactory();
        animal.getAnimal();
    }
}

如果再想生产鸟，只需要开启一个生产鸟的车间小工厂继承大工厂即可，这个大工厂是不需要动的。

缺点：

如果此时我不仅想生产动物，我想生产口罩了咋办？那么就得在AnimalFactory接口里增加 Mask getMaskByFactory,那么这样每个车间小工厂都会多出一个屋来生产口罩（因为都是同一个接口），但是其他车间小工厂是无法生产口罩的，无法在生产狗的车间小工厂生产其他物品，因为大工厂是AnimalFactory。也就是说工厂方法模式只适合来生产同一类产品。

interface AnimalFactory{
Animal getAnimalByFactory();

Mask getMaskByFactory();
}

抽象工厂模式

把大工厂分成2类子工厂，一个是Linda的工厂，有2个车间，负责生产狗和白口罩，一个是crry的工厂，有2个车间，负责生产猫和黑口罩。

如果想在生产汽车，那么就新建一个join工厂。

此时有3个子工厂：Linda的工厂，3个车间，负责生产狗和白口罩和汽车。carry的工厂，3个车间，负责生产猫和黑口罩和汽车。join工厂，3个车间，一个生产汽车，其他2个随意。

因为他们都在大工厂Factory里的，所以再开辟其他工厂很简单。工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

动物接口及实现类

public interface Animal {
    void getAnimal();
}

class Cat implements Animal {
    @Override
    public void getAnimal() {
        System.out.println("喵喵我是一只猫");
    }
}

class Dog implements Animal {

    @Override
    public void getAnimal() {
        System.out.println("汪汪我是一只狗");
    }
}

口罩接口及实现类

interface Mask {
    void getMask();
}

class BlackMask implements Mask {
    @Override
    public void getMask() {
        System.out.println("我是一个黑口罩");
    }
}

class WhiteMask implements Mask {

    @Override
    public void getMask() {
        System.out.println("我是一个白口罩");
    }
}

生产动物和口罩的接口

interface Factory {
    Animal getAnimalByFactory();
    Mask getMaskByFactory();
}

生产动物和口罩的实现类

class FactoryOfLinda implements Factory {

    @Override
    public Animal getAnimalByFactory() {
        return new Dog();
    }
    @Override
    public Mask getMaskByFactory() {
        return new BlackMask();
    }
}

class FactoryOfCarry implements Factory {

    @Override
    public Animal getAnimalByFactory() {
        return new Cat();
    }
    @Override
    public Mask getMaskByFactory() {
        return new WhiteMask();
    }
}

调用

class TestClass {
    public static void main(String[] agrs) {
        // linda 想生产一只狗
        Factory factory = new FactoryOfLinda();
        Animal animal = factory.getAnimalByFactory();
        animal.getAnimal();
        // carry想生产一只猫 只需要改动把FactoryOfLinda 换成FactoryOfCarry即可
        factory = new FactoryOfCarry();
        animal = factory.getAnimalByFactory();
        animal.getAnimal();

        // linda 想生产一个口罩
        factory = new FactoryOfLinda();
        Mask mask = factory.getMaskByFactory();
        mask.getMask();
    }
}