Método (programação) 📖 Wikipedia

Em orientação a objetos, uma Função (ou função membro) é uma sub-rotina (ou procedimento ou função) associada a um objeto, e que possui acesso aos seus dados, as variáveis membro. Ele é executado por um objeto ao receber uma mensagem. Os métodos determinam o comportamento dos objetos de uma classe e são análogos às funções ou procedimentos da programação estruturada. O envio de mensagens (chamada de métodos) pode alterar o estado de um objeto.

Em linguagens baseadas em classe eles são definidos na classe. Métodos definem o comportamento a ser exibido pelas instâncias da classe associada no tempo de execução do programa. Métodos possuem a propriedade especial que em tempo de execução, possuem acesso aos dados armazenados em uma instância da classe (ou instância de classe ou objeto de classe ou objeto) que estão associados e são, desta forma, capazes de controlar o estado da instância. A associação entre classe e método é chamada de ligação (binding). Um método associado com uma classe é dito estar ligado (bound) à classe. Métodos podem ser ligados a uma classe em tempo de compilação (ligação estática) ou a um objeto em tempo de execução (ligação dinâmica).

A sobreposição (overriding) e a sobrecarga (overloading) de métodos são duas das formas mais significativas pelas quais um método se diferencia de um procedimento ou chamada de função convencional.

A sobreposição refere-se a uma subclasse que redefine a implementação de um método de sua superclasse. Por exemplo, findArea pode ser um método definido em uma classe de forma geométrica (shape);^[1] as subclasses Circle, Triangle, etc., definiriam, cada uma, a fórmula apropriada para calcular sua própria área. A ideia é visualizar os objetos como "caixas pretas", de modo que alterações nos internos do objeto possam ser feitas com o mínimo de impacto nos outros objetos que o utilizam. Isso é conhecido como encapsulamento e visa tornar o código mais fácil de manter e reutilizar.

Por outro lado, a sobrecarga de métodos refere-se à diferenciação do código usado para processar uma mensagem com base nos parâmetros do método. Se considerarmos o objeto receptor como o primeiro parâmetro de qualquer método, então a sobreposição é apenas um caso especial de sobrecarga, onde a seleção é baseada apenas no primeiro argumento. O seguinte exemplo simples em Java ilustra a diferença:

Métodos de acesso (accessors) são usados para ler os valores dos dados de um objeto. Métodos de modificação (mutators) são usados para alterar os dados de um objeto. Já os métodos de gerenciamento (managers) são usados para inicializar e destruir objetos de uma classe, como construtores e destrutores.

Esses métodos fornecem uma camada de abstração que facilita o encapsulamento e a modularidade. Por exemplo, se uma classe de conta bancária fornece um método de acesso getBalance() para recuperar o saldo atual (em vez de acessar diretamente os campos de dados do saldo), revisões futuras do mesmo código podem implementar um mecanismo mais complexo para a recuperação do saldo (como uma busca em um banco de dados), sem que o código dependente precise ser alterado. Os conceitos de encapsulamento e modularidade não são exclusivos da programação orientada a objetos. De fato, em muitos aspectos, a abordagem orientada a objetos é simplesmente a extensão lógica de paradigmas anteriores, como tipos abstratos de dados e programação estruturada.^[2]

Um construtor é um método chamado no início da vida de um objeto para criá-lo e inicializá-lo, um processo chamado instanciação. A inicialização pode incluir a aquisição de recursos. Os construtores podem ter parâmetros, mas geralmente não retornam valores na maioria das linguagens. Veja o seguinte exemplo em Java:

public class Person {
    private String name;
    private int age;

    // método construtor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Um destrutor é um método chamado automaticamente ao final da vida de um objeto, um processo chamado destruição. Na maioria das linguagens, a destruição não permite argumentos no método destrutor nem valores de retorno. Os destrutores podem ser implementados para realizar tarefas de limpeza e outras atividades no momento da destruição do objeto.

Em linguagens com coleta de lixo (garbage collection), como Java,^{[3]:26, 29} C#^[4]:208-209 e Python, os destrutores são conhecidos como finalizadores. Eles têm propósito e função semelhantes aos destrutores, mas, devido às diferenças entre as linguagens que utilizam coleta de lixo e aquelas com gerenciamento manual de memória, a sequência em que são chamados é diferente.

Um método abstrato é aquele que possui apenas uma assinatura e nenhum corpo de implementação. Ele é frequentemente usado para especificar que uma subclasse deve fornecer uma implementação do método, como ocorre em uma classe abstrata. Métodos abstratos também são utilizados para definir interfaces em algumas linguagens de programação.^[5]

O seguinte código em Java mostra uma classe abstrata que precisa ser estendida:

abstract class Shape {
    // assinatura de método abstrato
    abstract int area(int height, int width);
}

A subclasse a seguir estende a classe principal:

public class Rectangle extends Shape {
    @Override
    int area(int height, int width) {
        return height * width;
    }
}

Se uma subclasse fornece uma implementação para um método abstrato, uma outra subclasse posterior pode torná-lo abstrato novamente. Isso é chamado de reabstração.

Na prática, este recurso é raramente utilizado.

Em C#, um método virtual pode ser sobreposto por um método abstrato (isso também se aplica ao Java, onde todos os métodos não privados são virtuais por padrão).

class IA
{
    public virtual void M()
    {
        // ...
    }
}

abstract class IB : IA
{
    // permitido
    public override abstract void M();
}

Métodos padrão (default methods) de interfaces também podem ser reabstratos, exigindo que as subclasses os implementem.

interface IA
{
    void M() 
    { 
        // ...
    }
}

interface IB : IA
{
    abstract void IA.M();
}

// erro: a classe 'C' não implementa 'IA.M'.
class C : IB 
{ 
    // ...
}

Métodos de classe são métodos que são chamados sobre uma classe (comparar este com métodos de instância de classe ou métodos de objeto). Seu significado pode variar dependendo da linguagem de programação:^[6]

• Em algumas linguagens (por exemplo, C++, Java), métodos de classe são sinônimos de métodos estáticos (ver seção abaixo), que são chamados com um nome de classe conhecido em tempo de compilação. this não pode ser usado em métodos estáticos
• Em outras linguagens (por exemplo, Smalltalk, Ruby, Objective-C), métodos de classe são métodos que são chamados sobre um objeto de classe, que pode ser computado em tempo de execução, não existindo diferença entre chamar um método sobre um objeto regular ou um objeto de classe. Entretanto, ambos os métodos de instância e de classe são resolvidos dinamicamente e não há métodos "estáticos". Notavelmente, nesses métodos de classe, o this se refere ao objeto de classe
• Algumas linguagens possuem ambos. Por exemplo, em Python, pode-se criar métodos de classe e métodos estáticos usando os decoradores classmethod e staticmethod, respectivamente. O primeiro possui acesso ao this (isto é, o objeto de instância, convencionalmente conhecido como self), enquanto o segundo não.

Os métodos especiais são altamente específicos de cada linguagem, e um sistema pode suportar nenhum, alguns ou todos os métodos definidos aqui. O compilador de uma linguagem pode gerar automaticamente métodos especiais padrão, ou o programador pode ter a permissão de defini-los opcionalmente. A maioria dos métodos especiais não pode ser chamada diretamente; em vez disso, o compilador gera código para chamá-los nos momentos apropriados.

Os métodos estáticos devem ser relevantes para todas as instâncias de uma classe, em vez de uma instância específica. Eles são semelhantes às variáveis estáticas nesse sentido. Um exemplo seria um método estático para somar os valores de todas as variáveis de cada instância de uma classe. Por exemplo, se houvesse uma classe Produto, ela poderia ter um método estático para calcular o preço médio de todos os produtos.

Um método estático pode ser invocado mesmo que nenhuma instância da classe exista ainda. Eles são chamados de "estáticos" porque são resolvidos em tempo de compilação com base na classe em que são chamados, e não dinamicamente como no caso dos métodos de instância, que são resolvidos de forma polimórfica com base no tipo do objeto em tempo de execução.

Em Java, um método estático comumente usado é o Math.max().

// chamado como:
Math.max(a, b);

// declarado como:
public class Math {
    // ...

    public static double max(double a, double b) {
        return (a < b) ? b : a;
    }
}

Este método estático não possui um objeto proprietário e não é executado em uma instância. Ele recebe todas as informações por meio de seus argumentos.^[1]

Os operadores de atribuição de cópia definem as ações a serem executadas pelo compilador quando um objeto de classe é atribuído a outro objeto do mesmo tipo.

Os métodos de operador definem ou redefinem símbolos de operadores e as operações a serem realizadas com o símbolo e os parâmetros associados. Exemplo em C++:

import std;

using std::string;

class Person {
private:
    string name;
    int age;
public:
    bool operator<(const Person& other) const {
        return age < other.age;
    }

    bool operator==(const Person& other) const {
        return name == other.name && age == other.age;
    }
};

Algumas linguagens procedurais foram estendidas com recursos orientados a objetos para aproveitar o vasto conjunto de habilidades e códigos legados dessas linguagens, mantendo os benefícios do desenvolvimento orientado a objetos. O exemplo mais conhecido é o C++, uma extensão orientada a objetos da linguagem de programação C. Devido aos requisitos de design para adicionar o paradigma orientado a objetos a uma linguagem procedural existente, a passagem de mensagens em C++ possui capacidades e terminologias exclusivas. Por exemplo, em C++, um método é conhecido como uma função membro. O C++ também possui o conceito de funções virtuais, que são funções membro que podem ser sobrepostas em classes derivadas e permitem o despacho dinâmico.

As funções virtuais são o meio pelo qual uma classe C++ pode alcançar comportamento polimórfico. Funções membro não virtuais, ou métodos regulares, são aquelas que não participam do polimorfismo.

Exemplo em C++:

#include <iostream>
#include <memory>

class Super {
 public:
  virtual ~Super() = default;

  virtual void IAm() { std::cout << "Eu sou a superclasse!\n"; }
};

class Sub : public Super {
 public:
  void IAm() override { std::cout << "Eu sou a subclasse!\n"; }
};

int main() {
  std::unique_ptr<Super> inst1 = std::make_unique<Super>();
  std::unique_ptr<Super> inst2 = std::make_unique<Sub>();

  inst1->IAm();  // Chama |Super::IAm|.
  inst2->IAm();  // Chama |Sub::IAm|.
}

Outros projetos Wikimedia também contêm material sobre este tema:
	Livros e manuais no Wikilivros