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

本文转自： https://blog.csdn.net/wq6ylg08/article/details/81092056
类和类之间关系包括了 is a，has a, use a三种关系
（1）is a包括了继承，实现关系
（2）has a包括了组合，聚合，关联关系
（3）use a包括了依赖关系

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

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

public class Animal{}
public class Dog extends Animal{}

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

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

public interface UserService{}
public class UserServiceImpl implements UserService{}

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

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

public class Train{
public void move(){}
}
public class Person{
public void move(Train train){
train.move();
}
}

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

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

关联:一个人可以有一辆汽车，而这个汽车不是一个人出生就有，而是后期买的(以下例子也就是聚合)

public class Car{}
public class Person{
private Car car;
publicvoid setCar(Car car){
this.car=car;
}
}

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

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

public class Engine{}
public class Car{
private Engine engine;
public Car(Engine engine){
this.engine=engine;
}
}

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

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

public class Brain{}

public class Person{

private Brain brain;

public Person(){

this.brain=new Brain();

}

}

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

Association, Composition and Aggregation in Java

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

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

Association（关联）

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

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

图片来源于网络geeksforgeeks

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

我们先看个例子：

// Java program to illustrate the  
// concept of Association 
import java.io.*; 
  
// class bank 
class Bank  
{ 
    private String name; 
      
    // bank name 
    Bank(String name) 
    { 
        this.name = name; 
    } 
      
    public String getBankName() 
    { 
        return this.name; 
    } 
}  
  
// employee class  
class Employee 
{ 
    private String name; 
      
    // employee name  
    Employee(String name)  
    { 
        this.name = name; 
    } 
      
    public String getEmployeeName() 
    { 
        return this.name; 
    }  
} 
  
// Association between both the  
// classes in main method 
class Association  
{ 
    public static void main (String[] args)  
    { 
        Bank bank = new Bank("Axis"); 
        Employee emp = new Employee("Neha"); 
          
        System.out.println(emp.getEmployeeName() +  
               " is employee of " + bank.getBankName()); 
    } 
}

运行结果：

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

Aggregation(聚合)

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

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

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

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

Composition(组合)

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

代表这一种part-of的关系，就是一个类是另一个类的一部分
在组合的关系中，实例是彼此依赖的。
当两个实例是组合关系，它们就是高度耦合的，一个对象必须依赖另一个对象的存在而存在。
听上去有点不好理解，我们再来看以下代码：

// 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组合）

聚合和组合的比较：

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

// 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的。

---------------------
作者：萌新JedLee
来源：CSDN
原文：https://blog.csdn.net/wq6ylg08/article/details/81092056