工人负责不同的工作,并写了几个函数分别调用这几个方法:
class worker
{
public:
void dowrite()
{
cout << "wrtie" << endl;
}
void docheck()
{
cout << "check" << endl;
}
void domarket()
{
cout << "market" << endl;
}
};
void dowritething(worker* w)
{
w->dowrite();
}
void docheckthing(worker* w)
{
w->docheck();
}
void domarketthing(worker* w)
{
w->domarket();
}
void test4()
{
worker* w = new worker;
dowritething(w);
docheckthing(w);
domarketthing(w);
}
int main()
{
test4();
return 0;
}
但是抽象不应该依赖细节,细节应该依赖抽象。通过依赖倒置,可以减少类与类之间的耦合性,提高系统的稳定性,提高代码的可读性和可维护性,并且能够降低修改程序所造成的风险。举个例子:当工人的方法被新增 了一项,那么首先需要修改worker类的代码。并且要新增一个函数去调用对应的方法。那么是非常复杂的,因为这是高耦合的代码,如果出现错误了,就会牵一发而动全身。如果采用了如下的方法,那么当新增方法时,直接新写一个类继承自抽象类worker即可。
class worker
{
public:
virtual void dothing() = 0;
};
class dowrite :public worker
{
virtual void dothing()
{
cout << "write" << endl;
}
};
class docheck :public worker
{
virtual void dothing()
{
cout << "check" << endl;
}
};
class domarket :public worker
{
virtual void dothing()
{
cout << "market" << endl;
}
};
void dowhat(worker* w)
{
w->dothing();
}
int main()
{
domarket* dmr = new domarket();
dowhat(dmr);
return 0;
}