JAVA类与类之间的全部关系简述+代码详解
类和类之间关系包括了 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 Heart{}
public class Person{
private Heart heart;
public Person(){
this.heart=new Heart();
}
}七、关联，组合，聚合的具体区别+代码详解
Association, Composition and Aggregation in Java
每次在画UML的时候，总是会把类的关系搞混，特别是在处理组合和聚合的时候，傻傻分不清楚，然后看到了一篇文章，来翻译一下，不过我想，Java编程思想讲的比较好，记得经常温习温习。
原文地址：Association, Composition and Aggregation in Java
Association（关联）
关联指的是两个分开的类通过对象或实例建立的关系。关联可以是一对一，一对多，多对一，还有多对多，就好像数据库中的关联表，外键一样，我觉得可以结合数据库进行理解。
在面向对象的编程当中，一个对象通过调用另一个对象的方法和服务来进行交流合作。下面有一张图形象的表现出关联，组合，聚合的关系。
图片来源于网络geeksforgeeks
很明显关联比较宽泛，组合是聚合的一个子集。组合－》聚合－》关联。
我们先看个例子：
运行结果：
Neha is employee of Axis- 1
在上面的例子中，银行和雇员是两个不同的类，通过对象将它们关联起来，就比如银行里有某某哪个雇员，一个银行可以有很多雇员，相当于是一对多的关系，而这个关系是我们手动关联起来的。
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 students;
Department(String name, List students)
{
this.name = name;
this.students = students;
}
public List 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 departments;
Institute(String instituteName, List departments)
{
this.instituteName = instituteName;
this.departments = departments;
}
// count total students of all departments
// in a given institute
public int getTotalStudentsInInstitute()
{
int noOfStudents = 0;
List 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 cse_students = new ArrayList();
cse_students.add(s1);
cse_students.add(s2);
// making a List of
// EE Students
List ee_students = new ArrayList();
ee_students.add(s3);
ee_students.add(s4);
Department CSE = new Department("CSE", cse_students);
Department EE = new Department("EE", ee_students);
List departments = new ArrayList();
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(组合)
组合是一种聚合的限制形式，其中两个实体高度相互依赖。也就是说，两个类高度耦合。有以下特征：
- 代表这一种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 books;
Library (List books)
{
this.books = books;
}
public List 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 books = new ArrayList();
books.add(b1);
books.add(b2);
books.add(b3);
Library library = new Library(books);
List 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的。