Menu

Tech

Deutsch

Struct-Initialisierung

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

Go bietet verschiedene Möglichkeiten, Structs zu initialisieren, die jeweils in unterschiedlichen Situationen nützlich sind.

Initialisierung mit benannten Feldern

type Person struct {
    Name string
    Age  int
    City string
}

p1 := Person{
    Name: "Alice",
    Age:  25,
    City: "New York",
}

Positionale Initialisierung (Reihenfolge muss mit der Felddeklaration übereinstimmen)

p2 := Person{"Bob", 30, "London"}

Nullwert-Initialisierung (alle Felder erhalten Standardwerte)

p3 := Person{}
// Name: "", Age: 0, City: ""

Teilweise Initialisierung (nicht gesetzte Felder erhalten Nullwerte)

p4 := Person{Name: "Charlie"}
// Name: "Charlie", Age: 0, City: ""

Zeiger auf eine Struktur mit &

p5 := &Person{
    Name: "Diana",
    Age:  28,
    City: "Paris",
}
fmt.Println(p5.Name) // Diana

Verwendung von var und anschließendes Zuweisen von Feldern

var p6 Person
p6.Name = "Eve"
p6.Age = 22

Die Initialisierung benannter Felder ist der gängigste und lesbarste Ansatz. Verwende &, wenn du einen Zeiger auf die Struktur benötigst.

Aufgabe

Mittel

Erstelle drei Player-Objekte mit verschiedenen Initialisierungsmethoden:

player1: Initialisierung benannter Felder mithilfe der Eingabewerte
player2: Initialisierung benannter Felder mit Name: "Guest", Class: "Novice", HitPoints: 50
player3: Verwende die Deklaration var und weise anschließend jedes Feld einzeln zu

Probier es selbst

package main

import "fmt"

func main() {
    var name, class string
    var hp int
    fmt.Scan(&name, &class, &hp)

    // TODO: Erstelle player1 unter Verwendung der Initialisierung mit benannten Feldern und den Eingabewerten

    // TODO: Erstelle player2 unter Verwendung der Initialisierung mit benannten Feldern:
    // Name: "Guest", Class: "Novice", HitPoints: 50

    // TODO: Erstelle player3 unter Verwendung der var-Deklaration und weise dann die Felder zu:
    // Name: "Hero", Class: "Knight", HitPoints: 200

    fmt.Printf("Player 1: %s (%s) - HP: %d\n", player1.Name, player1.Class, player1.HitPoints)
    fmt.Printf("Player 2: %s (%s) - HP: %d\n", player2.Name, player2.Class, player2.HitPoints)
    fmt.Printf("Player 3: %s (%s) - HP: %d\n", player3.Name, player3.Class, player3.HitPoints)
}

Teste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Alle Lektionen in Objektorientierte Programmierung

1Grundlagen der OOP in Go

Externe Dateien Go-Workspace & Module Packages & Imports Exportierte vs. nicht exportierte Namen Einführung in OOP mit Go Structs als Klassen Methoden für Structs definieren Pointer- vs. Value-ReceiverStruct-InitialisierungKonstruktorfunktionen Rückblick – Einfacher Taschenrechner

4Schnittstellen

Einführung in Schnittstellen Implizite Implementierung Schnittstelle als Vertrag Leere Schnittstelle (any)Typzusicherung Typwechsel Zusammensetzung von Schnittstellen Stringer- und Error-Schnittstellen Rückblick – Formenrechner

7Kapselung

Exportierte vs. nicht exportierte Felder Kapselung auf Paketebene Getter- und Setter-Methoden Informationsverbergung in Go Rückblick – Studierendendatensätze

10Generics (Go 1.18+)

Einführung in Generics Typparameter Typbeschränkungen Generische Strukturen Workaround für generische Methoden Zusammenfassung – Generische Sammlung

13Entwurfsmuster Teil 1

Einführung in Entwurfsmuster Singleton-Muster Factory-Muster Abstraktes Factory-Muster Observer-Muster Strategy-Muster

16Abschließende Herausforderungen

E-Learning-Plattform Bankingsystem Spielcharaktersystem

2Typen & Structs im Detail

Grundlegende & zusammengesetzte Typen Benutzerdefinierte Typdefinitionen Struct-Tags Anonyme Structs Verschachtelte Structs Nullwerte & Standardwerte Rückblick – Kontaktbuch

5Komposition statt Vererbung

Warum Go keine Vererbung hat Grundlagen der Struct-Einbettung Methoden-Promotion Mehrere Structs einbetten Einbettung vs. Aggregation Verbergen eingebetteter Methoden Rückblick – Mitarbeiterhierarchie

8Fehlerbehandlung & OOP

Das Error-Interface Benutzerdefinierte Fehlertypen Error-Wrapping (fmt.Errorf)Sentinel-Fehler errors.Is() und errors.As()Panic, Defer und Recover Rückblick – Dateiparser

11Standardbibliothek & OOP

io.Reader & io.Writer sort.Interface fmt.Stringer-Interface encoding/json mit Structs http.Handler-Interface Rückblick – REST-API-Modelle

14Entwurfsmuster Teil 2

Command-Muster Adapter-Muster Decorator-Muster Template-Methoden-Muster State-Muster Composite-Muster Middleware als Decorator

3Zeiger & Speicher

Grundlagen von Zeigern in Go Zeiger auf Structs Übergabe per Wert vs. Referenz Die Funktion new()Garbage Collection in Go Rückblick – Verkettete Liste erstellen

6Polymorphismus in Go

Polymorphismus über Interfaces Duck-Typing in Go Regeln zur Interface-Erfüllung Polymorphe Sammlungen Dependency Injection Zusammenfassung – Zahlungsprozessor

9Konkurrenz & OOP

Grundlagen der Goroutines Channels & Kommunikation Gepufferte vs. ungepufferte Channels Select-Anweisung sync.Mutex & sync.RWMutex sync.WaitGroup Thread-sicheres Struct-Design Rückblick – Worker Pool

12Fortgeschrittene OOP-Konzepte

Functional-Options-Pattern Builder-Pattern in Go Method Chaining Typ-Aliase vs. Definitionen Grundlagen der Reflection Überblick über Codegenerierung

15Projekt: Bibliotheksverwaltung

Projektübersicht & Struktur Buch- und Benutzer-Structs

Projekt-Lektion

Projekt-Lektion

Suche mit Interfaces

Projekt-Lektion

JSON-Persistenzschicht

Projekt-Lektion

Admin-CLI-Oberfläche

Projekt-Lektion

Tests & Integration

Projekt-Lektion

Übe selbstständig: Online-Go-Compiler