自学内容网 自学内容网
自学内容网 > 正文

设计模式之---工厂模式

🕗 发布于 2024-10-11 10:59 设计模式  java  开发语言  

设计模式–工厂模式

一 什么是工厂模式

使用工厂模式是为了将创建对象的具体过程屏蔽隔离起来 快速的将对象实例化 从而提高了代码的灵活性和改善了简洁性，工厂模式具体分为以下三类：

1 简单工厂模式（Simple Factory）

2 工厂方法模式（Factory Method）

3 抽象工厂模式（Abstract Factory）

三种模式从上到下逐渐变得抽象，但主要可以分为工厂方法模式和抽象工厂模式，而简单工厂模式则可以看为工厂方法模式中一个特别的案例，两者归为一类，我们先举一个例子对工厂模式做一个初步的了解

1 从前世上并没有工厂，如果客户想要一辆大众车，则需要为客户制造一辆大众车

2 简单工厂模式: 后来出现了工厂，用户不需要再去制造大众车，由工厂进行制造，想要什么车直接发给工厂制造就可以了，比如要制造帕萨特系列的车，工厂就制造这个系列的车

3 工厂方法模式：为了满足客户的需求，大众车的系列越来越多，如帕萨特，高尔夫等系列，一个工厂只能制造一个系列，所以又分为多个制造不同系列的工厂，每个具体工厂制造一个系列的车，但是大众工厂只是一个抽象的，你还需要实现具体的工厂才可以制造对应系列的车辆

4 抽象工厂模式：随着客户的要求越来越高，大众车必须配置显示屏，于是这个工厂开始生产对应系列的显示屏的车，最终客户只需要说：我想要配备小米显示屏的大众车，工厂就直接生产相应的车辆了。

下面针对几种不同的工厂模式进行详细的说明：

二 简单工厂模式

简单工厂模式的核心是定义一个创建对象的接口，将对象的创建和本身的业务逻辑分离，降低系统的耦合度，使得两个修改起来相对容易些，当以后实现改变时，只需要修改工厂类即可。

代码实现：

动物类：

public class Animal {
    public Animal(){}
}

class Cat extends Animal{
    public Cat(){
        System.out.println("您领养了一只猫");
    }
}

class Dog extends Animal{
    public Dog(){
        System.out.println("您领养了一只狗");
    }
}

class Tiger extends Animal{
    public Tiger(){
        System.out.println("您领养了一只老虎");
    }
}


一只老虎");
    }
}

工厂类：

public class AnimalFactory {
    public Animal createAnimal(String animal){
        switch (animal){
            case "dog":
                return new Dog();
            case "cat":
                return new Cat();
            case "tiger":
                return new Tiger();
                default:
                    break;
        }
        return null;
    }
//用户端
    public static void main(String[] args) {
        AnimalFactory af = new AnimalFactory();
        Animal dog = af.createAnimal("dog");
        Animal cat = af.createAnimal("cat");
        Animal tiger = af.createAnimal("tiger");
    }
}

三 工厂方法模式

工厂方法模式将工厂抽象化，并定义一个创建对象的接口。每增加新产品，只需增加该产品以及对应的具体实现工厂类，由具体工厂类决定要实例化的产品是哪个，将对象的创建与实例化延迟到子类，这样工厂的设计就符合“开闭原则”了，扩展时不必去修改原来的代码。
但缺点在于，每增加一个产品都需要增加一个具体产品类和实现工厂类，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

代码实现：

动物类：

public class Animal {
    public Animal(){}
}

class Cat extends Animal{
    public Cat(){
        System.out.println("您领养了一只猫");
    }
}

class Dog extends Animal{
    public Dog(){
        System.out.println("您领养了一只狗");
    }
}

class Tiger extends Animal{
    public Tiger(){
        System.out.println("您领养了一只老虎");
    }
}

工厂类：

public interface AnimalFactory {
    Animal createAnimal();
}

class CatFactory implements AnimalFactory{
    @Override
    public Animal createAnimal() {
        return new Cat();
    }
}

class DogFactory implements AnimalFactory{
    @Override
    public Animal createAnimal() {
        return new Dog();
    }
}

class TigerFactory implements AnimalFactory{
    @Override
    public Animal createAnimal() {
        return new Tiger();
    }
}

客户类：

public class Customer {
    public static void main(String[] args) {
        CatFactory catFactory = new CatFactory();
        catFactory.createAnimal();
        DogFactory dogFactory = new DogFactory();
        dogFactory.createAnimal();
    }
}

四 抽象工厂模式

在工厂方法模式中，我们使用一个工厂创建一个产品，一个具体工厂对应一个具体产品，但有时候我们需要一个工厂能够提供多个产品对象，而不是单一的对象，这个时候我们就需要使用抽象工厂模式。
在介绍抽象工厂模式前，我们先厘清两个概念：

产品等级结构：产品等级结构指的是产品的继承结构，比如一个狗粮抽象类，它有A品牌狗粮、B品牌狗粮等一系列的子类，那么这个狗粮抽象类和他的子类就构成了一个产品等级结构。
产品族：产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如，狗咖生产狗粮和狗绳，那么狗狗粮则位于狗粮产品族中。

什么是抽象工厂模式？

抽象工厂模式主要用于创建相关对象的家族。当一个产品族中需要被设计在一起工作时，通过抽象工厂模式，能够保证客户端始终只使用同一个产品族中的对象；并且通过隔离具体类的生成，使得客户端不需要明确指定具体生成类；所有的具体工厂都实现了抽象工厂中定义的公共接口，因此只需要改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。
但该模式的缺点在于添加新的行为时比较麻烦，如果需要添加一个新产品族对象时，需要更改接口及其下所有子类，这必然会带来很大的麻烦。

代码实现：

产品类：

public interface Food {
}

class DogFood implements Food{
    public DogFood(){
        System.out.println("生产狗粮");
    }
}

class CatFood implements Food{
    public CatFood(){
        System.out.println("生产猫粮");
    }
}
interface Tool{

}

class DogTool implements Tool{
    public DogTool(){
        System.out.println("生产养狗工具");
    }
}

class CatTool implements Tool{
    public CatTool(){
        System.out.println("生产养猫工具");
    }
}

工厂类：

public interface AnimalFactory {
    public Food createFood();
    public Tool createTool();
}

class CatFactory implements AnimalFactory{
    @Override
    public Food createFood() {
        return new CatFood();
    }

    @Override
    public Tool createTool() {
        return new CatTool();
    }
}

class DogFactory implements AnimalFactory{
    @Override
    public Food createFood() {
        return new DogFood();
    }

    @Override
    public Tool createTool() {
        return new DogTool();
    }
}

用户类：

public class Customer {
    public static void main(String[] args) {
        CatFactory catFactory = new CatFactory();
        catFactory.createFood();
        catFactory.createTool();
        DogFactory dogFactory = new DogFactory();
        dogFactory.createFood();
        dogFactory.createTool();
    }
}

五 工厂模式小结

工厂方法模式与抽象方法模式的区别在于：

  • 工厂方法模式只有一个抽象产品类和抽象工厂类，但可以派生出许多具体的产品类和工厂类，每个具体的产品类和工厂类只能创建一个具体的实例

  • 抽象工厂模式具有多个抽象产品类和一个抽象工厂类，每个抽象产品类可以派生出来多个具体的产品类，抽象工厂类也可以派生出许多个具体的工厂类，同时每个具体的工厂类也可以创建出多个产品类的实例


原文地址：https://blog.csdn.net/Arguan_/article/details/142830792

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2024