Java中类与类、类与接口、接口与接口之间是什么关系？

公告

View Post

Java中类与类之间是什么关系?

1.依赖

依赖是指一个类（称为依赖类）使用到了另一个类（称为被依赖类），而这种使用关系是具有偶然性的、临时性的、非常弱的，但是被依赖类（目标类）的变化会影响到依赖类。

例如，比如人A要过河，需要借用一条船B，此时人A与船B之间的关系就是依赖。表现在代码层面，为类B作为参数被类A在某个方法中使用

Boat 类

点击查看代码

package com.itcq.dependency;

/**
 * Boat 类表示一艘带有名称的水上交通工具。
 */
public class Boat {
    private String name;
    /**
     * 用指定的名称构造 Boat 对象。
     *
     * @param name 船的名称。
     */
    public Boat(String name) {
        this.name = name;
    }
    /**
     * 获取船的名称。
     *
     * @return 船的名称。
     */
    public String getName() {
        return name;
    }
    /**
     * 设置船的名称。
     *
     * @param name 船的新名称。
     */
    public void setName(String name) {
        this.name = name;
    }
}

Person 类

点击查看代码

package com.itcq.dependency;
/**
 * Person 类表示能够使用船渡河的个体。
 */
public class Person {
    /**
     * 使用指定的船渡河。
     *
     * @param boat 用于渡河的船。
     */
    public void crossRiver(Boat boat){
        System.out.println("我乘坐"+boat.getName()+"过河···");
    }
}

App测试类

点击查看代码

package com.itcq.dependency;

/**
 * App 类包含 main 方法，用于演示 Person 和 Boat 类之间的依赖关系。
 */
public class App {

    public static void main(String[] args) {

        // 创建 Person 的实例
        Person person = new Person();

        // 通过将 Boat 对象作为参数演示依赖关系
        person.crossRiver(new Boat("传琦T-001"));
    }
}

依赖关系的强弱:

依赖关系的强度取决于以下几个因素：

依赖的程度：如果一个类对另一个类的依赖程度高，则依赖关系更强。
耦合的程度：如果两个类之间的耦合度高，则依赖关系更强。
生命周期：如果两个类具有相同的生命周期，则依赖关系更强。

总结:

依赖关系是一种比较常见的类与类之间的关系。
依赖关系的强度取决于几个因素，包括依赖程度、耦合程度和生命周期。

其他示例:

Person 类依赖于 Address 类，因为人需要住址。
Order 类依赖于 Product 类，因为订单包含商品。
FileReader 类依赖于 File 类，因为文件读取器需要读取文件。

依赖关系可以通过参数、成员变量、方法调用、配置文件等方式体现。选择哪种方式体现依赖关系，需要根据具体情况来决定。

2.关联

关联关系是指两个或多个类之间存在着一种相互依赖的关系，但这种依赖关系不是强依赖关系，而是弱依赖关系，这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的。关联可以是单向关联、双向关联。单向关联在代码层面表现为：类A当中使用了类B，其中B作为类A的成员变量。双向关联在代码层面表现为：类A当中使用了类B作为成员变量；同时类B中也使用了类A作为成员变量。

例如:

双向关联：一个Student类关联于Teacher类，因为Student类需要Teacher类来进行教学，而Teacher类也需要Student类来进行教学。

Student类

点击查看代码

package com.itcq.association;

public class Student {
    private String name;
    private Teacher teacher;
    public Student(String name) {
        this.name = name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public Teacher getTeacher() {
        return teacher;
    }
    // 学生需要老师进行教学
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
    // 学生的其他方法...
    public void attendClass() {
        System.out.println(name + "正在上课，老师是：" + teacher.getName());
    }
}

Teacher类

点击查看代码

package com.itcq.association;

public class Teacher {
    private String name;
    private Student student;
    public Teacher(String name) {
        this.name = name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public Student getStudent() {
        return student;
    }
    // 老师需要学生进行教学
    public void setStudent(Student student) {
        this.student = student;
    }
    // 老师的其他方法...
    public void conductClass() {
        System.out.println(name + "正在授课，学生是：" + student.getName());
    }
}

测试类App

点击查看代码

package com.itcq.association;
public class App {
    public static void main(String[] args) {
        // 创建学生和老师的实例
        Student student = new Student("小明");
        Teacher teacher = new Teacher("张老师");
        // 建立相互关联
        student.setTeacher(teacher);
        teacher.setStudent(student);
        // 学生上课
        student.attendClass();//小明正在上课，老师是：张老师
        // 老师授课
        teacher.conductClass();//张老师正在授课，学生是：小明
    }
}

单向关联：当一个类关联到另一个类，但另一个类不直接关联回来，就是单向关联。以下是一个示例，演示了Student类关联到Teacher类的单向关联：

Student类

点击查看代码

package com.itcq.association;
public class Student {
    private String name;
    private Teacher teacher;

    public  Student(){

    }

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public Teacher getTeacher() {
        return teacher;
    }

    // 学生需要老师进行教学
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    // 学生的其他方法...

    public void attendClass() {
        if (teacher != null) {
            System.out.println(name + "正在上课，老师是：" + teacher.getName());
        } else {
            System.out.println(name + "正在上课，但尚未分配老师。");
        }
    }
}

Teacher类

点击查看代码

package com.itcq.association;

public class Teacher {
    private String name;

    public Teacher(){

    }

    public Teacher(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }
    // 老师的其他方法...

    public String getName() {
        return name;
    }
}

App测试类

点击查看代码

package com.itcq.association;

public class App {
    public static void main(String[] args) {
        // 创建学生和老师的实例
        Student student = new Student("小明");
        Teacher teacher = new Teacher("张老师");

        // 建立单向关联，学生关联到老师
        student.setTeacher(teacher);

        // 学生上课
        student.attendClass();//小明正在上课，老师是：张老师
    }
}

3.继承

继承指的是一个类（称为子类（派生类）、子接口）继承另外的一个类（称为父类（基类）、父接口）的功能，并可以增加它自己的新功能的能力。在Java中继承关系通过关键字extends明确标识

Java中类只能单继承，不支持多继承，但可以多层继承，爸爸继承爷爷，儿子继承爸爸，儿子同时拥有爸爸和爷爷的非私有成员变量和方法

下面是一个使用继承关系的示例，其中有一个父类 Animal，以及两个子类 Cat 和 Dog。Cat 类继承自 Animal，而 Dog 类也继承自 Animal。每个类都有自己的方法 eat 来描述它们的饮食习惯。

Animal类

点击查看代码

package com.itcq.generalization;

// Animal 类作为父类
public class Animal {
    private String name;

    public Animal(){

    }

    public Animal(String name) {
        this.name = name;
    }

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

    public String getName() {
        return name;
    }

    // eat 方法在父类中被定义，具体的实现在子类中完成
    public void eat() {
        System.out.println(name + "正在进食");
    }
}

Cat类

点击查看代码

package com.itcq.generalization;

// Cat 类继承自 Animal 类
public class Cat extends Animal {
    public Cat(){
        super();
    }

    public Cat(String name) {
        super(name);
    }

    // 重写父类的 eat 方法
    @Override
    public void eat() {
        System.out.println(getName() + "正在吃鱼");
    }
}

Dog类

点击查看代码

package com.itcq.generalization;
// Dog 类继承自 Animal 类
public class Dog extends Animal {
    public Dog(){
        super();
    }
    public Dog(String name) {
        super(name);
    }

    // 重写父类的 eat 方法
    @Override
    public void eat() {
        System.out.println(getName() + "正在吃肉");
    }
}

App测试类

点击查看代码

package com.itcq.generalization;

public class App {
    public static void main(String[] args) {
        // 创建 Cat 和 Dog 实例
        Cat cat = new Cat("小猫");
        Dog dog = new Dog("小狗");

        // 调用各自的 eat 方法
        cat.eat(); // 输出：小猫正在吃鱼
        dog.eat(); // 输出：小狗正在吃肉
    }
}

4.聚合

聚合关系是关联关系的一种，耦合度强于关联，它们的代码表现是相同的，仅仅是在语义上有所区别：关联关系的对象间是相互独立的，而聚合关系的对象之间存在着包容关系，它体现的是整体与部分的关系，即has-a的关系。此时整体与部分之间是可分离的，它们可以具有各自的生命周期。比如计算机与CPU、公司与员工的关系等，比如一个航母编队包括海空母舰、驱护舰艇、舰载飞机及核动力攻击潜艇等。表现在代码层面，聚合关系和关联关系可能会使用相似的语法，通常通过类的属性或方法参数来表示。区分它们主要依赖于对业务需求和语义的理解。

当我们使用聚合关系时，表示一个对象（整体）包含另一个对象（部分），但它们的生命周期可以独立存在。以下是一个简单的示例，展示了计算机与CPU之间的聚合关系：

CPU类

点击查看代码

package com.itcq.aggregation;

// CPU 类表示计算机的中央处理器
public class CPU {
    private String brand;

    public CPU(){

    }

    public CPU(String brand) {
        this.brand = brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    // CPU 的其他方法...
}

Computer类

点击查看代码

package com.itcq.aggregation;

// Computer 类表示计算机，包含一个 CPU 对象
public class Computer {
    private String model;
    private CPU cpu;  // 计算机聚合了一个 CPU 对象

    public Computer(){

    }

    public Computer(String model, CPU cpu) {
        this.model = model;
        this.cpu = cpu;
    }

    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public CPU getCpu() {
        return cpu;
    }

    public void setCpu(CPU cpu) {
        this.cpu = cpu;
    }

    // Computer 的其他方法...

    // 获取计算机的 CPU 品牌
    public String getCpuBrand() {
        return cpu.getBrand();
    }
}

App测试类

点击查看代码

package com.itcq.aggregation;

// 示例用法
public class App {
    public static void main(String[] args) {
        // 创建 CPU 和 Computer 实例
        CPU cpu = new CPU("Intel i7");
        Computer computer = new Computer("Desktop", cpu);

        // 访问计算机的信息，包括 CPU 品牌
        System.out.println("计算机型号：" + computer.getModel());//计算机型号：Desktop
        System.out.println("计算机使用的 CPU 品牌：" + computer.getCpuBrand());//计算机使用的 CPU 品牌：Intel i7
    }
}

5.组合

相比于聚合，组合是一种耦合度更强的关联关系。存在组合关系的类表示“整体-部分”的关联关系，“整体”负责“部分”的生命周期，他们之间是共生共死的；并且“部分”单独存在时没有任何意义。(这种关系比聚合更强，也称为强聚合。它同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束，比如人和人的大脑。表现在代码层面，和关联关系是一致的，只能从语义级别来区分。)

以下是一个简单的示例，展示了人和大脑之间的组合关系：

Brain 类

点击查看代码

package com.itcq.compostion;

// Brain 类表示大脑
public class Brain {
    // 大脑的属性和方法...
    public Brain(){
        
    }
    public void think() {
        System.out.println("大脑正在思考...");
    }
}

Person类

点击查看代码

package com.itcq.compostion;

// Person 类表示人，包含一个 Brain 对象
public class Person {
    private String name;
    private Brain brain;  // 人组合了一个大脑对象

    public Person(){

    }

    public Person(String name, Brain brain) {
        this.name = name;
        this.brain = brain;
    }

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

    public void setBrain(Brain brain) {
        this.brain = brain;
    }


    public Brain getBrain() {
        return brain;
    }


    // Person 的其他方法...

    // 人思考，调用大脑的思考方法
    public void contemplate() {
        System.out.println(name + "正在思考人生...");
        brain.think();
    }
}

App测试类

点击查看代码

package com.itcq.compostion;

// 示例用法
public class App {
    public static void main(String[] args) {
        // 创建 Brain 和 Person 实例
        Brain brain = new Brain();
        Person person = new Person("小明", brain);

        // 调用人的思考方法，实际上会调用大脑的思考方法
        person.contemplate();
        //小明正在思考人生...
        //大脑正在思考...
    }
}

Java中类与接口之间是什么关系?

实现关系

实现指的是一个class类实现interface接口（可以是多个）的功能，实现是类与接口之间最常见的关系。在Java中此类关系通过关键字implements明确标识，

Animal接口

点击查看代码

package com.itcq.realization;

public interface Animal {
    void makeSound();
}

Dog类

点击查看代码

package com.itcq.realization;
// 实现接口的类

public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

Cat类

点击查看代码

package com.itcq.realization;

public class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

App测试类

点击查看代码

package com.itcq.realization;

public class App {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();

        dog.makeSound(); // 输出：Dog barks
        cat.makeSound(); // 输出：Cat meows
    }
}

Java中接口与接口之间的关系?

在Java中，接口与接口之间存在两种主要的关系：继承关系和多继承关系。

继承关系

继承关系（extends）：一个接口可以继承另一个接口。这种关系类似于类之间的继承，但是接口可以继承多个接口。继承的接口将包含在子接口的声明中。例如：

interface Shape {
    void draw();
}

interface Circle extends Shape {
    void radius();
}

在这个例子中，Circle 接口继承了 Shape 接口，因此它包含了 draw 方法。实现 Circle 接口的类需要提供对这两个方法的具体实现。

多继承关系

多继承关系： 一个接口可以同时继承多个接口。这是Java中接口灵活性的一部分，允许一个接口组合多个其他接口的行为。例如：

interface Flyable {
    void fly();
}

interface Swimmable {
    void swim();
}

interface FlyingFish extends Flyable, Swimmable {
    // FlyingFish 接口继承了 Flyable 和 Swimmable 接口
}

在这个例子中，FlyingFish 接口同时继承了 Flyable 和 Swimmable 接口，表示飞鱼既可以飞也可以游泳。

需要注意的是，虽然Java支持接口之间的多继承，但在类的继承中，一个类只能继承一个类。接口之间的多继承关系使得我们能够以更灵活的方式组合和定义接口。

posted on 2024-03-03 11:56 周政然阅读(316) 评论(0) 收藏举报

刷新页面返回顶部

奋斗的软件工程师

公告

View Post