Menu

Tech

Deutsch

Externe Dateien

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

In Go kannst du deinen Code auf mehrere .go-Dateien innerhalb desselben Pakets aufteilen. Alle Dateien mit derselben package-Deklaration können direkt auf die Funktionen und Typen der jeweils anderen zugreifen: kein Import erforderlich.

// helper.go
package main

func Add(a, b int) int {
    return a + b
}

Verwende die Funktion in einer anderen Datei desselben Pakets

// main.go
package main

import "fmt"

func main() {
    result := Add(3, 5)
    fmt.Println(result) // Ausgabe: 8
}

Beide Dateien deklarieren package main, daher ist Add in main.go ohne Import verfügbar. So kannst du den Code in logischen Dateien organisieren und sie gleichzeitig im selben Paket behalten.

Aufgabe

Einfach

Erstelle zwei Funktionen in helper.go, die von main.go verwendet werden:

Add: nimmt zwei int-Parameter entgegen und gibt ihre Summe zurück
Subtract: nimmt zwei int-Parameter entgegen und gibt ihre Differenz zurück

Probier es selbst

package main

import "fmt"

func main() {
    var a, b int
    fmt.Scan(&a, &b)

    fmt.Printf("Sum: %d\n", Add(a, b))
    fmt.Printf("Difference: %d\n", Subtract(a, b))
}

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 DateienGo-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-Initialisierung Konstruktorfunktionen 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