Grundlagen der Struct-Einbettung

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

Struct-Einbettung ist der Mechanismus von Go, um einen Struct-Typ in einen anderen einzubinden. Anstatt einen Feldnamen zu verwenden, gibst du einfach den Typ an, und Go stellt die Felder des eingebetteten Structs im äußeren Struct bereit.

Hier ist die grundlegende Syntax:

type Address struct {
    City    string
    Country string
}

type Person struct {
    Name string
    Address  // eingebettet - kein Feldname
}

Wenn du Address in Person einbettest, kannst du auf die eingebetteten Felder direkt über die äußere Struktur zugreifen:

func main() {
    p := Person{
        Name: "Alice",
        Address: Address{
            City:    "London",
            Country: "UK",
        },
    }
    
    fmt.Println(p.City)     // London - direkter Zugriff
    fmt.Println(p.Country)  // UK - direkter Zugriff
    fmt.Println(p.Address.City)  // funktioniert auch
}

Beachte, wie p.City funktioniert, ohne dass du ausdrücklich p.Address.City schreiben musst. Go stellt die Felder der eingebetteten Struktur automatisch bereit, sodass sie zugänglich sind, als würden sie zur äußeren Struktur gehören. Bei Bedarf kannst du weiterhin über den Namen des eingebetteten Typs auf sie zugreifen.

Dies unterscheidet sich von regulären verschachtelten Strukturen, bei denen du immer den Feldnamen verwenden musst, um auf innere Felder zuzugreifen. Einbetten schafft eine flachere, bequemere API und bewahrt gleichzeitig die logische Gruppierung zusammengehöriger Daten.

Aufgabe

Einfach

Lass uns ein Fahrzeugregistrierungssystem erstellen, das Struct-Einbettung verwendet, um ein sauberes, übersichtliches Datenmodell zu erstellen. Du trennst Kontaktinformationen von Fahrzeugdetails und ermöglichst gleichzeitig den direkten Zugriff auf alle fields durch die Einbettung.

Du organisierst deinen Code über zwei Dateien:

vehicle.go: Erstelle zwei Structs, die durch Einbettung zusammenarbeiten:
- Eine ContactInfo-Struct mit den fields OwnerName und Phone (beide vom Typ String)
- Eine Vehicle-Struct, die ContactInfo einbettet (ohne field name) und ihre eigenen fields Make, Model und Year hinzufügt
Erstelle außerdem eine Methode namens Summary für Vehicle, die einen formatierten String mit allen Fahrzeug- und Kontaktinformationen zurückgibt.
main.go: Lies Fahrzeug- und Besitzer details aus der Eingabe ein, erstelle eine Vehicle-instance mit eingebettetem ContactInfo und zeige den Zugriff auf die eingebetteten fields sowohl direkt als auch über den Namen des eingebetteten Typs. Gib am Ende die Fahrzeugzusammenfassung aus.

Die following Eingaben werden bereitgestellt:

Zeile 1: Besitzername
Zeile 2: Telefonnummer
Zeile 3: Fahrzeug-Marke
Zeile 4: Fahrzeug-Modell
Zeile 5: Jahr (Ganzzahl)

Deine Summary-Methode sollte einen String in diesem Format zurückgeben:

[Year] [Make] [Model] - Owner: [OwnerName], Phone: [Phone]

Zeige in deiner main-Datei die field promotion durch folgende Ausgaben:

Den direkt auf dem Vehicle accessed Besitzernamen (z. B. v.OwnerName)
Die über den eingebetteten Typ accessed Telefonnummer (z. B. v.ContactInfo.Phone)
Die vollständige Zusammenfassung aus deiner Summary-Methode

Wenn beispielsweise Alice Smith, 555-1234, Toyota, Camry und 2023 eingegeben werden, sollte deine Ausgabe wie folgt aussehen:

Alice Smith
555-1234
2023 Toyota Camry - Owner: Alice Smith, Phone: 555-1234

Beachte, wie beide Zugriffsmuster funktionieren: der direkte Zugriff durch field promotion und der explizite Zugriff über den Namen des eingebetteten Typs. Dadurch erhältst du Flexibilität beim Arbeiten mit eingebetteten Daten.

REQUIRED OUTPUT FORMAT: [Your translated content here]

Probier es selbst

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Besitzername einlesen
	ownerName, _ := reader.ReadString('\n')
	ownerName = strings.TrimSpace(ownerName)

	// Telefonnummer einlesen
	phone, _ := reader.ReadString('\n')
	phone = strings.TrimSpace(phone)

	// Fahrzeugmarke einlesen
	make, _ := reader.ReadString('\n')
	make = strings.TrimSpace(make)

	// Fahrzeugmodell einlesen
	model, _ := reader.ReadString('\n')
	model = strings.TrimSpace(model)

	// Jahr einlesen
	yearStr, _ := reader.ReadString('\n')
	yearStr = strings.TrimSpace(yearStr)
	year, _ := strconv.Atoi(yearStr)

	// TODO: Erstelle eine Vehicle-Instanz mit eingebettetem ContactInfo
	// Verwende die oben aus der Eingabe gelesenen Werte

	// TODO: Gib den Besitzernamen aus, der direkt am Vehicle zugegriffen wird (Feldpromotion)
	// Beispiel: fmt.Println(v.OwnerName)

	// TODO: Gib die Telefonnummer aus, die über den eingebetteten Typnamen zugegriffen wird
	// Beispiel: fmt.Println(v.ContactInfo.Phone)

	// TODO: Gib die vollständige Zusammenfassung mit der Summary-Methode aus
	// Beispiel: fmt.Println(v.Summary())

	// Entferne diese Zeilen, sobald du die Lösung implementierst
	_ = ownerName
	_ = phone
	_ = make
	_ = model
	_ = year
}