如有兴趣了解更多请关注我的个人博客https://07xiaohei.com/
(一)依赖:
1. 概念:
是一种使用关系,耦合度最弱。
类A使用类B的一部分属性和方法,不会主动改变类B的内容,但是类B的变化会影响到A。
具有偶然性、临时性。
2. 体现:
- 类B作为类A的成员函数参数。
- 类B作为A的成员函数的局部变量
- 类A的成员函数调用的类B的静态方法
3. 代码:
#include<iostream>
using namespace std;
class B
{
public:
static void showB()
{
cout << "showB" << endl;
}
};
class A
{
public:
void CallB1()
{
B::showB();
return;
}
void CallB2(B b)
{
b.showB();
return;
}
void CallB3()
{
B b;
b.showB();
return;
}
};
int main()
{
B b;
A a;
a.CallB1();
a.CallB2(b);
a.CallB3();
return 0;
}
//运行结果:
//showB
//showB
//showB
(二)关联:
1. 概念:
关联是对象之间的一种引用关系,用于表示一类对象与另一类对象的联系。
关连也是一种弱从属关系,是可以有方向的,可以是单向也可以是双向的。
关联体现的是两个类之间的一种强依赖关系,不存在偶然性和临时性,一般是长期性的、平等的。
依赖和关联都是一个类用乐另一个类,但是前者是使用,后者是拥有。
2. 体现:
- 被关联类B以类的属性形式出来在关联类A中。
- 关联类A引用了一个类型为被关联类B的全局变量。
3. 代码:
#include<iostream>
using namespace std;
//A和B是关联关系:
class Me;
class You
{
private:
Me* pm;
public:
void printMe();
void printYou();
};
class Me
{
private:
You* py;
public:
void printme();
void printyou();
};
void You::printMe()
{
cout << "You:" << endl;
pm->printme();
return;
}
void You::printYou()
{
cout << "我中有你" << endl;
return;
}
void Me::printyou()
{
cout << "Me:" << endl;
py->printYou();
return;
}
void Me::printme()
{
cout << "你中有我" << endl;
return;
}
int main()
{
Me zzh;
zzh.printyou();
zzh.printme();
You xxx;
xxx.printMe();
xxx.printYou();
return 0;
}
//
//Me:
//我中有你
//你中有我
//You :
//你中有我
//我中有你
(三)聚合:
1. 概念:
聚合关系又名委托关系,聚合关系是关联关系的一种,是一种强关联关系,是整体和部分之间的关系,是has-a的关系。
聚合关系也是一种弱所属关系,整体和部分之间是可分离的,具有各自的生命周期,部分可以属于多个整体的对象,也可以为多个整体对象共享。
聚合和关联的区别主要是语义,关联的两个对象一般是平等的,而聚合一般不是平等的。
2. 体现:
聚合通过成员对象来实现的。
聚合需要配合语义,结合上下文才能判断出是否为聚合,无法直接判断。
3. 代码:
#include<iostream>
using namespace std;
class Husband;
class Wife;
class House
{
private:
string name;
public:
House(string s="家"):name(s){}
void showname()
{
cout << "家:" << name << endl;
}
};
class Husband
{
private:
House h;
string name;
public:
Husband(string s1, string s2="zzh") :h(s1),name(s2)
{
}
void showHouse()
{
h.showname();
cout << "丈夫" << name << endl;
}
};
class Wife
{
private:
House h;
string name;
public:
Wife(string s1, string s2 = "xxx") :h(s1), name(s2)
{
}
void showHouse()
{
h.showname();
cout << "妻子:"<<name << endl;
}
};
int main()
{
Husband me("home");
Wife who("Home");
me.showHouse();
who.showHouse();
return 0;
}
//运行结果:
//家:home
//丈夫zzh
//家 : Home
//妻子 : xxx
(四)组合:
1. 概念:
也是关联关系的一种特例,是整体和部分的关系,一个对象(是部分)被放到另一个对象中(是整体),是contains-a的关系。
是一种强所属关系(比聚合更强),和聚合不同的是,整体和部分是不可分的,具有相同的生命周期,整体(组合类)可以控制部分(被组合类)的生命周期,整体的对象不存在,则部分的对象也不存在,也就是部分对象不能独立存在。
相比聚合,组合的两个对象的不平等性进一步加大。
2. 体现:
同聚合关系,组合也是通过成员对象来实现的。
组合也需要配合语义,结合上下文才能判断出是否为聚合,无法直接判断。
聚合和组合的最关键区别是两个对象的生命周期是否一致,而不是出现的形式。
3. 代码:
#include<iostream>
using namespace std;
class eye
{
private:
double lefteyesight;
double righteyesight;
public:
eye(double d1, double d2) :lefteyesight(d1), righteyesight(d2)
{
}
void printeyesight()
{
cout << "左眼:" << lefteyesight << endl;
cout << "右眼:" << righteyesight << endl;
return;
}
};
class person
{
private:
eye e;
int sex;
public:
person(int x=0, double d1 = 1.0, double d2 = 1.0) :e(d1, d2), sex(x){}
void printperson()
{
cout << "性别:" << sex << endl;
e.printeyesight();
return;
}
};
int main()
{
person p;
p.printperson();
return 0;
}
//运行结果:
//性别:0
//左眼 : 1
//右眼 : 1
(五)实现:
1. 概念:
是接口与实现类之间的关系,在此关系中,类实现接口,类中的操作实现了接口中所声明的所有的抽象操作。
2. 体现:
接口通过纯虚函数来实现,多态就是通过虚函数来实现的。
3. 代码:
#include<iostream>
using namespace std;
class person
{
public:
virtual void printperson() = 0;
};
class student:public person
{
private:
string name;
public:
student(string s="zzh") :name(s) {}
void printperson()
{
cout << "这是一个人" << endl;
cout << "是学生,名字是:" << name << endl;
}
};
int main()
{
student s;
s.printperson();
return 0;
}
//运行结果:
//这是一个人
//是学生, 名字是:zzh
(六)继承:
1. 概念:
继承关系又名泛化关系,是面向对象的三大特征之一,是对象之间耦合度最大的一种关系,表示一般与特殊的关系,是is-a关系。
继承表达的是一种上下级关系。
更多内容详见c++类——继承关系。
2. 体现:
通过面向对象的继承机制实现继承关系。
3. 代码:
#include<iostream>
using namespace std;
class person {};
class student :public person {};
(七)不同类之间关系的强弱比较:
继承=实现>组合>聚合>关联>依赖