本文转自: 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