类之间的6中关系

总述

java类之间有6种关系,分别是依赖关系(dependence), 关联关系(association), 聚合关系(aggregation), 组合关系(composition), 继承关系(generalization), 实现关系(implementation). 他们的耦合度一次递增, 并且聚合关系, 组合关系也是关联关系的一种.
一个类作为另一个类的成员变量，可能的关系是关联关系、聚合关系、组合关系

代码的形式介绍6种关系

依赖关系(dependence)

概念: 类A当中使用了类B，其中类B是作为类A的方法参数、方法中的局部变量、或者静态方法调用。
代码演示
Book.java

public class Book {
    private String name="《红楼梦》";
    public String getName(){
        return this.name;
    }
}

People.java

public class People {
//    Book作为read()方法的形参
    public void read(Book book){
        System.out.println("读的书是 "+ book.getName());
    }
}

解释
依赖关系是类与类之间的联接, 一个类依赖于另一个类的定义. 例如, 一个人看书, 人这个类, 依赖于书这个类, 如果没有书, 人怎么有看书这个行为呢? 依赖关系通常是作为另一个类的局部变量或者方法的参数, 或者调用书这个类的静态方法.

关联关系(association)

概念: 单向关联表现为：类A当中使用了类B，其中类B是作为类A的成员变量。双向关联表现为：类A当中使用了类B作为成员变量；同时类B中也使用了类A作为成员变量。
代码演示
Son.java

public class Son {
    private String name;
    Father father=new Father();
    public String getName(){
        return this.name;
    }
    public void giveGift(){
        System.out.println("送给" + father.getName() + "礼物");
    }
}

Father.java

public class Father {
    private String name;
    Son son = new Son();
    public String getName(){
        return this.name;
    }
    public void getGift(){
        System.out.println("从" + son.getName() + "获得礼物");
    }
}

解释
关联关系是一个类获得另一个类的属性和方法.关联关系可以是单向的,也可以是双向的.例如:儿子送个父亲一个礼物,儿子和父亲都需要打印一句话.从儿子的角度,儿子需要知道父亲的名字,从父亲的角度,父亲需要知道儿子的名字,于是就需要在各自的类中实例对方的类,为得到对方的名字,这样,儿子和父亲都可以访问对方的属性和方法了.

聚合关系(aggregation)

概念: 聚合关系是关联关系的一种，耦合度强于关联，他们的代码表现是相同的，仅仅是在语义上有所区别：关联关系的对象间是相互独立的，而聚合关系的对象之间存在着包容关系，他们之间是“整体-个体”的相互关系。
代码演示
Car.java

public class Car {
    private String type;
    public String getType(){
        return this.type;
    }
}

House.java

public class House {
    private String address;
    public String getAddress(){
        return this.address;
    }
}

People.java

public class People {
    Car car;
    House house;
//  聚合关系中作为成员变量的类一般使用set方法赋值   
    public void setCar(Car car){   
        this.car = car;   
    }   
    public void setHouse(House house){   
        this.house = house;   
    }   
 
    public void driver(){   
        System.out.println("车的型号：" + car.getType());   
    }   
    public void sleep(){   
        System.out.println("我在房子里睡觉：" + house.getAddress());   
    }   
}

解释
聚合关系是强的关联关系.它有包含之意,关联关系的类是在一个平行位置,这是与关联关系的区别.

组合关系(composition)

概念: 相比于聚合，组合是一种耦合度更强的关联关系。存在组合关系的类表示“整体-部分”的关联关系，“整体”负责“部分”的生命周期，他们之间是共生共死的；并且“部分”单独存在时没有任何意义。
代码演示
Body.java

public class Body {
    private String name;
    public String getName(){
        return this.name;
    }
}

Soul.java

public class Soul {
    private String name;
    public String getName(){
        return this.name;
    }
}

People.java

public class People {
    Soul soul;
    Body body;
  //组合关系中的成员变量一般会在构造方法中赋值  
    public People(Soul soul, Body body){   
       this.soul = soul;  
       this.body = body;  
   }  
 
   public void study(){  
       System.out.println("学习要用灵魂"+soul.getName());  
   }  
   public void eat(){  
       System.out.println("吃饭用身体："+body.getName());  
   }  
}

解释
它也是关联关系,但是聚合度比聚合关系还要强.组合关系是整体-部分,部分单独存在没有意义,需要与整体结合使用.也就是表示整体的这个类负责部分的这些类的生命周期,整体消亡,部分也就不存在了.

继承关系(generalization)

概念: 类A当中使用了类B，其中类B是作为类A的方法参数、方法中的局部变量、或者静态方法调用。
代码演示
Animal.java

public class Animal {
    private void getPrivate(){
        System.out.println("private");
    }
    void getDefault(){
        System.out.println("default");
    }
    protected void getProtected(){
        System.out.println("protected");
    }
    public void getPublic(){
        System.out.println("public");
    }
}

Dog.java

public class Dog extends Animal{
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.getDefault();
        dog.getProtected();
        dog.getPublic();
    }
}

输出结果

default
protected
public

解释
继承关系是非常常用的一种关系,使用extends来进行子类继承父类.子类可以继承父类的非私有属性和方法

实现关系(implementation)

概念: 表示一个类实现一个或多个接口的方法。接口定义好操作的集合，由实现类去完成接口的具体操作。在java中使用implements表示。

代码演示
IPeople.java

public interface IPeople {
    public void eat();
}

People.java

public class People implements IPeople{
 
    @Override
    public void eat() {
        System.out.println("人正在吃饭。。。");
    }
}

解释
实现是指一个类实现一个接口,接口使用interface定义,接口并不是一个类.接口中属性只有常量,方法是抽象的,只能定义,不能包含方法体,并且属性和方法都必须是public的(即使不写方法修改符,也是公共方法),实现类必须使用implements去实现接口的所有方法,可以为空方法.
转载自： https://blog.csdn.net/guobailu/article/details/82193560