Methode (Method)

Eine Methode ist eine Funktion, die einem Objekt Verhalten verleiht. Man unterteilt sie in vier Gruppen: Instanzmethoden, Operatorüberladung, Getter/Setter und abstrakte Methoden.

1. Instance methods Instanzmethoden

1. Sie gehören zu einem Instanzobjekt einer Klasse;
2. Dürfen direkt auf Instanzvariablen zugreifen und das Schlüsselwort this verwenden;
3. Haben einen vollständigen Funktionskörper und können Geschäftsrechnungen sowie logische Abläufe durchführen.

import 'dart:math';

class Point {
  final double x;
  final double y;

  // Konstruktor initialisiert Instanzvariablen
  Point(this.x, this.y);

  // Instanzmethode: Berechnet den Abstand zwischen zwei Punkten
  double distanceTo(Point other) {
    var dx = x - other.x;
    var dy = y - other.y;
    return sqrt(dx * dx + dy * dy);
  }
}

void main() {
  Point p1 = Point(0, 0);
  Point p2 = Point(3, 4);
  print(p1.distanceTo(p2)); // Gibt 5.0 aus
}Code-Sprache: JavaScript (javascript)

2. Operators Operatorüberladung

1. Die meisten Operatoren sind im Grunde Instanzmethoden mit speziellen Namen;
2. Deklarationssyntax: operator Operator(Parameter) Rückgabetyp { ... };
3. Liste der überladbaren Operatoren:
   < > <= >= == ~
- + / ~/ * %
| ˆ & << >>> >>
[]= []
4. Eingebaute Operatoren lassen sich nicht überladen (z. B. !=, wird von Dart im Hintergrund automatisch implementiert, keine manuelle Definition nötig);
5. Wenn man == überlädt, muss zwingend auch hashCode überschrieben werden, sonst treten Fehler bei Gleichheitsvergleichen auf.

class Vector {
  final int x, y;

  Vector(this.x, this.y);

  // Überlade + für Vektoraddition
  Vector operator +(Vector v) => Vector(x + v.x, y + v.y);
  // Überlade - für Vektorsubtraktion
  Vector operator -(Vector v) => Vector(x - v.x, y - v.y);

  // Überlade == für Gleichheitsvergleich
  @override
  bool operator ==(Object other) =>
      other is Vector && x == other.x && y == other.y;

  // Passende Überschreibung von hashCode
  @override
  int get hashCode => Object.hash(x, y);
}

void main() {
  final v = Vector(2, 3);
  final w = Vector(2, 2);

  assert(v + w == Vector(4, 5));
  assert(v - w == Vector(0, 1));
  print(v + w);
}Code-Sprache: JavaScript (javascript)

Durch die Überladung können wir zwei Vector-Objekte genau wie Zahlen mit Rechenoperatoren wie +, -, == verarbeiten.

3. Getters and setters Zugriffsmethoden

1. get: Schreibgeschützte Methode zum Auslesen berechneter Eigenschaften, ohne Parameter;
2. set: Schreibmethode zum Ändern zugehöriger Variablen, besitzt genau einen Parameter;
3. Alle Instanzvariablen haben einen impliziten Getter, veränderbare Variablen zusätzlich einen impliziten Setter;
4. Vorteil: Später lassen sich einfache Variablen zu Berechnungslogik umbauen, ohne externen Aufrufcode zu ändern;
5. Inkrement-/Dekrementoperatoren ++/-- rufen den Getter nur einmal auf und speichern den Wert, um Nebeneffekte zu vermeiden.

/// Rechteck im Bildschirmkoordinatensystem, Ursprung (0,0) oben links
class Rectangle {
  double left, top, width, height;

  Rectangle(this.left, this.top, this.width, this.height);

  // Getter: Berechnet die rechte Begrenzung
  double get right => left + width;

  // Setter: Setzt die rechte Begrenzung und aktualisiert left rückwärts
  set right(double value) => left = value - width;

  // Getter: Berechnet die untere Begrenzung
  double get bottom => top + height;

  // Setter: Setzt die untere Begrenzung und aktualisiert top rückwärts
  set bottom(double value) => top = value - height;
}

void main() {
  var rect = Rectangle(3, 4, 20, 15);
  assert(rect.left == 3);

  // Aufruf des Setters
  rect.right = 12;
  assert(rect.left == -8);
  print(rect.left); // -8
}Code-Sprache: JavaScript (javascript)

4. Abstract methods Abstrakte Methoden

1. Definiert nur eine Schnittstelle ohne Funktionskörper, ein Semikolon ; ersetzt die Implementierung;
2. Darf nur in abstract class abstrakten Klassen oder Mixins vorkommen;
3. Unterklassen müssen alle abstrakten Methoden überschreiben und implementieren. Andernfalls muss die Unterklasse ebenfalls als abstract markiert werden.

// Abstrakte Klasse mit abstrakter Methode
abstract class Doer {
  // Abstrakte Methode: Nur Deklaration, keine Implementierung
  void doSomething();
}

// Normale Unterklasse, muss alle abstrakten Methoden der Oberklasse implementieren
class EffectiveDoer extends Doer {
  @override
  void doSomething() {
    print("Ausführen der konkreten Geschäftslogik");
  }
}

void main() {
  Doer worker = EffectiveDoer();
  worker.doSomething(); // Gibt aus: Ausführen der konkreten Geschäftslogik
}Code-Sprache: JavaScript (javascript)

Vergleich