0Pricing
JavaScript Academy · Lektion

Klassenfelder, private #-Felder und statische Member

Klassen mit öffentlichen Feldern erstellen, Daten mit privaten #-Feldern verbergen und statische Eigenschaften und Methoden hinzufügen

Klassenfelder, private #-Felder und statische Member ist eine kostenlose JavaScript Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des JavaScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der JavaScript Academy-Kurs umfasst insgesamt 3 Lektionen.

Warum Klassen?

Ziel: Kleine, klare Klassen erstellen.

  • Öffentliche Felder und Methoden
  • #private-Felder für verborgenen Zustand
  • static-Eigenschaften und -Methoden für Hilfsfunktionen auf Klassenebene
  • Beispiele klein und gut lesbar halten
Klassenfelder, private #-Felder und statische Member — Illustration 1

Öffentliche Felder und Konstruktor

Erstellen Sie eine Klasse mit einem öffentlichen Feld und kleinen Methoden; halten Sie die Logik für Anfänger einfach.

// Public fields and a simple method
class Counter {
  // public field with default
  value = 0;

  constructor(start) {
    // use a default if start is not provided
    this.value = Number.isFinite(start) ? start : 0;
  }

  inc() {
    this.value = this.value + 1;
  }
}

const c1 = new Counter(2);
c1.inc();
console.log("value:", c1.value); // 3
Klassenfelder, private #-Felder und statische Member — Illustration 2

Private # fields

#private-Felder werden von der Sprache erzwungen und können nur innerhalb des Klassenkörpers verwendet werden. Stellen Sie bei Bedarf Methoden zum Lesen bereit.

// Private # fields hide internal state
class SafeCounter {
  // private field (only inside the class)
  #value = 0;

  constructor(start) {
    this.#value = Number.isFinite(start) ? start : 0;
  }

  inc() { this.#value = this.#value + 1; }
  getValue() { return this.#value; } // expose via method
}

const sc = new SafeCounter(5);
sc.inc();
console.log("safe value:", sc.getValue());

// External access fails (uncommenting the next line would throw):
// console.log(sc.#value);
Klassenfelder, private #-Felder und statische Member — Illustration 3

Getter für sicheres Lesen

Ein getter kann einen abgeleiteten oder validierten Wert zurückgeben und dabei das Feld privat halten.

// Getters provide read-only views; simple guard logic
class User {
  #name = "Anonymous";
  constructor(name) {
    if (typeof name === "string" && name.trim().length > 0) {
      this.#name = name.trim();
    }
  }
  get name() {
    return this.#name;
  }
}

const u = new User(" Ayla ");
console.log("name:", u.name);
Klassenfelder, private #-Felder und statische Member — Illustration 4

Statische Member

static-Member werden auf der Klasse aufgerufen (z. B. MathHelp.circleArea()), nicht auf Instanzen.

// Static = belongs to the class, not to instances
class MathHelp {
  static PI = 3.14159;
  static circleArea(r) {
    if (!(typeof r === "number" && r >= 0)) return 0;
    return MathHelp.PI * r * r;
  }
}

console.log("PI:", MathHelp.PI);
console.log("area r=2:", MathHelp.circleArea(2));

// Instances do not have the static members:
const mh = new MathHelp();
console.log("instance has PI?", "PI" in mh); // false
Klassenfelder, private #-Felder und statische Member — Illustration 5

Anfängerfreundliche Gewohnheiten

Tipps:

  • Bevorzugen Sie kleine Klassen mit wenigen, klaren Methoden.
  • Verwenden Sie #private für echte Privatsphäre; Unterstriche sind lediglich eine Namenskonvention.
  • Legen Sie Konstanten und Hilfsfunktionen in static-Member.
  • Stellen Sie bei Bedarf minimale Methoden zum Lesen (Getter) für den Zugriff von außen bereit.
Klassenfelder, private #-Felder und statische Member — Illustration 6

Quiz zu privaten Feldern

Kurze Überprüfung: #private-Felder.

Klassenfelder, private #-Felder und statische Member — Illustration 7

Zusammenfassung

Zusammenfassung: Verwenden Sie öffentliche Felder für einfachen Zustand, #private, um Interna zu verbergen, und static für Hilfsfunktionen auf Klassenebene. Halten Sie jede Klasse klein und gut lesbar.

Klassenfelder, private #-Felder und statische Member — Illustration 8

Häufig gestellte Fragen

Ist die Lektion „Klassenfelder, private #-Felder und statische Member“ kostenlos?

Ja — der vollständige Text von „Klassenfelder, private #-Felder und statische Member“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des JavaScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der JavaScript Academy-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Klassenfelder, private #-Felder und statische Member“?

Klassen mit öffentlichen Feldern erstellen, Daten mit privaten #-Feldern verbergen und statische Eigenschaften und Methoden hinzufügen Du übst JavaScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um JavaScript Academy zu starten?

Keine Vorkenntnisse erforderlich. JavaScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 3.

Wie lange dauert die Lektion „Klassenfelder, private #-Felder und statische Member“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser JavaScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede JavaScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Klassenfelder, private #-Felder und statische Member
  2. Vererbung, super und wann Komposition vorzuziehen ist
  3. Mixins (Einblick) – einfache Wiederverwendung ohne tiefe Hierarchien
← Zurück zu JavaScript Academy