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.
Ricardo Mantovani
Desenvolvimento Código Aberto 