依赖(Dependence)
- 表示一个类依赖于另一个类的定义。依赖关系总是单向的。
- 简单的理解,就是一个类A使用到了另一个类B,而这种使用关系是具有偶然性的、临时性的、非常弱的,但是B类的变化会影响到A。
- 在代码层面,表现为类B作为参数被类A在某个method方法中使用。具体体现为局部变量、方法中的参数、静态方法的调用等。
代码实例:
public class Book {
private String name;
public Book() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class Food {
private String name;
public Food() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class People {
private String name;
public People(String name) {
this.name = name;
}
//Dependency
public void eat(Food food){
System.out.println("eat " + food.getName());
}
//Dependency
public void read(Book book){
System.out.println("read " + book.getName());
}
}
public class Main {
public static void main(String[] args) {
People people = new People("White");
Food food = new Food();
food.setName("seafood");
Book book = new Book();
book.setName("cs");
people.eat(food);
people.read(book);
}
}
以上代码中People类依赖Food类和Book类,这种依赖关系表现为Food类和Book类作为People类中方法的参数,局部变量和静态方法调用的情况也比较简单,此处省略。
关联(Association)
- 表示类与类之间的联接, 它使一个类知道另一个类的属性和方法。
- 关联可以使用单箭头表示单向关联, 使用双箭头或不使用箭头表示双向关联, 不建议使用双向关联.。关联有两个端点, 在每个端点可以有一个基数, 表示这个关联的类可以有几个实例。
- 单向关联表现为类A当中使用了类B,其中类B是作为类A的成员变量。双向关联表现为类A当中使用了类B作为成员变量,同时类B中也使用了类A作为成员变量。
代码实例:
public class Father {
//Association
private Son son;
public Father() {
}
public void giveGift(){
System.out.println("father gives a gift to son");
}
public Son getSon() {
return son;
}
public void setSon(Son son) {
this.son = son;
}
}
public class Son {
//Association
private Father father;
public Son() {
}
public void getGift(){
System.out.println("son gets a gift from father");
}
public Father getFather() {
return father;
}
public void setFather(Father father) {
this.father = father;
}
}
public class Main {
public static void main(String[] args) {
Father father = new Father();
Son son = new Son();
father.setSon(son);
son.setFather(father);
father.giveGift();
son.getGift();
}
}
以上代码中Father类和Son类相互关联,各自使用对方作为自己的成员变量。
聚合(Aggregation)
- 聚合是关联关系的一种特例,耦合性比关联关系更强。
- 聚合表示的是整体与个体之间的关系,即has-a的关系。
- 整体与个体之间是可以分离的,他们各自有自己的生命周期。
- 它和关联关系的区别在于,关联关系的两个类是同等级别的,而聚合关系中有整体和个体的区分。
代码实例:
public class House {
private String address;
public House(String address) {
this.address = address;
}
public void getHouseAddress(){
System.out.println(this.address);
}
}
public class Car {
private String brand;
public Car(String brand) {
this.brand = brand;
}
public void getCarBrand(){
System.out.println(this.brand);
}
}
public class People {
private House house;
private Car car;
public People() {
}
public void showAssets(){
house.getHouseAddress();
car.getCarBrand();
}
public House getHouse() {
return house;
}
public void setHouse(House house) {
this.house = house;
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
}
public class Main {
public static void main(String[] args) {
House house = new House("Central Park");
Car car = new Car("Ford");
People p = new People();
p.setCar(car);
p.setHouse(house);
p.showAssets();
}
}
以上代码中People类和House类、Car类是一个整体与个体的关系,它们都有各自的生命周期,是一种聚合关系。
组合(Composition)
- 组合关系也是关联关系的一种特例,耦合性比聚合关系更强,它体现的是整体与部分的关系,表现为contains-a。整体和部分是不可分割的,要么同生,要么共死。
代码实例:
public class Body {
public Body() {
}
public void showBody(){
System.out.println("body");
}
}
public class Soul {
public Soul() {
}
public void showSoul(){
System.out.println("soul");
}
}
public class People {
private Body body;
private Soul soul;
public People(Body body,Soul soul) {
this.body = body;
this.soul = soul;
}
public void print(){
body.showBody();
soul.showSoul();
}
}
public class Main {
public static void main(String[] args) {
People people = new People(new Body(),new Soul());
people.print();
}
}
以上代码中,People类和Body类、Soul类是整体与部分的关系,它们同生同死,不能分离单独存在。比如,这边Body和Soul都是在People的构造函数中实例化的,表示同生,且不能更换。而在前面的聚合关系中,People的House和Car是可以随时更换的。
继承/泛化(Generalization)
- 表示类与类(或者接口与接口)之间的父子关系。
代码实例:
public class Animal {
public Animal() {
}
public void makSound(){
System.out.println("Animal make sound!");
}
}
public class Human extends Animal{
public Human() {
}
@Override
public void makSound() {
System.out.println("Human make sound!");
}
}
public class Main {
public static void main(String[] args) {
Animal peter = new Human();
peter.makSound();
}
}
实现(Implementation)
- 表示一个类实现一个或多个接口的方法,接口定义好操作的集合,由实现类去完成接口的具体操作。
代码实例:
public interface Animal {
public void eat();
public void move();
}
public class Human implements Animal {
public Human() {
}
@Override
public void eat() {
System.out.println("Human eat...");
}
@Override
public void move() {
System.out.println("Human move...");
}
}
public class Main {
public static void main(String[] args) {
Animal mason = new Human();
mason.eat();mason.move();
}
}
结束。