总述
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去实现接口的所有方法,可以为空方法.