Menu

Tech

Deutsch

Zusammenfassung – Einfacher Taschenrechner

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

Aufgabe

Schwer

Erstellen Sie einen vollständigen Calculator unter Verwendung von allem, was Sie gelernt haben:

Struct (Exportierte Felder) — Definieren Sie Calculator mit Name (string), LastResult (float64) und History (int)
Konstruktor-Funktion — NewCalculator(name string) gibt *Calculator zurück. Wenn der Name leer ist, verwenden Sie standardmäßig "Unnamed"
Value Receiver — GetInfo() gibt den Namen des Taschenrechners als formatierten String zurück
Pointer Receivers — Add, Subtract, Multiply speichern jeweils das Ergebnis in LastResult und erhöhen History
Divide — Pointer Receiver, der (float64, string) zurückgibt. Wenn durch Null geteilt wird, geben Sie 0 und "Error: division by zero" zurück, ohne History oder LastResult zu aktualisieren

Probier es selbst

package main

import "fmt"

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

    calc := NewCalculator(name)

    fmt.Println(calc.GetInfo())
    fmt.Printf("History: %d\n", calc.History)

    fmt.Printf("%.0f + %.0f = %.2f\n", a, b, calc.Add(a, b))
    fmt.Printf("%.0f - %.0f = %.2f\n", a, b, calc.Subtract(a, b))
    fmt.Printf("%.0f * %.0f = %.2f\n", a, b, calc.Multiply(a, b))

    result, err := calc.Divide(a, b)
    if err != "" {
        fmt.Println(err)
    } else {
        fmt.Printf("%.0f / %.0f = %.2f\n", a, b, result)
    }

    fmt.Printf("History: %d\n", calc.History)
    fmt.Printf("Last Result: %.2f\n", calc.LastResult)
}

Alle Lektionen in Objektorientierte Programmierung

1Grundlagen der Go OOP

Externe Dateien Go Workspace & Module Packages & Imports Exportierte vs. nicht-exportierte Namen Einführung in OOP in Go Structs als Klassen Methoden für Structs definieren Pointer- vs. Value-Receiver Struct-Initialisierung Konstruktor-FunktionenZusammenfassung – Einfacher Taschenrechner

4Interfaces

Einführung in Interfaces Implizite Implementierung Interface als Vertrag Leeres Interface (any)Type Assertion Type Switch Interface-Komposition Stringer & Error Interfaces Rückblick - Formen-Rechner

7Kapselung

Exportierte vs. nicht exportierte Felder Kapselung auf Paket-Ebene Getter- & Setter-Methoden Information Hiding in Go Zusammenfassung - Studierendendatensätze

10Generics (Go 1.18+)

Einführung in Generics Typparameter Type Constraints Generische Structs Workaround für generische Methoden Zusammenfassung – Generische Collection

13Entwurfsmuster Teil 1

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

16Abschließende Herausforderungen

E-Learning-Plattform Bankensystem Spielcharakter-System

2Vertiefung: Typen & Structs

Basis- & zusammengesetzte Typen Benutzerdefinierte Typdefinitionen Struct Tags Anonyme Structs Verschachtelte Structs Zero Values & Standardwerte Zusammenfassung - Kontaktbuch

5Komposition statt Vererbung

Warum Go keine Vererbung hat Grundlagen des Struct Embedding Method Promotion Einbetten mehrerer Structs Embedding vs. Aggregation Shadowing eingebetteter Methoden Zusammenfassung – Mitarbeiter-Hierarchie

8Fehlerbehandlung & OOP

Das error-Interface Eigene Fehlertypen Error Wrapping (fmt.Errorf)Sentinel-Fehler errors.Is() und errors.As()Panic, Defer und Recover Zusammenfassung – Datei-Parser

11Standardbibliothek & OOP

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

14Entwurfsmuster Teil 2

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

3Zeiger & Speicher

Zeiger-Grundlagen in Go Zeiger auf Structs Wertübergabe vs. Referenzübergabe Die new() Funktion Garbage Collection in Go Wiederholung – Linked List Builder

6Polymorphismus in Go

Polymorphismus über Interfaces Duck Typing in Go Interface-Erfüllungsregeln Polymorphe Collections Dependency Injection Zusammenfassung – Payment Processor

9Nebenläufigkeit & OOP

Goroutines Grundlagen Channels & Kommunikation Gepufferte vs. ungepufferte Channels Select-Anweisung sync.Mutex & sync.RWMutex sync.WaitGroup Thread-sicheres Struct-Design Zusammenfassung - Worker Pool

12Fortgeschrittene OOP-Konzepte

Functional Options Pattern Builder-Pattern in Go Methodenverkettung Typ-Aliase vs. Definitionen Reflection-Grundlagen Überblick zur Code-Generierung

15Projekt: Bibliotheksverwaltung

Projektübersicht & Struktur Buch- und Benutzer-Structs

Projekt-Lektion

Projekt-Lektion

Suche mit Interfaces

Projekt-Lektion

JSON-Persistenzschicht

Projekt-Lektion

Admin-CLI-Interface

Projekt-Lektion

Testing & Integration

Projekt-Lektion