Existem muitos estilos de programação e estes chamados de paradigmas. As linguagens mais antigas possuem o estilo processual (procedural) , pois da ênfase sobre a especificação computacional de procedimentos, enquanto as linguagens mais modernas são orientadas a objeto, as linguagens que evoluirão ou as que nasceram de uma linguagem de outro paradigma e ainda mantém as suas características seja por opção ou por compatibilidade, estas são chamadas de hibridas, que em ciência da computação é uma linguagem de programação que se baseia em elementos de mais de um paradigma de programação.
Um paradigma de programação fornece e determina a visão que o programador possui sobre a estruturação e execução do programa. Por exemplo, em programação orientada a objetos, programadores podem abstrair um programa como uma coleção de objetos que interagem entre si, enquanto em programação funcional os programadores abstraem o programa como uma sequência de funções executadas de modo empilhado.
Em linguagens multi paradigmas a maioria da programação hoje em dia é orientada a objeto, o que significa que o foco está em objetos e suas interações.
Em programação orientada a objetos existem dois tipos de métodos, chamados métodos de classe e métodos de objetos. Métodos de classe são identificados pela palavra-chave static na primeira linha. Qualquer método que não possua a palavra-chave static é um método de objeto. Este significado pode variar dependendo da linguagem de programação vide Python.
Então podemos dividir os métodos entre estáticos e não estáticos:
Estáticos: métodos estáticos não requerem uma instância da classe nem podem acessar implicitamente os dados (this, self, Me, etc.) de tal instância. Um método estático é distinguido em algumas linguagens de programação com a palavra-chave static colocada em algum lugar na assinatura do método.
Não Estáticos: métodos não estáticos requerem uma instância da classe e podem acessar implicitamente os dados (this, self, Me, etc.) de tal instância. Este método exige um tipo de código diferente da programação de códigos estáticos, pois está sempre se referindo a instancia do objeto e não da classe.
Código do Método Objeto:
- Não declarar a instrução estática.
- Nomear o método para ser mais idiomático.
- Remover o parâmetro da própria classe na declaração.
- Dentro do método de objeto você deve se referir as variáveis de instância como variáveis locais.
Exemplo:
A por default a maioria das linguagens de programação orientada a objetos fornecem um método chamado equals(igual) que define a equivalência entre objetos As classes default fornecem o método equals que já faz toda a coisa do modo correto. Mas para os tipos definidos pelo usuário o comportamento padrão é o mesmo que identidade, que normalmente não é o resultado que você quer. Então tudo o que temos a fazer é reescrever o método equals para nosso objeto.
O modo correto é criar uma função Override para o método equals, mas aqui vamos escrever a função com o nome traduzido para que fique claro a diferença entre métodos de classe e métodos de objeto, que é o objetivo deste post.
Java
Classe #1
public class Program { public static void main(String[] args) { // Instancia dos Objetos Quadrado q1 = new Quadrado(32); Quadrado q2 = new Quadrado(32); System.out.println("Verifica se os Objetos são iguais\n"); // Usa método da Classe System.out.print("Testa método da classe:"); System.out.println(Quadrado.iguaisQ(q1, q2)); // Usa método do Objeto System.out.print("Testa método do objeto:"); System.out.println(q1.iguais(q2)); } }
Classe #2
public class Quadrado { private double lado; Quadrado (double lado) { this.lado = lado; } // Método da Classe - Estatico static public boolean iguaisQ(Quadrado q1, Quadrado q2) { return (q1.lado == q2.lado); } // Método do Objeto - Não Estatico public boolean iguais(Quadrado q2) { return (lado == q2.lado); } }
C++
Classe #1
#include "stdafx.h" #include <iostream> #include "Quadrado.h" using namespace std; int _tmain(int argc, _TCHAR* argv[]) { // Instancia dos Objetos Quadrado q1 (32); Quadrado q2 (32); cout << "Verifica se os Objetos são iguais\n" << endl; // Usa método da Classe cout << "Testa método da classe:"; cout << Quadrado::iguaisQ(q1, q2) << endl; // Usa método do Objeto cout << "Testa método do objeto:"; cout << q1.iguais(q2) << endl; system("pause"); return 0; }
Classe #2
#include "stdafx.h" #include <iostream> using namespace std; class Quadrado { private: double lado; public: Quadrado(double lado) { this->lado = lado; } // Método da Classe - Estatico static bool iguaisQ(Quadrado q1, Quadrado q2) { return (q1.lado == q2.lado); } // Método do Objeto - Não Estatico bool iguais(Quadrado q2) { return (lado == q2.lado); } };
C#
Classe #1
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace DesenvolvimentoAberto { class Program { static void Main(string[] args) { // Instancia dos Objetos Quadrado q1 = new Quadrado(32); Quadrado q2 = new Quadrado(32); Console.WriteLine("Verifica se os Objetos são iguais\n"); // Usa método da Classe Console.Write("Testa método da classe:"); Console.WriteLine(Quadrado.iguaisQ(q1, q2)); // Usa método do Objeto Console.Write("Testa método do objeto:"); Console.WriteLine(q1.iguais(q2)); Console.ReadKey(); } } }
Classe #2
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace DesenvolvimentoAberto { class Quadrado { private double lado; public Quadrado(double lado) { this.lado = lado; } // Método da Classe - Estatico static public Boolean iguaisQ(Quadrado q1, Quadrado q2) { return (q1.lado == q2.lado); } // Método do Objeto - Não Estatico public Boolean iguais(Quadrado q2) { return (lado == q2.lado); } } }
Python
Classe #1
#!/usr/bin/env python # -*- coding: latin-1 -*- # Desenvolvimento Aberto # objetos_metodos.py class Q: lado = 0 class Quadrado(Q) : def __init__(self, lado = 0): self.lado = lado def iguais(self,q2 = Q()): return self.lado == q2.lado @staticmethod def iguaisQ(q1 = Q() , q2 = Q()): return q1.lado == q2.lado # Instancia dos Objetos q1 = Quadrado(32) q2 = Quadrado(32) print "Verifica se os Objetos são iguais\n" # Usa método da Classe print "Testa método da classe:" print Quadrado.iguaisQ(q1, q2) # Usa método do Objeto print "Testa método do objeto:" print q1.iguais(q2) raw_input()
Abap
Classe #1
*&---------------------------------------------------------------------* *& Report ZMETODOS *& *&---------------------------------------------------------------------* *& Desenvolvimento Aberto *& Metodos Estaticos e de Objetos *&---------------------------------------------------------------------* REPORT ZMETODOS. class Quadrado DEFINITION. PUBLIC SECTION. DATA lado TYPE i. METHODS: CONSTRUCTOR IMPORTING lado TYPE i, IGUAIS IMPORTING Q2 TYPE REF TO QUADRADO RETURNING VALUE(resultado) TYPE ABAP_BOOL. CLASS-METHODS IGUAISQ IMPORTING Q1 TYPE REF TO QUADRADO Q2 TYPE REF TO QUADRADO RETURNING VALUE(resultado) TYPE ABAP_BOOL. ENDCLASS. CLASS QUADRADO IMPLEMENTATION. METHOD CONSTRUCTOR. CALL METHOD SUPER->CONSTRUCTOR. me->LADO = LADO. ENDMETHOD. METHOD IGUAIS. IF me->LADO EQ Q2->LADO. RESULTADO = ABAP_TRUE. ELSE. RESULTADO = ABAP_FALSE. ENDIF. ENDMETHOD. METHOD IGUAISQ. IF Q1->LADO EQ q2->LADO. RESULTADO = ABAP_TRUE. ELSE. RESULTADO = ABAP_FALSE. ENDIF. ENDMETHOD. ENDCLASS. START-OF-SELECTION. DATA Q1 TYPE REF TO QUADRADO. DATA Q2 TYPE REF TO QUADRADO. DATA RT TYPE ABAP_BOOL. CREATE OBJECT Q1 EXPORTING LADO = 32. CREATE OBJECT Q2 EXPORTING LADO = 32. WRITE : / 'Verifica se os Objetos são iguais'. * Usa método da Classe WRITE: / 'Testa método da classe:'. QUADRADO=>IGUAISQ( exporting Q1 = Q1 Q2 = Q2 receiving RESULTADO = RT ). PERFORM RESULTADO USING RT. * Usa método do Objeto WRITE : / 'Testa método do objeto:'. RT = Q1->IGUAIS( Q2 ). PERFORM RESULTADO USING RT. FORM RESULTADO USING VALUE(R) TYPE ABAP_BOOL. IF R = ABAP_TRUE. WRITE : 'TRUE'. ELSE. WRITE : 'FALSE'. ENDIF. ENDFORM.