Método (Method)

Um método é uma função que fornece comportamentos a um objeto, dividido em quatro categorias: métodos de instância, sobrecarga de operadores, Getters/Setters e métodos abstratos.

1. Instance methods Métodos de instância

1. Métodos pertencentes aos objetos de instância da classe;
2. Podem acessar diretamente variáveis de instância e utilizar a palavra-chave this;
3. Possuem um corpo de função completo para realizar cálculos comerciais e operações lógicas.

import 'dart:math';

class Point {
  final double x;
  final double y;

  // Construtor que inicializa variáveis de instância
  Point(this.x, this.y);

  // Método de instância: calcular distância entre dois pontos
  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)); // Imprime 5.0
}Code language: JavaScript (javascript)

2. Operators Sobrecarga de operadores

1. A maioria dos operadores são, essencialmente, métodos de instância com nomes especiais;
2. Sintaxe de declaração: operator operador(parâmetro) TipoRetorno { ... };
3. Lista de operadores com suporte à sobrecarga:
   < > <= >= == ~
- + / ~/ * %
| ˆ & << >>> >>
[]= []
4. Operadores nativos não podem ser sobrecarregados (ex: !=, implementado automaticamente pelo Dart sem necessidade de definição manual);
5. Ao sobrecarregar == é obrigatório reescrever também o hashCode, caso contrário haverá falhas na comparação de igualdade.

class Vector {
  final int x, y;

  Vector(this.x, this.y);

  // Sobrecarregar + para soma de vetores
  Vector operator +(Vector v) => Vector(x + v.x, y + v.y);
  // Sobrecarregar - para subtração de vetores
  Vector operator -(Vector v) => Vector(x - v.x, y - v.y);

  // Sobrecarregar == para comparação de igualdade
  @override
  bool operator ==(Object other) =>
      other is Vector && x == other.x && y == other.y;

  // Reescrita complementar do 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 language: JavaScript (javascript)

Após sobrecarregar os operadores, conseguimos realizar operações como +, -, == em dois objetos Vector da mesma forma que fazemos com números.

3. Getters and setters Acessores

1. get: método somente leitura para recuperar propriedades calculadas, sem parâmetros;
2. set: método de escrita para alterar variáveis associadas, aceita apenas um parâmetro;
3. Todas as variáveis de instância possuem um getter implícito; variáveis mutáveis trazem um setter implícito;
4. Vantagem: posteriormente é possível converter variáveis simples em lógica de cálculo sem alterar o código de chamada externo;
5. Os operadores de incremento/decremento ++/-- chamam o getter apenas uma vez e armazenam o valor para evitar efeitos colaterais.

/// Retângulo do sistema de coordenadas da tela, origem (0,0) no canto superior esquerdo
class Rectangle {
  double left, top, width, height;

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

  // Getter: calcular limite direito
  double get right => left + width;

  // Setter: definir limite direito e atualizar left de forma inversa
  set right(double value) => left = value - width;

  // Getter: calcular limite inferior
  double get bottom => top + height;

  // Setter: definir limite inferior e atualizar top de forma inversa
  set bottom(double value) => top = value - height;
}

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

  // Chamada ao setter
  rect.right = 12;
  assert(rect.left == -8);
  print(rect.left); // -8
}Code language: JavaScript (javascript)

4. Abstract methods Métodos abstratos

1. Apenas definem uma interface sem corpo de função; um ponto e vírgula ; substitui a implementação;
2. Só podem existir dentro de abstract class classes abstratas ou mixins;
3. As subclasses devem sobrescrever e implementar todos os métodos abstratos; caso contrário, a subclasse também deve ser marcada como abstract.

// Classe abstrata contendo métodos abstratos
abstract class Doer {
  // Método abstrato: apenas declaração, sem implementação
  void doSomething();
}

// Subclasse comum, obrigada a implementar todos os métodos abstratos da classe pai
class EffectiveDoer extends Doer {
  @override
  void doSomething() {
    print("Executar lógica de negócio concreta");
  }
}

void main() {
  Doer worker = EffectiveDoer();
  worker.doSomething(); // Imprime: Executar lógica de negócio concreta
}Code language: JavaScript (javascript)

Comparação