Método (Method)

Un método es una función que proporciona comportamientos a un objeto, dividido en cuatro categorías: métodos de instancia, sobrecarga de operadores, Getters/Setters y métodos abstractos.

1. Instance methods Métodos de instancia

1. Métodos pertenecientes a los objetos de instancia de la clase;
2. Pueden acceder directamente a las variables de instancia y usar la palabra clave this;
3. Tienen un cuerpo de función completo para realizar cálculos de negocio y operaciones lógicas.

import 'dart:math';

class Point {
  final double x;
  final double y;

  // Constructor que inicializa las variables de instancia
  Point(this.x, this.y);

  // Método de instancia: calcular la distancia entre dos puntos
  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)); // Muestra 5.0
}Lenguaje del código: JavaScript (javascript)

2. Operators Sobrecarga de operadores

1. La mayoría de los operadores son esencialmente métodos de instancia con nombres especiales;
2. Sintaxis de declaración: operator operador(parámetro) TipoRetorno { ... };
3. Lista de operadores soportados para sobrecarga:
   < > <= >= == ~
- + / ~/ * %
| ˆ & << >>> >>
[]= []
4. Los operadores integrados no se pueden sobrecargar (ej: !=, implementado automáticamente por Dart sin definición manual);
5. Al sobrecargar == es obligatorio sobrescribir también hashCode, de lo contrario habrá fallos en la comparación de igualdad.

class Vector {
  final int x, y;

  Vector(this.x, this.y);

  // Sobrecargar + para suma de vectores
  Vector operator +(Vector v) => Vector(x + v.x, y + v.y);
  // Sobrecargar - para resta de vectores
  Vector operator -(Vector v) => Vector(x - v.x, y - v.y);

  // Sobrecargar == para comparación de igualdad
  @override
  bool operator ==(Object other) =>
      other is Vector && x == other.x && y == other.y;

  // Sobreescritura complementaria de 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);
}Lenguaje del código: JavaScript (javascript)

Al sobrecargar los operadores, podemos realizar operaciones como +, -, == en dos objetos Vector igual que si fueran números.

3. Getters and setters Accesores

1. get: método de solo lectura para obtener propiedades calculadas, sin parámetros;
2. set: método de escritura para modificar variables asociadas, solo admite un parámetro;
3. Todas las variables de instancia traen un getter implícito; las variables mutables incluyen un setter implícito;
4. Ventaja: se puede convertir una variable normal en lógica de cálculo más tarde sin modificar el código de llamada externo;
5. Los operadores incremento/decremento ++/-- llaman al getter una única vez y almacenan el valor para evitar efectos secundarios.

/// Rectángulo del sistema de coordenadas de pantalla, origen (0,0) en la esquina superior izquierda
class Rectangle {
  double left, top, width, height;

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

  // Getter: calcular límite derecho
  double get right => left + width;

  // Setter: asignar límite derecho y actualizar left al revés
  set right(double value) => left = value - width;

  // Getter: calcular límite inferior
  double get bottom => top + height;

  // Setter: asignar límite inferior y actualizar top al revés
  set bottom(double value) => top = value - height;
}

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

  // Llamada al setter
  rect.right = 12;
  assert(rect.left == -8);
  print(rect.left); // -8
}Lenguaje del código: JavaScript (javascript)

4. Abstract methods Métodos abstractos

1. Solo definen una interfaz sin cuerpo de función; se usa un punto y coma ; en lugar de implementación;
2. Solo pueden existir dentro de abstract class clases abstractas o mixins;
3. Las subclases deben sobrescribir e implementar todos los métodos abstractos; si no, la subclase también debe marcarse como abstract.

// Clase abstracta que contiene métodos abstractos
abstract class Doer {
  // Método abstracto: solo declaración, sin implementación
  void doSomething();
}

// Subclase normal, debe implementar todos los métodos abstractos del padre
class EffectiveDoer extends Doer {
  @override
  void doSomething() {
    print("Ejecutar lógica de negocio concreta");
  }
}

void main() {
  Doer worker = EffectiveDoer();
  worker.doSomething(); // Muestra: Ejecutar lógica de negocio concreta
}Lenguaje del código: JavaScript (javascript)

Comparación