Desenvolvimento Código Aberto

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.