Verschachtelte Structs

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

Eine verschachtelte Struktur ist eine Struktur, die eine andere benannte Struktur als eines ihrer Felder enthält. Dadurch kannst du komplexe, hierarchische Daten modellieren, indem du kleinere, wiederverwendbare Typen miteinander kombinierst.

type Address struct {
    Street string
    City   string
    ZIP    string
}

type Person struct {
    Name    string
    Age     int
    Address Address  // verschachteltes Struct
}

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 wiederverwendet
}

Sie können Structs über mehrere Ebenen hinweg verschachteln, obwohl 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 Strukturen dabei helfen, Hierarchien aus der realen Welt zu modellieren. Du erstellst eine Struktur, in der Mitarbeiter Abteilungen angehören und Abteilungen über Standortinformationen verfügen.

Du organisierst deinen Code über zwei Dateien:

models.go: Definiere drei Strukturen, 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 die Mitarbeiterinformationen aus der Eingabe ein, erstelle einen Employee mit korrekt verschachtelten Strukturen und zeige das vollständige Mitarbeiterprofil an, 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 Chen, Engineering, Tower A und 5 angegeben werden, sollte deine Ausgabe folgendermaßen aussehen:

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

Greife mithilfe der Punktnotation auf die verschachtelten Felder zu, um die Strukturhierarchie 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)
}