In UML there are five different types of relationships:

Association , Aggregation , Composition , dependency , and inheritance.

• OOP Relationships
  • Sections
• Symbols
• Association
  • Types
• Aggregation
  • example:
  • Aggregation:
• Composition
  • example:
  • Composition:
• Comparison
• Example
• Extra

• an Object communicates to another object to use functionality and services provided by that object.
• Association is defined as the relationship between objects.
• when one object has one or more references to other objects.
• the relationship among the objects determines what an object instance can cause another to perform an action on its behalf.

Association:

• I have a relationship with an object.

• Foo uses Bar

   class Foo {         
       Bar bar;
   };
  

NB: See Fowler's definition - the key is that Bar is semantically related to Foo rather than just a dependency (like an int or string).

uni-directional association:

• only one of the classes is aware of the relationship.

class printer{
    print(String  value)
}

class Teacher{
    printExam(Printer printer)=> printer.print("");
}

bi-directional association:

• both classes know about each other and with

class Student{
    List<Teacher> teachers;
    assignATempTeacher(Teacher teacher){
        teacher.assignAHomeWork(homeWork);
    }
}
class Teacher{
    List<Student> students;
    assignExamToStudent(Student student,Exam exam){
      student.setExam(exam);  
    } 
}

• is a weak type of association
• one-way relationship that specifies a 'has-a' relationship between two classes.

• you can say that a wallet has money.
• However, the money does not need a wallet in order to exist, so the relationship is one-way.

• I have an object which I've borrowed from someone else.
• When Foo dies, Bar may live on.
• 

•   class Foo { 
        Bar bar; 
        Foo(Bar bar) { 
            this.bar = bar; 
        }
    }

• is a stricter (strong type) form of association.
• also called death relationship.
• It defines a one-way relationship that specifies an 'is-part-of' relationship between two classes.
• This type of relationship controls the life cycle of the owned object in a way that if the owner is destroyed then the owned object is destroyed too.

• you can say that a room is part of a house.
• The rooms cannot exist outside of the house. In a town planning simulation, if you deleted a house object, the rooms would also be deleted.

• I own an object and I am responsible for its lifetime.
• When Foo dies, so does Bar.
• 

•       class Foo {
            // Must be final 
            final Bar bar = Bar(); 
        }

• example 1: https://www.scaler.com/topics/association-composition-and-aggregation-in-java/

• example 2:

  • Example of Composition

          //Car must have Engine
          class Car {
          //engine is a mandatory part of the car
          final Engine engine;
              Car () {
                  engine = Engine();
              }
          }
  
          //Engine Object
          class Engine {}
  • Example of Aggregation

      //Team
      class Team {      
          //players can be 0 or more
          List players;
  
          Team () {
              players = ArrayList();
          }
      }
      //Player Object
      class Player {}

• Coupling

• composition-aggregation-association

• Implementing a bidirectional association relationship in Python

• Change Bidirectional Association to Unidirectional