Métodos

Los métodos son funciones que proporcionan comportamiento para un objeto.

Los métodos de instancia en los objetos pueden acceder a las variables de instancia y a this. El método distanceTo() en el siguiente ejemplo es un ejemplo de un método de instancia:

import 'dart:math';
​
class Point {
  final double x;
  final double y;
​
  // Sets the x and y instance variables
  // before the constructor body runs.
  Point(this.x, this.y);
​
  double distanceTo(Point other) {
    var dx = x - other.x;
    var dy = y - other.y;
    return sqrt(dx * dx + dy * dy);
  }
​
}

La mayoría de los operadores son métodos de instancia con nombres especiales. Dart te permite definir operadores con los siguientes nombres:

Para declarar un operador, usa el identificador incorporado operator seguido del operador que estás definiendo. El siguiente ejemplo define la suma de vectores (+), la resta (-) y la igualdad (==):

class Vector {
  final int x, y;
​
  Vector(this.x, this.y);
​
  Vector operator +(Vector v) => Vector(x + v.x, y + v.y);
  Vector operator -(Vector v) => Vector(x - v.x, y - v.y);
​
  @override
  bool operator ==(Object other) =>
      other is Vector && x == other.x && y == other.y;
​
  @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));
}

Los getters y setters son métodos especiales que proporcionan acceso de lectura y escritura a las propiedades de un objeto. Recuerda que cada variable de instancia tiene un getter implícito, además de un setter si corresponde. Puedes crear propiedades adicionales implementando getters y setters, utilizando las palabras clave get y set:

/// A rectangle in a screen coordinate system,
/// where the origin `(0, 0)` is in the top-left corner.
class Rectangle {
  double left, top, width, height;
​
  Rectangle(this.left, this.top, this.width, this.height);
​
  // Define two calculated properties: right and bottom.
  double get right => left + width;
  set right(double value) => left = value - width;
  double get bottom => top + height;
  set bottom(double value) => top = value - height;
}
​
void main() {
  var rect = Rectangle(3, 4, 20, 15);
  assert(rect.left == 3);
  rect.right = 12;
  assert(rect.left == -8);
}

Con los getters y setters, puedes comenzar con variables de instancia y envolverlas más tarde con métodos, todo sin cambiar el código del cliente.

Los métodos de instancia, getter y setter pueden ser abstractos, definiendo una interfaz pero dejando su implementación en manos de otras clases. Los métodos abstractos solo pueden existir en clases abstractas (abstract classes) o mixins.

Para hacer que un método sea abstracto, usa un punto y coma (;) en lugar del cuerpo del método:

abstract class Doer {
  // Define instance variables and methods...
​
  void doSomething(); // Define an abstract method.
}
​
class EffectiveDoer extends Doer {
  void doSomething() {
    // Provide an implementation, so the method is not abstract here...
  }
}