设计模式之UML类图六大关系辨析【2】

　　六大关系：继承(extends)、实现(Realization)、依赖(use-a)、关联(association)、聚合(has-a)、组合(强聚合)(Composition)。

　　类与类之间的强弱关系：NULL<依赖<关联<聚合<组合

　　

　　有事没事，懂与不懂，先见此图。

　　一、继承/泛化(Extends;is-a)　

　　　　指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力，继承是类与类或者接口与接口之间最常见的关系。

　　　

abstract class Animal{
        //property
        public boolean 有生命力;
 
        //action/method
        public void 新陈代谢(O2 氧气,Water 水);
        public void 繁殖();
}
abstract class Bird extends Animal{
　　　　 //property
        public Object 羽毛;
        public Object 眼睛;
        public Object 脚;
 
        public java.util.Collection<翅膀> 翅膀;　　
 
        //action/method
        public 鸟蛋 下蛋(){...}
 
}   

　　

　　二、实现(Realization)

　　　　指的是一个class类实现interface接口（可以是多个）的功能；实现是类与接口之间最常见的关系；在Java中此类关系通过关键字implements明确标识，在设计时一般没有争议性；

interface 说话{
   public void 说话();
}
 
public class 唐老鸭 extends 鸭 implements 说话 {
 
   //property
   public void 讲人话() {
      // TODO: implement
   }
 
}

　　三、依赖（Dependency;use-a）　　

　　　　一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是B类的变化会可能会影响到A；

class 氧气 {...}
 
class 水{...}
 
abstract class Animal{
        //property
        public boolean 有生命力;
 
        //action/method
        public void 新陈代谢(O2 氧气,Water 水);
        public void 繁殖();
}

　　

　　四、关联(Association)【较为混淆和难以理解的】

　　　　他体现的是两个类、或者类与接口之间语义级别的一种强依赖关系，比如我和我的朋友；这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的、关联可以是单向、双向的；表现在代码层面，为被关联类B以类属性的形式出现在关联类A中，也可能是关联类A引用了一个类型为被关联类B的全局变量；

　　

class 气候{
}
 
class 企鹅 extends Bird {
　　    //property
　　　　 public 气候 气候;
 
        //action/method
        public 企鹅蛋 下蛋(){...}
 
}　

　　补充：

　　关联描述两个类之间行为的一般二元关系。例如，一个学生选修一门特定的课程是学生类Student和课程类Course之间的一个关联，而一个教师教授一门课程是师资类Faculty和课程类Course之间的一个关联。Java代码中，关联可以用属性和方法来实现。

public class Student {
    private Course[] courses;
 
    public void addCourse(Course s) {
        . . . . . .
    }
}
 
public class Course {
    private Strudent[] students;
    private Faculty faculty;
 
    public void addStudent(Student s) {
        . . . . . .
    }
 
    public void setFaculty(Faculty faculty) {
        this.faculty = faculty;
    }
}
 
public class Faculty {
    private Course[] courses;
 
    public void addCourse(Course s) {
        . . . . . .
    }
}

　　五、聚合(has-a)

　　聚合是关联关系的一种特例，他体现的是整体与部分、拥有的关系，即has-a的关系，此时整体与部分之间是可分离的，他们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享；比如计算机与CPU、公司与员工的关系等；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；　

class 大雁 extends Bird implements 飞翔{
 
        //action/method
        public 雁蛋 下蛋(){...}
        public void 飞(){...}
}
 
class 雁群 {
       //property
       public 大雁 obj_大雁;
 
       //action/method
       public void V形飞行();
       public void 人形飞行(); 
 
}

　　补充：一家公司拥有多名员工

public class Company {
    private List<Employee> employees;
}
 
public class Employee {
    private String name;
}

　　六、组合（强聚合）（contains-a）　

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

　　

abstract class Bird extends Animal{
　　　　 //property
        public Object 羽毛;
        public Object 眼睛;
        public Object 脚;
 
        public java.util.Collection<翅膀> 翅膀;　　
 
        //action/method
        public 鸟蛋 下蛋(){...}
 
}   

　　补充：

　　 聚合是一种较弱形式的对象包含(一个对象包含另一个对象)关系。较强形式是组合(Composition). 在组合关系中包含对象负责被包含对象的创建以及生命周期，即当包含对象被销毁时被包含对象也会不复存在。例如一辆汽车拥有一个引擎是汽车类Car与引擎类Engine的组合关系。下面是组合的一些例子。　　

(1)通过成员变量初始化
public class Car {
    private final Engine engine = new Engine();
}
 
class Engine {
    private String type;
}
 
(2)通过构造函数初始化 
public class Car {
    private final Engine engine;  
 
    public Car(){
       engine  = new Engine();
    }
}
 
public class Engine {
    private String type;
}
 
(3)通过延迟初始化
public class Car {
    private final Engine engine;
    public Engine getEngine() {
        if (null == engine) {
            engine = new Engine();
        }
        return engine;
    }
}
 
public class Engine {
    private String type;
}

=====================================================

补充：

　　参考文献

　　　　[1] 《UML类图中的六大关系：关联、聚合、组合、依赖、继承、实现》