Objetos – Métodos de Classe e Métodos de Objeto – Java, C++, C#, Python, Abap

Publicado: 4 de março de 2014 em Abap, C#, C/C++, Java, Python

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.
Anúncios

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair /  Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair /  Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair /  Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair /  Alterar )

Conectando a %s