继承、组合、聚合的区别

柔情只为你懂 2023-10-09 17:48 54阅读 0赞

### 继承、组合、聚合的定义 ###

继承、组合和聚合是面向对象编程中，用于实现类与类之间关系的三种常用机制。

继承（inheritance）是指一个类从另一个类中继承（inherit）其属性和方法，被继承的类被称作父类、基类或超类，继承的类被称作子类、派生类或衍生类。子类可以继承父类的所有属性和方法，也可以重写或添加自己的属性和方法，还可以继续被其他类继承。继承实现了“is-a”（是一个）的关系，即一个类是另一个类的特殊类型。例如，Animal类可以作为一个基类，而Fish类和Bird类可以分别继承Animal类，他们就都继承了Animal类的属性和方法，并且可根据自身的需要对这些属性和方法进行进一步扩展或重写。

组合（composition）是指一个类由其他类组成，这些类被称作成员变量或组成部分。通过组合，一个类可以实现更加复杂的功能，并且可以随时替换或改变其中的组成部分。组合实现了“has-a”（有一个）的关系，即一个类拥有其他类的对象。例如，一个汽车有发动机和轮胎等组件，这些组件就可以看作是汽车类的成员变量。

聚合（aggregation）是指一种整体与部分之间的关系，表示个体一般都可以脱离整体独立存在。在聚合中，一个类可以包含其他类的对象，但是被包含的对象也可以不属于该聚合对象。聚合是一种比组合更为弱关联、模糊的关系。例如，一个学校包含多个班级，班级是被聚合的对象，它们可以独立存在，即一个班级可以迁移到另一个学校。

### java举例说明继承、组合、聚合的区别 ###

下面是一个简单的Java代码示例，用于说明继承、组合和聚合的区别：

继承：
    // 定义一个Animal基类
    public class Animal {
        private String name;
        private int age;
    
        // Animal类构造方法
        public Animal(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        // Animal类方法
        public void eat() {
            System.out.println("Animal is eating.");
        }
    }
    
    // 继承
    public class Dog extends Animal {
        private String barkSound;
    
        // 继承Animal类的构造方法
        public Dog(String name, int age, String barkSound) {
            super(name, age);
            this.barkSound = barkSound;
        }
    
        // 重写Animal类的方法
        @Override
        public void eat() {
            System.out.println("Dog is eating.");
        }
    
        public void bark() {
            System.out.println(barkSound);
        }
    }

![UML类图-继承][UML_-]

// 组合
    public class Car {
        private Engine engine;
    
        public Car(Engine engine) {
            this.engine = engine;
        }
    
        public void start() {
            engine.start();
        }
    }
    
    public class Engine {
        public void start() {
            System.out.println("Engine is starting.");
        }
    }

组合是一种部分和整体的关系，部分不能离开整体而单独存在，这里的Engine不能离开Car而存在，如果这个例子不太好理解，再举一个例子，公司和部门的关系，部门不能离开公司而单独存在  
![UML类图-组合][UML_- 1]

// 聚合
    public class Student {
        private String name;
        private int age;
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }
    
    public class Classroom {
        private List<Student> students;
    
        public Classroom(List<Student> students) {
            this.students = students;
        }
    }

这里聚合也是一种部分和整体的关系，但部分可以离开整体而存在，比如Student可以离开CalssRoom而存在，在举一个例子，部门和员工的关系，员工可以离开部门而单独存在。  
![UML类图-聚合][UML_- 2]

测试：
    
    public class Test {
        public static void main(String[] args) {
            // 继承
            Dog dog = new Dog("小黑", 2, "汪汪汪");
            dog.eat();
            dog.bark();
    
            // 组合
            Engine engine = new Engine();
            Car car = new Car(engine);
            car.start();
    
            // 聚合
            Student stu1 = new Student("小明", 18);
            Student stu2 = new Student("小红", 19);
            List<Student> students = new ArrayList<Student>();
            students.add(stu1);
            students.add(stu2);
            Classroom classroom = new Classroom(students);
        }
    }

### 总结 ###

下面是继承、组合和聚合的应用场景总结：

继承：继承常常用于实现“is-a”（是一个）的关系，例如Animal类作为基类，Dog类和Cat类作为其派生类，它们都是动物，因此继承了公共的属性和方法。另外，继承也提供了代码重用的机制，可以大幅减少程序代码量。

组合：组合常常用于实现“has-a”（有一个）的关系，例如汽车有发动机和轮胎等组件，这些组件可以看作是汽车类的成员变量。此外，通过组合的方式，可以灵活地组合不同的组件，实现更加灵活的对象构建。

聚合：聚合常用于实现整体与部分之间的关系，其关系较为松散，可以随时替换或改变其中的组成部分。例如，一个学校包含多个班级，班级是被聚合的对象，它们可以独立存在，即一个班级可以迁移到另一个学校。聚合的好处是可以在整体和部分之间建立一种“弱耦合”的关系，在保持整体完整性的同时允许部分的灵活变化。

需要注意的是，不同的应用场景对应不同的需求，因此应根据具体需求来选择实现方式。在实际开发中，可以根据以上总结，选择最适合的机制来实现类之间的关系，并且在设计时尽量符合面向对象编程的基本原则，例如单一职责原则、开放-封闭原则、里氏替换原则等。

[UML_-]: https://img-blog.csdnimg.cn/a7059faa583c4f87bf6923caa2872992.png#pic_center
[UML_- 1]: https://img-blog.csdnimg.cn/e2a4be75990a48ba9cd3007725cfa865.png#pic_center
[UML_- 2]: https://img-blog.csdnimg.cn/8e2fd1d25706436ca428ecbdc2f109c5.png#pic_center