设计模式——19. 访问者模式

最新推荐文章于 2024-10-10 21:34:07 发布
最新推荐文章于 2024-10-10 21:34:07 发布
阅读量444 收藏 2
点赞数 1
分类专栏： 设计模式大全 文章标签： 设计模式 访问者模式 java python golang c++ javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guohuang/article/details/133783114
版权

1. 说明

访问者模式（Visitor Pattern）是一种行为型设计模式，它允许你在不改变元素类（被访问者）的前提下，定义对元素的新操作（访问者），并将这些操作封装到独立的访问者类中。这样，你可以在不修改被访问者的类的情况下，通过不同的访问者来执行不同的操作。
访问者模式的主要目的是将数据结构和数据操作分离，使得可以在不修改数据结构的情况下，添加新的操作。这对于复杂的数据结构和多种不同的操作场景非常有用。它提供了一种可扩展性强的方式来处理各种数据结构和操作的组合。
访问者模式通常包含以下几个关键角色：

  1. 访问者（Visitor）：定义了访问被访问者元素的方法，通常为每一种被访问的元素类型定义一个访问方法。
  2. 具体访问者（Concrete Visitor）：实现了访问者接口中定义的方法，即针对每种被访问的元素类型提供了具体的操作逻辑。
  3. 被访问者（Element）：定义了一个接受访问者的方法，通常是 accept(Visitor visitor)，用于接收访问者的访问。
  4. 具体被访问者（Concrete Element）：实现了被访问者接口中的 accept 方法，将自身传递给访问者，使访问者能够访问自身。
  5. 结构对象（Object Structure）：包含了多个被访问者，可以遍历这些被访问者，并将访问者应用到它们身上。

访问者模式的优点包括了支持新的操作扩展而无需修改元素类，以及将相关操作封装在独立的访问者类中，使代码更加清晰和易于维护。然而，它也会导致访问者类的数量增加，增加了系统的复杂性。因此，访问者模式适用于那些需要频繁添加新操作而不希望修改现有类的情况。

2. 使用的场景

访问者模式在以下情况下通常很有用：

  1. 需要对复杂对象结构进行操作和遍历：当你有一个复杂的对象结构，其中包含不同类型的元素，并且你需要对这些元素执行各种不同的操作，访问者模式可以将操作和元素解耦，使得操作能够轻松应用于整个对象结构。
  2. 不希望修改现有元素类：如果你不想修改已经存在的元素类，但需要为这些类添加新的操作，访问者模式是一种有效的方式。你可以通过创建新的访问者类来添加新的操作，而无需修改已存在的元素类。
  3. 支持多种不同的操作：当你需要为对象结构添加多个不同的操作，这些操作可能是不断变化和扩展的，访问者模式可以让你更容易地管理和扩展这些操作。
  4. 数据结构和算法分离：访问者模式将数据结构和数据操作分离开来，使得数据结构可以专注于数据的表示，而操作可以专注于数据的处理。这样有助于保持代码的清晰和可维护性。
  5. 分布式操作：当你需要在对象结构的元素上执行分布在多个类中的操作时，访问者模式可以用于将这些操作组织起来，并在需要时轻松添加新的操作。

总之，访问者模式适用于需要对复杂对象结构进行多种不同操作，且这些操作可能会不断变化和扩展的情况。它提供了一种灵活的方式来处理这些情况，同时保持代码的可维护性和可扩展性。

3. 应用例子

下面是一个使用Python实现的访问者模式的简单例子，我们将创建一个动物园的模拟，其中有不同种类的动物，我们将使用访问者模式来访问并执行不同的操作：

# 抽象访问者
class Visitor:
    def visit_dog(self, dog):
        pass

    def visit_cat(self, cat):
        pass


# 具体访问者
class AnimalSoundVisitor(Visitor):
    def visit_dog(self, dog):
        print(f"The dog makes a sound: {dog.sound}")

    def visit_cat(self, cat):
        print(f"The cat makes a sound: {cat.sound}")


# 抽象被访问者
class Animal:
    def accept(self, visitor):
        pass


# 具体被访问者
class Dog(Animal):
    def __init__(self):
        self.sound = "Woof!"

    def accept(self, visitor):
        visitor.visit_dog(self)


class Cat(Animal):
    def __init__(self):
        self.sound = "Meow!"

    def accept(self, visitor):
        visitor.visit_cat(self)


# 对象结构
class Zoo:
    def __init__(self):
        self.animals = []

    def add_animal(self, animal):
        self.animals.append(animal)

    def perform_operation(self, visitor):
        for animal in self.animals:
            animal.accept(visitor)


if __name__ == "__main__":
    zoo = Zoo()
    zoo.add_animal(Dog())
    zoo.add_animal(Cat())

    sound_visitor = AnimalSoundVisitor()
    zoo.perform_operation(sound_visitor)

在这个示例中，我们创建了两个具体被访问者类 Dog 和 Cat，它们都实现了 accept 方法，以便接受访问者的访问。我们还创建了一个具体访问者类 AnimalSoundVisitor，它实现了对不同动物对象的访问操作。
Zoo 类是对象结构，它包含了多个被访问者动物对象，并提供了 perform_operation 方法来接受访问者的访问。

当我们运行这个示例时，AnimalSoundVisitor 将访问动物对象并执行不同的操作，输出每种动物的声音。这展示了如何使用访问者模式来在不修改动物类的情况下添加新的操作。

4. 实现要素

访问者模式的实现要素包括以下几个关键组件：

  1. 抽象访问者（Visitor）：定义了访问被访问者元素的方法，通常为每一种被访问的元素类型定义一个访问方法。
  2. 具体访问者（Concrete Visitor）：实现了访问者接口中定义的方法，即针对每种被访问的元素类型提供了具体的操作逻辑。
  3. 抽象被访问者（Element）：定义了一个接受访问者的方法，通常是 accept(Visitor visitor)，用于接收访问者的访问。
  4. 具体被访问者（Concrete Element）：实现了被访问者接口中的 accept 方法，将自身传递给访问者，使访问者能够访问自身。
  5. 对象结构（Object Structure）：包含了多个被访问者，可以遍历这些被访问者，并将访问者应用到它们身上。

5. Java/golang/javascrip/C++ 等语言实现方式

5.1 Java实现

上述例子用Java语言实现示例如下：

// 抽象访问者
interface Visitor {
    void visit(Dog dog);
    void visit(Cat cat);
}

// 具体访问者
class AnimalSoundVisitor implements Visitor {
    @Override
    public void visit(Dog dog) {
        System.out.println("The dog makes a sound: " + dog.getSound());
    }

    @Override
    public void visit(Cat cat) {
        System.out.println("The cat makes a sound: " + cat.getSound());
    }
}

// 抽象被访问者
interface Animal {
    void accept(Visitor visitor);
}

// 具体被访问者
class Dog implements Animal {
    private String sound = "Woof!";

    public String getSound() {
        return sound;
    }

    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

class Cat implements Animal {
    private String sound = "Meow!";

    public String getSound() {
        return sound;
    }

    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

// 对象结构
class Zoo {
    private List<Animal> animals = new ArrayList<>();

    public void addAnimal(Animal animal) {
        animals.add(animal);
    }

    public void performOperation(Visitor visitor) {
        for (Animal animal : animals) {
            animal.accept(visitor);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Zoo zoo = new Zoo();
        zoo.addAnimal(new Dog());
        zoo.addAnimal(new Cat());

        AnimalSoundVisitor soundVisitor = new AnimalSoundVisitor();
        zoo.performOperation(soundVisitor);
    }
}

在上述示例中，我们使用Java编程语言实现了访问者模式。类似于Python示例，我们定义了抽象访问者接口（Visitor）以及具体访问者类（AnimalSoundVisitor），并实现了访问不同动物对象的方法。

具体的被访问者类（Dog 和 Cat）实现了accept方法，以接受访问者的访问。Zoo 类是对象结构，包含多个被访问者动物对象，并提供了 performOperation 方法来接受访问者的访问。
在 main 方法中，我们创建了动物对象，将它们添加到动物园中，并创建了一个 AnimalSoundVisitor 实例来执行访问操作。运行程序后，将输出不同动物的声音。这演示了如何使用访问者模式来添加新的操作而无需修改现有动物类。

5.2 Golang实现

上述例子用golang实现示例如下：

package main

import "fmt"

// 抽象访问者
type Visitor interface {
        VisitDog(dog *Dog)
        VisitCat(cat *Cat)
}

// 具体访问者
type AnimalSoundVisitor struct{}

func (v *AnimalSoundVisitor) VisitDog(dog *Dog) {
        fmt.Printf("The dog makes a sound: %s\n", dog.GetSound())
}

func (v *AnimalSoundVisitor) VisitCat(cat *Cat) {
        fmt.Printf("The cat makes a sound: %s\n", cat.GetSound())
}

// 抽象被访问者
type Animal interface {
        Accept(visitor Visitor)
}

// 具体被访问者
type Dog struct {
        sound string
}

func NewDog() *Dog {
        return &Dog{sound: "Woof!"}
}

func (d *Dog) GetSound() string {
        return d.sound
}

func (d *Dog) Accept(visitor Visitor) {
        visitor.VisitDog(d)
}

type Cat struct {
        sound string
}

func NewCat() *Cat {
        return &Cat{sound: "Meow!"}
}

func (c *Cat) GetSound() string {
        return c.sound
}

func (c *Cat) Accept(visitor Visitor) {
        visitor.VisitCat(c)
}

// 对象结构
type Zoo struct {
        animals []Animal
}

func (z *Zoo) AddAnimal(animal Animal) {
        z.animals = append(z.animals, animal)
}

func (z *Zoo) PerformOperation(visitor Visitor) {
        for _, animal := range z.animals {
                animal.Accept(visitor)
        }
}

func main() {
        zoo := &Zoo{}
        zoo.AddAnimal(NewDog())
        zoo.AddAnimal(NewCat())

        soundVisitor := &AnimalSoundVisitor{}
        zoo.PerformOperation(soundVisitor)
}

在这个示例中，我们使用Go语言实现了访问者模式。与前面的示例类似，我们定义了抽象访问者接口（Visitor），具体访问者类（AnimalSoundVisitor），以及抽象被访问者接口（Animal）和具体被访问者类（Dog 和 Cat）。然后，我们创建了对象结构 Zoo，将动物对象添加到动物园中，并使用 PerformOperation 方法执行访问操作。

在 main 函数中，我们创建了动物对象，将它们添加到动物园中，并创建了一个 AnimalSoundVisitor 实例来执行访问操作。运行程序后，将输出不同动物的声音。这演示了如何使用访问者模式来添加新的操作而无需修改现有动物类。

5.3 Javascript实现

上述例子用javascript实现示例如下：

// 抽象访问者
class Visitor {
  visitDog(dog) {}
  visitCat(cat) {}
}

// 具体访问者
class AnimalSoundVisitor extends Visitor {
  visitDog(dog) {
    console.log(`The dog makes a sound: ${dog.getSound()}`);
  }

  visitCat(cat) {
    console.log(`The cat makes a sound: ${cat.getSound()}`);
  }
}

// 抽象被访问者
class Animal {
  accept(visitor) {}
}

// 具体被访问者
class Dog extends Animal {
  constructor() {
    super();
    this.sound = "Woof!";
  }

  getSound() {
    return this.sound;
  }

  accept(visitor) {
    visitor.visitDog(this);
  }
}

class Cat extends Animal {
  constructor() {
    super();
    this.sound = "Meow!";
  }

  getSound() {
    return this.sound;
  }

  accept(visitor) {
    visitor.visitCat(this);
  }
}

// 对象结构
class Zoo {
  constructor() {
    this.animals = [];
  }

  addAnimal(animal) {
    this.animals.push(animal);
  }

  performOperation(visitor) {
    for (const animal of this.animals) {
      animal.accept(visitor);
    }
  }
}

// 创建动物园和动物
const zoo = new Zoo();
zoo.addAnimal(new Dog());
zoo.addAnimal(new Cat());

const soundVisitor = new AnimalSoundVisitor();
zoo.performOperation(soundVisitor);

在这个示例中，我们使用JavaScript语言实现了访问者模式。我们定义了抽象访问者类 Visitor 和具体访问者类 AnimalSoundVisitor，以及抽象被访问者类 Animal 和具体被访问者类 Dog 和 Cat。然后，我们创建了对象结构 Zoo，将动物对象添加到动物园中，并使用 performOperation 方法执行访问操作。

在示例的最后部分，我们创建了动物园和动物对象，并执行了访问操作，输出不同动物的声音。这演示了如何使用访问者模式来添加新的操作而无需修改现有动物类。

5.4 C++实现

上述例子用C++实现如下：

#include <iostream>
#include <vector>

// 前置声明
class Dog;
class Cat;

// 抽象访问者
class Visitor {
public:
    virtual void visit(Dog* dog) = 0;
    virtual void visit(Cat* cat) = 0;
};

// 具体访问者
class AnimalSoundVisitor : public Visitor {
public:
    void visit(Dog* dog) override {
        std::cout << "The dog makes a sound: " << dog->getSound() << std::endl;
    }

    void visit(Cat* cat) override {
        std::cout << "The cat makes a sound: " << cat->getSound() << std::endl;
    }
};

// 抽象被访问者
class Animal {
public:
    virtual void accept(Visitor* visitor) = 0;
};

// 具体被访问者
class Dog : public Animal {
private:
    std::string sound = "Woof!";

public:
    std::string getSound() {
        return sound;
    }

    void accept(Visitor* visitor) override {
        visitor->visit(this);
    }
};

class Cat : public Animal {
private:
    std::string sound = "Meow!";

public:
    std::string getSound() {
        return sound;
    }

    void accept(Visitor* visitor) override {
        visitor->visit(this);
    }
};

// 对象结构
class Zoo {
private:
    std::vector<Animal*> animals;

public:
    void addAnimal(Animal* animal) {
        animals.push_back(animal);
    }

    void performOperation(Visitor* visitor) {
        for (Animal* animal : animals) {
            animal->accept(visitor);
        }
    }
};

int main() {
    Zoo zoo;
    zoo.addAnimal(new Dog());
    zoo.addAnimal(new Cat());

    AnimalSoundVisitor soundVisitor;
    zoo.performOperation(&soundVisitor);

    return 0;
}

在这个示例中，我们使用C++语言实现了访问者模式。我们定义了抽象访问者类 Visitor 和具体访问者类 AnimalSoundVisitor，以及抽象被访问者类 Animal 和具体被访问者类 Dog 和 Cat。然后，我们创建了对象结构 Zoo，将动物对象添加到动物园中，并使用 performOperation 方法执行访问操作。

在 main 函数中，我们创建了动物园和动物对象，并执行了访问操作，输出不同动物的声音。这演示了如何使用访问者模式来添加新的操作而无需修改现有动物类。

6. 练习题

考虑一个图书馆管理系统，其中包括不同类型的图书（例如，小说、非小说、杂志等）。每种类型的图书都有不同的属性和操作。使用访问者模式来实现一个报表生成器，该报表生成器可以根据不同类型的图书生成不同的报表。

要求：

  1. 定义一个抽象访问者类 Visitor，其中包括用于访问不同类型的图书的抽象方法（例如，visitNovel、visitMagazine等）。
  2. 定义具体访问者类 ReportGenerator，该类实现了抽象访问者类中的方法，用于生成不同类型图书的报表。
  3. 定义一个抽象图书类 Book，其中包括图书的通用属性和一个抽象方法 accept，用于接受访问者的访问。
  4. 定义具体图书类，如 Novel、NonFiction、Magazine，它们继承自抽象图书类，并实现了 accept 方法，以便接受 ReportGenerator 访问。
  5. 创建一个图书馆类，该类包含图书的集合，并提供方法来添加不同类型的图书。
  6. 在主程序中，创建图书馆对象，添加不同类型的图书，并使用 ReportGenerator 来生成报表。

你可以使用 C++、Java、Python 或任何其他编程语言来实现这个练习。
你可以在评论区里或者私信我回复您的答案，这样我或者大家都能帮你解答，期待着你的回复~

guohuang
关注
专栏目录
java 观察者模式类图_设计模式——观察者模式
weixin_33788424的博客
02-25 2807
生活中，许多事物不是单独存在的，其中一个事物发生变化可能会导致一个或多个其他事物的行为也发生变化。例如：公众号的博主与用户之间(每当推送一篇文章，我们就能被动的接收到一篇文章，前提是你关注了它)。在软件设计中也是一样，例如：MVC 模式中的模型与视图的关系。此类场景使用观察者模式来实现的话，就非常方便。一、观察者模块的定义与优缺点观察者模式(Observer Pattern)：定义对象间的一种一对...
设计模式-访问者模式
希望能帮助大家，希望大家多多支持，你们的支持是我前进的动力。
03-07 449
访问者模式结构图 意图：主要将数据结构与数据操作分离。 主要解决：稳定的数据结构和易变的操作耦合问题。 其中： Visitor（访问者） 为该对象结构中ConcreteElement的每一个类声明一个Visit操作。该操作的名字和特征标识了发送Visit请求给该访问者的那个类，这使得访问者可以确定正被访问的元素的具体的类。这样访问者就可以通过该元素的特定接口直接访问它。 Conc...
设计模型之Visitor模式-图书馆管理系统应用C++实现
zjjtilm的博客
04-04 669
今天看到<<软件设计师>>面向对象第七章讲到几种设计模式，其中一种为Visitor模式。这种设计模式通过访问者对象的建立，在访问过程中将访问者作为参数传到被访问对象的函数中，实现了有选择性的访问不同类的资源。 其中有一个Visitor模式设计的应用，参考书中的代码，在本地测试跑了一下。 // // library_visitor.cpp // data_structure /*某图书管理系统中管理者两种类型的文献:图书和论文。现在要求统计所有馆藏文献的总页码(假设图书馆中有
Visitor（访问者）示例
qq_25927437的博客
02-15 954
示例： 某图书馆里系统中管理着两种类型的文献：图书和论文。现在要求统计所有馆藏文献的总页码（假设图书馆中有一本540页的图书和两篇个25页的论文，那么馆藏文献的总页码就是590页）。适合采用Visitor模式实现该要求。   Java程序如下： public interface LibraryVisitor {     void visit(Book p_book);     void...
津津乐道设计模式 - 访问者模式详解（以图书馆系统举例带你快速了解）
傲泣龙腾的博客
06-29 5953
本章节主要介绍了访问者模式、访问者模式适用场景、访问者模式的优缺点，并以图书馆系统举例模访问者模式的使用方法，如果本文对你有用，欢迎关注收藏评论，后续将陆续推出贴切生活的搞笑讲解方式带大家一起学编程～
设计模式之访问者模式（Java实现）
qq_46234643的博客
06-23 309
访问者模式
设计模式行为型——访问者模式
tszc95的博客
08-09 2247
访问者模式（Visitor Pattern）属于行为型设计模式，它允许在不修改现有对象结构的前提下，定义对这些对象执行操作的新操作。访问者模式将数据结构和操作分离，使得操作可以独立变化。访问者模式基本思想是，针对系统中拥有固定类型数的对象结构（元素），在其内提供一个 accept()方法来接受访问者对象的访问。不同的访问者对同一个元素的访问内容是不同，使得相同的元素集合可以产生不同的数据结果。
Java设计模式——GoF设计模式
weixin_40587145的博客
03-24 2260
一、GoF设计模式简介 本节内容参考《Java设计模式》@刘伟 编著，清华大学出版社出版，设计模式详解请参考原书。 1.GoF 的 23 种模式一览表 范围/目的 创建型模式 结构型模式 行为型模式 类模式 工厂方法模式 （类）适配器模式 解释器模式 模板方法模式 对象模式 抽象工厂模式 建造者模式 原型模式 单例模式 （对象）适配器模式 桥接模式 组合模式
设计模式第19讲——命令模式（Command）
让~学习~成为一种习惯（橡 皮 人の技术博客）
06-30 8937
命令模式（Command Pattern）是一种行为型设计模式，又叫动作模式或事务模式。一、什么是命令模式 二、角色组成 三、优缺点 四、应用场景 4.1 生活场景4.2 java场景五、代码实现5.0 UML类图 5.1 抽象命令（Command）——Command5.2接收者（Receiver）——Chef5.3具体命令（Concrete Command）——OrderCommand六、总结
java设计模式——代理模式
u014627852的博客
06-27 688
代理模式(Proxy)基本介绍 代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。 被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象 代理模式有不同的形式,主要有三种静态代理、动态代理 (JDK代理、接口代理)和 Cglib代理 (可以在内存动态的创建对象，而不需要实现接口，他是属于动态代理的范畴)。 代理模式示意图 静态代理 静态代理在使用时,需要定义接口
设计模式代码——c#
04-07
C#设计模式(23种设计模式) 1. 单件模式(Singleton Pattern) 2. 抽象工厂（Abstract Factory） 3. 建造者模式(Builder) 4. 工厂方法模式（Factory Method) 5. 原型模式(Prototype) 结构型： 6. 适配器...
设计模式可复用面向对象软件的基础.zip
09-30
1.7 怎样选择设计模式 19 1.8 怎样使用设计模式 20 第2章 实例研究：设计一个文档编 辑器 22 2.1 设计问题 23 2.2 文档结构 23 2.2.1 递归组合 24 2.2.2 图元 25 2.2.3 组合模式 27 2.3 格式化 27 2.3.1 封装格式化...
设计模式——Go语言（Golang）版：19_中介模式
weixin_42117918的博客
04-07 205
示例代码： package main import ( "fmt" "strings" ) type CDDriver struct { Data string } func (c *CDDriver) ReadData() { //c.Data = "音乐、图片" fmt.Println("CD驱动器正在读取：", c.Data) } type CPUDriver struct { Video string Sound string } func (c *CPUDriver)
设计模式-模版方法模式
ZSS1753936255的博客
10-04 713
模版方法模式(Template Method):定义一个操作中的算法骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重新定义算法的某些定义步骤。抽象类：负责实现一个算法的骨架，他是由一个final修饰的模版方法和若干个基本方法组成的。
设计模式之---工厂模式
Arguan_的博客
10-10 466
抽象工厂模式主要用于创建相关对象的家族。当一个产品族中需要被设计在一起工作时，通过抽象工厂模式，能够保证客户端始终只使用同一个产品族中的对象；并且通过隔离具体类的生成，使得客户端不需要明确指定具体生成类；所有的具体工厂都实现了抽象工厂中定义的公共接口，因此只需要改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。但该模式的缺点在于添加新的行为时比较麻烦，如果需要添加一个新产品族对象时，需要更改接口及其下所有子类，这必然会带来很大的麻烦。System.out.println("生产狗粮");
设计模式之访问者
qq_74811378的博客
10-02 1259
（Visitor） 是一种行为设计模式， 它能将算法与其所作用的对象隔离开来。适用场景代码如下：问题：做一款生成冰激凌和雪糕的程序，要求可以扩展新的口味，并且可以扩展新的包装方式。解决方案：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
c#代码介绍23种设计模式_22访问者模式
最新发布
soarfeng的专栏
10-10 734
访问者模式是封装一些施加于某种数据结构之上的操作。一旦这些操作需要修改的话，接受这个操作的数据结构则可以保存不变。访问者模式适用于数据结构相对稳定的系统， 它把数据结构和作用于数据结构之上的操作之间的耦合度降低，使得操作集合可以相对自由地改变。数据结构的每一个节点都可以接受一个访问者的调用，此节点向访问者对象传入节点对象，而访问者对象则反过来执行节点对象的操作。这样的过程叫做“双重分派”。节点调用访问者，将它自己传入，访问者则将某算法针对此节点执行。
设计模式-建造者模式
m0_45164511的博客
10-10 300
建造者模式(builder模式，属于创建型模式)：通过，使得对象的构建更加灵活和可控。它适用于构建复杂对象，特别是当对象的构建过程。
设计模式-桥接模式
ZSS1753936255的博客
10-03 1163
手机按照品牌分可以分为华为、小米、oppo、vivo等m个品牌，如果这些手机按照内存分又可以分为4G、6G、8G等n个内存。通过继承来实现的话，则需要 m*n个实现类（小米4g,小米6g,小米8g,华为4g,华为6g,华为8g，vivo4g,vivo6g,vivo8g,oppo4g,oppo6g,oppo8g）。减低了系统的复杂度。而Brand依赖了Memory部门，想当是这部分的依赖，就是一座桥。桥接模式将继承关系转化成关联关系，封装了变化，完成了解耦，减少了系统中类的数量，也减少了代码量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

guohuang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值