1、Java-类/对象之间的关系-概述

  1. 1、Java-类/对象之间的关系-概述
  2.     1-1、Java 类是由任意数量以及任意类型的其他类构成。
  3.     1-2、java的类之间的关系有：泛化、依赖、关联、实现、聚合、组合等。
  4.     1-3、关于关联，聚合，组合在实现上并没有显著区别，相区别他们只有通过判断关系双方之间的实际关系，如关系强弱、创建与销毁之间有无必要关联等。 
  5.         1-3-1、依赖 < 关联 < 聚合 < 组合<泛化(继承)
  6. 2、实现方式区别：
  7.     依赖关系：关系对象出现在局部变量或者方法的参数里，或者关系类的静态方法被调用。
  8.     聚合关系: 关系对象出现在实例变量中。【 A 类的对象在创建时不会立即创建 B 类的对象，而是在 A 类的某个方法中设计一个参数，用于接收 B 类对象。当 A 类的这个对象消亡时，它所接收的 B 类的对象没有影响。也就是说，这两个类的生命周期是不一致的。】
  9.     组合关系：关系对象出现在实例变量中。【我们会在 A 类的构造方法中创建 B 类对象。这样当创建一个 A 类对象时，也会随之产生 B 类的对象；当 A 类的这个对象消亡时，它所包含的 B 类的对象也会随之消亡。也就是说，这两个类的生命周期是一致的。】
  10.     泛化关系: extends 。
  11.     实现关系： implements 。

1.1、Java-类/对象之间的关系-泛化(Generalization)

  1. 1、Java-类/对象之间的关系-泛化(Generalization)
  2.     1-1、泛化关系，也就是继承关系，也称为"is-a-kind-of"关系。
  3.     1-2、泛化关系用于描述父类与子类之间的关系，父类又称作基类或超类，子类又称作派生类。
  4.     1-3、在UML中，泛化关系用带空心三角形的直线来表示。
  5.         1-3-1、在UML当中，对泛化关系有三个要求：
  6.             a、子类与父类应该完全一致，父类所具有的属性、操作，子类应该都有；
  7.             b、子类中除了与父类一致的信息以外，还包括额外的信息；
  8.             c、可以使用父类的实例的地方，也可以使用子类的实例；
  9.     1-4、泛化关系-举例代码
  10.         public class　Animal {
  11.         }
  12.         public class Tiger extends Animal {
  13.         }

1.2、Java-类/对象之间的关系-依赖(Dependency)

  1. 1、Java-类/对象之间的关系-依赖(Dependency)
  2.     1-1、依赖关系，一种使用关系，特定事物的改变有可能会影响到使用该事物的其他事物，在需要表示一个事物使用另一个事物时使用依赖关系。
  3.     1-2、大多数情况下，依赖关系体现在某个类的方法使用另一个类的对象作为参数。 
  4.     1-3、在UML中，依赖关系用带箭头的虚线表示，由依赖的一方指向被依赖的一方。
  5.     1-4、依赖关系，通常有三种情况：
  6.         1-4-1、A类是B类中的（某中方法的）局部变量；
  7.         1-4-2、A类是B类方法当中的一个参数；
  8.         1-4-3、A类向B类发送消息，从而影响B类发生变化；
  9.     1-5、依赖关系-举例代码：
  10.         public class Screwdriver {    //螺丝刀，作为人类的工具，是用来被人类使用的
  11.         }
  12.         public class Person{
  13.             public void screw(Screwdriver src){    //拧螺丝，需使用螺丝刀
  14.             }
  15.         }

1.3、Java-类/对象之间的关系-关联(Association)

  1. 1、Java-类/对象之间的关系-关联(Association)
  2.     1-1、关联关系，一种结构关系，说明一个事物的对象与另一个事物的对象相联系。给定有关联的两个类，可以从一个类的对象得到另一个类的对象。
  3.     1-2、关联有两元关系和多元关系。两元关系是指一种一对一的关系，多元关系是一对多或多对一的关系。两个类之间的简单关联表示了两个同等地位类之间的结构关系。
  4.     1-3、在UML类图中，用实线连接有关联的对象所对应的类，表示关联关系时可以在关联线上标注角色名。
  5.     1-4、关联关系，可分为：
  6.         1-4-1、双向关联
  7.             public class Customer {  
  8.                 private Product[] products;  
  9.                 ……  
  10.             }  
  11.             public class Product {  
  12.                 private Customer customer;  
  13.                 ……  
  14.             }  
  15.         1-4-2、单向关联
  16.             public class Customer {  
  17.                 private Address address;  
  18.                 ……  
  19.             }  
  20.             public class Address {  
  21.                 ……  
  22.             }  
  23.         1-4-3、自关联
  24.             public class Node {  
  25.                 private Node subNode;  
  26.                 ……  
  27.             }

1.4、Java-类/对象之间的关系-聚合(Aggregation)

  1. 1、Java-类/对象之间的关系-聚合(Aggregation)
  2.     1-1、聚合关系，一种整体与部分的关系，通常在定义一个整体类后，再去分析这个整体类的组成结构，从而找出一些成员类，该整体类和成员类之间就形成了聚合 关系。 
  3.     1-2、在聚合关系中，成员类是整体类的一部分，即成员对象是整体对象的一部分，但是成员对象可以脱离整体对象独立存在。
  4.     1-3、在UML中，聚合关系用带空心菱形的直线表示。
  5.     1-4、聚合关系-举例代码：
  6.         public class Student{
  7.         }
  8.         public class School{  
  9.                private List students ;  //学校与学生是聚合关系
  10.         }

1.5、Java-类/对象之间的关系-组合(Composition)

  1. 1、Java-类/对象之间的关系-组合(Composition)
  2.     1-1、组合关系，表示类之间整体和部分的关系；组合关系中部分和整体具有统一的生存期。一旦整体对象不存在，部分对象也将不存在，部分对象与整体对象之 间具有同生共死的关系。 
  3.     1-2、组合关系中，成员类是整体类的一部分，而且整体类可以控制成员类的生命周期，即成员类的存在依赖于整体类。
  4.     1-3、在UML中，组合关系用带实心菱形的直线表示。 
  5.     1-4、组合关系-举例代码：
  6.         //菜单的存在前提是窗口的存在，两者之间存在很强的拥有关系。
  7.         //且窗口对菜单的生命周期负责，只有在窗口创建之后，菜单才能够创建，
  8.         //菜单必须在窗口销毁之前销毁。
  9.         public class Menu{
  10.         }
  11.         public class Window{
  12.                private List menus = new ArrayList<Menu>();
  13.         }

1.6、Java-类/对象之间的关系-实现(Implementation)

  1. 1、Java-类/对象之间的关系-实现(Implementation)
  2.     1-1、接口之间也可以有与类之间关系类似的继承关系和依赖关系，但是接口和类之间还存在一种实现关系(Realization)。
  3.     1-2、类实现了接口，类中的操作实现了接口中所 声明的操作。
  4.     1-3、在UML中，类与接口之间的实现关系用带空心三角形的虚线来表示。 
  5.     1-4、实现关系-举例代码：
  6.         public interface Vehicle {  
  7.             public void move();  
  8.         }  
  9.         public class Ship implements Vehicle {  
  10.             public void move()   
  11.             {  
  12.             ……  
  13.             }  
  14.         }