Arquivo de março, 2014

Até agora aprendemos os princípios do Java, suas classes, pacotes, apis, objetos, coleções e tudo mais. Toda nossa entrada e  saída de dados era através do console, neste post vamos aprender como desenvolver programas visuais em Java.

O que é Swing?

Swing é o principal Java GUI Widget Toolkit. Faz parte das Classes do Oracle Java Foundation (JFC) – Uma API para fornecer uma interface gráfica do usuário (GUI) para programas em Java.

Swing foi desenvolvido para fornecer um conjunto mais sofisticado de componentes GUI do que o anterior Abstract Window Toolkit (AWT). O Swing proporciona um look and feel nativo que simula a aparência de diversas plataformas, e também suporta um look and feel pluggable que permite que os aplicativos tenham um Look sem ter relação com a plataforma subjacente. Ele tem componentes mais poderosos e flexíveis do que AWT. Além de componentes familiares, tais como botões, caixas de seleção e rótulos, Swing fornece vários componentes avançados, como painel com abas, painéis de rolagem, árvores, tabelas e listas.

Exemplo:

Neste exemplo vamos simplesmente criar uma janela vazia usando as APIs do Swing.

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingUtilities;

public class Formulario
 {

public static void main(String[] args)
  {

 // Invoca Thread do Swing
 SwingUtilities.invokeLater(new Runnable()
 {

    // roda o a janela
    @Override
    public void run()
    {

     // Cria a janela
     JFrame formulario = new JFrame("Hello World");

     // Seta o comportamento da janela
     formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

     // Seta o tamanho da janela
     formulario.setSize(400, 300);

     // seta visibilidade da janela
     formulario.setVisible(true);

    }
   });
 }
}

Objetos – Collection – MAP – Abap

Publicado: 6 de março de 2014 em Abap

Podemos ver muitos posts por ai dizendo que Abap não possui Arrays em vez disto possui Internal Tables e que são melhores que Arrays pela sua facilidade de manipulação.

Bem isto não é de inteira verdade, o Abap possui sim Arrays, como vimos em nosso post anterior, criamos uma Lista de Arrays contendo objetos usando a classe de coleção standart (CL_OBJECT_COLLECTION) e vamos usar agora outra forma de array para guardar objetos, mas desta vez teremos um pouco mais de controle sobre eles.

Map é um objeto que mapeia chaves e valores. Um mapa não pode conter chaves duplicadas, cada chave pode mapear , no máximo, um valor. Em algumas linguagens de programação um MAP chama-se Dictionary.

A interface Map fornece três visualizações de coleta, que permitem que o conteúdo de um mapa seja visto como um conjunto de chaves, cobrança de valores, ou um conjunto de mapeamentos chave-valor. A ordem de um mapa é definida como a ordem em que os iteradores em exibições de coleta do mapa devolver os seus elementos.

Em ABAP um MAP pertence a classe: CL_OBJECT_MAP

Exemplo: Neste exemplo criamos um simples programa que guarda objetos dentro de um objeto MAP e usa sua chave para remover um objeto do mapa, para dar ênfase nos mapas usamos um estilo de programação hibrida.

Abap

*&---------------------------------------------------------------------*
*& Report  ZCOLLECTION
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Collection - MAP
*&---------------------------------------------------------------------*

REPORT  ZCOLLECTION.

* Classe MAPA

CLASS MAPA DEFINITION.

PUBLIC SECTION.

     DATA CHAVE TYPE STRING.
     DATA VALOR TYPE STRING.

METHODS: CONSTRUCTOR  IMPORTING  CHAVE TYPE STRING OPTIONAL
                                 VALOR TYPE STRING OPTIONAL.

ENDCLASS.

CLASS MAPA IMPLEMENTATION.

  METHOD constructor.
    me->CHAVE = CHAVE.
    me->VALOR = VALOR.
  ENDMETHOD.

ENDCLASS.

START-OF-SELECTION.

* Declara e instancia objeto MAP

DATA MAP TYPE REF TO CL_OBJECT_MAP.
CREATE OBJECT MAP.

* cria Objeto MAPA

DATA MAPA TYPE REF TO MAPA.

* Adiciona CHAVE e VALOR no MAP

WRITE : / 'Lista de musicas do Beatles'.

PERFORM ADD USING '01' 'Let it be'.
PERFORM ADD USING '02' 'Dont let me down'.
PERFORM ADD USING '03' 'Come togheter'.
PERFORM ADD USING '04' 'Hey Jude'.
PERFORM ADD USING '05' 'Twist and shout'.

* Declara Iterador

DATA ITERADOR TYPE REF TO CL_OBJECT_COLLECTION_ITERATOR.
ITERADOR ?= MAP->GET_VALUES_ITERATOR( ).

PERFORM MOSTRAMAPA.

WRITE : / , / .
WRITE : / 'Remove musica 04 da lista'.
MAP->REMOVE( '04' ).

* Lembre-se que com o  Iterador podemos fazer
* uma alusão ao result de um banco de dados

ITERADOR ?= MAP->GET_VALUES_ITERATOR( ).

PERFORM MOSTRAMAPA.

* Retorna conteudo do mapa usando o Iterador

FORM MOSTRAMAPA.

  WHILE  ITERADOR->HAS_NEXT( ) IS NOT INITIAL.
    MAPA ?= ITERADOR->GET_NEXT( ).
    WRITE : / 'Chave:', MAPA->CHAVE,'Valor:', MAPA->VALOR.
  ENDWHILE.

ENDFORM.

* Adiciona objeto no objeto MAP

FORM ADD USING VALUE(C) TYPE STRING
   VALUE(V) TYPE STRING.

   CREATE OBJECT MAPA
       exporting
            CHAVE = C
            VALOR = V.

   MAP->PUT( exporting KEY  = MAPA->CHAVE  VALUE = MAPA ).

ENDFORM.

Objetos – Collections e Iterators – Abap

Publicado: 6 de março de 2014 em Abap

Iterator

Em português iterador, é um objeto que permite a um programador examinar uma coleção ou container. Vários tipos de iteradores são frequentemente fornecidos através de uma interface de container. Apesar da interface e semântica de um determinado iterador serem fixas, iteradores são frequentemente implementados em termos de estruturas subjacentes a uma implementação de container e são muitas vezes ligados intimamente ao container para permitir a semântica operacional do iterador.

Observe que um iterador percorre e também dá acesso aos elementos de dados em um container, mas não realiza iteração (isto é, não sem alguma liberdade significativa tomada com este conceito ou com uso trivial da terminologia). Um iterador tem um comportamento semelhante a um cursor de banco de dados. Iteradores datam da linguagem de programação CLU de 1974.

Collection

É uma coleção, às vezes chamada de um recipiente(container), é simplesmente um objeto que agrupa vários elementos em uma única unidade. Coleções são usadas ​​para armazenar, recuperar, manipular e comunicar dados agregados, ou seja uma coleção é um objeto que contém outros objetos, existem outras coleções com diferentes capacidades.

Historicamente, o quadro de coleções têm sido bastante complexo, o que lhes deu uma reputação de ter uma grande curva de aprendizagem. Os exemplos mais conhecidos de frameworks de coleções são o C ++ Standard Template Library (STL). A nomenclatura das APIs e suas sintaxes podem mudar de uma linguagem de programação para outra.

As Classes ABAP:

A SAP fornece por padrão duas classes para manipular objetos usando coleções e iteradores:

  • CL_OBJECT_COLLECTION – para a coleta de objetos.
  • CL_OBJECT_COLLECTION_ITERATOR para Iterator.

As interfaces subjacentes não são genéricas o suficiente para distribuir outros tipos de opções de coleta, métodos obrigatórios, como, adicionar, remover, etc,  não fazem parte da interface. Portanto, você precisa criar interfaces de usuário semelhantes as da implementação da classes Standard e que podem ser usadas ​​em diferentes coleções e implementação de iterador.

A partir das classes Standards é possível criar uma classe Z para as coleções e iteradores, para que se assemelhe ao framework de coleções do java que possui muito mais  flexibilidade para colecionar e iterar objetos.

Exemplo:

neste exemplo mostramos como se usa uma Collection(coleções) para guardar uma lista de objetos (Array), e navegar pela lista de objetos usando o seu Iterator(iterador).

Abap

*&---------------------------------------------------------------------*
*& Report  ZITERADOR
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Coleções e Iteradores
*&---------------------------------------------------------------------*

REPORT  ZITERADOR.

* Classe Item

CLASS ITEM DEFINITION.
    PUBLIC SECTION.

    DATA: ITENS TYPE STRING READ-ONLY.

    METHODS: CONSTRUCTOR IMPORTING ITENS TYPE STRING.

ENDCLASS.

CLASS ITEM IMPLEMENTATION.

   METHOD constructor.
      me->ITENS = ITENS.
   ENDMETHOD.

ENDCLASS.

START-OF-SELECTION.

* Define collection LIST

DATA LIST TYPE REF TO CL_OBJECT_COLLECTION.
CREATE OBJECT LIST.

* Cria Objeto Item
DATA ITEM TYPE REF TO ITEM.

* musicas dos Beatles

PERFORM ADD USING 'Let it be'.
PERFORM ADD USING 'Dont let me down'.
PERFORM ADD USING 'Come togheter'.
PERFORM ADD USING 'Hey Jude'.
PERFORM ADD USING 'Twist and shout'.

* Cria Iterador

DATA ITERADOR TYPE REF TO CL_OBJECT_COLLECTION_ITERATOR.
ITERADOR = LIST->GET_ITERATOR( ).

* Usa iterator como um cursor de banco de dados

WHILE  ITERADOR->HAS_NEXT( ) IS NOT INITIAL.
   ITEM ?= ITERADOR->GET_NEXT( ).
   WRITE : / ITEM->ITENS.
ENDWHILE.

* Adiciona Itens na lista

FORM ADD USING VALUE(S) TYPE STRING.
   CREATE OBJECT ITEM
         exporting
             ITENS = S.
   LIST->ADD( ITEM ) .
ENDFORM.

Iterator

Em português iterador, é um objeto que permite a um programador examinar uma coleção ou container. Vários tipos de iteradores são frequentemente fornecidos através de uma interface de container. Apesar da interface e semântica de um determinado iterador serem fixas, iteradores são frequentemente implementados em termos de estruturas subjacentes a uma implementação de container e são muitas vezes ligados intimamente ao container para permitir a semântica operacional do iterador.

Observe que um iterador percorre e também dá acesso aos elementos de dados em um container, mas não realiza iteração (isto é, não sem alguma liberdade significativa tomada com este conceito ou com uso trivial da terminologia). Um iterador é tem um comportamento semelhante a um cursor de banco de dados. Iteradores datam da linguagem de programação CLU de 1974.

Collection

É uma coleção, às vezes chamada de um recipiente(container), é simplesmente um objeto que agrupa vários elementos em uma única unidade. Coleções são usadas ​​para armazenar, recuperar, manipular e comunicar dados agregados, ou seja uma coleção é um objeto que contém outros objetos, existem outras coleções com diferentes capacidades.

Historicamente, o quadro de coleções têm sido bastante complexo, o que lhes deu uma reputação de ter uma grande curva de aprendizagem. Os exemplos mais conhecidos de frameworks de coleções são o C ++ Standard Template Library (STL). A nomenclatura das APIs e suas sintaxes podem mudar de uma linguagem de programação para outra.

O framework de coleção e as suas APIs:

Collection é a raiz da hierarquia do conjunto. A coleção representa um grupo de objetos conhecidos como seus elementos.

A interface Collection é o mínimo denominador comum que todos os conjuntos implementam e é usado para passar coleções para manipular objetos quando generalidade máxima é desejada. Alguns tipos de coleções permitem elementos duplicados, e outros não.

  • SET – Está diretamente relacionada com a ideia de conjuntos. Assim como um conjunto, as classes que implementam esta interface não podem conter elementos repetidos.
  • List –  É uma coleção ordenada, pode conter valores duplicados, o controle da posição de cada elemento é acessado pelo seu índice.
  • Queue: é uma lista tipo FIFO (First-In-First-Out), também conhecida como fila.
  • Map: é uma lista de relação de chave-valor entre os elementos. Cada chave pode conter apenas um único valor associado.(um mapa não é uma coleção verdadeira).

Exemplos:

Neste exemplo criamos uma collection do tipo List e a alimentamos com nomes de musicas dos Beatles, usamos o iterator para navegar no dentro dos objetos da coleção como cursores de banco de dados, registro a registro, e os alteramos manualmente, fator que as coleções não permitem por default.

Java

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Iterador
 {

 public static void main(String[] args)
 {
      List<String> colecao = new ArrayList<String>();

   // musicas dos Beatles
   colecao.add("Let it be");
   colecao.add("Dont let me down");
   colecao.add("Come togheter");
   colecao.add("Hey Jude");
   colecao.add("Twist and shout");

   // Usa iterator como um cursor de banco de dados
   Iterator<String>  iterador =  colecao.iterator();

   System.out.println("Cinco musicas dos Beatles:\n");

   while (iterador.hasNext())
   {
     Object item = iterador.next();
     System.out.println(item);
   }

   // Usa iterador como o result de um banco de dados.
   ListIterator<String>  iteradorLista = colecao.listIterator();

   // Update - altera lista
   while (iteradorLista.hasNext())
   {
     Object item = iteradorLista.next();
     iteradorLista.set("Beatles: " + item);
   }

   //Lista a coleção

   System.out.println("\nIverte a ordem da coleção:\n");
   while (iteradorLista.hasPrevious())
   {
     Object item = iteradorLista.previous();
     System.out.println(item);
   }
 }
}

C++

#include "stdafx.h"
#include <iostream>
#include <string>
#include <list>
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
 {
  list<string> colecao;

  colecao.push_back("Let it be");
  colec}ao.push_back("Dont let me down");
  colecao.push_back("Come togheter");
  colecao.push_back("Hey Jude");
  colecao.push_back("Twist and shout");

  // Usa iterator como um cursor de banco de dados
  list<string>::const_iterator
  inicio(colecao.begin()),
  fim(colecao.end());

  list<string>::iterator altera;

  cout << "Cinco musicas dos Beatles:\n" << endl;
  for (; inicio != fim; ++inicio)
  {
   cout << *inicio << endl;
  }

// Usa iterador como o result de um banco de dados.
  // Update - altera lista
  for (altera = colecao.begin(); altera != colecao.end(); ++altera)
  {
    *altera =  "Beatles: " + *altera;
  }

  //Lista a coleção
  colecao.reverse();

  cout << "\nIverte a ordem da coleção:\n" << endl;

  for (altera = colecao.begin(); altera != colecao.end(); ++altera)
  {
   cout << *altera << endl;
  }
  system("pause");
  return 0;
 }

C#

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
 {
     class Program
     {
         static void Main(string[] args)
         {
             List<String> colecao = new List<String>();

        // musicas dos Beatles
       colecao.Add("Let it be");
       colecao.Add("Dont let me down");
       colecao.Add("Come togheter");
       colecao.Add("Hey Jude");
       colecao.Add("Twist and shout");

       // Usa iterator como um cursor de banco de dados
       Console.WriteLine("Cinco musicas dos Beatles:\n");
       foreach( string item in colecao)
       {
          Console.WriteLine(item);
       }

       // Usa iterador como o result de um banco de dados.
       // Update - altera lista
       int i = 0;
       while (i <= colecao.Count() -1)
       {
          colecao[i] = "Beatles: " + colecao.ElementAt(i);
          i = i + 1;
       }

       //Lista a coleção
       colecao.Reverse();
       Console.WriteLine("\nIverte a ordem da coleção:\n");
       foreach( string item in colecao)
       {
          Console.WriteLine(item);
       }
       Console.ReadKey();
}
    }
 }

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.

Matriz – Python – Linux

Publicado: 4 de março de 2014 em Python

Sim, está é a famosa palavra que traduzida para a língua inglesa da nome ao famoso filme Matrix onde as maquinas tomam conta do planeta terra escravizando a raça humana e a usando como fonte de energia. Mas ficção cientifica a parte, fica a pergunta,  o que é matriz?

Sinônimos de útero e mãe, na ciência da computação as matrizes são estruturas matemáticas organizadas na forma de tabela com linhas e colunas, utilizadas na organização de dados e informações. Nos assuntos ligados à álgebra, as matrizes são responsáveis pela solução de sistemas lineares.

Na programação Python trabalhar com matrizes e vetores é muito simples, além dos tradicionais vetores e matrizes build-in da linguagem, podemos utilizar módulos científicos adicionas  com Numpy e Scypy, tornando o trabalho muito mais fácil e tornado o Python muito mais poderoso.

Exemplos

Neste exemplo criaremos uma classe que contém uma matriz com as cartas do baralho, usaremos as matrizes e arrays built-in da linguagem.

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# matriz.py

class Cartas:
     cartas = [[ "Paus", "Ouros", "Copas", "Espadas"],["Curinga", "As", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Valete", "Dama", "Rei" ]]

     def jogaCartas(self, naipe= 0, componentes=0):
         resultado = []
         resultado.append(self.cartas[naipe][componentes])
         return resultado

     def tNaipes(self):
         return len(self.cartas[0])

     def tComponentes(self):
         return len(self.cartas[1])

# Inicia Jogos
jogador1 = Cartas()

# Cartas Disponiveis
print "Naipes da Matriz"

resultado =[]

for i in range(jogador1.tNaipes()):
     resultado.append(jogador1.jogaCartas(0,i))

print resultado
print ""
print "Componentes da Matriz"
resultado =[]

for x in range(jogador1.tComponentes()):
     resultado.append(jogador1.jogaCartas(1,x))

print resultado
raw_input()

Matriz – Java, C++ e C#

Publicado: 3 de março de 2014 em C#, C/C++, Java

Sim, está é a famosa palavra que traduzida para a língua inglesa da nome ao famoso filme Matrix onde as maquinas tomam conta do planeta terra escravizando a raça humana e a usando como fonte de energia. Mas ficção cientifica a parte, fica a pergunta,  o que é matriz?

Sinônimos de útero e mãe, na ciência da computação as matrizes são estruturas matemáticas organizadas na forma de tabela com linhas e colunas, utilizadas na organização de dados e informações. Nos assuntos ligados à álgebra, as matrizes são responsáveis pela solução de sistemas lineares.

Em C++ para utilizar matrizes dentro de classes é necessário alguns detalhes extras, o compilador Microsoft não permite inicializar arrays ou matrizes em uma classe fora do construtor, também possui regras sobre a ordem da declaração da matriz dentro da classe e requer a adição do parâmetro /c na hora da compilação. Para saber mais sobre o assunto use o link abaixo:

Compiler Error C2536: http://msdn.microsoft.com/en-us/library/9f53ks1w.aspx

Como C++ é uma linguagem hibrida e de paradigmas não é necessário utilizar objetos de classe e um código menor consegue obter um programa com o mesmo resultado que em Java e C#.

Exemplos:

Neste exemplo criaremos uma classe que contém uma matriz com as cartas do baralho. Em C++ teremos dois exemplos diferentes, o primeiro sem objetos de classe e o segundo com objetos de classe, mas não utilizando os requisitos da Microsoft.

Java

Classe #1 – Jogo

public class Jogo
 {

public static void main(String[] args)
{
  Cartas jogador1 =  new Cartas();

  // Cartas Disponiveis
  System.out.println("Naipes da Matriz");

  for (int naipes = 0; naipes <= jogador1.tNaipe()-1; naipes++ )
  {
    jogador1.jogaCartas(0, naipes);
  }

  System.out.println();
  System.out.println();
  System.out.println("Componentes da Matriz");

  for (int componentes = 0; componentes <= jogador1.tComponentes()-1; componentes++ )
  {
     jogador1.jogaCartas(1, componentes);
  }

  }
}

Classe #2 -Cartas

public class Cartas
{
private int naipe;
private int componetes;

private String cartas[][] =
{
{ "Paus",  "Ouros",  "Copas",  "Espadas", },
{ "Curinga", "As", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Valete", "Dama", "Rei" }

};

Cartas ()
{ }

Cartas (int naipe, int componentes)
{
this.naipe = naipe;
this.componetes = componentes;
}

public void jogaCartas(int naipe, int componentes)
{
System.out.print(cartas[naipe][componentes] + ", ");
}

public int tNaipe()
{
return this.cartas[0].length;
}

public int tComponentes ()
{
return this.cartas[1].length;
}
}

C#

Classe #1 – Jogo

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)
      {
       Cartas jogador1 =  new Cartas();

      // Cartas Disponiveis
      Console.WriteLine("Naipes da Matriz");

      for (int naipes = 0; naipes <= jogador1.tNaipe()-1; naipes++ )
      {
          jogador1.jogaCartas(0, naipes);
      }

      Console.WriteLine();

      Console.WriteLine();
      Console.WriteLine("Componentes da Matriz");

     for (int componentes = 0; componentes <= jogador1.tComponentes()-1; componentes++ )
      {
          jogador1.jogaCartas(1, componentes);
      }

      Console.ReadKey();
      }
    }
 }

Classe #2 -Cartas

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
 {
     public class Cartas
     {
      private int naipe;
      private int componetes;

         private string[][] cartas =
         {
             new string[]
             { "Paus",  "Ouros",  "Copas",  "Espadas", },

             new string[]

             { "Curinga", "As", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Valete", "Dama", "Rei" }
                                           };
      public Cartas ()
      { }

      public Cartas (int naipe, int componentes)
      {
       this.naipe = naipe;
       this.componetes = componentes;
      }

      public void jogaCartas(int naipe, int componentes)
      {
         Console.Write(cartas[naipe][componentes] + ", ");
      }

      public int tNaipe()
      {
         return this.cartas[0].Length;
      }

      public int tComponentes ()
      {
       return this.cartas[1].Length;
      }
   }
 }

C++

Arquivo #1:

#include "stdafx.h"
#include <iostream>
#include <string>

using namespace std;

 const int tnaipe = 4;
 const int tcompo = 14;

const string cartas[tnaipe][tcompo] =
 {
  { "Paus", "Ouros", "Copas", "Espadas", },

  { "Curinga", "As", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Valete", "Dama", "Rei" }
 };

 void jogaCartas(int naipe, int componentes)
 {
  cout << cartas[naipe][componentes] << ", ";
 }

 int _tmain(int argc, _TCHAR* argv[])
 {

// Cartas Disponíveis

  cout << "Naipes da Matriz" << endl;

  for (int naipes = 0; naipes <= tnaipe - 1; naipes++)
  {
   jogaCartas(0, naipes);
  }

  cout << endl;  cout << endl;
  cout << "Componentes da Matriz" << endl;

  for (int componentes = 0; componentes <= tcompo - 1; componentes++)
  {
   jogaCartas(1, componentes);
  }

  cout << endl;  system("pause");
  return 0;
 }

C++ – exemplo 2

Arquivo #1 – Jogo

#include "stdafx.h"
#include <iostream>
#include <string>
#include "cartas.h"
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
 {
  Cartas jogador1;

  cout << "Naipes da Matriz" << endl;

  for (int naipes = 0; naipes <= jogador1.tNaipe() - 1; naipes++)
  {
   jogador1.jogaCartas(0, naipes);
  }

  cout << endl;  cout << endl;
  cout << "Componentes da Matriz" << endl;

  for (int componentes = 0; componentes <= jogador1.tComponentes() - 1; componentes++)
  {
   jogador1.jogaCartas(1, componentes);
  }

  cout << endl;
  system("pause");

  return 0;
 }

Arquivo #2 – Classe Cartas (.h)

#include "stdafx.h"
#include <iostream>
#include <string>
#include "da_matriz.h"
using namespace std;

class Cartas
 {
 public:

  void jogaCartas(int naipe, int componentes)
  {
   cout << cartas[naipe][componentes] << ", " ;
  }

  int tNaipe()
  {
   return tnaipe;
  }

  int tComponentes()
  {
   return tcompo ;
  }

};

Arquivo #3 – da matriz  (.h)

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;

const int tnaipe = 4;
const int tcompo = 14;

const string cartas[tnaipe][tcompo] =
 {
  { "Paus", "Ouros", "Copas", "Espadas", },

  { "Curinga", "As", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Valete", "Dama", "Rei" }
 };

Método de sobrecarga é uma característica encontrada em várias linguagens de programação, que permite a criação de vários métodos com o mesmo nome, que diferem uns dos outros no tipo da entrada e a saída da função. É simplesmente definido como a capacidade de uma função para executar diferentes tarefas.

Construtores, são usados ​​para criar instâncias de um objeto, também podem ser sobrecarregados em algumas linguagens de programação orientadas a objeto. Porque em muitas línguas o nome do construtor é pré-determinado pelo nome da classe. Sempre que são necessários vários construtores são implementados como funções sobrecarregadas. Um construtor padrão não tem parâmetros, instanciam os membros do objeto com um valor zero.

Ter pelo menos dois construtores é quase obrigatório em programação orientada a objeto, o construtor default facilita criar métodos Modifiers e Fill-in, pois é possível manipular objetos sem ter que passar nenhum parâmetros para eles e trabalhar com seus atributos dentro dos métodos, enquanto ao mesmo tempo é pratico criar objetos com valores inicializados, sem ter que escrever varias linhas.

Em Java, C++ e C# sobrecarregar um construtor  é simples, basta apenas criar quantos construtores forem necessários, por outro lado linguagens hibridas como Abap e Python (C++ também é uma linguagem hibrida, mas é muito poderosa) não é possível  sobrecarregar o método construtor, mas como este é um recurso extremamente útil, existe um modo de criar o mesmo efeito de sobrecarga nos construtores.

Abap possui a palavra chave OPTIONAL, na qual marca o parâmetro como opcional, deste modo é possível criar um objeto que simula o construtor Overload.

Python é uma linguagem moderna e bem flexível em sua sintaxe e possibilita inicializar o construtor atribuindo valores a variável e podemos usar a palavra chave None para dizer que o conteúdo é vazio, simulando deste modo um construtor Overload.

Exemplo:

Neste exemplo criamos dois construtores : o construtor default e um construtor Overload, para as linguagens Java, C++ e C# e para as  linguagens Abap e Python usamos um recurso da língua para simular o construtor Overload obtendo o mesmo efeito.

Java

public class Sobrecarga
  {
     int x = 0;
     int y = 0;

     public Sobrecarga () {}

     public Sobrecarga(int x, int y)
   {
     this.x = x;
     this.y = y;
   }

   public  void imprimeSb()
   {
     System.out.println("X=" + this.x + " Y=" + this.y);
   }

   public static void main(String[] args)
   {
       Sobrecarga sc1 = new Sobrecarga();
       Sobrecarga sc2 = new Sobrecarga(10,20);
       System.out.println("Construtor Default");
       sc1.imprimeSb();
       System.out.println("Construtor Overload");
       sc2.imprimeSb();
  }
 }

C++

#include "stdafx.h"
#include <iostream>

using namespace std;

class Sobrecarga
  {
  public:
   int x = 0;
   int y = 0;

   Sobrecarga( )   {   }

   Sobrecarga(int x, int y)
   {
    this->x = x;
    this->y = y;
   }

  void imprimeSb()
   {
    cout << "X=" << this->x << " Y=" << this->y << endl;
   }
};

int _tmain(int argc, _TCHAR* argv[])
  {
   Sobrecarga sc1;  Sobrecarga sc2(10, 20);
   cout << "Construtor Default" << endl;
   sc1.imprimeSb();

   cout << "Construtor Overload" << endl;
   sc2.imprimeSb();
   system("pause");
   return 0;
  }

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesenvolvimentoAberto
  {
      class Sobrecarga
      {
          int x = 0;
          int y = 0;

         public Sobrecarga() { }

         public Sobrecarga(int x, int y)
          {
              this.x = x;
              this.y = y;
          }

      public void imprimeSb()
       {
         Console.WriteLine("X=" + this.x + " Y=" + this.y);
       }

          static void Main(string[] args)
          {
              Sobrecarga sc1 = new Sobrecarga();
              Sobrecarga sc2 = new Sobrecarga(10,20);
              Console.WriteLine("Construtor Default");
              sc1.imprimeSb();
              Console.WriteLine("Construtor Overload");
              sc2.imprimeSb();
              Console.ReadKey();
          }
      }
  }

Abap

*&---------------------------------------------------------------------*
*& Report  ZOBJETOS_OVER
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Construtor Overload
*&---------------------------------------------------------------------*

REPORT  ZOBJETOS_OVER.

* Declara Classe

Class SobreCarga DEFINITION.

PUBLIC SECTION.
   DATA X TYPE i.
    DATA Y TYPE i.

" Efeito Overload
METHODS:
CONSTRUCTOR IMPORTING
             X TYPE i OPTIONAL
             Y TYPE i OPTIONAL,
ImprimeSB.

ENDCLASS.

Class SOBRECARGA IMPLEMENTATION.

 METHOD CONSTRUCTOR.
     me->X = X.
     me->Y = Y.
 ENDMETHOD.

 METHOD ImprimeSB.
     WRITE: / 'X=', me->X, 'Y=', me->Y.
 ENDMETHOD.

ENDCLASS.

START-OF-SELECTION.

DATA SB1 TYPE REF TO SOBRECARGA.
DATA SB2 TYPE REF TO SOBRECARGA.

* Cria Objetos Construtor Default e Overload
CREATE OBJECT SB1.
CREATE OBJECT SB2 EXPORTING X = 10 Y = 20.

WRITE: / 'Construtor Default:'.
SB1->IMPRIMESB( ).
WRITE: / 'Construtor Overload:'.
SB2->IMPRIMESB( ).

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# sobrecarga.py

class SobreCarga:
      x = 0
      y = 0
      def __init__(Self,x= None, y = None):
          if (x is not None) and (y is not None):
              Self.x = x
              Self.y = y
      def ImprimeSb(Self):
          print "X=", Self.x, "Y=", Self.y

sc1 = SobreCarga();
sc2 = SobreCarga(10,20);
print "Construtor Default"
sc1.ImprimeSb();
print "Construtor Overload"
sc2.ImprimeSb();
raw_input()

Pure Function

Usa os objetos como argumentos, mas não os modifica. o valor de retorno é ou um primitivo ou um novo objeto criado dentro do método.

Um método é considerado uma função pura se o resultado depender apenas dos argumentos, e não ter efeitos colaterais, como modificar um argumento ou imprimir algo. O único resultado de chamar uma função pura é o seu valor de retorno.

Na transformação funcional pura, um conjunto de funções, chamadas funções puras, definem a forma de como transformar um conjunto de dados estruturados a partir de sua forma original para outra forma. A palavra “pura” indica que as funções são combináveis​​, que exige que elas sejam:

Auto-suficiente, de modo que elas podem ser livremente ordenada e rearranjada sem emaranhamento ou interdependências com o resto do programa. Transformações puras não têm conhecimento ou efeito sobre o meio ambiente. Ou seja, as funções utilizadas para a transformação não tem efeitos colaterais.

Sem mudança de estado, de modo que a execução da mesma função ou conjunto específico de funções na mesma entrada sempre resultará na mesma saída. Transformações puras não têm memória do seu uso anterior. Funções puras ajudar a gerenciar a complexidade dos grandes projetos.

Modifiers

Usa objetos como argumentos e modifica alguns elementos ou todos eles. Muitas vezes, retorna uma def. Um método modificador muda a forma como os objetos funcionam.

Fill-in

Um dos argumentos é um objeto vazio que é preenchido em pelo método. Tecnicamente, este método também é um tipo de Modifier.

Melhores Praticas

É recomendado que você escreva funções puras sempre que for razoável, e recorra aos Modifiers e Fill-ins apenas se houver uma grande vantagem.

Métodos Modifiers e Fill-in  são eficientes porque eles não têm que criar novos objetos. Mas se torna mais difícil de isolar partes de um programa, e em grandes projetos podem causar erros que são difíceis de encontrar.

Exemplo:

Neste exemplo escrevemos três métodos diferentes: Pure function, Modifier e um fill-in, e manipulamos objetos utilizando estes métodos.

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# objetos.py

class Retangulo:
    x = 0
    y = 0
    altura = 0
    largura = 0

    # Workaround para efeito de Overload
    # Constructor ()
    def __init__ (self, x= None, y= None, altura= None, largura= None):
        if (x is not None) and (y is not None) and (altura is not None) and (largura is not None):
            self.x = x
            self.y = y
            self.altura = altura
            self.largura = largura

    def imprimeRet(self):
         print "X=", self.x, "Y =", self.y, "Altura=", self.altura, "Largura=", self.largura

# Método Pure Function
def maxRet(ret = Retangulo(), altura = 0, largura = 0):
    if ( ret.altura <= altura) and (ret.largura <= largura):
        return True
    else:
        return False

# Método Modifier
def posicao(ret = Retangulo(), x = 0, y = 0):
    ret.x = ret.x + x
    ret.y = ret.y + y

# Método Fill-in
def modRet(r1 = Retangulo(), r2 = Retangulo(), r3 = Retangulo()):
    r1.x       =  r2.x      + r3.x
    r1.y       =  r2.y      + r3.y
    r1.altura  = r2.altura  + r3.altura
    r1.largura = r2.largura + r3.largura

ret1 = Retangulo(50,50,200,300)
ret2 = Retangulo(15,15,120,150)
ret3 = Retangulo() 
ret1.imprimeRet()

resultado =  maxRet(ret1, 500, 600)
print "Retangulo está dentro do limite maximo:", resultado
print ""

print "Modifica posição do retangulo:"
posicao(ret1, 20, 20)
ret1.imprimeRet()

print ""
print "Modifica tamanho do retangulo:"
modRet(ret3, ret1, ret2);
ret3.imprimeRet()

raw_input()

Pure Function

Usa os objetos como argumentos, mas não os modifica. o valor de retorno é ou um primitivo ou um novo objeto criado dentro do método.

Um método é considerado uma função pura se o resultado depender apenas dos argumentos, e não ter efeitos colaterais, como modificar um argumento ou imprimir algo. O único resultado de chamar uma função pura é o seu valor de retorno.

Na transformação funcional pura, um conjunto de funções, chamadas funções puras, definem a forma de como transformar um conjunto de dados estruturados a partir de sua forma original para outra forma. A palavra “pura” indica que as funções são combináveis​​, que exige que elas sejam:

Auto-suficiente, de modo que elas podem ser livremente ordenada e rearranjada sem emaranhamento ou interdependências com o resto do programa. Transformações puras não têm conhecimento ou efeito sobre o meio ambiente. Ou seja, as funções utilizadas para a transformação não tem efeitos colaterais.

Sem mudança de estado, de modo que a execução da mesma função ou conjunto específico de funções na mesma entrada sempre resultará na mesma saída. Transformações puras não têm memória do seu uso anterior. Funções puras ajudam a gerenciar a complexidade dos grandes projetos.

Modifiers

Usa objetos como argumentos e modifica alguns elementos ou todos eles. Muitas vezes, retorna um method. Um método modificador muda a forma como os objetos funcionam.

Fill-in

Um dos argumentos é um objeto vazio que é preenchido em pelo método. Tecnicamente, este método também é um tipo de Modifier.

Melhores Praticas

É recomendado que você escreva funções puras sempre que for razoável, e recorra aos Modifiers e Fill-ins apenas se houver uma grande vantagem.

Métodos Modifiers e Fill-in  são eficientes porque eles não têm que criar novos objetos. Mas se torna mais difícil de isolar partes de um programa, e em grandes projetos podem causar erros que são difíceis de encontrar.

Exemplo:

Neste exemplo escrevemos três métodos diferentes: Pure function, Modifier e um fill-in, e manipulamos objetos utilizando estes métodos.

Abap

*&---------------------------------------------------------------------*
*& Report  ZOBJETOS_M
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Objetos - Métodos - Pure Function, Modifier e Fill-in
*&---------------------------------------------------------------------*

REPORT  ZOBJETOS_M.

* Classe Retangulo
Class Retangulo DEFINITION.
PUBLIC SECTION.

DATA : x       TYPE i,
       y       TYPE i,
       altura  TYPE i,
       largura TYPE i.

METHODS:

" Workaround para efeito Overload
CONSTRUCTOR IMPORTING
       X       TYPE i OPTIONAL
       Y       TYPE i OPTIONAL
       altura  TYPE i OPTIONAL
       largura TYPE i OPTIONAL,

imprimeRet.

ENDCLASS.

Class RETANGULO IMPLEMENTATION.

METHOD CONSTRUCTOR.
   me->X       = X.
   me->Y       = Y.
   me->ALTURA  = ALTURA.
   me->LARGURA = LARGURA.
ENDMETHOD.

METHOD IMPRIMERET.
   WRITE: / 'X=', me->X, 'Y=', me->Y, 'Altura=', me->ALTURA, 'Largura=', me->LARGURA.
ENDMETHOD.

ENDCLASS.

* Classe Métodos
CLASS METODOS DEFINITION INHERITING FROM RETANGULO.
PUBLIC SECTION.

METHODS:

CONSTRUCTOR,

maxRet   IMPORTING
 ret     TYPE REF TO RETANGULO
 altura  TYPE i
 largura TYPE i
         RETURNING VALUE(resultado) TYPE abap_bool,

posicao  IMPORTING
     ret TYPE REF TO RETANGULO
     x   TYPE i
     y   TYPE i,

modRet  IMPORTING
     r1 TYPE REF TO RETANGULO
     r2 TYPE REF TO RETANGULO
     r3 TYPE REF TO RETANGULO.

ENDCLASS.

CLASS METODOS IMPLEMENTATION.

METHOD CONSTRUCTOR.
     CALL METHOD SUPER->CONSTRUCTOR.
ENDMETHOD.

* Método Pure Function
METHOD MAXRET.
  IF  me->altura LT altura AND me->largura LT largura.
    RESULTADO = abap_true.
  ELSE.
    RESULTADO = abap_false.
  ENDIF.
ENDMETHOD.

* Método Modifier
METHOD POSICAO.
   RET->X = RET->X + X.
   RET->Y = RET->Y + Y.
ENDMETHOD.

* Método Fill-in
METHOD MODRET.
   R1->X = R2->X + R3->X.
   R1->Y = R2->Y + R3->Y.
   R1->ALTURA = R2->ALTURA + R3->ALTURA.
   R1->LARGURA =  R2->LARGURA +  R3->LARGURA.
ENDMETHOD.

ENDCLASS.

START-OF-SELECTION.

* Cria Instâncias e Objetos

DATA RET1 TYPE REF TO RETANGULO.
DATA RET2 TYPE REF TO RETANGULO.
DATA RET3 TYPE REF TO RETANGULO.
DATA MET1 TYPE REF TO METODOS.
DATA REST TYPE ABAP_BOOL.

* Objetos instanciados contrutores

CREATE OBJECT RET1 EXPORTING X = 50 Y = 50 ALTURA = 200 LARGURA = 300.
CREATE OBJECT RET2 EXPORTING X = 15 Y = 15 ALTURA = 120 LARGURA = 150.

* Objeto instanciado Overload

CREATE OBJECT RET3.

* Objeto de Metodos

CREATE OBJECT MET1.

* Manipula Método Pure Function

RET1->IMPRIMERET( ).
MET1->MAXRET( exporting RET = RET1 ALTURA = 500 LARGURA = 600 RECEIVING RESULTADO = REST  ).

IF REST = abap_true.
   WRITE : / 'Retangulo está dentro do limite maximo: TRUE'.
ELSE.
   WRITE : / 'Retangulo está dentro do limite maximo: FALSE'.
ENDIF.

* Manipula Método Modifier
WRITE : / .
WRITE : / 'Modifica posição do retangulo:'.
MET1->POSICAO( exporting RET = RET1 X   = 20 Y   = 20 ).
RET1->IMPRIMERET( ).

* Manipula Métodos Fill-in
WRITE : / .
WRITE : / 'Modifica tamanho do retangulo:'.
MET1->MODRET( exporting R1 = RET3 R2 = RET1 R3 = RET2 ).
RET3->IMPRIMERET( ).