关于java: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. 它要求一般的聚合关系中代表整体的对象负责代表局部的对象的生命周期。艰深的讲：“人”有四个“肢体”，如果“人”死了，那么四个肢体也没有用途了。

五、依赖关系

            依赖：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. 对于两个绝对独立的零碎，当一个零碎负责结构另一个零碎的实例，或者依赖另一个零碎的服务时，这两个零碎之间体现为依赖关系.

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

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

3. 依赖总是单向的。

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

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

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