深入解析类与类之间的关系

 类之间的关系有五种：继承、依赖、关联、聚合、组合.在UML绘制图的过程中我们也要使用这五种关系图.

*1 、关 联  Association    关联指的是类之间的引用关系。这是实体域对象之间最普遍使用最广泛的一种关系。关联可分为一对一、一对多和多对多关联

 

案例：

Customer( 客户 ) 对象与 Orders( 订单 ) 对象之间就存在着一对多的关联关系 , 一个 Customer( 客户 ) 可以有多个 Orders( 订单 ), 而一个 Orders( 订单 ) 只能属于一个 Customer( 客户 ) 。显然客户与订单之间存在着一对多的关系 , 反之订单与客户之间存在着多对一的关系。

那么对于 java 中的类到底怎么实现一对多与多对一得关联呢 ?

  答 : 如果类 Customer 与 Orders 关联 , 那么第一种方式：在 Customers( 客户 ) 类中定义集合 Orders( 订单 ) 类的对象作为 Customer( 客户 )  类的一个属性 . 这样就解决了 Customer 类与 Orders 类之间的一对多的关系了 . 具体的代码如下：

package  redarmy_chen.edu;

 

import  java.util.HashSet;

import  java.util.Set;

 

public  class  Customer {

     /**  客户的 ID */

     private  int  id ;

     /**  客户的名称  */

     private  String  name ;

     /**  客户的邮箱  */

     private  String  email ;

 

     /**  所有与客户 Customer 对象关联的 Order 对象  */

     private  Set<Orders> allOrders = new HashSet<Orders>();

 

     /** 默认的构造器 */

     public  Customer() {

 

    }

     /** 完整的构造器 */

     public  Customer( int  id, String name, String email, Set<Orders> allOrders) {

        this . id  = id;

        this . name  = name;

        this . email  = email;

        this . allOrders  = allOrders;

    }

 

     /** 下面是对应私有属性的 set get 方法  */

     public  int  getId() {

        return  id ;

    }

 

     public  void  setId( int  id) {

        this . id  = id;

    }

 

     public  String getName() {

        return  name ;

    }

 

     public  void  setName(String name) {

        this . name  = name;

    }

 

     public  String getEmail() {

        return   email ;

    }

 

     public  void  setEmail(String email) {

        this . email  = email;

    }

 

     public  Set<Orders> getAllOrders() {

        return   allOrders ;

    }

 

     public  void  setAllOrders(Set<Orders> allOrders) {

        this . allOrders  = allOrders;

    }

 

}

以上就构成了 Customer 类到 Orders 类的一对多关联。关联的 EA 图如图 1.1 所示：

图 1.1

同样也可以建立从 Orders 类到 Customer 类的关联 , 一个 Orders 类的对象只能对应一个 Customer 的对象 , 因此在 Orders 类中定义一个 Customer 对象 , 来存放该订单属于哪个客户。这样就可实现 java 类中的多对一的关系了 . 具体代码如下：

package  redarmy_chen.edu;

 

public  class  Orders {

     /** Orders 订单对象的序号 ID */

     private  int  id ;

     /** Orders 订单对象的编号  */

     private  String  orderNumber ;

     /** Orders 订单对象的价格  */

     private  double  price ;

     /**  与 Orders 对象关联的 Customer 对象  */

     private  Customer  customer ;

 

     public  Orders() {

 

    }

 

     public  Orders( int  id, String orderNumber,  double  price, Customer customer) {

        this . id  = id;

        this . orderNumber  = orderNumber;

        this . price  = price;

        this . customer  = customer;

    }

 

     /**  下面是对应私有属性的 set get 方法  */

     public  int  getId() {

        return  id ;

    }

 

     public  void  setId( int  id) {

        this . id  = id;

    }

 

     public  String getOrderNumber() {

        return  orderNumber ;

    }

 

     public  void  setOrderNumber(String orderNumber) {

        this . orderNumber  = orderNumber;

    }

 

     public  double  getPrice() {

        return  price ;

    }

 

     public  void  setPrice( double  price) {

        this . price  = price;

    }

 

     public  Customer getCustomer() {

        return  customer ;

    }

 

     public  void  setCustomer(Customer customer) {

        this . customer  = customer;

    }

 

}

以上就构成了 Orders 类到 Customer 类的多对一的关联。关联的 EA 图如 1.2 图所示：

图 1.2

同过以上的讲解我们又可以把关联分为单向关联和双向关联

a、 单向关联：仅仅建立从 Customer 到 Orders 的一对多的关联 , 即仅仅在 Customer 类中定义 allOrders 集合 , 或者仅仅建立从 Orders 到 Customer 的多对一的关联 , 即仅仅在 Orders 类中定义 customer 属性 ( 参考以上两个图的结果 ) 。

b、 双向关联 : 即建立从 Customer 到 Orders 的一对多的关联 , 又建立从 Orders 到 Customer 的多对一的关联。如图 1.3 所示：

图 1.3

*2 、 依赖  Dependency  依赖指的是类之间的访问关系 。如果类 A 访问类 B 的属性或方法，或者类 A 负责实例化类 B,  那么可以说类 A 依赖类 B

和关联关系不同，无需把类 B 定义为类 A 的属性

案例 1 ：在原有的 Customer 类的基础之上 , 我们再创建一个 CustomerOper 的类 , 此类完成向数据库表中插入一条 Customer( 客户 ) 记录 . 代码如下：

package  redarmy_chen.edu;

 

public  class  CustomerOper {

     /** 在此方法中我们使用到 Customer 类对象 并使用此对象的属性 或者方法 */

     public  boolean  insert(Customer customer){

/** 在此方法中省略了插入数据库实现的方法 , 如果学员有兴趣可以自己实现 */

        return  false ;

    }

}

以上就构成了 CustomerOper 类到 Customer 类的依赖关系。依赖的 EA 图如 1.4 图所示：

                                      图1.4

案例 2 ：在原有的 Customer 类的基础 , 创建 CreateCustomer 类 , 此类负责创建一个 Customer 类的实例 . 代码如下：

package  redarmy_chen.edu;

 

public class  CreateCustomer {

     /** 在此负责创建一个 Customer 的实例并返回 */

     public  Customer loadCustomer(){

        /** 具体实现方法省略  */

        return  null ;

    }

 

}

以上就构成了 CustomerCreate 类到 Customer 类的依赖关系。依赖的 EA 图如 1.5 图所示：

       

此外 , 软件应用中上层的类总是依赖下层的类或接口 . 比如在业务逻辑层的类依赖持久化层的类或接口。

  总结：谁使用了谁 , 谁负责创建谁 = è 谁就依赖谁。

 

*3 、 聚合  Aggregation 聚集是关联关系的一种特例 聚集指的是整体与部分之间的关系   他体现的是整体与部分、拥有的关系，即 has-a 的关系，此时整体与部分之间是可分离的，他们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享；比如计算机与 CPU 、公司与员工的关系等；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；例如：人与手就是聚集关系 . 由于聚集关系比较简单 , 通过图 1.6 所示：

                 

 

*4 、 组合也是关联关系的一种特例，他体现的是一种 contains-a 的关系，这种关系比聚合更强，也称为强聚合；他同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束；比如你和你的大脑；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；如图 1.7 所示

                

*5 、一 般化  Generalization  一般化值得是类之间的继承关系 在学习面向对象的时候老师都会重点讲解：下面给出 EA 图的绘制方法如图 1.8 所示