UML简单介绍—类图详解

类图详解

1、泛化关系

　　一个动物类：

 1 /**
 2  * 动物类
 3  */
 4 public class Animal {
 5 
 6     public String name;//名字
 7     public int age;//年龄
 8 
 9     public String getName() {
10         return name;
11     }
12 
13     public void setName(String name) {
14         this.name = name;
15     }
16 
17     public int getAge() {
18         return age;
19     }
20 
21     public void setAge(int age) {
22         this.age = age;
23     }
24 }

　　属性的表示方式为：【可见性】【属性名称】：【类型】={缺省值，可选}

　　方法的表示方式为：【可见性】【方法名称】（【参数列表】）：【类型】

　　如下：

　　子类Dog：

 1 public class Dog extends Animal{
 2 
 3     private String sound = "汪汪";//声音
 4 
 5     protected void sleep(){
 6         System.out.println("睡四个小时");
 7     }
 8 
 9     public String getSound() {
10         return sound;
11     }
12 }

　　子类Cat：

 1 public class Cat extends Animal {
 2 
 3     private String sound = "喵喵";//声音
 4 
 5     protected void sleep(){
 6         System.out.println("睡六个小时");
 7     }
 8 
 9     public String getSound() {
10         return sound;
11     }
12 }

　　类图表示如下：

2、实现关系

　　动物接口：

1 /**
2  * 动物接口
3  */
4 public interface Animal {
5 
6     public void getName();
7     public void getAge();
8 }

　　实现类Dog：

 1 public class Dog implements Animal{
 2 
 3     @Override
 4     public void getName() {
 5         System.out.println("我是小汪");
 6     }
 7 
 8     @Override
 9     public void getAge() {
10         System.out.println("我4岁了");
11     }
12 }

　　实现类Cat：

 1 public class Cat implements Animal {
 2 
 3     @Override
 4     public void getName() {
 5         System.out.println("我是小喵");
 6     }
 7 
 8     @Override
 9     public void getAge() {
10         System.out.println("我3岁了");
11     }
12 }

3、依赖关系

　　人过河要依赖船，鱼依赖水，动物依赖水、食物和空气等，这些都是依赖关系。

　　船类:

1 public class Ferry {
2 
3     public void move(){
4 
5     }
6 }

　　人依赖船，船类作为参数、属性被类Person在某个method方法中使用。

1 public class Person {
2 
3     /**
4      * 人过河要使用船（依赖船）
5      */
6     public void boating(Ferry ferry){
7         ferry.move();
8     }
9 }

4、关联关系

　　关联是一种拥有关系，人拥有手机。被拥有者作为拥有者的成员变量存在。

　　被拥有着：

1 public class Mobile {
2 
3     /**
4      * 手机有看视频功能
5      */
6     public void watchTV(){
7 
8     }
9 }

　　拥有者：

 1 public class Person {
 2 
 3     //被拥有者成员变量
 4     private Mobile mobile;
 5 
 6     /**
 7      * 人拥有手机可以看视频
 8      */
 9     public void watchTV(){
10         mobile.watchTV();
11     }
12 }

5、聚合关系

　　聚合是整个与个体的关系，此时整体和部分是可以分离的。作为一个程序员，每天都和电脑打交道，我们以电脑为例，假设电脑有显示器、主机、键盘组成的。

1 /**
2  * 显示器
3  */
4 public class Monitor {
5 }

1 /**
2  * 主机
3  */
4 public class Host {
5 }

1 /**
2  * 键盘
3  */
4 public class keyboard {
5 }

 1 import javax.swing.*;
 2 
 3 public class Computer {
 4 
 5     private Monitor monitor;//显示器
 6     private Host host;//主机
 7     private KeyStroke keyStroke;//键盘
 8 
 9     public Computer(Monitor monitor, Host host, KeyStroke keyStroke) {
10         this.monitor = monitor;
11         this.host = host;
12         this.keyStroke = keyStroke;
13     }
14 
15     public void program(){
16         System.out.println("开始编程");
17     }
18 }

6、组合关系

　　组合关系：是整体与部分的关系，但部分不能离开整体而单独存在。组合关系是关联关系的一种，是比聚合关系还要强的关系，它要求普通的聚合关系中代表整体的对象负责代表部分的对象的生命周期。比如大雁有两个翅膀，雁翅无法脱离大雁而单独生存。

 1 /**
 2  * 大雁
 3  */
 4 public class WildGoose {
 5 
 6     private Wing wing;//翅膀
 7 
 8     public WildGoose(Wing wing) {
 9         wing = new Wing();
10     }
11 }

1 /**
2  * 翅膀
3  */
4 public class Wing {
5 }

总合实例：

　　一个动物类，动物依赖氧气、水、食物；

　　鸟类继承动物，是泛化关系；

　　鸟类和翅膀是组合关系；

　　大雁和鸭继承鸟类，是泛化关系；

　　大雁实现飞行接口，和雁群是聚合关系；

　　唐老鸭继承鸭类，是泛化关系，实现讲话接口；