对象之间的关系

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

1. 依赖

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

• 类比：人类生存依赖食物和空气

• 体现：被依赖者体现为依赖者的局部变量、参数、静态方法的调用

• 示例：
  
  UML：
  
  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：
  
  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:
  
  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：
  
  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:
  
  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:
  
  code:

  public interface Animal {
      void live();
  }
  
  class Cat implements Animal {
      @Override
      public void live() {
          System.out.println("生存");
      }
  }