JAVA类与类之间的全部关系简述+代码详解

类和类之间关系包括了 is a，has a, use a三种关系
（1）is a包括了 继承，实现关系
（2）has a包括了 组合，聚合，关联关系
（3）use a包括了 依赖关系

一、继承关系      继承指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力。在Java中继承关系通过关键字extends明确标识，在设计时一般没有争议性。在UML类图设计中，继承用一条带空心三角箭头的实线表示，从子类指向父类，或者子接口指向父接口。 

继承:子是父的关系，狗是动物

publicclass Animal{}
publicclass Dog extendsAnimal{}

二、实现关系      实现指的是一个class类实现interface接口（可以是多个）的功能，实现是类与接口之间最常见的关系。在Java中此类关系通过关键字implements明确标识，在设计时一般没有争议性。在UML类图设计中，实现用一条带空心三角箭头的虚线表示，从类指向实现的接口。 

实现:实现类实现接口，同样是是的关系，UserServiceImpl实现了UserService接口

publicinterface UserService{}
publicclass UserServiceImpl implementsUserService{}

三、依赖关系      简单的理解，依赖就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A。比如某人要过河，需要借用一条船，此时人与船之间的关系就是依赖。表现在代码层面，为类B作为参数被类A在某个method方法中使用。在UML类图设计中，依赖关系用由类A指向类B的带箭头虚线表示。 

依赖:使用的关系，一个人可以做火车到达想去的地方，但火车不是这个人的东西，人只是使用火车移动

publicclass Train{
    publicvoid move(){}
}
publicclass Person{
    publicvoid move(Train train){
        train.move();
    }
}

四、关联关系  关联体现的是两个类之间语义级别的一种强依赖关系，比如我和我的朋友，这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的。关联可以是单向、双向的。表现在代码层面，为被关联类B以类的属性形式出现在关联类A中，也可能是关联类A引用了一个类型为被关联类B的全局变量。在UML类图设计中，关联关系用由关联类A指向被关联类B的带箭头实线表示，在关联的两端可以标注关联双方的角色和多重性标记。 

关联关系一般分为两类：
单向关系：单向一对一、单向一对多、单向多对一、单向多对多
双向关系：双向一对一、双向一对多、双向多对多

关联:一个人可以有一辆汽车，而这个汽车不是一个人出生就有，而是后期买的

publicclass Car{}
publicclass Person{
    privateCar car;
    publicvoid setCar(){
        this.car=car;
    }
}

五、聚合关系      聚合是关联关系的一种特例，它体现的是整体与部分的关系，即has-a的关系。此时整体与部分之间是可分离的，它们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享。比如计算机与CPU、公司与员工的关系等，比如一个航母编队包括海空母舰、驱护舰艇、舰载飞机及核动力攻击潜艇等。表现在代码层面，和关联关系是一致的，只能从语义级别来区分。在UML类图设计中，聚合关系以空心菱形加实线箭头表示。 

聚合:有的关系,汽车有发动机，而且汽车产生就有发动机了，而对于汽车制造的时候，发动机不一定是自己造的，可以拿别人造好的发动机

publicclass Engine{}
publicclass Car{
    privateEngine engine;
    publicCar(Engine engine){
        this.engine=engine;
    }
}

六、组合关系     组合也是关联关系的一种特例，它体现的是一种contains-a的关系，这种关系比聚合更强，也称为强聚合。它同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束，比如人和人的大脑。表现在代码层面，和关联关系是一致的，只能从语义级别来区分。在UML类图设计中，组合关系以实心菱形加实线箭头表示。 

组合:有的关系，人有一个心脏，而且这个心脏是在创造人时，内部创造的

publicclass Heart{}

publicclass Person{

    privateHart hart;

    publicPerson(){

        this.hart=newHart();

    }

}

七、关联，组合，聚合的具体区别+代码详解

Association, Composition and Aggregation in Java

每次在画UML的时候，总是会把类的关系搞混，特别是在处理组合和聚合的时候，傻傻分不清楚，然后看到了一篇文章，来翻译一下，不过我想，Java编程思想讲的比较好，记得经常温习温习。

原文地址：Association, Composition and Aggregation in Java

Association（关联）

关联指的是两个分开的类通过对象或实例建立的关系。关联可以是一对一，一对多，多对一，还有多对多，就好像数据库中的关联表，外键一样，我觉得可以结合数据库进行理解。

在面向对象的编程当中，一个对象通过调用另一个对象的方法和服务来进行交流合作。下面有一张图形象的表现出关联，组合，聚合的关系。

图片来源于网络geeksforgeeks

很明显关联比较宽泛，组合是聚合的一个子集。组合－》聚合－》关联。

我们先看个例子：

•  

运行结果：

Neha is employee of Axis

• 1

在上面的例子中，银行和雇员是两个不同的类，通过对象将它们关联起来，就比如银行里有某某哪个雇员，一个银行可以有很多雇员，相当于是一对多的关系，而这个关系是我们手动关联起来的。

Aggregation(聚合)

聚合是关联的一种特殊形式：主要体现在一下三个方面

1. 聚合代表了has-a的关系
2. 并且是一种单向关系。单向的。比如说，公寓里面有学生，但是学生里面不能有公寓，这是一种天生的单向关系。
3. 在聚合的关系中，两种实例是可以单独存在的，不会相互影响，一个实例的存在与否不会影响与之聚合的实例的存在与否。

我们来看下聚合的例子：

// Java program to illustrate
//the concept of Aggregation.
import java.io.*;
import java.util.*;

// student class
class Student 
{
    String name;
    int id ;
    String dept;

    Student(String name, int id, String dept) 
    {

        this.name = name;
        this.id = id;
        this.dept = dept;

    }
}

/* Department class contains list of student
Objects. It is associated with student
class through its Object(s). */
class Department 
{

    String name;
    private List<Student> students;
    Department(String name, List<Student> students) 
    {

        this.name = name;
        this.students = students;

    }

    public List<Student> getStudents() 
    {
        return students;
    }
}

/* Institute class contains list of Department
Objects. It is asoociated with Department
class through its Object(s).*/
class Institute 
{

    String instituteName;
    private List<Department> departments;

    Institute(String instituteName, List<Department> departments)
    {
        this.instituteName = instituteName;
        this.departments = departments;
    }

    // count total students of all departments
    // in a given institute 
    public int getTotalStudentsInInstitute()
    {
        int noOfStudents = 0;
        List<Student> students; 
        for(Department dept : departments)
        {
            students = dept.getStudents();
            for(Student s : students)
            {
                noOfStudents++;
            }
        }
        return noOfStudents;
    }

} 

// main method
class GFG
{
    public static void main (String[] args) 
    {
        Student s1 = new Student("Mia", 1, "CSE");
        Student s2 = new Student("Priya", 2, "CSE");
        Student s3 = new Student("John", 1, "EE");
        Student s4 = new Student("Rahul", 2, "EE");

        // making a List of 
        // CSE Students.
        List <Student> cse_students = new ArrayList<Student>();
        cse_students.add(s1);
        cse_students.add(s2);

        // making a List of 
        // EE Students
        List <Student> ee_students = new ArrayList<Student>();
        ee_students.add(s3);
        ee_students.add(s4);

        Department CSE = new Department("CSE", cse_students);
        Department EE = new Department("EE", ee_students);

        List <Department> departments = new ArrayList<Department>();
        departments.add(CSE);
        departments.add(EE);

        // creating an instance of Institute.
        Institute institute = new Institute("BITS", departments);

        System.out.print("Total students in institute: ");
        System.out.print(institute.getTotalStudentsInInstitute());
    }
}

输出结果：

Total students in institute: 4

• 1

上面这个例子中，一个学院会有很多专业或者部门，每个专业又包含很多学生。因此，学院类中会持有一个专业或部门列表引用，然后专业类中会持有学生列表引用，也就是说，学院类会通过持有专业类的对象与之关联，专业与学生的关系也是如此。都体现了has-a的关系。

使用场景
代码重用时，可以考虑使用聚合。

Composition(组合)

组合是一种聚合的限制形式，其中两个实体高度相互依赖。也就是说，两个类高度耦合。有以下特征：

1. 代表这一种part-of的关系，就是一个类是另一个类的一部分
2. 在组合的关系中，实例是彼此依赖的。
3. 当两个实例是组合关系，它们就是高度耦合的，一个对象必须依赖另一个对象的存在而存在。

听上去有点不好理解，我们再来看以下代码：

// Java program to illustrate 
// the concept of Composition
import java.io.*;
import java.util.*;

// class book
class Book 
{

    public String title;
    public String author;

    Book(String title, String author)
    {

        this.title = title;
        this.author = author;
    }
}

// Libary class contains 
// list of books.
class Library 
{

    // reference to refer to list of books.
    private final List<Book> books;

    Library (List<Book> books)
    {
        this.books = books; 
    }

    public List<Book> getTotalBooksInLibrary(){

       return books;  
    }

}

// main method
class GFG 
{
    public static void main (String[] args) 
    {

        // Creating the Objects of Book class.
        Book b1 = new Book("EffectiveJ Java", "Joshua Bloch");
        Book b2 = new Book("Thinking in Java", "Bruce Eckel");
        Book b3 = new Book("Java: The Complete Reference", "Herbert Schildt");

        // Creating the list which contains the 
        // no. of books.
        List<Book> books = new ArrayList<Book>();
        books.add(b1);
        books.add(b2);
        books.add(b3);

        Library library = new Library(books);

        List<Book> bks = library.getTotalBooksInLibrary();
        for(Book bk : bks){

            System.out.println("Title : " + bk.title + " and "
            +" Author : " + bk.author);
        }
    }
}

运行结果：

Title : EffectiveJ Java and  Author : Joshua Bloch
Title : Thinking in Java and  Author : Bruce Eckel
Title : Java: The Complete Reference and  Author : Herbert Schildt

上述例子中，图书管中会有很多相同或不同主题的图书，但是如果图书馆被销毁后，对应里面的图书也被销毁了，图书不能独立于图书馆而存在，图书馆没了，图书也没有了，这就是组合关系。

Aggregation vs Composition（聚合vs组合）

聚合和组合的比较：

1. 依赖：聚合代表被关联的一方可以独立于关联一方而存在的关系，比如说，银行和雇员，将银行对象删除后，雇员对象仍然存在。然后，组合代表着被关联的一方不能独立于一方而存在的关系，比如，人没有心脏就无法生存，心脏也是相对人而言的，没有人，也就没有心脏这么一说。
2. 关系类型：聚合是has-a关系，组合是part-of关系。
3. 关联类型：组合是一种强关联关系，聚合是一种弱关联关系。

我们再看一个例子：

// Java program to illustrate the
// difference between Aggregation
// Composition.

import java.io.*;

// Engine class which will 
// be used by car. so 'Car'
// class will have a field 
// of Engine type.
class Engine 
{
    // starting an engine.
    public void work()
    {

        System.out.println("Engine of car has been started ");

    }

}

// Engine class
final class Car 
{

    // For a car to move, 
    // it need to have a engine.
    private final Engine engine; // Composition
    //private Engine engine;     // Aggregation

    Car(Engine engine)
    {
        this.engine = engine;
    }

    // car start moving by starting engine
    public void move() 
    {

        //if(engine != null)
        {
            engine.work();
            System.out.println("Car is moving ");
        }
    }
}

class GFG 
{
    public static void main (String[] args) 
    {

        // making an engine by creating 
        // an instance of Engine class.
        Engine engine = new Engine();

        // Making a car with engine.
        // so we are passing a engine 
        // instance as an argument while
        // creating instace of Car.
        Car car = new Car(engine);
        car.move();

    }
}

在聚合关系的代码实现中，汽车通过引擎对象来实现部分功能，但是，引擎不是总存在汽车的内部，引擎可以换，并且可以从汽车中卸下来，这也是为什么聚合关系中，引擎对象是非final的。