Menu

Konstruktorfunktionen

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

Go hat keine Konstruktoren wie andere Sprachen. Stattdessen besteht die Konvention darin, eine Funktion namens NewTypeName zu erstellen, die eine initialisierte Struktur zurückgibt, häufig als Zeiger.

Einfache Konstruktorfunktion

type Person struct {
    Name string
    Age  int
}

func NewPerson(name string, age int) *Person {
    return &Person{
        Name: name,
        Age:  age,
    }
}

Konstruktor mit Standardwerten

type Config struct {
    Host    string
    Port    int
    Timeout int
}

func NewConfig(host string) *Config {
    return &Config{
        Host:    host,
        Port:    8080,    // Standardwert
        Timeout: 30,      // Standardwert
    }
}

Konstruktor mit Validierung

func NewPerson(name string, age int) *Person {
    if name == "" {
        name = "Unknown"
    }
    if age < 0 {
        age = 0
    }
    return &Person{
        Name: name,
        Age:  age,
    }
}

Konstruktorfunktionen verwenden

func main() {
    p1 := NewPerson("Alice", 25)
    fmt.Println(p1.Name) // Alice

    p2 := NewPerson("", -5)
    fmt.Println(p2.Name) // Unknown
    fmt.Println(p2.Age)  // 0
}

Konstruktorfunktionen geben mithilfe von & einen Zeiger (*StructName) zurück. Dadurch wird vermieden, dass die Struktur kopiert wird, und Methoden mit Zeigerempfängern können direkt funktionieren. Validierung und Standardwerte gehören in den Konstruktor.

Aufgabe

Mittel

Erstelle eine Konstruktorfunktion NewBankAccount für die Struktur BankAccount mit Validierung:

Nimmt name (string) und balance (float64) als Parameter entgegen
Wenn name leer ist, verwende standardmäßig "Unnamed"
Wenn balance negativ ist, verwende standardmäßig 0
Setze Owner immer auf "Default Owner"
Gib einen Zeiger auf die neue Struktur zurück

Probier es selbst

package main

import "fmt"

func main() {
    var name string
    var balance float64
    fmt.Scan(&name, &balance)

    account := NewBankAccount(name, balance)

    fmt.Printf("Account: %s\n", account.Name)
    fmt.Printf("Balance: %.2f\n", account.Balance)
    fmt.Printf("Owner: %s\n", account.Owner)
}

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-Receiver Struct-InitialisierungKonstruktorfunktionenRü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