Relationship of classes in design mode-category summary

In Java and other object-oriented design patterns, there are 6 main types of relationships between classes and classes: Dependency, association, aggregation, composition, inheritance, implementation. Their coupling degree is increased in turn.

1. Dependency (dependence)

Dependencies are defined as: for two relatively independent objects, when one object is responsible for constructing an instance of another object, or a service that relies on another object, the two objects are primarily dependent. The definition is obscure, but the performance in Java is fairly straightforward: Class A uses Class B, where Class B is a method parameter of Class A, a local variable in a method, or a static method call. Class in the legend above: The People class relies on the book class and the Food class, and the book class and the food class appear in the People class as parameter forms of the methods in the class.

Code Sample:

[Java]View Plaincopy < param name= "wmode" value= "Transparent" >

1. Public class people{
2. //book as the formal parameter of the Read method   
3. Public void read (book book) {
4. System.out.println ("Read the book is" +book.getname ());
5. }
6. }

2. Association (association),

One-Way Association:

Bidirectional Association:

For two relatively independent objects, when an instance of one object has a fixed correspondence with some specific instance of another object, the two objects are associated. Association relationships are divided into one-way and two-way associations. In Java, a one-way association behaves as follows: Class A uses Class B, where Class B is the member variable of Class A. The bidirectional association is represented by the use of Class B as a member variable in Class A, and Class A as a member variable in Class B.

Code Sample:

[Java]View Plaincopy

2. Public class son{
4. //A class that is a member variable in an association is typically assigned a value in a class   
6. Father Father = new Father ();
8. Public void getgift () {
10. System.out.println ("from" +father.getname () + "Get Gift");
12. }
14. }
18. Public class father{
20. Son son = new son ();
22. Public void givegift () {
24. System.out.println ("Give" +son.getname () + "gift");
26. }
28. }

3. Aggregation (Aggregation)

The aggregation relation is one kind of correlation relation, the coupling degree is stronger than the association, their code performance is the same, only has the semantic difference: the Relation object is mutually independent, but the aggregation relation object has the containment relation, between them is "the whole-individual" the interrelationship.

Code Sample:

[Java]View Plaincopy

2. Public class people{
4. Car car;
6. House House;
8. A class that is a member variable in an aggregate relationship is typically assigned using the Set method   
10. Public void setcar (car car) {
12. This.car = car;
14. }
16. Public void Sethouse (House house) {
18. This.house = House;
20. }
24. Public void driver () {
26. SYSTEM.OUT.PRINTLN ("Model of the car:" +car.gettype ());
28. }
30. Public void sleep () {
32. System.out.println ("I sleep in the house:" +house.getaddress ());
34. }
36. }

4. Combination (composition)

In contrast to aggregation, a combination is a more coupling relationship. A class that has a composition relationship represents the "whole-part" relationship, and "the whole" is responsible for the life cycle of the "part", and they are symbiotic, and there is no meaning in the "partial" existence alone. In the example, people and soul, the body is a combination of relations, when the life cycle begins, must have both the soul and the body, when the end of the human life cycle, the soul of the body with its demise, whether it is the soul or the body, can not exist alone, they must be a part of human existence.

[Java]View Plaincopy

2. Public class people{
4. Soul Soul;
6. Body Body;
8. the member variables in the//composite relationship are typically assigned in the constructor method   
10. Public people (Soul Soul, body body) {
12. This.soul = Soul;
14. This.body = body;
16. }
20. Public void study () {
22. System.out.println ("Learn to use the Soul" +soul.getname ());
24. }
26. Public void eat () {
28. System.out.println ("Eat with Body:" +body.getname ());
30. }
32. }

5. Inheritance (generalization)

Inheritance represents a parent-child relationship between a class and a class (or interface and interface). In Java, the inheritance relationship is represented by the keyword extends. In the UML legend, the inheritance relationship is represented by a solid + hollow arrow, and the arrow points to the parent class.

6. Implementation (Implementation)

Represents a method for a class to implement one or more interfaces. The interface defines the set of operations that are implemented by the implementation class to accomplish the specific operation of the interface. In Java, the implements representation is used. In the UML legend, the implementation relationship is indicated by a dashed + hollow arrow, and the arrow points to the interface.

Relationship of classes in design mode-category summary