Verschachtelte Structs

Teil des Abschnitts Objektorientierte Programmierung der GO-Journey von Coddy. Lektion 16 von 107.

Eine verschachtelte Struktur ist eine Struktur, die eine weitere benannte Struktur als eines ihrer Felder enthält. So kannst du komplexe, hierarchische Daten modellieren, indem du kleinere, wiederverwendbare Typen zusammensetzt.

type Address struct {
    Street string
    City   string
    ZIP    string
}

type Person struct {
    Name    string
    Age     int
    Address Address  // verschachtelte Struktur
}

Um auf Felder in einer verschachtelten Struktur zuzugreifen, verkettest du die Feldnamen mit Punkten.

p := Person{
    Name: "Alice",
    Age:  30,
    Address: Address{
        Street: "123 Main St",
        City:   "Boston",
        ZIP:    "02101",
    },
}

fmt.Println(p.Address.City) // Boston

Verschachtelung fördert die Wiederverwendung von Code. Der Typ Address kann in mehreren Structs wie Person, Company oder Order verwendet werden, ohne Felder zu duplizieren. Dieser Ansatz spiegelt reale Beziehungen wider, in denen Entitäten andere Entitäten enthalten.

type Company struct {
    Name      string
    Employees int
    Address   Address  // derselbe Address-Typ wird wiederverwendet
}

Du kannst Structs über mehrere Ebenen hinweg verschachteln, wobei flache Hierarchien die Lesbarkeit verbessern. Verschachtelte Structs sind grundlegend für den Aufbau objektorientierter Datenmodelle in Go.

Aufgabe

Einfach

Erstellen wir ein Mitarbeiterverwaltungssystem, das zeigt, wie verschachtelte Structs reale Hierarchien abbilden können. Du erstellst eine Struktur, in der Mitarbeiter zu Abteilungen gehören und Abteilungen Standortinformationen enthalten.

Du organisierst deinen Code auf zwei Dateien:

models.go: Definiere drei Structs, die zusammenarbeiten:
- Location mit den Feldern Building (string) und Floor (int)
- Department mit Name (string) und einem verschachtelten Feld Location
- Employee mit ID (int), Name (string) und einem verschachtelten Feld Department
main.go: Lies Mitarbeiterinformationen aus der Eingabe ein, erstelle einen Employee mit korrekt verschachtelten Structs und gib das vollständige Mitarbeiterprofil aus, indem du über die verschachtelte Struktur auf die Felder zugreifst.

Die folgenden Eingaben werden bereitgestellt:

Zeile 1: Mitarbeiter-ID (Ganzzahl)
Zeile 2: Name des Mitarbeiters
Zeile 3: Name der Abteilung
Zeile 4: Name des Gebäudes
Zeile 5: Stockwerksnummer (Ganzzahl)

Ausgabeformat:

Employee: [Name] (ID: [ID])
Department: [DepartmentName]
Location: [Building], Floor [Floor]

Wenn beispielsweise 101, Alice, Engineering, Tower und 5 gegeben sind, sollte deine Ausgabe wie folgt aussehen:

Employee: Alice (ID: 101)
Department: Engineering
Location: Tower, Floor 5

Greife mit Punktnotation auf die verschachtelten Felder zu, um die Struct-Hierarchie zu durchlaufen (z. B. employee.Department.Location.Building).

Probier es selbst

package main

import "fmt"

func main() {
	// Mitarbeiterinformationen lesen
	var id int
	var name string
	var deptName string
	var building string
	var floor int

	fmt.Scanln(&id)
	fmt.Scanln(&name)
	fmt.Scanln(&deptName)
	fmt.Scanln(&building)
	fmt.Scanln(&floor)

	// TODO: Erstelle einen Employee mit korrekt verschachtelten Structs
	// Verwende die Structs Location, Department und Employee aus models.go
	// Initialisiere alle verschachtelten Felder mit den Eingabewerten

	// TODO: Gib das Mitarbeiterprofil in folgendem Format aus:
	// Employee: [Name] (ID: [ID])
	// Department: [DepartmentName]
	// Location: [Building], Floor [Floor]
	// Greife auf verschachtelte Felder über die Punktnotation zu (z. B. employee.Department.Location.Building)
}