Packages – Java

Publicado: 15 de fevereiro de 2014 em Java
0

Uma Package (pacote) é um agrupamento de tipos relacionados que fornecem proteção de acesso e gerenciamento de espaço de nome(namespaces). Note-se que os tipos refere-se a classes, interfaces, enumerações e tipos de anotações.

Os pacotes servem para organizar as classes semelhantes e em algum momento, todo programador precisa usar uma classe pública que está contida dentro de um pacote. Se a classe está em um pacote diferente, então o programa deve dizer ao compilador onde encontrá-lo. Há três maneiras de fazer referência a uma classe em outro pacote: use o seu nome completo, importe a classe, importe o pacote.

Melhores Praticas:

  • Cada classe pertence a um pacote.
  • Classes no mesmo pacote devem servir a um propósito semelhante.
  • Pacotes são apenas diretórios. As classes em outros pacotes precisam ser importados.

Combinar funcionalidade semelhantes:

  • org.desenvolvimentoaberto.bibliotecas.Livraria
  • org.desenvolvimentoaberto.bibliotecas.Livros

Separar nomes semelhantes:

  • shopping.Lista
  • pacotes.Lista

Pacotes Especiais:

  • Todas as classes  ” podem ver” as classes no mesmo pacote (sem importação necessário).
  • Todas as classes de “podem ver” classes em java.lang.
  • Exemplo : java.lang.String; java.lang.System

Criando uma Package:

  1. Crie um novo projeto Java chamado: DevAberto.
  2. Na janela Package Explorer, navegue até nosso projeto e expanda até encontrar a pasta scr.
  3. Clique com o botão direito e clique em nova package.
  4. Nomeie a package de org.desenvolvimentoaberto.
  5. Clique com o botão direito em nossa package e escolha nova classe.
  6. Nomeie a classe de Menssagem e copie o codigo da classe Menssagem abaixo.
  7. Em nosso projeto na pasta scr, botão direito nova classe.
  8. Na opção package na Janela da classe clique em Browse e escolha (default package).
  9. Nomeie a classe de Principal e clique no checkbox public static void main(String[] args e clique em Finish.
  10. Nossa classe Menssagem não esta visivel dentro da classe Principal.
  11. No editor antes da instrução “public class Principal”, de um enter.
  12. Escreva a seguinte instrução: import org.desenvolvimentoaberto.Menssagem;
  13. Agora a classe Menssagem esta visivel da classe Principal.
  14. Escreva o codigo da classe Principal abaixo e rode o programa.

Exemplo:

Neste exemplo vamos criar um simples pacote e usa-lo de um outro pacote, mostrando os três modos de como referenciar pacotes:

Java

Classe Principal – Pacote #1

import org.desenvolvimentoaberto.Menssagem;

public class Principal
 {

public static void main(String[] args)
  {
      // Você pode chamar as packages de 3 modos diferentes:
      // Modo #1: chamando pelo nome completo da package e classe

      org.desenvolvimentoaberto.Menssagem menssagem = new org.desenvolvimentoaberto.Menssagem();
      menssagem.Menssagem("Meu novo pacote java - modo #1");
      // Modo #2: usando a instrução import e importando a classe especifica
      // import org.desenvolvimentoaberto.Menssagem;
      // Modo #3 importando toda a package e assim todas as classes
      // import org.desenvolvimentoaberto.*;

      Menssagem msg = new Menssagem();
      msg.Menssagem("Meu novo pacote java - modo #2");
  }
}

Classe Menssagem – Pacote #2

package org.desenvolvimentoaberto;

public class Menssagem
{
    public void Menssagem (String menssagem )
    {
       System.out.println( menssagem);
    }
    public Menssagem()
    {
    }
}

Looping – While e Expressões Aritméticas – Abap

Publicado: 15 de fevereiro de 2014 em Abap
0

A declaração WHILE executa continuamente um bloco de instruções enquanto uma determinada condição é verdadeira.

Sintaxe:

WHILE condição.
[bloco de instruções.]
ENDWHILE.

Operadores Aritméticos

  • (+) – adição.
  • (-) – subtração.
  • (*) – multiplicação.
  • (/) – divisão.
  • DIV – divisão inteira.
  • MOD – Resto da divisão inteira.
  • ** – Potenciação.

Ao usar expressões matemáticas, os operadores +, -, *, **, e /, bem como abertura e fechamento de parênteses, são interpretados como palavras ABAP e devem ser precedidos e seguidos por espaços em branco.

Em operações de divisão, o divisor não pode ser zero se o dividendo não é zero. Com a divisão inteira, você usa os operadores DIV ou MOD em vez de /. DIV calcula o quociente inteiro, MOD calcula o resto da divisão.

Exemplo:

Neste exemplo criamos dois loopings para calcular os números primos em uma faixa de 1 à 1000. Vale  deixar como nota que a linguagem ABAP possui uma sintaxe estilo velha guarda, as linguagens mais modernas reformularam a sintaxe do comando While para que não gere erros de logica.

Podemos ver isto no exemplo abaixo, em ABAP inicializamos o valor do looping e alimentamos o contador fora do comando while, o que não acontece em linguagens como Java, C# e  o moderno C++. Em nosso exemplo a inicialização do looping é essencial para o resultado do calculo e pode ser facilmente esquecida ou não prevista, criando um resultado indesejado, já o contador se não for incrementado  irá entrar em um laço infinito impedindo a continuidade do programa, para entender melhor você pode ver o mesmo exemplo de laço com a sintaxe moderna clicando aqui:

ABAP

*&---------------------------------------------------------------------*
*& Report  ZPRIMOS
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Primos
*&---------------------------------------------------------------------*

REPORT  ZPRIMOS.

DATA : numeros TYPE i,
       primos  TYPE i.

numeros = 1.
*// Inicie a variável primos aqui e obterá um erro logico.

WHILE numeros LE 1000.

   primos  = 2. " // Old Style, tente inicializar a variável fora do looping.
   WHILE primos LE ( numeros - 1 ).

       IF ( ( numeros MOD primos ) EQ 0 ).
         EXIT.
       ENDIF.

   primos = primos + 1. " // Old Style, sem está instrução obterá um laço infinito.
   ENDWHILE.

   IF primos EQ numeros.
     WRITE : numeros, ','.
   ENDIF.

 numeros = numeros + 1. " //Old Style, sem está instrução obterá um laço infinito.
 ENDWHILE.

Condição – Case e Switch – Java, C++, C# e Abap

Publicado: 14 de fevereiro de 2014 em Abap, C#, C/C++, Java
0

A instrução CASE como o IF também é um comando clássico e existe em muitas linguagens de programação, seja ela compilada ou interpretada. O comando Case predominou por muitos anos e nos tempos atuais ganhou uma nova cara e um novo nome apesar de permanecer com a mesma estrutura, o SWITCH. Comando CASE ainda é usado nos dias atuais por varias linguagens de programação e linguagens de scripts entre elas o ABAP, PL/SQL, TRANSACT-SQL e outras.

A instrução CASE e SWITCH é como uma série de instruções IF, apenas usando a palavra-chave WHEN (Quando) ou CASE (Caso). A instrução é avaliada a partir de cima para baixo. Se a condição for verdadeira, então correspondente a cláusula é executado e execução salta para o fim do caso (avaliação curto-circuito).

Ou seja ao contrário de if-then e declarações if-then-else, a instrução switch pode ter um número de possíveis caminhos de execução. Um switch funciona com o byte, short, char, e tipos primitivos de dados int. Ele também funciona com tipos enumerados, a classe String, e algumas classes especiais que envolvem certos tipos primitivos: Character, Byte, Short, e Integer.

Exemplo:

Neste simples exemplo podemos ver como mostrar na tela o dia da semana usando um numero de 1 a 7.

Java

public class Caso {

public static void main(String[] args)
 {
      int dia = 5;
     switch (dia)
   {
       case 1:
      System.out.println("Segunda");
    break;
          case 2:
       System.out.println("Terça");
    break;
           case 3:
       System.out.println("Quarta");
    break;
           case 4:
       System.out.println("Quinta");
    break;
          case 5:
       System.out.println("Sexta");
    break;
          case 6:
       System.out.println("Sabado");
    break;

    default:
       System.out.println("Domingo");
    break;
  }

}

}

C#

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

namespace ConsoleApplication55
 {
     class Program
     {
         static void Main(string[] args)
         {
              int dia = 5;
     switch (dia)
   {
       case 1:
      Console.WriteLine("Segunda");
    break;
          case 2:
       Console.WriteLine("Terça");
    break;
           case 3:
       Console.WriteLine("Quarta");
    break;
           case 4:
       Console.WriteLine("Quinta");
    break;
          case 5:
       Console.WriteLine("Sexta");
    break;
          case 6:
       Console.WriteLine("Sabado");
    break;

   default:
   Console.WriteLine("Domingo");
   break;
  }

   Console.ReadKey();
         }
     }
 }

C++

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

int _tmain(int argc, _TCHAR* argv[])
 {
  int dia = 5;

switch (dia)
  {
  case 1:
   cout << "Segunda" << endl;
   break;

case 2:
   cout << "Terça" << endl;
   break;

case 3:
   cout << "Quarta" << endl;
   break;

case 4:
   cout << "Quinta" << endl;
   break;

case 5:
   cout << "Sexta" << endl;
   break;

case 6:
   cout << "Sabado" << endl;
   break;

default:
   cout << "Domingo" << endl;
   break;
  }
  system("pause");
  return 0;
 }

ABAP

*&---------------------------------------------------------------------*
*& Report  ZCASO
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Caso
*&---------------------------------------------------------------------*
REPORT  ZCASO.

DATA dia TYPE i.

dia = 5.

CASE dia.

WHEN 1.
               WRITE : / 'Segunda'.

WHEN  2.
               WRITE : / 'Terça'.

WHEN  3.
               WRITE : / 'Quarta'.

WHEN  4.
               WRITE : / 'Quinta'.

WHEN  5.
               WRITE : / 'Sexta'.

WHEN  6.
               WRITE : / 'Sabado'.

WHEN OTHERS.
               WRITE : / 'Domingo'.
ENDCASE.

Condição IF, ELSE, ELSEIF – Abap

Publicado: 14 de fevereiro de 2014 em Abap
1

IF é um dos comandos mais comuns e um dos mais importantes na programação, este comando é responsável pelas tomadas de decisões, existe praticamente em todas as linguagens de programação, antigamente este comando era conhecido como “se-então-senão” ou “if-then-else” mas as linguagens mais modernas substituirão o “então” pelo símbolo “{}” (colchetes), se a condição puder ser executada por apenas uma linha de comando então não é necessário usar o colchete.

Em ABAP a condição IF tem uma sintaxe um pouco diferente ficando assim:

IF(se) a condição for atendida faça algo, ELSEIF (senão, se) outra condição for atendida faça algo, ELSE (senão) faça algo, ENDIF (fim da condição).

Uma grande diferença do ABAP em relação as outras linguagens de programação é que mesmo nas instruções de condição se faz necessário dizer ao compilador que a linha foi terminada com o caractere .(ponto).

Sintaxe:

IF condição.
[bloco de comandos 1]
[ELSEIF condição.
[bloco de comandos 2]]
…
[ELSE.   [bloco de comando N]]
ENDIF.

Essas instruções definem uma estrutura de controle que pode conter vários blocos de instrução dos quais no máximo de um serão executados em conjunto com as expressões lógicas.

Outra diferença do ABAP são seus operadores, por não utilizar os símbolos padrões e sim instruções literais para avaliar as condições.

Operadores ABAP:

  • EQ  (=)  – É igual a.
  • NE (<>) – Não é igual a.
  • LT  (<) – É menor que.
  • GT  (>) – é maior do que.
  • LE (<=) – é menor do que ou igual a.
  • GE (>=) – é maior do que ou igual a.
  • AND – lógico e .
  • OR  – Lógico ou .
  • NOT – logico não.

Exemplo:

ABAP

*&---------------------------------------------------------------------*
*& Report  ZCONDICAO 
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Condições
*&---------------------------------------------------------------------*

REPORT  ZCONDICAO.

* Declarando Variáveis
DATA :    variavel1 TYPE i,
          variavel2 TYPE i,
          variavel3 TYPE i.

* Alimenta as Variáveis
variavel1 = 100.
variavel2 = 150.
variavel3 = 200.

* Verifica as Condições.

* Comando IF
IF variavel1 LT variavel2.
WRITE : / 'Condicao1:', variavel1, ' é menor que ', variavel2.
ENDIF.

* Comando IF e ELSE
 IF variavel1 GT variavel2.
   WRITE : / 'Condicao2:', variavel1, ' é menor que ', variavel2.
 ELSE.
   WRITE : / 'Condicao2:', variavel2, ' é maior que ', variavel1.
 ENDIF.

* Comando IF e ELSEIF
 IF variavel1 EQ variavel2.
   WRITE : / 'Condicao3:', variavel1, ' é menor que ', variavel2.
 ELSEIF variavel2 LT variavel3.
   WRITE : / 'Condicao3:', variavel2, ' é menor que ', variavel3.
 ENDIF.

Classes – Escopos – Java, C++ e C#

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

Escopo refere-se à vida e acessibilidade de uma variável. Quão grande é o alcance depende de onde uma variável é declarada. Por exemplo, se uma variável é declarada na parte superior de uma classe, ela será acessível a todos os métodos de classe. Se for declarada num método, em seguida, só pode ser utilizada em tal método.

O escopo de uma variável é a parte do programa que pode acessar uma variável. Quando você tenta acessar uma variável que não está no escopo, você normalmente tém um erro do compilador. Aqui estão algumas das regras de escopo:

  1. Variáveis ​​de classe (campos estáticos) estão no escopo em todos os lugares na classe.
  2. Se uma variável de classe é declarada “pública”, está no escopo em todas as classes.
  3. As variáveis ​​de instância (campos não-estáticos) estão no escopo em métodos não estáticos chamados em um objeto apropriado.
  4. As variáveis ​​e parâmetros locais estão no escopo apenas dentro do método que os declarou.

Exemplo:

Neste exemplo veremos o alcance do escopo das variáveis estáticas, publicas e privadas em sua classe. Na classe principal vemos o resultado do escopo utilizado na classe planeta.

As variáveis privadas podem ser utilizadas somente dentro da classe planeta, a variável publica pode ser utilizada por todas as classes ou neste caso pelo objeto, a variável estática é utilizada globalmente e não precisa ser instanciada, todos os objeto que você criar, ou seja outros planetas irão compartilhar os dados desta variável, as variáveis locais criadas dentro do construtor só podem ser utilizadas dentro do método em que foi criada.

Criamos o objeto da classe planeta chamado Marte, experimente criar outros objetos com nome de planetas e imprima seus valores.

Java

Classe #1 – Principal

public class principal {

public static void main(String[] args)
  {
      Planetas marte = new Planetas(3.0, 1.5, 6.419e23);

      marte.apelido = "Marte";

      System.out.println("Quantidade de planetas: " + Planetas.numeroDePlanetas);
      System.out.println("Nome do Planeta: " + marte.apelido);
      System.out.println("As outras variaveis da classe não podem ser alcançadas devido ao escopo");
      System.out.println("mas podem ser utlizadas dentro da classe");
  }
 }

Classe #2 – Planetas

public class Planetas {

 // Variavel da classe é compartilhada por todos
 public static long numeroDePlanetas;

 // Variavel de intancias
 private double x, y;
 private double massa;
 public String apelido;

      // Construtor
      //  x e y são  variaveis instanciadas,
      //  mas newX and newY são variaveis locais
      //  O construtor incrementa o valor
    public  Planetas(double novoX, double novoY, double novaMassa)
    {
       x = novoX;
       y = novoY;

       massa = novaMassa;
       numeroDePlanetas++;
    }
}

C#

Classe #1 – Principal

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

namespace ConsoleApplication53  {
      class Program
      {
          static void Main(string[] args)
          {
              Planetas marte = new Planetas(3.0, 1.5, 6.419e23);

              marte.apelido = "Marte";

              Console.WriteLine("Quantidade de planetas: " + Planetas.numeroDePlanetas);
              Console.WriteLine("Nome do Planeta: " + marte.apelido);
              Console.WriteLine("As outras variaveis da classe não podem ser alcançadas devido ao escopo");
              Console.WriteLine("mas podem ser utlizadas dentro da classe");

              Console.ReadKey();
          }
      }
  }

Classe #2 – Planetas

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication53 {

public class Planetas {

         // Variavel da classe é compartilhada por todos
          public static long numeroDePlanetas;

         // Variavel de intancias
          private double x, y;
          private double massa;
          public String apelido;

          // Construtor
          //  x e y são  variaveis instanciadas,
          //  mas newX and newY são variaveis locais
          //  O construtor incrementa o valor

          public Planetas(double novoX, double novoY, double novaMassa)
          {
              x = novoX;
              y = novoY;

              massa = novaMassa;
              numeroDePlanetas++;
          }
    }
}

C++

Classe #1 – Principal

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

using namespace std;

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

   Planetas marte(3.0, 1.5, 6.419e23);

   marte.apelido = "Marte";

   cout << "Quantidade de planetas: " << marte.numeroDePlanetas << endl;
   cout << "Nome do Planeta: " << marte.apelido << endl;
   cout << "As outras variaveis da classe não podem ser alcançadas devido ao escopo" << endl;
   cout << "mas podem ser utlizadas dentro da classe" << endl;

   system("pause");

   return 0;
}

Classe #2 – Planetas

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

using namespace std;

class Planetas {

private:
    // Variavel de intancias
     double x, y;
     double massa;

public:

     // Variavel de intancias
     string apelido;

     // Variavel da classe é compartilhada por todos
     static int numeroDePlanetas;

     // Construtor
     //  x e y são  variaveis instanciadas,
     //  mas newX and newY são variaveis locais
     //  O construtor incrementa o valor

  Planetas(double novoX, double novoY, double novaMassa)
  {
    x = novoX;
    y = novoY;

    massa = novaMassa;
    numeroDePlanetas++;
   }
};

  int Planetas::numeroDePlanetas;

PARAMETERS – ABAP

Publicado: 13 de fevereiro de 2014 em Abap
0

Você pode usar a declaração PARAMETERS para declarar variáveis ​​de uma forma semelhante a declaração variáveis ​​DATA. Para cada parâmetro declarado, um campo de entrada aparece na tela de seleção correspondente. No lado esquerdo do campo de entrada, o nome do parâmetro é apresentado como texto. Os valores inseridos no campo de entrada pelo usuário são atribuídos à variável correspondente, enquanto o sistema processa a tela de seleção.

Sintaxe:

PARAMETERS variável TYPE tipo LENGTH tamanho DEFAULT valor.

Exemplo:

ABAP

*&---------------------------------------------------------------------*
*& Report  ZPARAMETROS
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Parametros
*&---------------------------------------------------------------------*

REPORT  ZPARAMETROS.

PARAMETERS:  Nome   TYPE c LENGTH 50 DEFAULT 'Digite seu nome',
             Rua    TYPE c LENGTH 40 DEFAULT 'Digite sua Rua',
             Numero TYPE i,
             Bairro TYPE c LENGTH 30 DEFAULT 'Digite seu Bairro',
             CEP    TYPE c LENGTH 9 DEFAULT  'Cep',
             Cidade TYPE c LENGTH 40 DEFAULT 'Digite sua Cidade',
             Estado TYPE c LENGTH 2.

WRITE – Abap

Publicado: 13 de fevereiro de 2014 em Abap
0

A declaração ABAP básica para exibir dados na tela é WRITE.

Sintaxe:

WRITE <campo>.

Exemplo:

ABAP

*&---------------------------------------------------------------------*
*& Report  ZSAIDA
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Saida de Tela
*&---------------------------------------------------------------------*

REPORT  ZSAIDA.

WRITE  10 'Saida1'.
*Saida começa na coluna 10.

WRITE (3) 'Saida2'.
*Saida tem apenas 3 caracteres.

WRITE (*) 'Saida3'.
*Saida é escrita em um tamanho suficiente sem espaços.

WRITE  10(3) 'Saida4'.
*Combinação das tecnicas acima.

WRITE / 'Saida5'.
*Saida é escrita na proxima linha.

WRITE /10(3) 'Saida6'.
*Combinação das tecnicas acima.

CONSTANTS – Abap

Publicado: 13 de fevereiro de 2014 em Abap
0

Constantes são chamados objetos de dados que você cria estaticamente usando uma instrução declarativa. Eles permitem que você armazene dados sob um nome específico dentro da área de memória de um programa. O valor de uma constante deve ser definida ao declará-lo. Ele não pode ser alterado posteriormente. O valor de uma constante, não pode ser alterado durante a execução do programa. Se você tentar alterar o valor de uma constante, um erro de sintaxe ou erro de execução ocorre.

Existe um número de constantes mantidas pelo sistema Por exemplo, SY-MANDT irá exibir o número de cliente atual.

A sintaxe da instrução constantes é exatamente a mesma que a da declaração DATA, mas com as seguintes exceções:

  • Você deve usar a adição de valor na declaração de constantes. O valor inicial especificado na adição de valor não pode ser alterado durante a execução do programa.
  • Você não pode definir constantes para XSTRINGS, referências, tabelas internas, ou estruturas que contêm as tabelas internas.

Sintaxe:

 CONSTANTS nome TYPE tipo VALUE valor

Exemplos:

ABAP

*&---------------------------------------------------------------------*
*& Report  ZCONSTANTES
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Constantes
*&---------------------------------------------------------------------*
REPORT  ZCONSTANTES.

CONSTANTS chave_alpha_numerica TYPE string VALUE 'AKFDF43SD098EWE2739AA003'.

WRITE : / 'O valor da Chave Alpha Numerica é fixo e não pode ser alterado', CHAVE_ALPHA_NUMERICA.

Tipos de Variáveis – GLOBAL – Abap Dictionary (SE11) – Abap

Publicado: 13 de fevereiro de 2014 em Abap
0

 Tipos de Dados Globais

Para declarar dados globais você precisa acessar o dicionário ABAP através da transação se11. Para mais informações sobre os tipos built-in do Abap Dictionary clique aqui.

Declarando uma variável global

  1. Abra o ABAP Dictionary pela transação SE11.
  2. Clique na opção “Data type”.
  3. Para evitar a colisão de nomes para a classe, começe os nomes de tipo com Z
  4. Nome: zchavevalidade.
  5. Clique no botão Create e escolha a classe Data element.
  6. Em Short Description escreva: Chave de validade do programa.
  7. Clique em Predefined Type.
  8. Em Data Type escolha INT4 e Length de 30.
  9. Clique em Activate.
  10. Clique em Local Object,
  11. Abra a transação SE38  e digite o programa abaixo.

ABAP


*&---------------------------------------------------------------------*
*& Report  ZGLOBAL
*&
*&---------------------------------------------------------------------*
*&  Desenvolvimento Aberto
*&  Tipos de Variáveis Globais
*&---------------------------------------------------------------------*

REPORT  ZGLOBAL.

DATA chave TYPE ZCHAVEVALIDADE.

chave = 152626113.

WRITE : / 'Chave de validade do programa:', chave.

Criando Tipos de Variáveis – TYPES – Abap

Publicado: 13 de fevereiro de 2014 em Abap
0

TYPES:

Permite declarar tipos de dados locais que são mais específicos do que o tipo padrão.

Sintaxe:

TYPES  nome do tipo TYPE [tipo de variável]

Isso pode ser usado para criar um tipo padrão de variáveis  com um nome mais descritivo para a sua aplicação ou para definir mais especificamente a composição das variáveis.

TYPES – Não pode ter um valor default especificado pelo usuário.

TYPES –  São declarações  locais para  o programa. Declarações de tipos globais são possíveis através do uso do dicionário ABAP, permitindo uma gestão tipo em todo o sistema.

ABAP


*&---------------------------------------------------------------------*
*& Report  ZTIPOS2
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Declarando Tipos de Variáveis Locais.
*&---------------------------------------------------------------------*

REPORT  ZTIPOS2.

* Declara tipos de variáveis locais para o programa
TYPES :    valusuario  TYPE i,
           codusuario  TYPE n LENGTH 10,
           taxausuario TYPE p LENGTH 3 DECIMALS 2.

* Declara variáveis
 DATA : meuvalor  TYPE valusuario,
        meucodigo TYPE codusuario,
        minhataxa TYPE taxausuario.

* Alimenta Variáveis
meuvalor = 100.
meucodigo = 15262622.
minhataxa = '1.56'.

* Declara uma nova variável com base em outra ja existente
DATA novataxa LIKE minhataxa.

* Adiciona o valor da minha taxa na novataxa
ADD minhataxa TO novataxa.

* Modifica valor da variável
 novataxa novataxa = novataxa + '0.20'.

WRITE : / 'Taxa:', minhataxa, 'Nova Taxa:',novataxa.
WRITE : / 'Codigo:', meucodigo, 'Valor:', meuvalor.
Entradas mais Antigas
Entradas mais Recentes