Objektbeziehungen

Allgemeine Form

Multiplizität
1	ein Objekt
2	zwei Objekte
0..1	kein oder ein Objekt
0..*	kein oder beliebig viele Objekte
*	beliebig viele Objekte (außer 0)

Assoziation

Der Browser kennt den Webserver, was durch die Methode ``addHost(Webserver $server)`` zum Ausdruck gebracht wird. ### PHP ````php

public function addHost(Webserver $server): void
    {
        $this->hosts[] = $server;
    }    
}
````

### JAVA
````php
public class Webserver {

    private String title = "website title";
    private String ip = "192.168.0.1";    
    
}

public class Browser {

    private ArrayList hosts = new ArrayList();
        
    public void addHost(Webserver server) {
        this.hosts.add(server);
    }  
      
}
````


## Aggregation

![Klassendiagramm](/docs/img/uml-aggregation.png)

Eine Firma kann nicht ohne einen Mitarbeiter (einschließlich Geschäftsführung) existieren.
Ein Mitarbeiter kann jedoch auch ohne Firma existieren (Dann hat er den Status *arbeitslos*).
Wird eine neue Firma gegründet, muss wenigstens ein Mitarbeiter zugeordnet werden. Das
passiert im Konstruktor.

### PHP
````php
employees = $employee;
    } elseif($employee instanceof Employee) {
            $this->employees[] = $employee;
        } else {
            throw new \Exception('Construct parameter contains no employee!');
        }
        foreach($this->employees as $ip = '192.168.0.1';    
}

class Browser
{
    private array $0employee->setCompany($ip = '192.168.0.1';    
}

class Browser
{
    private array $1employee): void
{
    $ip = '192.168.0.1';    
}

class Browser
{
    private array $2this);
    $ip = '192.168.0.1';    
}

class Browser
{
    private array $3employee;        
}    

}

### JAVA
````php
public class Employee {

   private Company company;    

   public void setCompany(Company company) {
       this.company = company;
   }

}

public class Company {

   private ArrayList<Employeee> employees = new ArrayList<>();

    public Company(ArrayList<Employee> employees) {
        this.employees = employees;        
        for(Employee employee : this.employees) {
            employee.setCompany(this);
        }
    }

    public Company(Employee employee) {
        this.addEmployee(employee);
    }

    public void addEmployee(Employee employee)
    {
        this.employees.add(employee);
        employee.setCompany(this);      
    }    
}

Komposition

Ein neues Dokument benötigt mindestens einen Absatz. Daher wird bei Instantiierung eines Dokument-Objekts ein Paragraph-Objekt im Konstruktor instantiiert.

PHP

<?php

class Paragraph
{
    private string $ip = '192.168.0.1';    
}

class Browser
{
    private array $4paragraphs = [];

    public function __construct()
    {
        $this->paragraphs[] = new Paragraph();
    }

}

Ein weiteres Beispiel für eine Komposition findest du auch unter Magische Methoden im Abschnitt PHP. Weißt du, welches Beispiel gemeint ist?

JAVA

public class Paragraph {

    private String text;    

}

public class Document {

    private ArrayList<Paragraph> paragraphs = new ArrayList<>();

    public Document() {
        this.paragraphs.add(new Paragraph());
    }

}