第十二课类间关系

原创已于 2024-11-15 00:04:43 修改 · 388 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#java

于 2024-11-05 21:35:58 首次发布

java基础专栏收录该内容

4 篇文章

订阅专栏

Java类间关系一共有六种。

1、继承

一个情景：相同特征：高度、体重

独特特征：猫（胡须）、狗（嗅觉灵敏）、鱼（鳃）、螃蟹（壳）、鹰（喙）、乌鸦（黑羽）

描述：一个类（子类）继承另一个类（父类）的属性和方法。

继承的代码逻辑:子类有父类的特征。但是不用重复写代码，提高代码的复用能力。

继承的现实逻辑: is a关系。猫 is a 动物。所以猫是动物的子类，动物是猫的父类。

ps：现实情境下子类和对象的区分。

实际例子：一个Bird类继承Animal类。

子类从父类继承过来的属性/方法，不用重写即存在，可以直接使用或者访问。子类可以重写父类的方法，从而实现更加具体的功能，称之为多态。

编程实现：

public class Animal {
    private Double weight;
    
    public Double getWeight() {
        return weight;
    }

    public void setWeight(Double weight) {
        this.weight = weight;
    }
    
    public void move(){
        System.out.println("移动了");
    }
    public void eat(){
        System.out.println("吃饭了");
    }
}

public class Bird extends Animal{
    private int wingsNumber;

    public int getWingsNumber() {
        return wingsNumber;
    }

    public void setWingsNumber(int wingsNumber) {
        this.wingsNumber = wingsNumber;
    }
    
    @Override
    public void move(){
        System.out.println("飞翔了");
    }

    public static void main(String[] args) {
        Bird bird = new Bird();
        bird.setWingsNumber(2);
        bird.setWeight(20.5);
        System.out.println("翅膀数："+bird.getWingsNumber());
        System.out.println("重量："+bird.getWeight());
        bird.eat();
        bird.move();

        //Bird bird3 = new Animal();  这样是错的 动物不一定是鸟
        Animal bird2 = new Bird();    //这样可以 鸟一定是动物
        bird2.move();
        
        //输出结果
        //翅膀数：2
        //重量：20.5
        //吃饭了
        //飞翔了
        //飞翔了

    }
}

员工有id、有姓名，能工作，能下班；某部门员工有码龄，工作是敲代码。

2、实现

一个情景：猫、狗是一种陆地生物；鱼、螃蟹是一种水生生物；陆地生物和水生生物是一种动物。Java支持传递式继承、但不支持多继承。猫是一种哺乳动物、食肉动物。

描述：一个类实现了一个接口。

接口只有方法，没有属性。且方法只有抽象声明没有具体实现。

实际例子：一个Square类实现了Shape接口。
编程实现：

public interface Shape {
    void draw();
}
public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("画了一个正方形");
    }
}

一个图形接口有一个计算面积的方法；一个长方形类实现计算长方形面积的实际功能。

3、依赖

描述：一个类A依赖另一个类B的一个实例来完成某些操作，但类A不包含类B的实例。

依赖关系的实现方式：一个类作为另一个类方法的参数。

关系很弱，短暂的关系。SpringBoot中很少用到，尤其不直接用在实体类上。

实际例子：一个Student类可能依赖于一个Book类来借阅书籍。
编程实现：

public class Book {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Student {
    public void borrowBook(Book book) {
        System.out.println("借了"+book.getName());
    }
}

菜有名字、有重量；厨师有姓名，有年龄；厨师做菜

4、关联

描述：一个类的对象与另一个类的对象之间存在某种关系，类与类之间的连接。

关联关系的实现方式：一个类作为另一个类的属性。

关系较强，长久的关系。和依赖的最大区别：出现一对一，一对多，多对多的关系。

实际例子：一个People类可能有一个Address类（家庭住址）的实例作为其属性。
编程实现：

public class Address {
    private String province;
    private String city;
    private String district;
}

public class People {
    private String name;
    private String id;
    private Address address;
}

在SpringBoot中一个类作为另一个类的属性，与一个类的id作为另一个类的属性，作用其实是很接近的。

病人有名字、年龄；医生有名字和科室。病人看病有一个主治医生。

5、聚合

描述：一种特殊的关联关系，表示整体与部分的关系，但部分可以离开整体而单独存在。
实际例子：一个University类聚合多个Department类。
编程实现：

public class University {
    private List<Department> departments = new ArrayList<>();

    public void addDepartment(Department department) {
        departments.add(department);
    }
}
public class Department {
    // 部门相关的属性和方法
}

6、组合

描述：一种特殊的关联关系，表示整体与部分的关系，部分不能离开整体而单独存在。
实际例子：一个People类组合一个Heart类。
编程实现：

public class People {
    private String name;
    private String id;
    private Heart heart;
}
public class Heart{
    private double size;
}