What types of relationships exist in a class diagram?

In UML class diagram structures, the following types of relationships exist:

1. Association: A relationship between two or more classes, describing the connection between their instances. It can be directed or undirected. It may include multiplicity, which defines the number of instances of one class related to instances of another. Examples of multiplicity: 1 (exactly one), 0..1 (zero or one), 1..* (one or more), * (zero or more).

2. Aggregation: A special case of association representing a "part-whole" relationship. The "part" can exist independently of the "whole". It is visually represented by an unfilled diamond on the "whole" side.

3. Composition: A stricter form of aggregation. The "part" cannot exist without the "whole". When the "whole" is deleted, the "part" is also deleted. It is visually represented by a filled diamond on the "whole" side.

4. Dependency: A relationship where a change in the specification of one element (supplier) affects another element (client), but not vice versa. The client depends on the supplier. Usually depicted by a dashed arrow from the client to the supplier. Often used for relationships between classes where one class uses another as a method parameter, local variable, or return value.

5. Generalization/Inheritence: A relationship of similarity between a more general element (superclass) and more specific elements (subclasses). The subclass inherits properties and behaviors of the superclass and can add or override them. Depicted by an unfilled triangular arrow from the subclass to the superclass.

6. Realization: A relationship between two model elements where one element (client) implements (provides implementation for) the behavior defined by another element (supplier). Most often used for the relationship between a class and an interface, where the class implements methods defined in the interface. Depicted by a dashed arrow with an unfilled triangle at the end from the implementing element to the implemented one.

Example of inheritance relationship:

// Superclass
class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

// Subclass inheriting from Animal
class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

Example of realization relationship:

// Interface
interface Payable {
    double getPaymentAmount();
}

// Class implementing the interface
class Invoice implements Payable {
    private double amount;

    public Invoice(double amount) {
        this.amount = amount;
    }

    @Override
    public double getPaymentAmount() {
        return amount; // Implementation of the interface method
    }
}