Java面向对象：类之间的关系

类之间的关系有以下四种——

一、关联关系

1. 单向关联：从一个类中可以访问另一个类的成员，有这个类的引用。

2. 双向关联：两个类可以互相访问，互相有引用。

3. 自身关联：本类中调用自身self or this.

4. 多维关联：多个类互相之间有单向关联也有双向关联，还可以有自身关联，多个维度的关联。

5. 一对多关联：一个类有多个类的引用。

6. 多对多关联：多个类互相之间有单向关联也有双向关联。

7. 当一个类的属性保存了对另一个类的一个实例的引用时，就产生了关联。

   二.聚合关系

   1. 聚合关联是一种特殊的关联. 它表示类间的关系是整体与部分的关系. 简言之: 关联关系中的一个类描述了一个较大的事物, 它由较小的事物组成.

   2. 聚合关系中一个大类由多个小类组成，但是没有这个大类，这些小类可以再次聚合成另外一个大类而继续使用，这是与组合关系的区别。

   3. 聚合关系是关联关系的一种，是强的关联关系。

   4. 聚合是整体和部分之间的关系，例如汽车由引擎、轮胎以及其它零件组成。

   5. 聚合关系也是通过成员变量来实现的。但是，关联关系所涉及的两个类处在同 一个层次上，而聚合关系中，两个类处于不同的层次上，一个代表整体，一个代表部分。

   6. 通俗的讲：“汽车”有一个引擎和四个轮胎，如果这个“汽车”毁了，它的引擎和 轮胎还可以安在别的汽车上。

      只给出一段代码判断是关联，聚合，还是组合关系，是无法判断的。

      关联：类与类之间的联接，它使一个类知道另一个类的属性和方法。例如A依赖于B，B就是A的全局变量。

      聚合：聚合关系的两个类处于不同的层次，一个是整体，一个是部分。例如汽车和零件

      三、泛化关系

      1. 在 UML 中, 泛化关系用来表示类与类, 接口与接口之间的继承关系。更准确的说是不仅有继承关系，还有类和接口的实现关系。

      2. 泛化关系包括继承关系和实现关系。

      • 泛化就是从子类抽象出一个父类 ，包含了继承关系（由父类具体化一个子类）。

        继承关系：

            <pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n430" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: var(--monospace); font-size: 0.9em; display: block; break-inside: avoid; text-align: left; white-space: normal; background-image: inherit; background-position: inherit; background-size: inherit; background-repeat: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: rgb(248, 248, 248); position: relative !important; border: 1px solid rgb(231, 234, 237); border-radius: 3px; padding: 8px 4px 6px; margin-bottom: 15px; margin-top: 15px; width: inherit;">
public class Father {
            ​
            }
            public class Son extends Father{
             //继承Father类
            }</pre>

• 继承关系指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，在UML类图设计中，继承用一条带空心三角箭头的实线表示，从子类指向父类，或者子接口指向父接口。

• 继承与泛化可以看作一个逆过程

实现关系：

<pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n440" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: var(--monospace); font-size: 0.9em; display: block; break-inside: avoid; text-align: left; white-space: normal; background-image: inherit; background-position: inherit; background-size: inherit; background-repeat: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: rgb(248, 248, 248); position: relative !important; border: 1px solid rgb(231, 234, 237); border-radius: 3px; padding: 8px 4px 6px; margin-bottom: 15px; margin-top: 15px; width: inherit;">
public interface A {
         //    声明一个接口（注意:接口不是类）
        }
        public class B implements A{
         //    实现接口A
        }</pre>

• 实现指的是一个类实现一个interface接口（可以是多个）的功能，在UML类图设计中，实现用一条带空心三角箭头的虚线表示，从类指向实现的接口。

四、组合关系

组合：组合关系了表示2着缺一不可，同时存在同时消失。常常会使用构造方法来达到初始化的目的，

        <pre spellcheck="false" 
class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n342" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: var(--monospace); font-size: 0.9em; display: block; break-inside: avoid; text-align: left; white-space: normal; background-image: inherit; background-position: inherit; background-size: inherit; background-repeat: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: rgb(248, 248, 248); position: relative !important; border: 1px solid rgb(231, 234, 237); border-radius: 3px; padding: 8px 4px 6px; margin-bottom: 15px; margin-top: 15px; width: inherit;">
public Driver(Car car){   //　　构造方法
         mycar = car; 
        }</pre>

1. 整件拥有部件的生命周期, 所以整件删除时, 部件一定会跟着删除. 而且, 多个整件不可以同时共享同一个部件。

2. 组合关系中一个大类由多个小类组成，没有这个大类，小类不能存在。

3. 聚合关系是当描述一个大的事物时，大的事务可以包含小的事务，也可以不包含小的事物，比如图书馆和图书，而组合是一个大的事物的存在必须是由多个小的事务组成的，缺省了小的事务是不可以的。比如人与器官，人的器官可以移植，这是聚合关系;人与肢体，人没了，肢体便没有用了，这是组合关系。

4. 组合关系是关联关系的一种，是比聚合关系还要强的关系。

5. 它要求普通的聚合关系中代表整体的对象负责代表部分的对象的生命周期。 通俗的讲：“人”有四个“肢体”，如果“人”死了，那么四个肢体也没有用处了。

五、依赖关系

            依赖：A类方法中的参数包含了B。
<pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n333" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: var(--monospace); font-size: 0.9em; display: block; break-inside: avoid; text-align: left; white-space: normal; background-image: inherit; background-position: inherit; background-size: inherit; background-repeat: inherit; background-attachment: inherit; background-origin: inherit; background-clip: inherit; background-color: rgb(248, 248, 248); position: relative !important; border: 1px solid rgb(231, 234, 237); border-radius: 3px; padding: 8px 4px 6px; margin-bottom: 15px; margin-top: 15px; width: inherit;">
public class Car {    
public static void run(){
System.err.println("汽车在跑");
             }
            }
public class Driver {
public void Driver(Car car) {    //使用传递形参形成依赖
car.run();
             }
public void Driver() {
             //使用局部变量形成依赖
Car car = new Car();
car.run();
             }
public void Driver1() {
 Car.run();    //使用静态方法形成依赖
             }
            }
</pre>
            

1. 对于两个相对独立的系统，当一个系统负责构造另一个系统的实例，或者依赖另一个系统的服务时，这两个系统之间体现为依赖关系.

2. 一个类在某个时刻会用到另一个类，那么这两个类就是依赖关系。是一种短暂的关系。

3. 依赖关系也是类与类之间的联结

4. 依赖总是单向的。

5. 依赖关系在代码中中体现为局部变量、方法的参数或者对静态方法的调用。

6. 比如，人在出行的时候会依赖车的关系。

这四种关系的联系的紧密度排行为： 实现 > 聚合 > 关联 > 依赖