实验四 组合与继承
TASK1
GradeCalc.hpp
#pragma once
#include <vector>
#include <array>
#include <string>
class GradeCalc {
public:
GradeCalc(const std::string &cname);
void input(int n); // 录入n个成绩
void output() const; // 输出成绩
void sort(bool ascending = false); // 排序 (默认降序)
int min() const; // 返回最低分（如成绩未录入，返回-1)
int max() const; // 返回最高分 （如成绩未录入，返回-1)
double average() const; // 返回平均分 （如成绩未录入，返回0.0)
void info(); // 输出课程成绩信息
private:
void compute(); // 成绩统计
private:
std::string course_name; // 课程名
std::vector<int> grades; // 课程成绩
std::array<int, 5> counts; // 保存各分数段人数（[0, 60), [60, 70), [70, 80), [80, 90), [90, 100]
std::array<double, 5> rates; // 保存各分数段人数占比
bool is_dirty; // 脏标记，记录是否成绩信息有变更
};
GradeCalc.cpp
#include <algorithm>
#include <array>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#include "GradeCalc.hpp"
GradeCalc::GradeCalc(const std::string &cname):course_name{cname},is_dirty{true} {
counts.fill(0);
rates.fill(0);
}
void GradeCalc::input(int n) {
if(n < 0) {
std::cerr << "无效输入! 人数不能为负数\n";
std::exit(1);
}
grades.reserve(n);
int grade;
for(int i = 0; i < n;) {
std::cin >> grade;
if(grade < 0 || grade > 100) {
std::cerr << "无效输入! 分数须在[0,100]\n";
continue;
}
grades.push_back(grade);
++i;
}
is_dirty = true; // 设置脏标记：成绩信息有变更
}
void GradeCalc::output() const {
for(auto grade: grades)
std::cout << grade << ' ';
std::cout << std::endl;
}
void GradeCalc::sort(bool ascending) {
if(ascending)
std::sort(grades.begin(), grades.end());
else
std::sort(grades.begin(), grades.end(), std::greater<int>());
}
int GradeCalc::min() const {
if(grades.empty())
return -1;
auto it = std::min_element(grades.begin(), grades.end());
return *it;
}
int GradeCalc::max() const {
if(grades.empty())
return -1;
auto it = std::max_element(grades.begin(), grades.end());
return *it;
}
double GradeCalc::average() const {
if(grades.empty())
return 0.0;
double avg = std::accumulate(grades.begin(), grades.end(), 0.0)/grades.size();
return avg;
}
void GradeCalc::info() {
if(is_dirty)
compute();
std::cout << "课程名称:\t" << course_name << std::endl;
std::cout << "平均分:\t" << std::fixed << std::setprecision(2) << average() << std::endl;
std::cout << "最高分:\t" << max() << std::endl;
std::cout << "最低分:\t" << min() << std::endl;
const std::array<std::string, 5> grade_range{"[0, 60) ",
"[60, 70)",
"[70, 80)",
"[80, 90)",
"[90, 100]"};
for(int i = static_cast<int>(grade_range.size())-1; i >= 0; --i)
std::cout << grade_range[i] << "\t: " << counts[i] << "人\t"
<< std::fixed << std::setprecision(2) << rates[i]*100 << "%\n";
}
void GradeCalc::compute() {
if(grades.empty())
return;
counts.fill(0);
rates.fill(0.0);
// 统计各分数段人数
for(auto grade:grades) {
if(grade < 60)
++counts[0]; // [0, 60)
else if (grade < 70)
++counts[1]; // [60, 70)
else if (grade < 80)
++counts[2]; // [70, 80)
else if (grade < 90)
++counts[3]; // [80, 90)
else
++counts[4]; // [90, 100]
}
// 统计各分数段比例
for(size_t i = 0; i < rates.size(); ++i)
rates[i] = counts[i] * 1.0 / grades.size();
is_dirty = false; // 更新脏标记
}
task1.cpp
#include <iostream>
#include <string>
#include "GradeCalc.hpp"
void test() {
GradeCalc c1("OOP");
std::cout << "录入成绩:\n";
c1.input(5);
std::cout << "输出成绩:\n";
c1.output();
std::cout << "排序后成绩:\n";
c1.sort(); c1.output();
std::cout << "*************成绩统计信息*************\n";
c1.info();
}
int main() {
test();
}
Q1
std::string course_name;
功能：std::string 作为字符串类，用于存储课程名称的文本数据。
std::vector
功能：std::vector
std::array<int, 5> counts;
功能：std::array<int, 5> 作为固定大小数组容器，用于存储 5 个分数段的人数统计结果，保证大小固定且内存连续。
std::array<double, 5> rates;
功能：std::array<double, 5> 作为固定大小数组容器，用于存储 5 个分数段的比例统计结果，保证大小固定且内存连续。
bool is_dirty;
功能：bool 作为布尔类型，用于标记成绩数据是否被修改，控制统计结果的重新计算逻辑。
Q2
不合法，无法直接通过GradeCalc对象c访问其私有成员grades的push_back方法。
Q3
(1)compute被调用1 次。
is_dirty的作用：标记成绩数据是否发生变更。仅当is_dirty为true时，info才会调用compute重新计算统计信息；连续打印时，第一次调用后is_dirty被置为false，后续打印不会重复调用compute，避免冗余计算。
(2)需要修改compute调用位置：在update_grade函数中修改成绩后，需将is_dirty置为true，确保后续调用info时能触发compute重新计算统计信息。
Q4
// 在info函数中，compute之后添加
std::vector
std::sort(temp.begin(), temp.end());
double median;
size_t n = temp.size();
if (n % 2 == 1) {
median = temp[n / 2];
} else {
median = (temp[n/2 - 1] + temp[n/2]) / 2.0;
}
std::cout << "中位数:\t" << std::fixed << std::setprecision(2) << median << std::endl;
Q5
compute中不能去掉这两行。
引发错误的场景：当多次调用compute时，若不重置counts和rates，新的统计结果会与旧数据累加，导致统计人数和比例错误。
Q6
(1)
对程序功能无影响：reserve仅预分配内存，不改变vector的实际元素数量；去掉后push_back仍能正常动态扩容，功能不受影响。
(2)
对性能有影响：去掉后，当grades元素数量超过当前容量时，push_back会频繁触发内存重新分配和元素拷贝，降低程序执行效率。
TASK2
GradeCalc.hpp
#pragma once
#include <array>
#include <string>
#include <vector>
class GradeCalc: private std::vector<int> {
public:
GradeCalc(const std::string &cname);
void input(int n); // 录入n个成绩
void output() const; // 输出成绩
void sort(bool ascending = false); // 排序 (默认降序)
int min() const; // 返回最低分
int max() const; // 返回最高分
double average() const; // 返回平均分
void info(); // 输出成绩统计信息
private:
void compute(); // 计算成绩统计信息
private:
std::string course_name; // 课程名
std::array<int, 5> counts; // 保存各分数段人数（[0, 60), [60, 70), [70, 80), [80, 90), [90, 100]
std::array<double, 5> rates; // 保存各分数段占比
bool is_dirty; // 脏标记，记录是否成绩信息有变更
};
GradeCalc.cpp
#include <algorithm>
#include <array>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#include "GradeCalc.hpp"
GradeCalc::GradeCalc(const std::string &cname): course_name{cname}, is_dirty{true}{
counts.fill(0);
rates.fill(0);
}
void GradeCalc::input(int n) {
if(n < 0) {
std::cerr << "无效输入! 人数不能为负数\n";
return;
}
this->reserve(n);
int grade;
for(int i = 0; i < n;) {
std::cin >> grade;
if(grade < 0 || grade > 100) {
std::cerr << "无效输入! 分数须在[0,100]\n";
continue;
}
this->push_back(grade);
++i;
}
is_dirty = true;
}
void GradeCalc::output() const {
for(auto grade: *this)
std::cout << grade << ' ';
std::cout << std::endl;
}
void GradeCalc::sort(bool ascending) {
if(ascending)
std::sort(this->begin(), this->end());
else
std::sort(this->begin(), this->end(), std::greater<int>());
}
int GradeCalc::min() const {
if(this->empty())
return -1;
return *std::min_element(this->begin(), this->end());
}
int GradeCalc::max() const {
if(this->empty())
return -1;
return *std::max_element(this->begin(), this->end());
}
double GradeCalc::average() const {
if(this->empty())
return 0.0;
double avg = std::accumulate(this->begin(), this->end(), 0.0) / this->size();
return avg;
}
void GradeCalc::info() {
if(is_dirty)
compute();
std::cout << "课程名称:\t" << course_name << std::endl;
std::cout << "平均分:\t" << std::fixed << std::setprecision(2) << average() << std::endl;
std::cout << "最高分:\t" << max() << std::endl;
std::cout << "最低分:\t" << min() << std::endl;
const std::array<std::string, 5> grade_range{"[0, 60) ",
"[60, 70)",
"[70, 80)",
"[80, 90)",
"[90, 100]"};
for(int i = static_cast<int>(grade_range.size())-1; i >= 0; --i)
std::cout << grade_range[i] << "\t: " << counts[i] << "人\t"
<< std::fixed << std::setprecision(2) << rates[i]*100 << "%\n";
}
void GradeCalc::compute() {
if(this->empty())
return;
counts.fill(0);
rates.fill(0);
// 统计各分数段人数
for(int grade: *this) {
if(grade < 60)
++counts[0]; // [0, 60)
else if (grade < 70)
++counts[1]; // [60, 70)
else if (grade < 80)
++counts[2]; // [70, 80)
else if (grade < 90)
++counts[3]; // [80, 90)
else
++counts[4]; // [90, 100]
}
// 统计各分数段比例
for(size_t i = 0; i < rates.size(); ++i)
rates[i] = counts[i] * 1.0 / this->size();
is_dirty = false;
}
task2.cpp
#include <iostream>
#include <string>
#include "GradeCalc.hpp"
void test() {
GradeCalc c1("OOP");
std::cout << "录入成绩:\n";
c1.input(5);
std::cout << "输出成绩:\n";
c1.output();
std::cout << "排序后成绩:\n";
c1.sort(); c1.output();
std::cout << "*************成绩统计信息*************\n";
c1.info();
}
int main() {
test();
}
Q1
class GradeCalc: private std::vector<int> {
public:
GradeCalc(const std::string &cname);
void input(int n); // 录入n个成绩
void output() const; // 输出成绩
void sort(bool ascending = false); // 排序 (默认降序)
int min() const; // 返回最低分
int max() const; // 返回最高分
double average() const; // 返回平均分
void info(); // 输出成绩统计信息
private:
void compute(); // 计算成绩统计信息
private:
std::string course_name; // 课程名
std::array<int, 5> counts; // 保存各分数段人数（[0, 60), [60, 70), [70, 80), [80, 90), [90, 100]
std::array<double, 5> rates; // 保存各分数段占比
bool is_dirty; // 脏标记，记录是否成绩信息有变更
};
Q2
不会。因为GradeCalc是私有继承std::vector
不能编译通过。原因是GradeCalc私有继承std::vector
Q3
组合方式:通过grades成员,仅暴露GradeCalc自定义接口，vector接口被隐藏，封装性强
继承方式:通过*this,继承了vector的所有公有接口，接口暴露多，封装性弱
Q4
结论：组合方案更适合成绩计算场景。
理由：成绩计算的核心是 “管理成绩数据并提供统计功能”，vector是实现 “存储成绩” 的工具，而非GradeCalc的 “本质父类”；组合方式可隐藏vector的接口（避免外部直接修改成绩），仅暴露GradeCalc的业务接口，封装性更好，更符合 “成绩计算” 的业务语义。
TASK3
Graph.hpp
#pragma once
#include <string>
#include <vector>
enum class GraphType {circle, triangle, rectangle};
// Graph类定义
class Graph {
public:
virtual void draw() {}
virtual ~Graph() = default;
};
// Circle类声明
class Circle : public Graph {
public:
void draw();
};
// Triangle类声明
class Triangle : public Graph {
public:
void draw();
};
// Rectangle类声明
class Rectangle : public Graph {
public:
void draw();
};
// Canvas类声明
class Canvas {
public:
void add(const std::string& type); // 根据字符串添加图形
void paint() const; // 使用统一接口绘制所有图形
~Canvas(); // 手动释放资源
private:
std::vector<Graph*> graphs;
};
// 4. 工具函数
GraphType str_to_GraphType(const std::string& s); // 字符串转枚举类型
Graph* make_graph(const std::string& type); // 创建图形，返回堆对象指针
Graph.cpp
#include <algorithm>
#include <cctype>
#include <iostream>
#include <string>
#include "Graph.hpp"
// Circle类实现
void Circle::draw() { std::cout << "draw a circle...\n"; }
// Triangle类实现
void Triangle::draw() { std::cout << "draw a triangle...\n"; }
// Rectangle类实现
void Rectangle::draw() { std::cout << "draw a rectangle...\n"; }
// Canvas类实现
void Canvas::add(const std::string& type) {
Graph* g = make_graph(type);
if (g)
graphs.push_back(g);
}
void Canvas::paint() const {
for (Graph* g : graphs)
g->draw();
}
Canvas::~Canvas() {
for (Graph* g : graphs)
delete g;
}
// 工具函数实现
// 字符串 → 枚举转换
GraphType str_to_GraphType(const std::string& s) {
std::string t = s;
std::transform(s.begin(), s.end(), t.begin(),
[](unsigned char c) { return std::tolower(c);});
if (t == "circle")
return GraphType::circle;
if (t == "triangle")
return GraphType::triangle;
if (t == "rectangle")
return GraphType::rectangle;
return GraphType::circle; // 缺省返回
}
// 创建图形，返回堆对象指针
Graph* make_graph(const std::string& type) {
switch (str_to_GraphType(type)) {
case GraphType::circle: return new Circle;
case GraphType::triangle: return new Triangle;
case GraphType::rectangle: return new Rectangle;
default: return nullptr;
}
}
demo3.cpp
#include <string>
#include "Graph.hpp"
void test() {
Canvas canvas;
canvas.add("circle");
canvas.add("triangle");
canvas.add("rectangle");
canvas.paint();
}
int main() {
test();
}
Q1
Graph类作为抽象基类，通过virtual void draw() {}定义了图形绘制的统一接口
virtual ~Graph() = default确保子类析构时的多态调用，避免内存泄漏。
Circle、Triangle、Rectangle继承自Graph，并重写draw()实现各自的绘制逻辑，体现了多态性。
Q2
(1)g->draw()会根据g的静态类型调用Graph类的draw，无法触发多态，所有图形都会执行Graph::draw()的逻辑。
(2)子类对象（如 Circle）存入容器时，仅保留基类 Graph 的部分，丢失子类特有的行为，无法实现多态。
(3)Canvas析构时调用delete g，仅会调用Graph的析构函数，不会调用子类的析构函数，导致内存泄漏。
Q3
Graph.hpp：
新增Star类声明：class Star : public Graph { public: void draw(); };
扩展GraphType枚举：enum class GraphType {circle, triangle, rectangle, star};
Graph.cpp：
实现Star::draw()：void Star::draw() { std::cout << "draw a star...\n"; }
修改str_to_GraphType：添加if (t == "star") return GraphType::star;
修改make_graph的 switch：增加case GraphType::star: return new Star;
Q4
(1)在Canvas的析构函数中，通过delete g释放
(2) 利：使用简单、直接控制内存分配/释放，运行开销小。
弊：需手动管理内存，易出现内存泄漏、重复释放、悬空指针等问题，安全性低。
TASK4
Toy.hpp
#include<iostream>
#include<string>
#include<vector>
#pragma once
class Toy
{
public:
Toy(std::string name,std::string type,char size='s',std::vector<std::string>abilities={});
~Toy();
std::string GetToyName()const;
std::string GetToyType()const;
char GetToySize()const;
void have_abilities(Toy &t);
void input();
std::vector<std::string>GetAbilities ()const;
private:
std::string name;
std::string type;
char size;
std::vector<std::string>abilities;
};
Toy.cpp
#include<iostream>
#include<string>
#include<vector>
#pragma once
class Toy
{
public:
Toy(std::string name,std::string type,char size='s',std::vector<std::string>abilities={});
~Toy();
std::string GetToyName()const;
std::string GetToyType()const;
char GetToySize()const;
void have_abilities(Toy &t);
void input();
std::vector<std::string>GetAbilities ()const;
private:
std::string name;
std::string type;
char size;
std::vector<std::string>abilities;
};
ToyFactory.hpp
#include<iostream>
#include<string>
#include"Toy.hpp"
class ToyFactory
{
public:
ToyFactory(std::string F_name);
~ToyFactory();
void produce();
void print_all_toy();
std::string GetFactoryName()const ;
bool hasToy(const std::string& toyName) const;
const Toy* getToyByName(const std::string& toyName) const;
private:
std::string F_name;
std::vector<Toy>T;
};
ToyFactory.cpp
#include<iostream>
#include<string>
#include<vector> // 补充vector头文件
#include"Toy.hpp" // 包含Toy类的声明
#include"ToyFactory.hpp"
ToyFactory::ToyFactory(std::string F_name) : F_name(std::move(F_name))
{
}
ToyFactory::~ToyFactory()
{
}
void ToyFactory::produce()
{
std::string name, type;
int n;//玩具个数
char size;
std::vector<Toy>T;
std::vector<std::string> abilities;
std::cout <<"生产玩具个数"<<std::endl;
std::cin>>n;
for(int i=0; i<n; i++)
{
std::cout << "===== 生产新玩具 =====" << std::endl;
std::cout << "请输入玩具名称：";
std::cin >> name;
std::cout << "请输入玩具类型：";
std::cin >> type;
std::cout << "请输入玩具尺寸（s/m/l，默认s）：";
std::cin >> size;
if (size != 's' && size != 'm' && size != 'l')
{
size = 's'; // 默认尺寸为s
std::cout << "尺寸输入无效，默认设为's'" << std::endl;
}
// 输入玩具能力
std::cout << "请输入玩具能力数量：";
int n;
std::cin >> n;
std::cin.ignore(); // 忽略换行符
abilities.clear();
for (int i = 0; i < n; ++i)
{
std::string ab;
std::cout << "请输入能力" << i + 1 << "：";
std::getline(std::cin, ab);
abilities.push_back(ab);
}
// 创建Toy对象并添加到工厂的玩具列表中
T.emplace_back(name, type, size, abilities);
std::cout << "玩具【" << name << "】生产完成！" << std::endl;
}
}
// 打印工厂所有玩具信息
void ToyFactory::print_all_toy()
{
std::cout << "\n===== " << F_name << "工厂生产的所有玩具 =====" << std::endl;
if (T.empty())
{
std::cout << "暂无生产的玩具！" << std::endl;
return;
}
for (size_t i = 0; i < T.size(); ++i)
{
std::cout << "\n玩具" << i + 1 << "：" << std::endl;
std::cout << "名称：" << T[i].GetToyName() << std::endl;
std::cout << "类型：" << T[i].GetToyType() << std::endl;
std::cout << "尺寸：" << T[i].GetToySize() << std::endl;
std::cout << "能力：" << std::endl;
for (const auto& ab : T[i].GetAbilities())
{
std::cout << " - " << ab << std::endl;
}
}
}
std::string ToyFactory::GetFactoryName()const
{
return F_name;
}
bool ToyFactory::hasToy(const std::string& toyName) const
{
for (const auto& toy : T)
{
if (toy.GetToyName() == toyName)
return true;
}
return false;
}
const Toy* ToyFactory::getToyByName(const std::string& toyName) const
{
for (const auto& toy : T)
{
if (toy.GetToyName() == toyName)
return &toy;
}
return nullptr;
}
demo4.cpp
#include "Toy.hpp"
#include "ToyFactory.hpp"
#include <iostream>
#include <vector>
// 全局工厂容器声明
std::vector<ToyFactory> F;
// 函数声明
void input();
void queryMenu();
void queryToyBelonging();
void queryToyAbilities();
void queryToyDetails();
void print_all();
int main()
{
input();
queryMenu();
return 0;
}
void input()
{
int n;
std::cout << "请输入工厂数量:" << std::endl;
std::cin >> n;
std::cin.ignore(); // 清除换行符
for (int i = 0; i < n; ++i)
{
std::string factoryName;
std::cout << "请输入第" << i + 1 << "个工厂名称:" << std::endl;
std::getline(std::cin, factoryName);
F.emplace_back(factoryName);
}
for (int i = 0; i < n; ++i)
{
std::cout << "\n===== 工厂 " << F[i].GetFactoryName() << " 开始生产 =====" << std::endl;
F[i].produce();
}
}
void queryMenu()
{
while (true)
{
int flag;
std::cout << "\n请选择操作选项(1.查询玩具所属工厂 2.查询玩具能力 3.查询玩具详细信息 4.打印所有工厂及玩具信息 5.退出)" << std::endl;
std::cin >> flag;
std::cin.ignore(); // 清除换行符
switch (flag)
{
case 1:
queryToyBelonging();
break;
case 2:
queryToyAbilities();
break;
case 3:
queryToyDetails();
break;
case 4:
print_all();
break;
case 5:
std::cout << "程序退出" << std::endl;
return;
default:
std::cout << "无效选项，请重新输入" << std::endl;
}
}
}
void queryToyBelonging()
{
std::string toyName;
std::cout << "请输入玩具名称:" << std::endl;
std::getline(std::cin, toyName);
bool found = false;
for (const auto& factory : F)
{
if (factory.hasToy(toyName))
{
std::cout << "玩具[" << toyName << "]属于工厂[" << factory.GetFactoryName() << "]" << std::endl;
found = true;
break;
}
}
if (!found)
{
std::cout << "未找到名为[" << toyName << "]的玩具" << std::endl;
}
}
void queryToyAbilities()
{
std::string toyName;
std::cout << "请输入玩具名称:" << std::endl;
std::getline(std::cin, toyName);
bool found = false;
for (const auto& factory : F)
{
const Toy* toy = factory.getToyByName(toyName);
if (toy)
{
std::cout << "玩具[" << toyName << "]的能力:" << std::endl;
for (const auto& ability : toy->GetAbilities())
{
std::cout << "- " << ability << std::endl;
}
found = true;
break;
}
}
if (!found)
{
std::cout << "未找到名为[" << toyName << "]的玩具" << std::endl;
}
}
void queryToyDetails()
{
std::string toyName;
std::cout << "请输入玩具名称:" << std::endl;
std::getline(std::cin, toyName);
bool found = false;
for (const auto& factory : F)
{
const Toy* toy = factory.getToyByName(toyName);
if (toy)
{
std::cout << "\n===== 玩具详细信息 =====" << std::endl;
std::cout << "名称: " << toy->GetToyName() << std::endl;
std::cout << "类型: " << toy->GetToyType() << std::endl;
std::cout << "尺寸: " << toy->GetToySize() << std::endl;
std::cout << "所属工厂: " << factory.GetFactoryName() << std::endl;
std::cout << "能力:" << std::endl;
for (const auto& ability : toy->GetAbilities())
{
std::cout << "- " << ability << std::endl;
}
found = true;
break;
}
}
if (!found)
{
std::cout << "未找到名为[" << toyName << "]的玩具" << std::endl;
}
}
void print_all()
{
for (auto& factory : F)
{
factory.print_all_toy();
}
}
类之间的关系及设计理由
- Toy 类与 ToyFactory 类：组合关系（ToyFactory 组合 Toy）
关系描述：ToyFactory 类中通过私有成员 std::vectorT 存储多个 Toy 对象，即一个玩具工厂可以包含多个玩具，两者是整体与部分的关系。当 ToyFactory 对象被销毁时，其包含的 Toy 对象也会被自动销毁（由 vector 容器管理生命周期）。
设计理由：
玩具是工厂生产的产品，依附于工厂存在，不存在独立于工厂的玩具，符合组合关系 “部分不能脱离整体存在” 的特性。
采用 vector存储玩具，便于工厂对玩具进行批量管理，且容器自动管理内存，简化了对象生命周期的维护。 - 无继承关系
该系统中 Toy 和 ToyFactory 是两个独立的类，分别代表 “玩具” 和 “玩具工厂”，二者不存在 “is-a” 的继承关系，因此无需设计继承结构。 - 整体设计合理性
职责单一：Toy 类仅负责封装玩具的属性（名称、类型、尺寸、能力）及相关访问方法，ToyFactory 类负责管理工厂名称和玩具的生产、查询、打印等操作，符合单一职责原则。
低耦合：Toy 类通过公有方法暴露属性访问接口，ToyFactory 类通过这些接口操作玩具，两者之间依赖于接口而非具体实现，降低了耦合度。
可扩展性：若未来需要新增玩具类型，可通过继承 Toy 类实现；若需要新增工厂类型，可通过扩展 ToyFactory 类实现，符合开放 - 封闭原则。
![image]()
![image]()
浙公网安备 33010602011771号