Desenvolvimento Código Aberto

Objetos – Mutable, Reference, Return, Aliasing – Garbage Collection – Abap

Publicado: 1 de março de 2014 em Abap

Programação orientada a objetos apela em vários níveis. Para os gestores, que promete um desenvolvimento e manutenção mais rápido e mais barato. Para analistas e designers, o processo de modelagem torna-se mais simples e produz um design claro e gerenciável.

Para os programadores, a elegância e clareza do modelo de objeto e do poder de ferramentas e bibliotecas orientadas a objetos faz programação de uma tarefa muito mais agradável, e programadores experimentam um aumento na produtividade. Todo mundo ganha, ao que parece.

Se há um lado negativo, é à custa da curva de aprendizado. Pensar em objetos é uma dramática partida de pensar processualmente, e o processo de criação de objetos é muito mais desafiador do projeto processual, especialmente se você está tentando criar objetos reutilizáveis.

A abordagem orientada a objetos dá um passo mais longe, fornecendo ferramentas para o programador representar elementos no espaço do problema. Esta representação é geral o suficiente para que o programador não é fique restrito a qualquer tipo particular de problema.

Objetos são mutáveis

Você pode alterar o conteúdo de um objeto, fazendo uma atribuição a uma de suas variáveis de instância.

Você pode escrever métodos que retornam objetos. Observe que você pode usar a palavra chave CREATE OBJECT para criar um novo objeto, e logo em seguida usar o RETURNING (resultado) como valor de retorno.

Modificando objetos, passando-os como argumentos para métodos podem ser úteis, mas também pode tornar a depuração mais difícil, porque nem sempre são claras as invocações que o método faz ou não para modificar seus argumentos. Mais tarde, vamos discutir alguns prós e contras deste estilo de programação.

Passando e Retornando Objetos

Em programação orientada a objetos é possível criar métodos passando um objeto e retornando um objeto.

Alias de Objetos

Quando dois objetos referem-se ao mesmo objeto. Em outras palavras, este objeto tem dois nomes, Objeto1 e Objeto2. Quando uma pessoa usa dois nomes, é chamado de aliasing. A mesma coisa com os objetos. Quando duas variáveis são alias, todas as mudanças que afetam uma variável também afetara a outra.

Null

Quando você cria uma variável de objeto, lembre-se que você está criando uma referência a um objeto. Até você fazer variável apontar para um objeto, o valor da variável é nulo. null é um valor especial e uma palavra-chave que significa: nenhum objeto.

Garbage collection

Se ninguém se refere a um objeto, então ninguém pode ler ou gravar qualquer dos seus valores, ou chamar um método nele. Em efeito, ele deixa de existir. Poderíamos manter o objeto na memória, mas seria apenas um espaço de resíduos, assim como o seu programa é executado periodicamente, o sistema procura por objetos encalhados e tenta recupera-los, em um processo chamado de coleta de lixo. Posteriormente, o espaço de memória ocupado por o objeto estará disponível para ser utilizado como parte de um novo objeto. Você não tem que fazer nada para fazer a coleta de lixo acontecer, e em geral você não vai estar ciente disso. Mas você deve saber que é periodicamente executado em segundo plano.

Objetos e Primitivos

Existem dois tipos diferentes, tipos primitivos e tipos de objetos. primitivos, como int e boolean começam com letras minúsculas; tipos de objetos começam com letras maiúsculas. Esta distinção é útil porque nos lembra algumas das diferenças entre eles:

Quando você declara uma variável primitiva, você tem espaço de armazenamento para um valor primitivo. Quando você declara uma variável de objeto, você tem um espaço para uma referência a um objeto.

Se você não inicializar um tipo primitivo, é dado um valor padrão a ele que depende de cada tipo primitivo.

Variáveis primitivas são bem isoladas, no sentido de que não há nada você possa fazer em um método que vai afetar uma variável em outro método.

Há uma outra diferença entre primitivos e tipos de objetos. Você não pode adicionar novos primitivos, mas você pode criar novos tipos de objetos.

Exemplo:

Neste exemplo criamos dois objetos de classes distintas e usamos algumas técnicas de manipulação de objetos, como: métodos de referencias ao objeto, retorno de objetos, aliasing de objetos.

Dica:

Você pode rodar o código fonte abaixo, ou separar as classes no Class Builder, deixando o código fonte menor e muito mais limpo.

Abap

*&---------------------------------------------------------------------*
*& Report  ZOBJETO
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Objetos
*&---------------------------------------------------------------------*

REPORT  ZOBJETO.

* Cria classe Pontos

class PONTOS DEFINITION.

PUBLIC SECTION.

data : x TYPE i,
       y TYPE i.

METHODS :

        " Workaround para criar Overload
        " Constructor ()

        CONSTRUCTOR IMPORTING x TYPE i OPTIONAL
                              y TYPE i OPTIONAL.

ENDCLASS.

class PONTOS IMPLEMENTATION.

    METHOD CONSTRUCTOR.
       me->x = x.
       me->y = y.
    ENDMETHOD.

ENDCLASS.

* Cria Classe Retangulo.

class Retangulo DEFINITION INHERITING FROM PONTOS.

PUBLIC SECTION.

data: altura  TYPE i,
      largura TYPE i.

METHODS: " Workaround para criar Overload
         " Constructor ()

         CONSTRUCTOR IMPORTING x       TYPE i OPTIONAL
                               y       TYPE i OPTIONAL
                               altura  TYPE i OPTIONAL
                               largura TYPE i OPTIONAL,

         OBJETO.

ENDCLASS.

class Retangulo IMPLEMENTATION.

     METHOD CONSTRUCTOR.

        CALL METHOD SUPER->CONSTRUCTOR.
       me->X = x.
       me->Y = y.
       me->ALTURA = altura.
       me->LARGURA = largura.
     ENDMETHOD.

     METHOD OBJETO.

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

endclass.

* Cria classe coordenadas

class coordenadas DEFINITION INHERITING FROM PONTOS.

PUBLIC SECTION.

METHODS achaCentro IMPORTING ret TYPE REF TO RETANGULO
                   RETURNING VALUE(pt) TYPE REF TO PONTOS.

ENDCLASS.

class COORDENADAS IMPLEMENTATION.

      METHOD ACHACENTRO.
        me->X = RET->X + RET->LARGURA / 2.
        me->Y = RET->Y + RET->ALTURA  / 2.
        CREATE OBJECT PT
           EXPORTING
              X = me->X
              Y = me->Y.
        ENDMETHOD.

ENDCLASS.

START-OF-SELECTION.

* Instancia objeto

DATA pnt TYPE REF TO PONTOS.
CREATE OBJECT pnt
   EXPORTING
      X = 10
      Y = 15.

DATA ret1 TYPE REF TO RETANGULO.
CREATE OBJECT ret1
      EXPORTING
          X       = pnt->X
          Y       = pnt->Y
          ALTURA  = 150
          LARGURA = 200.

* Objetos são Mutaveis

MOVE 300 TO RET1->ALTURA.
MOVE 400 TO RET1->LARGURA.

RET1->OBJETO( ).

* Aliasing
* Utiliza método com efeito Overload feito no Workaround acima
DATA ret2 TYPE REF TO RETANGULO.
CREATE OBJECT RET2.

RET2 = RET1.

WRITE : / .
WRITE : / 'Aliasing:'.
WRITE : /  'Objeto2:'.

RET2->OBJETO( ).

* Altera objeto ret1
MOVE 100 TO RET1->ALTURA.
MOVE 200 TO RET1->LARGURA.

WRITE : / .
WRITE : / 'Alterando Objeto1 e afetendo Objeto2'.
WRITE : / 'Objeto2:'.

RET2->OBJETO( ).

* cria objeto de coordenadas
* passando e retornando objetos
* achando o centro do retangulo

DATA Coord TYPE REF TO COORDENADAS.
CREATE OBJECT COORD.

COORD->ACHACENTRO( RET1 ).

WRITE : / .
WRITE : / 'Centro do Retangulo:'.
WRITE : / 'Coordenadas X:', COORD->X.
WRITE : / 'Coordenadas Y:', COORD->Y.

Objetos – Mutable, Reference, Return, Aliasing – Garbage Collector – Java, C++ e C#

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

Objetos são mutáveis

Você pode alterar o conteúdo de um objeto, fazendo uma atribuição a uma de suas variáveis de instância.

Você pode escrever métodos que retornam objetos. Observe que você pode usar a palavra chave NEW para criar um novo objeto, e logo em seguida usar o RESULT (resultado) como valor de retorno.

Passando e Retornando Objetos

Em programação orientada a objetos é possível criar métodos passando um objeto e retornando um objeto.

Alias de Objetos

Null

Garbage collector

Objetos e Primitivos

Se você não inicializar um tipo primitivo, é dado um valor padrão a ele que depende de cada tipo primitivo.

Variáveis primitivas são bem isoladas, no sentido de que não há nada você possa fazer em um método que vai afetar uma variável em outro método.

Há uma outra diferença entre primitivos e tipos de objetos. Você não pode adicionar novos primitivos, mas você pode criar novos tipos de objetos.

Exemplo:

Neste exemplo criamos dois objetos de classes distintas e usamos algumas técnicas de manipulação de objetos, como: métodos de referencias ao objeto, retorno de objetos, aliasing de objetos.

Java

Classe #1 – Principal

public class Objetos
 {
  public static Pontos achaCentro (Retangulo ret)
  {
   int rx = ret.x + ret.largura/2;
   int ry = ret.y + ret.altura/2;
   return new Pontos(rx,ry);
  }
 public static void main(String[] args)
 {

      // Instancia objeto
      Pontos pontos = new Pontos (10,15);
      Retangulo ret1 = new Retangulo (pontos.x, pontos.y, 150, 200);
      System.out.println("Objeto1:" + ret1.objeto());

      // Objetos são Mutaveis
      ret1.altura = 300;
      ret1.largura = 400;
      System.out.println("Objeto1:" + ret1.objeto());

      // Aliasing
      Retangulo ret2 = new Retangulo();
      ret2 = ret1;
      System.out.println();
      System.out.println("Aliasing:");
      System.out.println("Objeto2:" + ret2.objeto());
      ret1.altura = 100;
      ret1.largura = 200;
      System.out.println();
      System.out.println("Alterando Objeto1 e afetendo Objeto2");
      System.out.println("Objeto2:" + ret2.objeto());

      // passando e retornando objetos
      //  achando o centro do retangulo
      Pontos coordenadas = new Pontos();
      coordenadas =  achaCentro(ret1);
      System.out.println();
      System.out.println("Centro do Retangulo:");
      System.out.println("coordenada X=" + coordenadas.x);
      System.out.println("coordenada Y=" + coordenadas.y);
  }
}

Classe #2 – Pontos

public class Pontos {

public int x = 0;
public int y = 0;

Pontos ()
{
}

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

Classe #3 – Retangulo

public class Retangulo extends Pontos
{
      public int altura = 0;
      public int largura = 0;
   Retangulo ()
  {
  }
   Retangulo(int x, int y, int altura, int largura)
  {
   this.x = x;
   this.y = y;
   this.altura = altura;
   this.largura = largura;
  }

    public String objeto ()
  {
   String resultado = "x=" + x + " y=" + y + " altura=" + altura + " largura="+ largura;
   return resultado;
  }
}

C++

Arquivo – Principal

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

static Pontos achaCentro(Retangulo& ret)
 {
  int rx = ret.x + ret.largura / 2;
  int ry = ret.y + ret.altura / 2;
  return  Pontos(rx, ry); }

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

  Pontos pontos(10, 15);

  Retangulo ret1 (pontos.x, pontos.y, 150, 200);

  cout << "Objeto1:" + ret1.objeto() << endl;

  // Objetos são Mutáveis

  ret1.altura = 300;
  ret1.largura = 400;

  cout << "Objeto1:" + ret1.objeto() << endl;

  // Aliasing

  Retangulo ret2;

  ret2 = ret1;

  cout << endl;  cout << "Aliasing:" << endl;
  cout << "Objeto2:" << ret2.objeto() << endl;

  ret1.altura = 100;
  ret1.largura = 200;

  cout << endl;  cout << "Alterando Objeto1 e afetendo Objeto2" << endl;
  cout << "Objeto2:" + ret2.objeto() << endl;

  // passando e retornando objetos
  //  achando o centro do retângulo

  Pontos coordenadas ;
  coordenadas = achaCentro(ret1);

  cout << endl;  cout << "Centro do Retangulo:" << endl;
  cout << "coordenada X=" << coordenadas.x << endl;
  cout << "coordenada Y=" << coordenadas.y << endl;

  system("pause");

  return 0;
 }

Arquivo – pontos.h

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

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

  Pontos()
  {  }

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

Arquivo – retângulo.h

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

class Retangulo : public  Pontos
 {
 public:
  int altura = 0;
  int largura = 0;

  Retangulo()
  {  }

  Retangulo(int rx, int ry, int altura, int largura)
  {
   x = rx;   y = ry;
   this->altura = altura;
   this->largura = largura;
  }

  string objeto()
  {
     string resultado = "x=" + to_string(x) + " y=" + to_string(y)  + " altura="
                     + to_string(altura) + " largura=" + to_string(largura);   return resultado;
  }

};

Classe #1 – Program

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

namespace DesenvolvimentoAberto
 {
     class Program
     {
         public static Pontos achaCentro(Retangulo ret)
         {
             int rx = ret.x + ret.largura / 2;
             int ry = ret.y + ret.altura / 2;
             return new Pontos(rx, ry);
         }
         static void Main(string[] args)
         {
             // Instancia objeto
             Pontos pontos = new Pontos (10,15);
             Retangulo ret1 = new Retangulo (pontos.x, pontos.y, 150, 200);
             Console.WriteLine("Objeto1:" + ret1.objeto());

            // Objetos são Mutaveis
            ret1.altura = 300;
            ret1.largura = 400;
            Console.WriteLine();
            Console.WriteLine("Mutando Objetos:");
            Console.WriteLine("Objeto1:" + ret1.objeto());

           // Aliasing
           Retangulo ret2 = new Retangulo();
           ret2 = ret1;

           Console.WriteLine();
           Console.WriteLine("Aliasing:");
           Console.WriteLine("Objeto2:" + ret2.objeto());
           ret1.altura = 100;
           ret1.largura = 200;

           Console.WriteLine("Alterando Objeto1 e afetendo Objeto2");
           Console.WriteLine("Objeto2:" + ret2.objeto());

           // passando e retornando objetos
           //  achando o centro do retangulo
           Pontos coordenadas = new Pontos();
           coordenadas =  achaCentro(ret1);

          Console.WriteLine();
          Console.WriteLine("Centro do Retangulo:");
          Console.WriteLine("coordenada X=" + coordenadas.x);
          Console.WriteLine("coordenada Y=" + coordenadas.y);
          Console.ReadKey();
         }
     }
 }

Classe #2 – Pontos

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

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

         public Pontos()
         {
         }

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

Classe #3 – Retangulo

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
 {
     public class Retangulo : Pontos
     {
         public int altura = 0;
         public int largura = 0;

         public Retangulo()
         {
         }

         public Retangulo(int x, int y, int altura, int largura)
         {
             this.x = x;
             this.y = y;
             this.altura = altura;
             this.largura = largura;
         }

         public String objeto()
         {
             String resultado = "x=" + x + " y=" + y + " altura=" + altura + " largura=" + largura;
             return resultado;
         }
    }
 }

Métodos Recursivos – Recursion – Java, C++, C#, Python e Abap

Publicado: 28 de fevereiro de 2014 em Abap, C#, C/C++, Java, Python

Já sabemos que é legal um método invocar o outro método, e vimos vários exemplos destes. Mas também é legal um método invocar ele mesmo. Pode não ser óbvio o por que é isto é necessário, mas acaba por ser uma das coisas mais interessantes que um programa pode fazer e este tipo de técnica é chamada de recursão.

Recursão é o processo de repetir itens de uma forma auto similar. Por exemplo, quando as superfícies dos dois espelhos são exatamente paralela uma com a outra as imagens que ocorrem aninhadas são uma forma de recursividade infinita. O termo tem uma variedade de significados específicos para uma variedade de disciplinas que vão desde a lógica linguística. A aplicação mais comum da recursividade é em matemática e ciência da computação, no que se refere a um método de definição de funções em que a função a ser definida é aplicada dentro de sua própria definição.

Mas é preciso planejar bem as recursões pois se houver erros em sua lógica, assim como os laços as recursões também podem ser infinitas.

Exemplo:

Neste exemplo vamos programar uma contagem regressiva utilizando um método recursivo.

Java

public class Recursiva
 {
  static void contagemRegressiva (int n )
  {
    if ( n == 0 )
    {
      System.out.println("Explosão!!!");
    }
    else
    {
      System.out.println(n);
      contagemRegressiva (n-1);
    }
  }
  public static void main(String[] args)
  {
   int contagem = 10;
   System.out.println("Iniciando contage regressiva");
   contagemRegressiva(contagem);
  }
}

C++

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

static void contagemRegressiva(int n)
 {
  if (n == 0)
  {
    cout << "Explosão!!!" << endl;
  }
  else
  {
    cout << n << endl;   contagemRegressiva(n - 1);
  }
 }

int _tmain(int argc, _TCHAR* argv[])
 {
  int contagem = 10;
  cout << "Iniciando contagem regressiva." << endl;
  contagemRegressiva(contagem);
  system("pause");
  return 0;
 }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
 {
     class Program
     {
         static void contagemRegressiva (int n )
      {
        if ( n == 0 )
        {
               Console.WriteLine("Explosão!!!");
        }
        else
        {
               Console.WriteLine(n);
               contagemRegressiva (n-1);
        }
      }

         static void Main(string[] args)
         {
             int contagem = 10;
             Console.WriteLine("Iniciando contagem regressiva");
             contagemRegressiva(contagem);
             Console.ReadKey();
         }
     }
 }

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# recursivo.py
# Importa OS
import os

# Limpa a tela
os.system("clear")

def ContagemRegressiva (n):
     if (n==0):
         print"Explosão!!!"
     else:
         print n
         ContagemRegressiva(n-1)

contagem = 10
print "Inciando contagem regressiva"
ContagemRegressiva (contagem)

raw_input()

Abap

*&---------------------------------------------------------------------*
*& Report  ZRECURSIVO
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Metodos Recursivos
*&---------------------------------------------------------------------*

REPORT  ZRECURSIVO.
PARAMETERS :CONTAGEM TYPE i.

WRITE : / 'Iniciando contage regressiva.'.

PERFORM CONTAGEM_REGRESSIVA USING CONTAGEM.

FORM CONTAGEM_REGRESSIVA USING N TYPE i.
  IF ( N EQ 0 ).
    WRITE : / 'Explosão!!!'.
  ELSE.
    WRITE : / N.
    N = N - 1.
    PERFORM CONTAGEM_REGRESSIVA USING  N.
  ENDIF.
ENDFORM.

SAP – Database e o Dicionário ABAP

Publicado: 28 de fevereiro de 2014 em Abap

O Dicionário ABAP (SE11) permite centralizar a definição e a gestão de tipos:

Criação de elementos de dados definidos pelo usuário, estruturas e tipos de tabela.
Definição de tabelas, índices e visualizações.
Definição dos serviços que suportam o desenvolvimento do programa.
O bloqueio de tabela e liberação de bloqueio.

Definindo a ajuda de entrada (F4) e a ajuda de campo (F1) .

Mudanças no Dicionário ABAP entram imediatamente em vigor para os programas que usam o que os elementos do dicionário.

Definição

Três tipos de dados podem ser definidos:

Elemento de dados (Data Element)
Estrutura (Structure)
Tipos de Tabela (internal tables)

Type Group

A opção tipo de grupo (Type Group) é fornecida pelo dicionário e está principalmente lá para apoiar o desenvolvimento antigo. (tipo de grupos estavam disponíveis antes de tipos de dados serem suportados.) Tipo de Grupos agora são usados principalmente para definir constantes não-orientadas a objetos.

Domain

Dados de domínio (Domain) estão disponíveis para apoiar a definição de tipos de dados, mas os dados de domínio não são acessível em um programa ABAP.

Tables

Tabelas consistem em colunas (campos) e linhas (entradas). No ABAP tabelas do Dicionário têm nomes e atributos gerais, como classe de entrega e manutenção de autorização. A tabela tem um ou mais campos-chave, designados como a chave primária. campos da tabela são geralmente baseados em elementos de dados que se baseiam em dados do domínio. Campos de tabela podem ser digitados sem referência a um elemento de dados (Foreing Key). Neste caso, o campo é dito ser digitado direto. Tabelas têm configurações técnicas que regem a forma como o sistema deve otimizar o armazenamento de dados e acessar a tabela.

Tabelas Transparentes

Quando uma tabela é definida no dicionário ABAP, ela é uma tabela transparente. Quando a tabela transparente é ativada, ela é criada no DBMS subjacente. A tabela específica do DBMS tem o mesmo nome que o nome da tabela transparente no ABAP Dictionary. Os tipos de campo na tabela DBMS específicas são convertidos para qualquer que seja a definição do tipo de dados apropriado no DBMS. Os elementos do quadro (por exemplo, campo, etc) subjacente podem ser alterados conforme necessário. A tabela transparente no Dicionário ABAP é a representação independente de banco de dados da tabela subjacente, e é usada em programação ABAP.

Open SQL

Instruções SQL abertas(Open SQL) em programa ABAP são convertidas em instruções específicas do banco de dados SQL pela interface de banco de dados.

É possível ter acesso ao banco de dados com SQL nativo, mas o código é então do banco de dados específico e menos transportável.

Muitas declarações Open SQL se espelham nas instruções de SQL “tradicionais”, mas com diferenças sutis e refinamentos.

Open SQL contém apenas manipulação de Dados por comandos de linguagem (DML). As operações são feitas utilizando o Dicionário ABAP.

Quatro comandos Open SQL básico:

SELECT – seleciona dados em uma tabela.
UPDATE – altera dados em uma tabela.
INSERT – insere dados em uma tabela.
DELETE – apaga dados em uma tabela.

Sap Luw

SAP LUW (unidade lógica de trabalho) é um conjunto de alterações lógicas para um banco de dados onde todas pertencem uma a outra. O LUW é feito de acordo com o princípio de “tudo ou nada”, se sequência inteira não pode ser terminada, a operação será revertida (Rollback).

Operação Commit é cometida implicitamente ou via instrução ABAP COMMIT WORK. Rollback é feito via instrução ROLLBACK WORK.

Necessidade do LUW

SAP ERP possui arquitetura cliente-servidor de três camadas. No servidor de aplicação, as aplicações do usuário final são executadas através de processos de trabalho. Trabalho de vários processos em vigor simultaneamente. Ao particionar operações de banco de dados em LUWs, a integridade do banco de dados pode ser mantida e um processo de trabalho pode acessar e liberar recursos de banco de dados rapidamente.

Database Locking

Para evitar alterações simultâneas em tabelas de banco de dados a partir de vários programas, os bloqueios são usados.

Exemplo: o comando select campo (single) da tabela DBTABLE FOR UPDATE irá bloquear o registro selecionado na expectativa de uma mudança pendente. No final do LUW, o bloqueio é libertada.

Para bloquear um recurso para uma sequência mais prolongada, o sistema mantém uma tabela de bloqueio global que gerencia as travas definidas programaticamente para vários recursos.

Para definir o bloqueio: lockobject ENQUEUE.

Para liberar o bloqueio: lockobject DEQUEUE.

SY-SUBRC é definida após todas as operações de banco de dados. 0 = conclusão bem sucedida. Outros valores indicam diferentes tipos de erro, sy-dbcnt está definido para o número de registros afetados pela última operação.

A maioria das tabelas de sistema contêm um campo MANDT para designar um cliente. Comandos OPEN SQL por padrão são feitos apenas para o cliente atual. Para substituir esse comportamento adicione a cláusula CLIENT SPECIFIED ao comando.

JOINS

É possível unir tabelas em uma consulta.

Sintaxe:

SELECT * FROM table1 INNER JOIN table2 ON table1~field = table2~field WHERE <condition>.

Chamado link em ABAP. Se um JOIN é feito em um programa, é um vínculo dinâmico. Links pré-existentes, links estáticos, são definidos no Dicionário ABAP. Estes são chamados de Views.

Revisão e Exemplos:

Comandos Open SQL tabelas transparentes: https://desenvolvimentoaberto.wordpress.com/2014/02/20/select-e-insert-abap/

Comandos Open SQL tabelas Internas: https://desenvolvimentoaberto.wordpress.com/2014/02/20/internal-tables-abap/

Modelo de Dados do Dicionário ABAP: https://desenvolvimentoaberto.wordpress.com/2014/02/20/netweaver-flight-model-introducao-ao-database-mini-sap/

I/O – Stream – Arquivos – Java, C++ e C#

Publicado: 27 de fevereiro de 2014 em C#, C/C++, Java

Um Stream pode ser definido como um fluxo de dados em um sistema computacional. Quando um arquivo é aberto para edição, todo ele ou parte dele fica na memória, permitindo assim alterações, por isto somente quando ele é fechado, tem-se a garantia de que nenhum dado se perderá ou será danificado.

Quando um arquivo é carregado na memória para ser editado, esta carga ocorre num fluxo “stream“, ou seja, byte a byte até o carregamento total do arquivo.

Stream

Lê um byte após o outro, um byte é apenas um número.
Os dados sobre o seu disco rígido é armazenado em bytes.
Bytes podem ser interpretados como caracteres, números e etc.

Byte

Um byte (Binary Term), baite ou octeto, é um dos tipos de dados integrais em computação. É usado com frequência para especificar o tamanho ou quantidade da memória ou da capacidade de armazenamento de um certo dispositivo, independentemente do tipo de dados.

A codificação padronizada de byte foi definida como sendo de 8 bits. O byte de 8 bits é mais comumente chamado de octeto no contexto de redes de computadores e telecomunicações.

Instruções

FileReader (java) é para a leitura de streams dos caracteres.

ifstream (C++) define um fluxo a ser utilizado para ler dados de caracteres de byte único em série a partir de um arquivo.

StreamReader (C#) é usado para ler linhas de informações de um arquivo de texto padrão.

Exemplos:

Neste exemplo vamos criar um stream para ler o arquivo chamado Leiame.txt.

Texto – Leiame.txt

Desenvolvimento Aberto.

Input/Output (Entrada/saída)

é um termo utilizado quase que exclusivamente no ramo da computação (ou informática),
indicando entrada (inserção) de dados por meio de algum código ou programa,
para algum outro programa ou hardware, bem como a sua saída (obtenção de dados) ou retorno de dados,
como resultado de alguma operação de algum programa, consequentemente resultado de alguma entrada.

Java

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class Bytes
 {

public static void main(String[] args) throws IOException
  {
   FileReader fr = new FileReader("./src/Leiame.txt");
   BufferedReader br = new BufferedReader(fr);
   String line = null;
   try
   {
    while ((line = br.readLine()) != null)
    {
       System.out.println(line);
    }
   }
   catch (IOException e)
   {
      e.printStackTrace();
   }
   br.close();
  }
 }

C++

#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
 {
  string linha;
  ifstream arquivo("C:/Desenvolvimento Aberto/Leiame.txt");
  if (arquivo.is_open())
  {
   while (getline(arquivo, linha))
   {
    cout << linha << endl;
   }
   arquivo.close();
  }

  else cout << "Erro ao abrir o arquivo.";

  system("pause");
  return 0;
 }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
namespace DesenvolvimentoAberto
 {
     class Program
     {
         static void Main(string[] args)
         {

             try
             {
                 StreamReader sr = new StreamReader("C:/Desenvolvimento Aberto/Leiame.txt");
                 String line = sr.ReadToEnd();
                 Console.WriteLine(line);
                 sr.Close();
             }
             catch (Exception e)
             {
                Console.WriteLine( e.StackTrace);
             }

             Console.ReadKey();
         }
     }
 }

Exception – Try … Catch – Raise – Abap

Publicado: 26 de fevereiro de 2014 em Abap

A Classe Exception, representa os erros que ocorrem durante a execução de aplicativos. Todas as classes de exceção devem herdar da superclasse CX_ROOT e uma de suas classes subclasses:

CX_STATIC_CHECK
CX_DYNAMIC_CHECK
CX_NO_CHECK

Todas as classes de exceção devem começar com o prefixo CX_. Elas são geralmente definidas globalmente no Class Builder do ABAP Workbench. Classes de exceção locais podem, no entanto, também ser definidas.

Execptions

Um erro de aplicativo é um erro de tempo de execução que não pode necessariamente ser evitado escrevendo um código livre de erros.

Erros de tempo de execução podem ocorrer por uma variedade de razões. No entanto, nem todos os erros devem ser tratados como exceções em seu código.

Em alguns casos, um erro de programa pode refletir uma condição de erro esperada ou de rotina. Neste caso, você pode querer evitar o uso de tratamento de exceção para lidar com o erro do programa.

Em outros casos, um erro de programa reflete uma condição de erro inesperado que pode ser manipulado em seu código. Por exemplo, mesmo que você tenha verificado para garantir que existe um arquivo, ele pode ser excluído antes que você possa abri-lo, ou ele pode estar corrompido.

A falha do sistema é um erro de tempo de execução que não podem ser tratada por meio de programação de uma maneira significativa. Por exemplo, qualquer método pode lançar uma exceção OutOfMemory se o Runtime é incapaz de alocar memória adicional

TRY … CATCH

Um modelo de tratamento de exceção que se baseia na representação de exceções como objetos, e a separação de código de programa e o código de tratamento de exceções em blocos TRY e blocos CATCH. Pode haver um ou mais blocos catch, cada um projetado para lidar com um determinado tipo de exceção, ou um bloco projetado para capturar uma exceção mais específica que outro bloco.

Exemplo:

Neste exemplo criamos uma classe para nosso erro herdada da classe CX_DYNAMIC_CHECK e usamos o comando Try…Catch para manipular o erro e exibir uma mensagem mais amigável para o usuário.

Abap

*&---------------------------------------------------------------------*
*& Report  ZEXCECAO
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Exceções
*&---------------------------------------------------------------------*

REPORT  ZEXCECAO.

CLASS CX_MinhaExcecao DEFINITION INHERITING FROM CX_DYNAMIC_CHECK.

PUBLIC SECTION.

METHODS : CONSTRUCTOR IMPORTING pvalor TYPE p.

DATA VALOR TYPE p DECIMALS 2.

ENDCLASS.

CLASS CX_MinhaExcecao IMPLEMENTATION.

METHOD CONSTRUCTOR.
CALL METHOD SUPER->CONSTRUCTOR( ) .
VALOR = pvalor.
ENDMETHOD.

ENDCLASS.

start-of-selection.

DATA ERRO         TYPE REF TO CX_MinhaExcecao.
DATA saldo        TYPE p DECIMALS 2.
DATA saque        TYPE p DECIMALS 2.
DATA insuficiente TYPE p DECIMALS 2.

* Efetua Um deposito na conta
WRITE : / 'Deposito de: R$ 500,00'.
saldo = 500.

* Tenta efetuar um saque
PERFORM SAQUE.

FORM SAQUE.
  try.
    " Efetua um saque na conta
    WRITE : /   'saque de: R$ 1000,00'.
    saque =  1000.

    if ( saque LT saldo ).
      saldo = saldo - saque.
    else.
      insuficiente = saque - saldo.
      RAISE EXCEPTION TYPE CX_MinhaExcecao
            EXPORTING
                 PVALOR = Insuficiente.
    ENDIF.

  catch CX_MinhaExcecao into ERRO.
    " Tenta efetuar um saque
    WRITE: / 'Desculpe mas seu pedido de saque ultrapassa o seu saldo em: ', ERRO->VALOR.
  ENDTRY.
ENDFORM.

Exception – Try … Catch – Java, C++ e C#

Publicado: 26 de fevereiro de 2014 em C#, C/C++, Java

A Classe Exception, representa os erros que ocorrem durante a execução de aplicativos.

Um erro de aplicativo é um erro de tempo de execução que não pode necessariamente ser evitado escrevendo um código livre de erros.

Erros de tempo de execução podem ocorrer por uma variedade de razões. No entanto, nem todos os erros devem ser tratados como exceções em seu código.

A falha do sistema é um erro de tempo de execução que não podem ser tratada por meio de programação de uma maneira significativa. Por exemplo, qualquer método pode lançar uma exceção OutOfMemory se o Runtime é incapaz de alocar memória adicional

Um modelo de tratamento de exceção que se baseia a representação de exceções como objetos, e a separação de código de programa e o código de tratamento de exceções em blocos TRY e blocos CATCH. Pode haver um ou mais blocos catch, cada um projetado para lidar com um determinado tipo de exceção, ou um bloco projetado para capturar uma exceção mais específica que outro bloco.

Exemplo:

Neste exemplo criamos uma classe para nosso erro herdada da classe Exception(Java, C++ e C#) e usamos o comando Try…Catch para manipular o erro e exibir uma mensagem mais amigável para o usuário.

Java

Classe #1 – Principal

public class Principal
 {
  static double saldo = 0.0;
  static void saque (double valor) throws MinhaExcecao
  {
   if ( valor <= saldo )
   {
    saldo -= valor;
   }
   else
   {
    double insuficiente = valor - saldo;
    throw new MinhaExcecao(insuficiente);
   }
  }
  public static void main(String[] args)
  {
   // Efetua Um deposito na conta
   System.out.println("Deposito de: R$ 500,00");
   saldo = 500.00;

   // Tenta efetuar um saque
   try
   {
    System.out.println("Saque de: R$ 1000,00");
    saque(1000.00);
   }
   catch (MinhaExcecao erro)
   {
    System.out.println("Desculpe mas seu pedido ultrapassa o saldo em: "
                       + erro.pegaValor() );

    // Imprime conteudo do erro
    erro.printStackTrace();
   }
}
}

Erro

public class MinhaExcecao extends Exception

{
  private  double valor;
  public  MinhaExcecao ( double valor )
  {
   this.valor = valor;
  }

  public double pegaValor ( )
  {
   return valor;
  }
}

C++

Programa – Principal

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

using namespace std;

static double saldo = 0.0;

static void saque(double valor)
 {
  if (valor <= saldo)
  {
   saldo -= valor;
  }
  else
  {
   double insuficiente = valor - saldo;
   throw  MinhaExcecao(insuficiente);
  }
 }

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

  // Efetua Um deposito na conta
  cout << "Deposito de: R$ 500,00" << endl;
  saldo = 500.00;

  // Tenta efetuar um saque
  try
  {
   cout << "Saque de: R$ 1000,00" << endl;   saque(1000.00);
  }
  catch (MinhaExcecao erro)
  {
   cout << "Desculpe mas seu pedido ultrapassa o saldo em: "    <<  erro.pegaValor() << endl;
  }
  system("pause");
  return 0;
 }

Erro – (.h)

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

using namespace std;

class MinhaExcecao : public exception
 {
private:

        double valor;

public:
    MinhaExcecao(double valor)
  {
   this->valor = valor;
  }

  double pegaValor()
  {
   return valor;
  }
 };

Classe #1 – Principal

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

namespace DesenvolvimentoAberto
 {
     class Program
     {
         static double saldo = 0.0;
         static void saque (double valor)
         {
            if ( valor <= saldo )
            {
               saldo -= valor;
            }
            else
            {
               double insuficiente = valor - saldo;
               throw new MinhaExcecao(insuficiente);
             }
          }

         static void Main(string[] args)
         {
             // Efetua Um deposito na conta
             Console.WriteLine("Deposito de: R$ 500,00");
             saldo = 500.00;

             // Tenta efetuar um saque
             try
             {
               Console.WriteLine("Saque de: R$ 1000,00");
               saque(1000.00);
             }
             catch (MinhaExcecao erro)
             {
               Console.WriteLine("Desculpe mas seu pedido ultrapassa o saldo em: "
                                  + erro.pegaValor() );

               // Imprime conteudo do erro
               Console.WriteLine(erro.StackTrace);
             }

             Console.ReadKey();
            }
     }
 }

Classe #2 – Erro

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

namespace DesenvolvimentoAberto
 {
     class MinhaExcecao : Exception
     {
         private double valor;

         public MinhaExcecao(double valor)
         {
             this.valor = valor;
         }

         public double pegaValor()
         {
             return valor;

         }
     }
 }

Classes – Interfaces – Abap

Publicado: 25 de fevereiro de 2014 em Abap

Os objetos definem sua interação com o mundo exterior através dos métodos que eles expõem. Métodos formam a interface do objeto com o mundo exterior; os botões na parte frontal do seu aparelho de televisão, por exemplo, são a interface entre você e a fiação elétrica do outro lado do seu invólucro de plástico. Você aperta o botão “Power” para ligar e desligar a televisão.

Na sua forma mais comum, uma interface é um conjunto de métodos relacionados com corpos vazios

A implementação de uma interface permite que uma classe se torne mais formal sobre o comportamento que promete proporcionar. Interfaces formam um contrato entre a classe e o mundo exterior, e este contrato é imposto em tempo de compilação.

Se sua classe reivindica implementar uma interface, todos os métodos definidos por essa interface deve aparecer em seu código-fonte antes da classe ser compilada com sucesso.

Em ABAP a palavra chave interface é realmente levada ao pé da letra, obrigando o programador a referenciar a interface na instrução entre o objeto e o método.

Sintaxe:

CALL METHOD Objeto->Interface~Método.

Lembrando que a interface obriga a classe na qual foi implementada a cumprir o que nela foi declarado. Caso não cumpra o determinado pela interface obterá o seguinte erro de compilação:

Erro: Implementention missing for method “Interface~Method”.

Conceito de interfaces

Não pode ser instanciada.
Só pode possuir assinaturas de métodos de instância, públicos e abstratos (sem corpo).
Não pode possuir métodos concretos (com corpo), nem métodos estáticos.

Uso Comum de Interface

Já que sabemos que os objetos Abap são baseados em C++ e Java, vamos fazer uma curta analogia para que você entenda perfeitamente o uso de interfaces. As classes Abap separam a implementação da definição, assim como C++, mas também assim como Java não permitem heranças múltiplas.

Na linguagem de programação C++ pode se utilizar uma interface abstrata, mas este uso não é muito comum, pois a convenção de classes C++ já contempla que a interface seja separada da implementação na criação da própria classe, utilizando arquivos diferentes (.h e .cpp). Além da linguagem C++ permitir múltiplas heranças tornando raro a necessidade do uso de interfaces abstratas.

Java e Abap utilizam a interface pois não permitem múltiplas heranças, então a interface se torna necessária para criar um efeito deste tipo, por exemplo, imagine que temos a classe Casa e queremos que esta classe herde as classes Portas e Janelas, isto não será possível em Java e Abap, mas é possível em C++.

Para garantir que teremos os métodos paras portas e janelas na classe Casa, precisamos utilizar a interface Portas e a Interface Janelas, ainda não garantindo como em C++ os tipos de portas e janelas já que as interfaces são abstratas e não métodos concretos, Mas este recurso permite que a classe Casa tenha obrigatoriamente, portas e janelas de qualquer tipo.

Este também é o motivo de uso de uma interface abstrata em C++, quando queremos métodos abstratos para uma classe dizendo que você permite portas e janelas de qualquer tipo. Nota-se assim que C++ é uma linguagem mais flexível em termos de recursos na criação de objetos

Exemplo:

Neste exemplo simulamos um programa de I/O de arquivos, criamos uma interface contendo os métodos obrigatórios para qualquer classe, que reivindicar a interface:

Abap

*&---------------------------------------------------------------------*
*& Report  ZINTERFACE
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Interfaces
*&---------------------------------------------------------------------*

REPORT  ZINTERFACE.

* Declara Interface

INTERFACE Acao.

   METHODS :
          ABRE   IMPORTING ARQUIVO TYPE STRING,
          GRAVA  IMPORTING ARQUIVO TYPE STRING,
          DELETA IMPORTING ARQUIVO TYPE STRING.

ENDINTERFACE.

* Declara Classe

CLASS ARQUIVO DEFINITION.

   PUBLIC SECTION.

      INTERFACES ACAO.

ENDCLASS.

* Declara Implementação da Classe

CLASS ARQUIVO IMPLEMENTATION.

   METHOD ACAO~ABRE.

      " ... Implementa método para abrir o arquivo.

      WRITE: / 'Arquivo:', ARQUIVO, 'em uso'.

   ENDMETHOD.

   METHOD ACAO~GRAVA.

      " ... Implementa método para gravar o arquivo.

      WRITE: / 'Arquivo:', ARQUIVO, 'Gravado com sucesso'.

   ENDMETHOD.

   METHOD ACAO~DELETA.

      " ... Implementa método para deletar o arquivo.

      WRITE: / 'Arquivo:', ARQUIVO, 'Deletado com sucesso'.

   ENDMETHOD.

ENDCLASS.

* Cria Objetos

START-OF-SELECTION.
DATA ARQ1 TYPE REF TO ARQUIVO.
CREATE OBJECT ARQ1.

ARQ1->ACAO~ABRE( EXPORTING ARQUIVO = 'Texto.txt' ).
ARQ1->ACAO~GRAVA( EXPORTING ARQUIVO = 'Texto.txt' ).
ARQ1->ACAO~DELETA( EXPORTING ARQUIVO = 'Texto.txt' ).

* ou

CALL METHOD ARQ1->ACAO~ABRE( EXPORTING ARQUIVO = 'Texto.txt' ).
* ...

Classes – Inheritance e Override – Abap

Publicado: 25 de fevereiro de 2014 em Abap

Inheritance (herança)

Programação orientada a objetos permite que classes possam herdar estados e comportamentos comuns usados de outras classes. Neste exemplo, bicicleta torna-se agora a superclasse de MountainBike. Na linguagem de programação, cada classe é permitido ter uma superclasse direta, e cada superclasse tem o potencial para um número ilimitado de subclasses.

Override

Métodos Override (substituição), em programação orientada a objeto, é um recurso de linguagem que permite que uma subclasse ou classe filha possa fornecer uma implementação específica de um método que já é fornecido por uma de suas superclasses ou classes pai.

A implementação Override das subclasses substitui a implementação na superclasse, fornecendo um método que tem o mesmo nome, mesmos parâmetros ou assinatura, e mesmo tipo de retorno como o método na classe pai.

Final e Abstract

Abap possui o conceito de classes e métodos finais, uma classe final não pode ter uma subclasse. Um método final não pode ser redefinido em uma subclasse. Eles concluem uma árvore de herança.

Um método abstrato é definido em uma classe abstrata e não pode ser implementado na classe. Em vez disso, ele é implementado em uma subclasse da classe. Classes abstratas não podem ser instanciadas.

Redefinition

É a instrução na qual cria um método override. A implementação da redefinição na subclasse obscurece a implementação original na superclasse.

Exemplo:

Utilizando o exemplo de classes anterior onde definimos e implementamos a classe ZBICICLETA no Class Builder vamos criar uma subclasse desta superclasse, para isto precisamos modificar o parâmetro da classe que por default no R/3 é marcado como uma classe final, siga os passos abaixo:

Entre no Class Builder, trasação SE24.
Escolha a classe que criamos anteriormente ZBICICLETA e clique no botão Change.
Na aba Properties, desmarque a opção Final, use como referencia a imagem abaixo:

Neste exemplo damos a classe BICICLETAMONTANHA todos os mesmos campos e métodos da classe bicicleta, e ainda permite que seu código se concentre exclusivamente sobre as características que a tornam única. Isso faz do código de suas subclasses fáceis de ler. Usamos métodos Override neste exemplo, para substituir o método BICICLETA da superclasse na subclasse.

No entanto, você deve tomar cuidado para documentar corretamente o estado e o comportamento que cada superclasse define, uma vez que o código não irá aparecer no arquivo de origem de cada subclasse.

Abap

*&---------------------------------------------------------------------*
*& Report  ZHERANCA
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Herança e Override
*&---------------------------------------------------------------------*

REPORT  ZHERANCA.

* Cria uma herança da classe ZBICICLETA

CLASS BICICLETAMONTANHA DEFINITION INHERITING FROM ZBICICLETA.

PUBLIC SECTION.

DATA:   marchas       TYPE STRING,
        amortecedores TYPE STRING,
        garrafa       TYPE STRING,
        gps           TYPE STRING.

METHODS BICICLETA REDEFINITION.

ENDCLASS.

CLASS BICICLETAMONTANHA IMPLEMENTATION.

METHOD BICICLETA.

CALL METHOD super->BICICLETA.

WRITE : / ' Marchas:', marchas.
WRITE : / ' Amortecedores:', amortecedores.
WRITE : / ' Garrafa:', garrafa.
WRITE : / ' Gps:', gps.

ENDMETHOD.

ENDCLASS.

* Cria Instancia da Classe Herdada
START-OF-SELECTION.
DATA BIKE1 TYPE REF TO BICICLETAMONTANHA.
CREATE OBJECT BIKE1.

* Propriedades (Atributos) da classe ZBICICLETA.

MOVE 'TRACK X100'       TO BIKE1->MODELO.
MOVE 'Fibra de Carbono' TO BIKE1->QUADRO.
MOVE 'Disco'            TO BIKE1->FREIOS.
MOVE 'Aluminio'         TO BIKE1->RODAS.

* Propriedades (Atributos) da classe BICICLETAMONTANHA

MOVE '18'              TO BIKE1->MARCHAS.
MOVE 'PRO III S'       TO BIKE1->AMORTECEDORES.
MOVE 'Aluminio 500 ml' TO BIKE1->GARRAFA.
MOVE 'Discovery PRO'   TO BIKE1->GPS.

* chama método OVERRIDE.

WRITE : / 'Bicicleta Montanha é uma herança da classe Bicicleta', / .

CALL METHOD BIKE1->BICICLETA.

SAP – Classes – Abap

Publicado: 24 de fevereiro de 2014 em Abap

Orientação a Objeto é geralmente considerada superior à programação procedural devido ao encapsulamento de dados com funcionalidades relacionadas. ABAP Objects é conceitualmente semelhante as linguagens como C++ e Java, no entanto as duas linguagens estão entre as mais utilizadas atualmente e evoluem em alta velocidade, o mesmo não acontece com ABAP OO, podemos dizer que na pratica a diferença na construção de classes é uma sintaxe um pouco mais pesada e a não permissão de criar métodos Overload dentro de uma classe, exemplo, não podemos ter um construtor vazio e um construtor utilizando parâmetros ao mesmo tempo.

Mas o ponto mais impactante entre o desenvolvimento ABAP OO e outras línguas orientadas a objeto segundo a própria SAP, “As instruções ABAP utilizadas para processamento de listas ainda não estão totalmente disponíveis em ABAP Objects“. Linguagens orientadas a objeto utilizam de forma intensa objetos de listas que são conhecidos como coleções ou Containers para manipular objetos, o ABAP possui algumas destas classes entretanto suas funcionalidades são precárias e não podem ser comparadas com os frameworks de coleções como STL para C++ e JCF para Java que praticamente definem conceitos para a manipulação de objetos.

Deste modo é comum mesmo em programas disponibilizados pela própria SAP, encontrarmos instruções consideradas procedurais como FORM e PERFORM entre outras sendo utilizada em conjunto com objetos, caso queira uma completa programação orientada a objeto como acontece em outras linguagens de programação, enquanto a SAP não disponibiliza a implementação total das coleções, você deve herdar as classes de coleções e estender as funcionalidades disponibilizadas pela SAP. Algumas construções da linguagem ABAP são consideradas obsoletas e ainda são suportadas em ABAP processual, não são permitidas em objetos ABAP.

ABAP Objects suporta:

Herança – uma classe compartilha a estrutura e comportamento com outra.
Polimorfismo – objetos diferentes (mas relacionados) têm a mesma interface de comunicação.
Eventos – respondem quando provocados. Os objetos podem disparar um evento.

Classe

A definição da estrutura e funcionalidade de um objeto. Define se o objeto de dados irá conter (atributos) e funcionalidades relacionadas (métodos).

Sintaxe da classe ABAP divide a definição de classe (contendo declarações de atributos e definições de interface do método) e a implementação da classe (definições de funcionalidade do método).

Sintaxe:

CLASS classe DEFINITION.

ENDCLASS.

CLASS classe IMPLEMENTATION.

ENDCLASS.

Uma classe pode ser definida localmente ou globalmente, usando a transação Class Builder SE24.

Objeto

A instanciação de uma classe, o armazenamento de dados reais e ou permitir a execução do método.

A definição de classe pode definir o seguinte: tipos, constantes, objetos de dados (atributos) e interfaces de método.

Os itens podem ser designados como:

PUBLIC (público) disponível a partir de fora do objeto.
PRIVATE (privada), disponível somente dentro do próprio objeto.
PROTECTED (protegida) disponível dentro do próprio objeto e suas sub classes.
STATIC (estático) é um atributo cujo valor é compartilhado entre todos os objetos em uma classe e não é dependente de instanciação, em ABAP a palavra chave Static não é utilizada e é referida como sendo “da classe” ou seja dados da classe, métodos da classes.

Um atributo público pode ser designado como somente leitura. Dentro da definição de classe, o setor público deve vir antes do setor privado.

Um atributo estático muitas vezes usado para coisas como contadores ocorrência de objeto e como os dados pertencem à classe e é compartilhado entre os objetos, ele é declarado como CLASS-DATA.

Método

Na definição de classe, a definição do método indica um método de interface.
Métodos podem ser designados como públicos ou privados.
Um método privado só pode ser chamado de dentro de outro método da classe.
Métodos de classe podem ser definidos e estes métodos só podem acessar atributos estáticos.
Métodos de classe podem ser invocados usando o nome da classe ou um objeto da classe.
Um objeto não precisa ser instanciado para chamar uma método de classe.
Código para a funcionalidade de um método é colocado na implementação da classe.
Os nomes de parâmetros e tipos não estão listados, pois eles já foram declarados na definição da classe.

Parâmetros do método:

IMPORTING – Parâmetros importador de entrada, usado para transferir dados de um método. Pode ser designado como opcional. Pode ter um valor padrão especificado.

EXPORTING – Parâmetros exportadores de saída. Parâmetros de exportação são sempre opcionais (por padrão).

CHANGING – Mudança de combinação acima. Passado para o método a ser utilizado. Pode ser alterado. Pode ser designado como opcional. Pode ter um valor padrão especificado.

Construtor

Uma classe pode definir um método construtor chamado constructor. O método deve ter parâmetros públicos e só importadores. O construtor não é chamado explicitamente, mas é chamado implicitamente quando um novo objeto é criado. Em ABAP Objects um método construtor não pode ser sobrecarregado (Overload) utilizando um outro método construtor, entretanto é possível criar este efeito através de parâmetros opcionais.

Construtores são úteis para:

Inicializar os atributos de um objeto.
Alocação de recursos para o objeto.
Modificando atributos estáticos (programação).
Disparando outras atividades que precisam acontecer quando um novo objeto é criado.

Auto Referencia

Dentro de um método, a referência aos atributos do objeto ou outros métodos geralmente não pode ser ambígua. Em caso de ambigüidade (um parâmetro tem o mesmo nome de um atributo), você pode se referir ao objeto, seus atributos e seus métodos usando: me.

Sintaxe:

me-> nomedotributo.

DIAGRAMA DE UMA CLASSE

Classe – Diagrama

CLASS BUILDER – SE24

O Class Builder permite criar e manter as classes ABAP globais e interfaces. Ambos os tipos de objetos, como os tipos de dados globais, são definidos no Repositório ABAP, compondo, assim, uma biblioteca de classes central. Juntos, eles formam uma biblioteca de classe central e são visíveis em todo o sistema. Você pode exibir as classes e interfaces existentes na biblioteca de classes usando o navegador de classe.

Criando Uma Classe no Class Builder

1 – Entre com a transação SE24.

2 – Crie a Classe ZBICICLETA como na imagem acima, utilizando os mesmos parâmetros mostrados em cada janela da imagem, na ultima janela acima escolha Local Object.

3 – Na aba Attributes crie os atributos MODELO, QUADRO, RODAS, FREIOS como String, utilize a imagem acima para referencia.

4 – Na aba Methods, crie o método BICICLETA utilizando a imagem acima como referencia.

5 – Na barra de tarefas clique em Source Code Based para ver o código fonte da classe, também é permitido altera-lo caso seja necessário.

6 – Digite o código como mostra na imagem acima para o método BICICLETA e clique em salvar, volte uma tela e clique em ACTIVATE para ativar a classe.

7 – Pronto já temos nossa classe ZBicicleta com quatro atributos e um método BICICLETA, agora entre na transação SE38 e crie um programa para nosso exemplo abaixo onde utilizaremos nossa classe.

Exemplo:

Neste exemplo instanciaremos a classe ZBICICLETA criada no Class Builder utilizando os parâmetros acima, criaremos uma nova classe chamada MOUNTAINBIKE utilizando parâmetros em seu construtor.

Obs: Para que uma classe forme um objeto completo é necessário métodos de entrada e saída. A classe abaixo ainda não contempla o conceito de métodos Getter e Setter (C++, Java e Abap) também equivalentes a propriedades em outras linguagens de programação (Delphi, C#, Python). Estes métodos são essências na manipulação dos atributos, veremos estes métodos no tópico exclusivo com o assunto métodos.

Abap

*&---------------------------------------------------------------------*
*& Report  ZLOJA
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Classes ABAP
*&---------------------------------------------------------------------*

REPORT  ZLOJA.

* Define Classe dinamicamente.

class MOUNTAINBIKE definition.

PUBLIC SECTION.

data MODELO type STRING .
data QUADRO type STRING .
data FREIOS type STRING .
data RODAS  type STRING .

methods CONSTRUCTOR IMPORTING
                        PMODELO TYPE STRING
                        PQUADRO TYPE STRING
                        PFREIOS TYPE STRING
                        PRODAS  TYPE STRING.

methods BICICLETA .

ENDCLASS.

CLASS MOUNTAINBIKE IMPLEMENTATION.

method BICICLETA.

" Minha implementação.

WRITE: / ' Bicicleta:', modelo.
WRITE: / ' Quadro:', quadro.
WRITE: / ' Rodas:', rodas.
WRITE: / ' Freios:',  freios.

endmethod.

method CONSTRUCTOR.

me->MODELO = pmodelo.
me->QUADRO = pquadro.
me->RODAS  = prodas.
me->FREIOS = pfreios.

endmethod.

ENDCLASS.

* Cria objetos Bicicleta - definidos na CLASS BUILDER.

START-OF-SELECTION.
DATA BIKE1 TYPE REF TO ZBICICLETA.
CREATE OBJECT BIKE1.

DATA BIKE2 TYPE REF TO ZBICICLETA.
CREATE OBJECT BIKE2.

* Alimenta Variáveis
* Tem uma pegadinha aqui! você já descobriu?

* Objeto Bicicleta #1
MOVE 'BMX'       TO BIKE1->MODELO.
MOVE 'Ferro'     TO BIKE1->QUADRO.
MOVE 'Ferro'     TO BIKE1->RODAS.
MOVE 'Pastilhas' TO BIKE1->FREIOS.

* Objeto Bicicleta #2
MOVE 'Caloi'        TO BIKE1->MODELO.
MOVE 'Aluminio'     TO BIKE1->QUADRO.
MOVE 'Aluminio'     TO BIKE1->RODAS.
MOVE 'Pastilhas'    TO BIKE1->FREIOS.

* Chama o metodo bicicleta

CALL METHOD BIKE1->BICICLETA.

WRITE: / .

CALL METHOD BIKE2->BICICLETA.

* Objeto criado usando o  metodo Construtor

WRITE: / .

DATA BIKE3 TYPE REF TO MOUNTAINBIKE.

CREATE OBJECT BIKE3 EXPORTING

pMODELO = 'ZX-Track'
pQUADRO = 'Fibra de Carbono'
pFREIOS = 'Disco'
pRODAS  = 'Aluminio'.

CALL METHOD BIKE3->BICICLETA.

Desenvolvimento Código Aberto

Arquivos

Categorias

Mais Acessados

Recomendados

Translate

Downloads

Desenvolvimento Aberto

Uteis

Visualizações

Comentários

Objetos – Mutable, Reference, Return, Aliasing – Garbage Collection – Abap

Objetos – Mutable, Reference, Return, Aliasing – Garbage Collector – Java, C++ e C#

Métodos Recursivos – Recursion – Java, C++, C#, Python e Abap

SAP – Database e o Dicionário ABAP

I/O – Stream – Arquivos – Java, C++ e C#

Exception – Try … Catch – Raise – Abap

Exception – Try … Catch – Java, C++ e C#

Classes – Interfaces – Abap

Classes – Inheritance e Override – Abap

SAP – Classes – Abap

Autores

Digite uma palavra chave para uma busca