对象之间的关系

男娘i 2023-09-25 15:08 72阅读 0赞

#### 目录 ####

*  1. 依赖
 *  2. 关联
 *  3. 聚合
 *  4. 组合
 *  5. 继承
 *  6. 实现

Java的对象/类之间有四种关系：依赖、关联、组合、聚合、继承、实现。

## 1. 依赖 ##

**依赖（Dependency）：** 一个对象的功能依赖于另一个对象。

*  类比：人类生存依赖食物和空气
 *  体现：被依赖者体现为依赖者的局部变量、参数、静态方法的调用
 *  示例：  
      
    UML：  
    ![579bd5b130c7425ea78ee497907d32f4.png][]  
    code：
    
        public class Human {
              
            public void live(Food food) {
              
                Air.breath();
                food.eat();
            }
        }
        
        class Air {
              
            public static void breath() {
              
                System.out.println("呼吸...");
            }
        }
        
        class Food {
              
            public void eat() {
              
                System.out.println("进食...");
            }
        }

## 2. 关联 ##

**关联（Association）：** 一个类需要知道另一个类的情况（属性、方法），可以是双向，也可以是单向。

*  类比：人类进食需要知道食物有没有过期
 *  体现：关联的对象一般是作为成员变量
 *  示例：  
      
    UML：  
    ![7ec39140055a4101abf6c0c645912d1a.png][]  
    code：
    
        public class Human {
              
        
            private Food food;
            public void judge() throws ParseException {
              
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");
                if (format.parse(food.getExpiration()).compareTo(new Date()) > 0 ) {
              
                    food.eat();
                } else {
              
                    System.out.println("食物已经过期");
                }
            }
        
            public Human(Food food) {
              
                this.food = food;
            }
        }
        
        class Food {
              
        
            private String expiration;
        
            public void eat() {
              
                System.out.println("食物安全，可以食用");
            }
        
            public Food() {
              
                this.expiration = "2023-04";
            }
        
            public String getExpiration() {
              
                return expiration;
            }
        }

## 3. 聚合 ##

**聚合（Aggregation）：** 一种强关联关系（has-a），关联（Association）的对象是同一层级的，而聚合（aggregation）则是整体与组成个体之间的关系。不同整体之间**可以共享个体**，比如说氢分子也由氢原子组成。

*  类比：水分子由氢原子和氧原子组成
 *  体现：被聚合对象作为成员变量
 *  实例:  
      
    UML:  
    ![16e56309d79943c49bd69047e168546b.png][]  
    code：
    
        public class WaterMolecule {
              
        
            private HydrogenAtom2 hydrogenAtom2;
            private OxygenAtom atom;
        
            public WaterMolecule(HydrogenAtom2 hydrogenAtom2, OxygenAtom atom) {
              
                this.hydrogenAtom2 = hydrogenAtom2;
                this.atom = atom;
            }
        }
        
        class OxygenAtom {
              
        
        }
        
        class HydrogenAtom2 {
              
        
        }

## 4. 组合 ##

**组合（Compostion）：** 比聚合更强的关联关系（is-a），组合关系要求聚合关系中代表整体的对象要负责代表个体/部分的对象的整个生命周期，所以**组合关系不能共享**。如果代表整体的对象被销毁或破坏,那么代表个体的对象也一定会被销毁或破坏。

*  类比：人和人的心脏、大脑
 *  体现：个体对象作为成员变量
 *  实例：  
      
    UML：  
    ![7e17304535a14cc08e0edcc448858406.png][]  
    code：
    
        public class Human {
              
            private Brain brain;
            private Heart heart;
            private String status;
        
            public void sustainLife() {
              
                brain.control(status);
                heart.beat(status);
            }
        
            public Human(Brain brain, Heart heart, String status) {
              
                this.brain = brain;
                this.heart = heart;
                this.status = status;
            }
        }
        
        class Brain {
              
            public void control(String status) {
              
                if (status.equals("0")) {
              
                    System.out.println("脑死亡");
                } else {
              
                    System.out.println("大脑控制身体");
                }
            }
        }
        
        class Heart {
              
            public void beat(String status) {
              
                if (status.equals("0")) {
              
                    System.out.println("心跳停止");
                } else {
              
                    System.out.println("心脏跳动");
                }
            }
        }

## 5. 继承 ##

**继承（extends）：** 对象之间耦合度最大的一种关系，是父与子的关系。

*  类比：父亲和儿子
 *  体现：子类（派生类）和父类（基类、超类）
 *  实例：  
      
    UML:  
    ![14cbbc85c5014c24a2d9450befb6e9b6.png][]  
    code:
    
        public class Tom {
              
        	public void farm() {
              
        		System.out.println("种地");
        	}
        }
        
        class Jack extends Tom {
              
        	@Override
        	public void farm() {
              
        		System.out.println("种地");
        	}
        
        	public void makeWine() {
              
        		System.out.println("酿酒");
        	}
        }

## 6. 实现 ##

**实现（implements）：** 接口与实现类之间的关系，实现类需要实现接口中所声明的所有方法。

*  实例：  
      
    UML:  
    ![ea46e8b09fc9402899b3e976feccf45f.png][]  
    code:
    
        public interface Animal {
              
            void live();
        }
        
        class Cat implements Animal {
              
            @Override
            public void live() {
              
                System.out.println("生存");
            }
        }

[579bd5b130c7425ea78ee497907d32f4.png]: https://img-blog.csdnimg.cn/579bd5b130c7425ea78ee497907d32f4.png
[7ec39140055a4101abf6c0c645912d1a.png]: https://img-blog.csdnimg.cn/7ec39140055a4101abf6c0c645912d1a.png
[16e56309d79943c49bd69047e168546b.png]: https://img-blog.csdnimg.cn/16e56309d79943c49bd69047e168546b.png
[7e17304535a14cc08e0edcc448858406.png]: https://img-blog.csdnimg.cn/7e17304535a14cc08e0edcc448858406.png
[14cbbc85c5014c24a2d9450befb6e9b6.png]: https://img-blog.csdnimg.cn/14cbbc85c5014c24a2d9450befb6e9b6.png
[ea46e8b09fc9402899b3e976feccf45f.png]: https://img-blog.csdnimg.cn/ea46e8b09fc9402899b3e976feccf45f.png