Menu

Tech

Deutsch

Exportierte vs. nicht exportierte Namen

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

In Go bestimmt der erste Buchstabe eines Namens dessen Sichtbarkeit. Namen, die mit einem Großbuchstaben beginnen, sind exportiert (aus anderen Paketen zugänglich). Namen, die mit einem Kleinbuchstaben beginnen, sind nicht exportiert (auf das Paket beschränkt).

Exportierte Namen: außerhalb des Pakets sichtbar

type User struct {
    Name  string  // Exportiertes Feld
    Email string  // Exportiertes Feld
}

func CreateUser(name string) User { // Exportierte Funktion
    return User{Name: name}
}

Nicht exportierte Namen: nur innerhalb des Pakets sichtbar

type secret struct {     // Unexportierte Struct
    password string      // Unexportiertes Feld
}

func validate() bool {   // Unexportierte Funktion
    return true
}

Gemischt: exportierte Struktur mit einigen nicht exportierten Feldern

type Account struct {
    Username string    // Exportiert - überall zugänglich
    Email    string    // Exportiert - überall zugänglich
    password string    // Unexportiert - nur innerhalb des Pakets
}

Diese Namenskonvention ersetzt Zugriffsmodifikatoren wie public und private, die in anderen Sprachen vorkommen.

// Großbuchstabe   = Exportiert (öffentlich)
// Kleinbuchstabe = Unexportiert (privat)

func SaveData() {}  // Exportiert
func loadData() {}  // Unexportiert

Diese Konvention ist in Go unerlässlich. Wenn andere Pakete deinen Code importieren, können sie nur auf Namen zugreifen, die mit einem Großbuchstaben beginnen.

Aufgabe

Mittel

Ändere alle Namen in product.go, damit sie der exportierten Namenskonvention von Go entsprechen. Schreibe den ersten Buchstaben groß bei:

Dem Namen der Struktur: product → Product
Allen Feldnamen: name, price, stock
Allen Funktionsnamen: totalValue, displayInfo
Allen Feldreferenzen innerhalb der Funktionen

Probier es selbst

package main

import "fmt"

func main() {
    var name string
    var price float64
    var stock int
    fmt.Scan(&name, &price, &stock)

    p := Product{
        Name:  name,
        Price: price,
        Stock: stock,
    }

    fmt.Println(DisplayInfo(p))
    fmt.Printf("Total Value: %.2f\n", TotalValue(p))
}

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 & ImportsExportierte vs. nicht exportierte NamenEinfü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