Método (programação de computador) - Method (computer programming)

Um método de programação orientada para o objecto (OOP) é um procedimento associado com uma mensagem e um objeto . Um objeto consiste em dados e comportamento ; eles compreendem uma interface , que especifica como o objeto pode ser utilizado por qualquer um de seus vários consumidores.

Os dados são representados como propriedades do objeto e os comportamentos são representados como métodos. Por exemplo, um Windowobjeto pode ter métodos como opene close, enquanto seu estado (se está aberto ou fechado em qualquer momento) seria uma propriedade.

Na programação baseada em classe , os métodos são definidos dentro de uma classe e os objetos são instâncias de uma determinada classe. Um dos recursos mais importantes que um método fornece é a substituição de método - o mesmo nome (por exemplo, area) pode ser usado para vários tipos diferentes de classes. Isso permite que os objetos de envio invoquem comportamentos e deleguem a implementação desses comportamentos ao objeto de recebimento. Um método de programação Java define o comportamento de um objeto de classe. Por exemplo, um objecto pode enviar uma areamensagem para um outro objecto e a fórmula apropriada é invocada se o objeto receptor é um rectangle, circle, triangle, etc.

Os métodos também fornecem a interface que outras classes usam para acessar e modificar as propriedades de um objeto; isso é conhecido como encapsulamento . Encapsulamento e substituição são os dois principais recursos de distinção entre métodos e chamadas de procedimento.

Substituindo e sobrecarregando

Substituição e sobrecarga de método são duas das maneiras mais significativas pelas quais um método difere de um procedimento convencional ou chamada de função. Substituir se refere a uma subclasse que redefine a implementação de um método de sua superclasse. Por exemplo, findAreapode ser um método definido em uma classe de forma triangle, etc., cada um definiria a fórmula apropriada para calcular sua área. A ideia é ver os objetos como "caixas pretas", de modo que as alterações nas partes internas do objeto possam ser feitas com o mínimo de impacto nos outros objetos que o utilizam. Isso é conhecido como encapsulamento e tem como objetivo tornar o código mais fácil de manter e reutilizar.

A sobrecarga do método, por outro lado, refere-se à diferenciação do código usado para tratar uma mensagem com base nos parâmetros do método. Se alguém vê o objeto receptor como o primeiro parâmetro em qualquer método, a substituição é apenas um caso especial de sobrecarga, em que a seleção é baseada apenas no primeiro argumento. O seguinte exemplo simples de Java ilustra a diferença:

Métodos acessadores, modificadores e gerenciadores

Os métodos de acesso são usados ​​para ler os valores dos dados de um objeto. Os métodos mutator são usados ​​para modificar os dados de um objeto. Métodos de gerenciamento são usados ​​para inicializar e destruir objetos de uma classe, por exemplo, construtores e destruidores.

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 getBalance()método de acesso para recuperar o saldo atual (em vez de acessar diretamente os campos de dados de saldo), então as revisões posteriores do mesmo código podem implementar um mecanismo mais complexo para recuperação de saldo (por exemplo, um banco de dados fetch), 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. Na verdade, em muitos aspectos, a abordagem orientada a objetos é simplesmente a extensão lógica de paradigmas anteriores, como tipos de dados abstratos e programação estruturada .

Construtores

Um construtor é um método chamado no início da vida útil de um objeto para criar e inicializar o objeto, um processo chamado construção (ou instanciação ). A inicialização pode incluir uma 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 Main {
    String _name;
    int _roll;

    Main(String name, int roll) { // constructor method
        this._name = name;
        this._roll = roll;
    }
}

Destruidores

Um destruidor é um método chamado automaticamente no final da vida útil de um objeto, um processo denominado destruição . A destruição na maioria das linguagens não permite argumentos de métodos destruidores nem valores de retorno. A destruição pode ser implementada para realizar tarefas de limpeza e outras tarefas na destruição de objetos.

Finalizadores

Em linguagens com coleta de lixo , como Java , C # e Python , destruidores são conhecidos como finalizadores . Eles têm um propósito e função semelhantes aos destruidores, mas devido às diferenças entre as linguagens que utilizam a coleta de lixo e as linguagens com gerenciamento manual de memória, a sequência em que são chamados é diferente.

Métodos abstratos

Um método abstrato é aquele com apenas uma assinatura e nenhum corpo de implementação . Geralmente é usado para especificar que uma subclasse deve fornecer uma implementação do método. Métodos abstratos são usados ​​para especificar interfaces em algumas linguagens de programação.

Exemplo

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

abstract class Shape {
    abstract int area(int h, int w); // abstract method signature
}

A seguinte subclasse estende a classe principal: 

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

Reabstração

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

Na prática, isso raramente é usado.

Exemplo

Em C #, um método virtual pode ser substituído por um método abstrato. (Isso também se aplica a Java, onde todos os métodos não privados são virtuais.) 

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

Os métodos padrão das interfaces também podem ser refeitos, exigindo subclasses para implementá-los. (Isso também se aplica a Java.) 

interface IA
{
    void M() { }
}
interface IB : IA
{
    abstract void IA.M();
}
class C : IB { } // error: class 'C' does not implement 'IA.M'.

Métodos de aula

Os métodos de classe são métodos chamados em uma classe em vez de em uma instância. Eles são normalmente usados ​​como parte de um metamodelo de objeto . Ou seja, para cada classe definida, é criada uma instância do objeto de classe no metamodelo. Os protocolos de metamodelo permitem que as classes sejam criadas e excluídas. Nesse sentido, eles fornecem a mesma funcionalidade que os construtores e destruidores descritos acima. Mas em algumas linguagens, como Common Lisp Object System (CLOS), o metamodelo permite ao desenvolvedor alterar dinamicamente o modelo de objeto em tempo de execução: por exemplo, para criar novas classes, redefinir a hierarquia de classes, modificar propriedades, etc.

Métodos especiais

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

Métodos estáticos

Os métodos estáticos devem ser relevantes para todas as instâncias de uma classe, e não para qualquer instância específica. Nesse sentido, são semelhantes a variáveis ​​estáticas . 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 Productclasse, ela poderia ter um método estático para calcular o preço médio de todos os produtos.

Em Java, um método estático comumente usado é: 

Math.max(double a, double b)

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

Um método estático pode ser chamado mesmo que ainda não exista nenhuma instância da classe. Os métodos estáticos 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 polimorficamente com base no tipo de tempo de execução do objeto.

Operadores de atribuição de cópia

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

Métodos do operador

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

#include <string>

class Data {
 public:
  bool operator<(const Data& data) const { return roll_ < data.roll_; }
  bool operator==(const Data& data) const {
    return name_ == data.name_ && roll_ == data.roll_;
  }

 private:
  std::string name_;
  int roll_;
};

Funções de membro em C ++

Algumas linguagens procedurais foram estendidas com recursos orientados a objetos para alavancar os grandes conjuntos de habilidades e código legado para essas linguagens, mas ainda fornecem os benefícios do desenvolvimento orientado a objetos. Talvez o exemplo mais conhecido seja 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 em uma linguagem procedural existente, a passagem de mensagens em C ++ tem alguns recursos e terminologias exclusivos. Por exemplo, em C ++, um método é conhecido como função de membro . C ++ também tem o conceito de funções virtuais, que são funções de membro que podem ser substituídas em classes derivadas e permitem o envio dinâmico .

Funções virtuais

As funções virtuais são os meios pelos quais uma classe C ++ pode atingir um comportamento polimórfico. Funções de membro não virtuais , ou métodos regulares , são aqueles que não participam do polimorfismo .

Exemplo C ++: 

#include <iostream>
#include <memory>

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

  virtual void IAm() { std::cout << "I'm the super class!\n"; }
};

class Sub : public Super {
 public:
  void IAm() override { std::cout << "I'm the subclass!\n"; }
};

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

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

Veja também

Notas

Referências