Arquivo de fevereiro, 2014

Encapsulamento que em programação orientada a objetos significa separar o programa em partes, o mais isoladas possível. A idéia é tornar o software mais flexível, fácil de modificar e de criar novas implementações. Objetos restringem a visibilidade de seus recursos (atributos e métodos) aos outros usuários. Todo objeto tem uma interface, que determina como os outros objetos podem interagir com ele. A implementação do objeto é encapsulada, isso é, invisível ou visível  fora do próprio objeto.

PublicQuando precede uma lista de membros de classe, o  públic  palavra-chave especifica que esses membros são acessíveis a partir de qualquer função. Isso se aplica a todos os membros declarados até o próximo especificador de acesso ou o fim da classe. Ou seja visível a todos.

Private – Quando precede uma lista de membros de classe, o private palavra-chave especifica que esses membros são acessíveis somente dentro de funções de membro e amigos da classe.  Isso se aplica a todos os membros declarados até o próximo especificador de acesso ou o fim da classe. Ou seja visível somente para membros dentro da classe.

Protected – O protected palavra-chave especifica o acesso a membros de classe no lista de membros até o próximo especificador de acesso (pública ou private) ou no final da definição de classe.  O Protected é mistura entre Public e Private ou seja é visível somente para membros da classe e visível para subclasses.

Publico VS Private

  • Publico todas as classes podem usar os métodos e campos.
  • Privado apenas a classe  podem usar os métodos e campos.

Por que Controlar o Acesso?

  • Proteger informação privada.
  • Esclarecer como outros programadores devem usar sua classe.
  • Manter a implementação separado da interface.

Exemplo:

imagine o seguinte cenário,  temos uma classe que é responsável por transações de cartões de credito geralmente este tipo de classe pertence a companhia de cartões de credito e foi desenvolvida por um outro programador e esta dentro de uma DLL ou OS, acontece que o desenvolvedor terceirizado cometeu um deslize deixando visível a propriedade numero do cartão. Um desenvolvedor malicioso pode facilmente capturar o numero do cartão referenciando o objeto.

Neste exemplo você deve brincar com o código fonte a fim de resolver o problema de controle de acesso , use CTRL+espaço após a classe para ver a visibilidade de acesso dos métodos e campos.

C++

Classe #1 – Principal

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

using namespace std;

void metodoMalicioso(CartaoCredito& cartao)
 {
    cartao.gastos = 0;
    cout << "Seu numero de cartão: " << cartao.numeroCartao;
 }

int _tmain(int argc, _TCHAR* argv[])
 {
   // Uma transação hipotetica
   CartaoCredito transacao;
   transacao.cobranca("3453 3636 0001 1267", 350.00);

   // Metodo malicioso Injeta um gasto valor de 0 e imprime o numero do cartão
   metodoMalicioso(transacao);

   cout << endl;

   system("pause");

   return 0;
 }

Classe #2 – Cartão de Credito

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

using namespace std;

class CartaoCredito
 {
  // Esta declaração esta errada
  // Deste modo é possive capturar o numero do cartão
  // A classe expos o numero para que seja acessivel de outra classe
  // para não expor os numero use private

// private:
 public:

string numeroCartao;
   double gastos;

//public:
  void cobranca(string nCartao, double valor)
  {
    numeroCartao = nCartao;
    gastos = gastos + valor;
  }

  CartaoCredito()
  {
  }
};

Encapsulamento que em programação orientada a objetos significa separar o programa em partes, o mais isoladas possível. A idéia é tornar o software mais flexível, fácil de modificar e de criar novas implementações. Objetos restringem a visibilidade de seus recursos (atributos e métodos) aos outros usuários. Todo objeto tem uma interface, que determina como os outros objetos podem interagir com ele. A implementação do objeto é encapsulada, isso é, invisível ou visível  fora do próprio objeto.

Public – deixa visível a classe ou membro para todas as outras classes, subclasses e pacotes do projeto Java, ou namespaces do projeto C#.

Private – deixa visível o atributo apenas para a classe em que este atributo se encontra.

Protected – deixa visível o atributo para todas as outras classes e subclasses que pertencem ao mesmo pacote ou namespace.  O protected é um intermediário entre public e private.

Publico VS Private

  • Publico todas as classes podem usar os métodos e campos.
  • Privado apenas a classe  podem usar os métodos e campos.

Por que Controlar o Acesso?

  • Proteger informação privada.
  • Esclarecer como outros programadores devem usar sua classe.
  • Manter a implementação separado da interface.

Exemplo: imagine o seguinte cenário,  temos uma classe que é responsável por transações de cartões de credito geralmente este tipo de classe pertence a companhia de cartões de credito e foi desenvolvida por um outro programador e esta dentro de uma DLL ou OS, acontece que o desenvolvedor terceirizado cometeu um deslize deixando visível a propriedade numero do cartão. Um desenvolvedor malicioso pode facilmente capturar o numero do cartão referenciando o objeto.

Neste exemplo você deve brincar com o código fonte a fim de resolver o problema de controle de acesso , use CTRL+espaço após a classe para ver a visibilidade de acesso dos métodos e campos.

Java

Classe #1 – Principal

public class Malicioso {

// Assim que setar private esta void não podera ser escrita
// Você não tera mais acesso as propriedades da classe

  static void metodoMalicioso(CartaoCredito cartao)
  {
     cartao.gastos = 0;
     System.out.println("Seu numero de cartão: " + cartao.numeroCartao);
  }

  public static void main(String[] args)
  {
      // Uma transação hipotetica
      CartaoCredito transacao = new CartaoCredito();
      transacao.cobranca("3453 3636 0001 1267", 350.00);

      // Metodo malicioso Injeta um gasto valor de 0 e imprime o numero do cartão
      metodoMalicioso(transacao);
  }

}

Classe #2 – Cartão de Credito

public class CartaoCredito {

  // Esta declaração esta errada
  // Deste modo é possive capturar o numero do cartão
  // A classe expos o numero para que seja acessivel de outra classe
  // para não expor os numero use private
  // private String numeroCartao;
  // private double gastos;

   public String numeroCartao;
   double gastos;

   // Em java mesmo não declarando publico a propriedade ainda é acessivel
   //  public para a void ser vista por outras classes

   public  void cobranca (String nCartao,double valor)
   {
      numeroCartao = nCartao;
      gastos = gastos + valor;
   }

}

C#

Classe #1 – Principal

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

namespace Malicioso {

class Program
{

   // Assim que setar private esta void não podera ser escrita
   // Você não tera mais acesso as propriedades da classe

   static void metodoMalicioso(CartaoCredito cartao)
   {
      cartao.gastos = 0;
      Console.WriteLine("Seu numero de cartão: " + cartao.numeroCartao);
   }

   static void Main(string[] args)
   {
      // Uma transação hipotética
      CartaoCredito transacao = new CartaoCredito();
      transacao.cobranca("3453 3636 0001 1267", 350.00);

     // Metodo malicioso Injeta um gasto valor de 0 e imprime o numero do cartão
     metodoMalicioso(transacao);
     Console.ReadKey();
   }
  }
}

Classe #2 – Cartão de Credito

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

namespace Malicioso
 {

     public class CartaoCredito
     {
         // Esta declaração esta errada
         // Deste modo é possive capturar o numero do cartão
         // A classe expos o numero para que seja acessivel de outra classe
         // para não expor os numero use private
         // private String numeroCartao;
         // private double gastos;

         public String numeroCartao;
         public double gastos;

         //  public para a void ser vista por outras classes
         public void cobranca(String nCartao, double valor)
         {
             numeroCartao = nCartao;
             gastos = gastos + valor;
         }
     }
}

Fundamentos SAP e ABAP DEVELOPMENT WORKBENCH

Publicado: 10 de fevereiro de 2014 em Abap

Desenvolvendo em um Ambiente Estabelecido

  • A programação é feita em um ambiente com muitos componentes chamados pré-existentes.
  • Colisão de nomes pode interromper uma funcionalidade existente.
  • Programas iniciados de A a X são reservados para uso exclusivo da SAP. Y e Z podem ser utilizados pelos clientes.
  • Modificação / programação é  possível apenas com uma chave de desenvolvedor e configuração adequada.
  • Chaves são dependentes de cliente e nome de usuário.
  • Chaves fornecidas pela SAP com base no contrato de licença. Pode exigir pagamento adicional.

Cenário de uma típica  empresa SAP

Um cenário típico envolve múltiplos sistemas:

  • Desenvolvimento (DEV)
  • Qualidade (QAS)
  • Produção (PROD)
  • Treinamento (TRN).

cenario

Ambientes SAP

  • Componentes são desenvolvidos para mover de um sistema para outro por meio de transportes.
  • Desenvolvimento feito dentro de pacotes que são vinculados a solicitações de transporte.
  • Os pedidos são exportados/importados para o transporte, por exemplo DEV para QAS.
  • A tarefa chave de administração do sistema de gestão de transportes serve para garantir a integridade do sistema e manter as dependências .

Aplicação de Três Camadas mais ABAP

cenario4

Processo de Programação

  1. Criar novo ou selecionar o pacote existente.
  2. Criar novo ou selecionar pedido de transporte existentes para o pacote.
  3. Iniciar  a criação de um novo programa.
  4. Inserir uma chave para autorizar o desenvolvimento (se não for feito anteriormente).
  5. Criar, depurar o programa e Salvar.
  6. Testar. Rever o programa  se necessário.
  7. Ativar o programa.
  8. Transportar os pacote (itens que não serão transportados pode ser atribuído ao pacote local $TMP).

Convenções de Desenvolvimento ABAP:

  • Programas ABAP  são compostos de sentenças individuais/declarações.
  • Cada instrução começa com uma palavra-chave.
  • A convenção para digitar palavras-chave todas as letras são maiúsculas.
  • A Convenção para digitar variáveis​​, operadores e outros, todas as letras minúsculas.
  • Cada instrução termina com um ponto final.
  • As declarações podem ser identadas como desejar.
  • Declarações podem se estender por várias linhas.
  • Linhas com *(asterisco) na coluna são linhas de comentário.
  • Aspas duplas (“) são comentários no final de linhas.
  • Para evitar a colisão de nomes, em todo o desenvolvimento feito no sistema começar seus programas com o prefixo Z ou Y.

ABAP WORKBENCH DEVELOPMENT

  1. Entre com a transação SE80.
  2. Selecione o objeto package
  3. Digite zDevAberto e clique em procurar.
  4. Quando for questionado para criar um novo objeto clique em sim.cenario1
  5. Na janela Create Package digite a descrição Desenvolvimento Aberto Pacote 00 e clique ok.cenario2
  6. Na janela Prompt for Local Workbench request clique em nova request.
  7. De volta na janela de Prompt clique em OK.
  8. Clique com o botão direito em nosso novo pacote ZDEVABERTO e selecione create program.cenario3
  9. Na janela Create Program digite: ZTESTEABERTO (tudo em maiusculo, lembre-se da conveção).
  10. Desmarque o check TOP include, clique em OK.
  11. Em Title digite: Desenvolvimento Aberto.
  12. Em Type: Executable Program.
  13. Em Status: Program Test e clique em salvar e depois clique em Local Object.
  14. Uma Janela para desenvolvimento vai abrir ao lado da barra lateral e voçê pode escrever o programa  abaixo e salvar o codigo fonte.
  15. No menu Program clique em Activate escolha o programa ZTESTEABERTO e clique ok.
  16. Aperte a tecla F8 para testar o programa.

ABAP


*&---------------------------------------------------------------------*

*& Report  ZTESTEABERTO

*&

*&---------------------------------------------------------------------*

*& Desenvolvimento Aberto.

*& Programa Teste Aberto 0001.

*&---------------------------------------------------------------------*

REPORT  ZTESTEABERTO.

WRITE : / 'Desenvolvimento Aberto'.

Write : / 'Usando o ABAP DEVELOPMENT WORKBENCH', ' SE80'.

MINI SAP e Hello World – ABAP

Publicado: 10 de fevereiro de 2014 em Abap

Em ABAP temos conceitos comuns com outras linguagens de programação orientada a objeto a diferença é que objetos ABAP  contam com um conceito do R/3 basicamente divididos em dois tipos distintos. Os objetos compõem todo o ambiente de tempo de execução ABAP e representam a extensão orientada a objeto da linguagem ABAP.

O ambiente de tempo de execução:

  • ABAP Workbench permite que você crie objetos R/3 Repository, como programas, objetos de autorização, objetos de travamento, objetos de customizing, e muitos outros. Usando módulos de funções, você pode encapsular funções em programas separados com uma interface definida.
  • Business Object Repository permite que você crie SAP Business Objects para uso interno e externo (DCOM/CORBA).

A extensão da linguagem orientada a objeto:

  • Objetos ABAP suportam programação orientada a objeto. Orientação a objeto (OO), é um modelo de programação que une dados e funções em objetos. O resto da linguagem ABAP é primeiramente intencionada para programação estruturada, onde os dados são guardados em tabelas de banco de dados e programas orientados por funções os manipulam.
  • A implementação do modelo orientado a objeto do ABAP é baseado em modelos de Java e C++. É compatível com objetos externos como DCOM e CORBA. A implementação de elementos orientados a objeto no kernel da linguagem ABAP tem aumentado consideravelmente o tempo de resposta quando se trabalha com objetos ABAP.

Programação Orientada a objeto

Programação orientada a objetos representa o mundo real. Na programação orientada a objetos, implementa-se um conjunto de classes que definem os objetos presentes no sistema de software, programação orientada a objeto, é um método de resolução de problemas no qual o solução do software reflete objetos do mundo real.

Objeto

Em ciência da computação, objeto é uma referência a um local da memória que possui um valor. Um objeto pode ser uma variável, função, ou estrutura de dados. Com a introdução da programação orientada a objetos, a palavra objeto se refere a uma instância de uma classe.

Em programação orientada a objetos, um objeto passa a existir a partir de um “molde” (classe); a classe define o comportamento do objeto, usando atributos (propriedades) e métodos (ações).

Classes

Em orientação a objetos, uma classe é uma estrutura que abstrai um conjunto de objetos com características similares. Uma classe define o comportamento de seus objetos através de métodos e os estados possíveis destes objetos através de atributos. Classes, que podem conter dados e funções, apresentar tipos definidos pelo usuário em um programa. Tipos definidos pelo usuário em linguagens de programação tradicionais são coleções de dados que, em conjunto, descrevem atributos de um objeto e estado.

Referencia

Referência na ciência da computação é registro que aponta o local em que se encontram armazenados os dados que identificam outro dado.

Encapsulamento

Objetos restringem a visibilidade de seus recursos (atributos e métodos) aos outros usuários. Todo objeto tem uma interface, que determina como os outros objetos podem interagir com ele. A implementação do objeto é encapsulada, isso é, invisível fora do próprio objeto.

Polimorfismo

Na programação orientada a objetos, o polimorfismo permite que referências de tipos de classes mais abstratas representem o comportamento das classes concretas que referenciam. Assim, é possível tratar vários tipos de maneira homogênea (através da interface do tipo mais abstrato). O termo polimorfismo é originário do grego e significa “muitas formas” (poli = muitas, morphos = formas).

O polimorfismo é caracterizado quando duas ou mais classes distintas tem métodos de mesmo nome, de forma que uma função possa utilizar um objeto de qualquer uma das classes polimórficas, sem necessidade de tratar de forma diferenciada conforme a classe do objeto.

Herança

Herança é um princípio de orientação a objetos, que permite que classes compartilhem atributos e métodos, através de “heranças”. Ela é usada na intenção de reaproveitar código ou comportamento generalizado ou especializar operações ou atributos. O conceito de herança de várias classes é conhecido como herança múltipla.

Primeiro programa ABAP

Após a seguir a instalação do Mini SAP e SAP GUI você está apto a executar seu primeiro programa ABAP.

  1. Execute o SAP LOGON.
  2. Escolha o servidor NSP.
  3. Entre com o LOGIN pelo usuário BCUSER.
  4. Digite a transação: se38.
  5. Em Program digite: Zhelloword (não esqueça que de iniciar seus programas com o caractere Z ou Y) e clique em Create.
  6. Em Title digite: Hello World.
  7. Em Type escolha: Executable Program.
  8. Clique em Save e em Local Object.
  9. Digite o código fonte do quadro abaixo.
  10. No menu Program clique em activate, escolha o nome do seu programa e clique OK.
  11. Após o programa ativo aperte a tecla F8 para testar.

ABAP

*---------------------------------------------------------------------*
* Report  ZHELLOWORLD
*
*---------------------------------------------------------------------*
* Desenvolvimento Aberto
* Primeiro Programa ABAP - Hello World Abap
*---------------------------------------------------------------------*

REPORT  ZHELLOWORLD.

write: / 'Hello World'.

Classes – Static e Construtores – C++

Publicado: 10 de fevereiro de 2014 em C/C++

Construtores

Construtores são métodos especiais chamados pelo sistema no momento da criação de um objeto. Eles não possuem valor de retorno, porque você não pode chamar um construtor para um objeto, você só usa o construtor no momento da inicialização do objeto. Construtores representam uma oportunidade de inicializar seus dados de forma organizada. Construtores são obrigatórios em uma classe, mas não é preciso declara-los, caso não declare um construtor por default a declaração é: Classe().

Static

Enquanto a maioria das variáveis ​​declaradas dentro de uma classe ocorre em uma base de instância a instância (o que quer dizer que, para cada instância de uma classe, a variável pode ter um valor diferente), uma variável de membro estático tem o mesmo valor em qualquer instância a classe e nem sequer exige uma instância da classe para existir.

Lembrando que C++ não é preciso declarar uma nova instancia da classe como em Java, um vez a classe declarada basta chama-la sem usar o clássico comando java new:


// Instanciando uma classe JAVA

Bebe Marcia = new Bebe();

// Instanciando uma classe C++

Bebe Marcia;

Exemplo:

Neste cenário queremos saber quantos objetos de uma determinada classe foram instanciados, para isto criamos um contador no construtor do objeto e a cada objeto criado o contador aumenta nos mostrando no final a quantidade exata de novos objetos de uma classe. Visto que nosso contador pertence a classe e não a cada instancia de cada classe, neste caso para usar o contador não precisamos instanciar a classe graças a declaração static.

C++

Classe #1  – Principal

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

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
 {
  Bebe bebe1;
  Bebe bebe2;
  Bebe bebe3;

  cout << "Bebe 1 Construtor: " << bebe1.numeroBebeStatico << " Publico estatico: " << bebe1.numeroPublico() << endl;
  cout << "Bebe 2 Construtor: " << bebe2.numeroBebeStatico << " Publico estatico: " << bebe2.numeroPublico() << endl;
  cout << "Bebe 3 Construtor: " << bebe3.numeroBebeStatico << " Publico estatico: " << bebe3.numeroPublico() << endl;

  system("pause");
  return 0;
 }

Classe # 2 – Construtor

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

 using namespace std;

class Bebe {
 private:
  int id;
  static int numeroBebePublico;

public:

static int numeroBebeStatico;

int numeroPublico()
  {
   numeroBebePublico++;
   return numeroBebePublico;
  }

// Construtor da classe
   Bebe()
  {
   id = Bebe::numeroBebeStatico++;
  }
};
 int Bebe::numeroBebeStatico = 0;
 int Bebe::numeroBebePublico = 0;

Classes – Static e Construtores – Java e C#

Publicado: 9 de fevereiro de 2014 em C#, Java

Construtores

Construtores são métodos especiais chamados pelo sistema no momento da criação de um objeto. Eles não possuem valor de retorno, porque você não pode chamar um construtor para um objeto, você só usa o construtor no momento da inicialização do objeto. Construtores representam uma oportunidade de inicializar seus dados de forma organizada. Construtores são obrigatórios em uma classe, mas não é preciso declara-los, caso não declare um construtor por default a declaração é: Classe().

Static

Declaração de  um tipo de Classe, método, propriedade ou variável que pertence exclusivamente a sua própria classe, classes estáticas não podem ser instanciadas.

Exemplo:

Neste cenário queremos saber quantos objetos de uma determinada classe foram instanciados, para isto criamos um contador no construtor do objeto e a cada objeto criado o contador aumenta nos mostrando no final a quantidade exata de novos objetos de uma classe. Visto que nosso contador pertence a classe e não a cada instancia de cada classe, neste caso para usar o contador não precisamos instanciar a classe graças a declaração static.

Java

Classe #1  – Principal


public class Principal {

public static void main(String[] args)
 {
      System.out.println("Quantidade de objetos:" + Construtor.quantidade);
      Construtor c1 = new Construtor();

      System.out.println("Quantidade de objetos:" + Construtor.quantidade);
      Construtor c2 = new Construtor();

      System.out.println("Quantidade de objetos:" + Construtor.quantidade);
      Construtor c3 = new Construtor();

      System.out.println("Quantidade de objetos:" + Construtor.quantidade);

}

}

Classe # 2 – Construtor


class Construtor {

static int quantidade;

Construtor() {
   quantidade = quantidade + 1;
 }

}

C#

Classe #1  – Principal

class Program     {
  static void Main(string[] args)  {

     Console.WriteLine("Quantidade de objetos:" + Construtor.quantidade);
     Construtor c1 = new Construtor();

     Console.WriteLine("Quantidade de objetos:" + Construtor.quantidade);
     Construtor c2 = new Construtor();

     Console.WriteLine("Quantidade de objetos:" + Construtor.quantidade);
     Construtor c3 = new Construtor();

     Console.WriteLine("Quantidade de objetos:" + Construtor.quantidade);

     Console.ReadKey();
    }
}

Classe # 2 – Construtor

class Construtor {

   public static  int quantidade;

   public  Construtor() {
      quantidade = quantidade+1;
   }

}

Instalando o SAP GUI e Conectando ao Mini SAP

Publicado: 8 de fevereiro de 2014 em Abap

Notas:

Antes de utilizar este walkthrough você precisa ter instalado o NetWeaver 7.x (Mini-SAP)

Para instruções de como instalar o Mini-Sap: Mini SAP

Após completar a instalação e configuração do SAP GUI, talvez você queira saber mais sobre como configurar seu NetWeaver (Mini-SAP) para criar um ambiente de desenvolvimento, então você pode utilizar os links a seguir:

Introdução ao Database NSP: Flight Model

Aprenda a programar em ABAP agora: Hello World Abap


 Iniciando a Instalação

Após instalar SAP NetWeaver Application Server ABAP  (Mini SAP) você precisa instalar o SAP GUI, em alguns computadores quando você tenta instalar o SAP GUI direto da imagem que você baixou da SCN pelo programa “sapinstgui” e encontra o seguinte erro:

Error while connecting to communication partner – see preceeding messages.
Could not connect to host localhost on port 21212. java.net.ConnectException:
Connection refused: connect java.net.ConnectException:
Connection refused: connect

Instalando o SAP GUI

O SAP GUI 7.20 para ser instalado no Windows precisa como pré requisito de componentes do Microsoft Outlook 98 à 2007. Para prevenir este problema você pode baixar o SAP GUI 7.30 da SAP Market Place mas é preciso ser um cliente ou um parceiro SAP para ter acesso ao download, você também pode baixar o SAP GUI de comunidades  de estudo SAP:

A versão do SAP GUI para Linux ou Mac é uma versão conhecida como SAP GUI para Java ou PlatinGUI, utilize somente a versão mais recente devido a compatibilidade, a SAP utiliza um instalador padrão (SAP Delivery Software Tool), então a instalação abaixo é equivalente a qualquer plataforma, salvo configurações do sistema operacional.

SAP GUI Family – para cliente ou parceiro: SAP GUI Family

SAP GUI 7.30 – para estudo: http://www.sju.edu/int/academics/hsb/accounting/sep/star/software.html

SAP GUI 7.30 – para estudo: http://student.bus.olemiss.edu/fmathew/SAP/

Instalando o SAP GUI 7.30 Para Windows

1 – Após o download execute o instalador do SAP GUI

gui

2 – Após a o termino da instalação abra o snap-in no mmc  SAP Management Console e certifique-se que o servidor NSP esta rodando (verde), caso contrario clique no servidor  e no botão start. A tela abaixo refere-se a instalação do SAP NetWeaver Application Server Abap 7.x  (Mini Sap).

gui2

3 – Abra o SAP Logon e clique em nova conexão, clique em next e preencha os seguintes parâmetros:

  • Descrição: Local NSP
  • Servidor de Aplicação: localhost
  • Numero da Instância: 00
  • Id do Sistema: NSP
  • Clique em completar

gui3

4 – Neste primeiro login precisamos configurar o sistema e precisamos de um usuário administrador, entre com os seguintes parâmetros:

  • Mandante: 001
  • Usuário: SAP*
  • Senha : sua senha Master configurada na instalação do Netweaver server
  • Idioma: EN

gui4

5 – Após logar no sistema pela primeira vez aguarde a compilação até aparecer a tela inicial:

gui5

6 – Agora precisamos configurar a licença Trial para 90 dias (pode ser prorrogada) e configurar nossa chave de desenvolvedor para começar nosso primeiro programa ABAP:

  • No Mini SAP digite a seguinte transação: SLICENSE 
  • Copie o valor do campo Active Hardware Key (necessário para solicitar a licença).
  • Clique neste link  para solicitar a licença: Mini SAP.
  • Após alguns minutos entre no email cadastrado na SCN  e baixe o arquivo de licença.
  • Entre no Mini SAP e digite a seguinte transação: SLICENSE (veja detalhes no final do post).
  • Clique no ícone licença e escolha o caminho até o arquivo .txt recebido.
  • Libere acesso ao arquivo (GRANT) e marque a opção lembrar minha decisão.
  • Efetue um logoff usando a transação: /nex.
  • Efetue um novo logon com o usuário DDIC e a senha master.
  • Entre com a transação: SU01.
  • Preencha BCUSER no campo usuário e clique em display.
  • Verifique na Aba PROFILES se o usuário possui direitos SAP_ALL.
  • Na aba LOGON DATA clique no ícone Display/Change e escolha uma nova senha.
  • Efetue logoff e um novo login com o usuário BCUSER.
  • Entre com a transação: se38.
  • Em program digite: zHelloWorld e clique em create.
  • Entre com a chave de acesso :29671482393151224771

gui7

7 – Após inserir a chave de licença você está apto a desenvolver programas ABAP.

Licença Mini SAP

SLICENSE

SLICENSE

A licença SAP para o Netweaver 7.x funciona da seguinte maneira:

Habilita a utilização por 90 dias, após o termino deste prazo a licença será automaticamente renovada por mais 30 dias, após o 120 dias você precisa solicitar uma nova licença de 90 dias e poderá estender o prazo normalmente, a versão TRIAL para o Netweaver Developer Edition não é bloqueada, você pode continuar aprimorando suas habilidades ABAP continuadamente apenas solicitando uma nova licença. Tenha certeza de solicitar a versão correta da licença para o seu sistema operacional e banco de dados.

OBS: A transação SLICENSE  não deve mostrar nenhuma licença , caso a versão que você baixe instale automaticamente uma licença, seu sistema mostrará  Installation Number = SAP-INTERN e não DEMOSYSTEM.

Para resolver: na aba Digitally-Signed License Keys  delete a licença SAP-INTERN  até o Installation Number voltar para INITIAL ou DEMOSYSTEM e instale sua  licença, se o ícone de sua licença ficar verde tudo terminado caso contrario se aparecer (Inactive Hardware Key) você não poderá renovar a licença e precisa reinstalar o NetWeaver 7.x após os 90 dias. O Inactive Hardware Key significa que você instalou uma licença não adequada a sua versão do sistema operacional + banco de dados, mas a SAP habilita você a utilizar o sistema do mesmo modo com ícone de aviso (Amarelo), para resolver apague a licença inativa, solicite e aplique a licença correta.

***** NÃO delete a licença na aba Old Licenses.

Classes – Referência – C++

Publicado: 8 de fevereiro de 2014 em C/C++

Tipos Primitivos

Um tipo primitivo (também conhecido por nativo ou básico) é fornecido por uma linguagem de programação como um bloco de construção básico. Dependendo da implementação da linguagem, os tipos primitivos podem ou não possuir correspondência direta com objetos na memória.

Ex: int, long, double, boolean, char, short, byte, float.

Referência

Referência na ciência da computação é registro que aponta o local em que se encontram armazenados os dados que identificam outro dado.

Tipos são arrays e objetos, – String, int[], Classes, …

Variáveis são como canecas fixas e os primitivos são pequenos o suficiente para caber dentro da caneca. Os objetos são grandes para caber dentro de variáveis. Variáveis guardam números que localizam um objeto e a localização do objeto é chamada de referencia.

Importante: Em C++ o objeto é instanciado a partir de sua criação e é usado o símbolo & ( e comercial)  para referenciar objetos.

Bebe Patricia;

Exemplo:

Neste cenário temos um bebê recém nascido que precisa ser registrado no cartório, para isto vamos criar um objeto bebê e através de um método vamos cadastrar os dados do bebê referenciando o objeto ao nosso bebê.

C++

1 – Classe Referencia – Arquivo referencia.cpp

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

// Inclui Classe Bebê
#include "bebe.h"
using namespace std;

// O objeto Bebe& é responsável pela referencia
// Bebe sem o & não é referenciado, deixando o objeto vazio.
void cartorio(int codigo, string cadastro[] , Bebe& objeto)
  {
      objeto.codigo    = codigo;
      objeto.nome      = cadastro[0];
      objeto.sobreNome = cadastro[1];
      objeto.nomeMae   = cadastro[2];
      objeto.nomePai   = cadastro[3];
      objeto.sexo      = cadastro[4];
  }
int _tmain(int argc, _TCHAR* argv[])
  {
 // Vamos instanciar um novo bebe
 Bebe Samanta;

// Vamos solicitar a ficha de registro para o novo bebê
int codigoCartorio = 1438275;
string fichaRegistro[] = { "Samanta", "Amaral", "Roberto Amaral", "Marcia Amaral", "Feminino" };

// Vamos preerncher a ficha do novo bebê
 cartorio(codigoCartorio, fichaRegistro, Samanta);

 // Imprime registro do bebê
 cout << "Registro de Nascimento:\n"; cout << "\n";
 cout << "Código: " << Samanta.codigo << "\n";
 cout << "Nome: " << Samanta.nome << " " << Samanta.sobreNome << "\n";
 cout << "Nome do Pai: " << Samanta.nomePai << "\n" ;
 cout << "Nome da Mãe: " + Samanta.nomeMae << "\n"; cout << "\n";
 cout << "Registro efetuado com sucesso\n";
 system("pause");
      return 0;
  }

C++ 2- Classe Bebe – Arquivo Bebe.h

#include "stdafx.h"
#include <iostream>
#include <string>
 using namespace std;
class Bebe
  {
   public:  Bebe()
  {
      codigo;
      nome;
      sobreNome;
      nomePai;
      nomeMae;
      sexo;
  }
public:
   int codigo;
   string nome;
   string sobreNome;
   string nomePai;
   string nomeMae;
   string sexo;

  };
 

Classes – Referência – Java e C#

Publicado: 8 de fevereiro de 2014 em C#, Java

Tipos Primitivos

Um tipo primitivo (também conhecido por nativo ou básico) é fornecido por uma linguagem de programação como um bloco de construção básico. Dependendo da implementação da linguagem, os tipos primitivos podem ou não possuir correspondência direta com objetos na memória.

Ex: int, long, double, boolean, char, short, byte, float.

Referência

Referência na ciência da computação é registro que aponta o local em que se encontram armazenados os dados que identificam outro dado.

Tipos são arrays e objetos, – String, int[], Classes, …

Variáveis são como canecas fixas e os primitivos são pequenos o suficiente para caber dentro da caneca. Os objetos são grandes para caber dentro de variáveis. Variáveis guardam números que localizam um objeto e a localização do objeto é chamada de referencia.

Exemplo:

Neste cenário temos um bebê recém nascido que precisa ser registrado no cartório, para isto vamos criar um objeto bebê e através de um método vamos cadastrar os dados do bebê referenciando o objeto ao nosso bebê.

JAVA

1 – Classe Referencia


public class Referencia
 {
 static void cartorio(int codigo, String[] cadastro, Bebe objeto )
 {
   objeto.codigo     = codigo;
   objeto.nome       = cadastro[0];
   objeto.sobreNome  = cadastro[1];
   objeto.nomeMae    = cadastro[2];
   objeto.nomePai    = cadastro[3];
   objeto.sexo       = cadastro[4];
 }
 public static void main(String[] args)
 {

    // Vamos instanciar um novo bebe
    Bebe Samanta = new Bebe();

    // Vamos solicitar a ficha de registro para o novo bebê
    int codigoCartorio = 1438275;
    String[] fichaRegistro = {"Samanta", "Amaral", "Roberto Amaral", "Marcia Amaral", "Feminino"};

    // Vamos preerncher a ficha do novo bebê
    cartorio(codigoCartorio, fichaRegistro, Samanta);

    // Imprime registro do bebê
    System.out.println("Registro de Nascimento:");
    System.out.println("");
    System.out.println("Código: "+ Samanta.codigo );
    System.out.println("Nome: " + Samanta.nome + " " + Samanta.sobreNome);
    System.out.println("Nome do Pai: " + Samanta.nomePai);
    System.out.println("Nome da Mãe: " + Samanta.nomeMae);
    System.out.println("");
    System.out.println("Registro efetuado com sucesso");
 }

}

JAVA
2- Classe Bebe

public class Bebe
 {
  public int codigo = 0;
  public String nome = null;
  public String sobreNome = null;
  public String nomePai = null;
  public String nomeMae = null;
  public String sexo = null;

  public Bebe()
    {
    }
 }

C#

Para C# basta trocar os seguintes comandos na classe Referencia:


// Trocar:

System.out.println

// por:

Console.WriteLine

Classes Python (Linux)

Publicado: 7 de fevereiro de 2014 em Python

Programação Orientada a objeto

Programação orientada a objetos representa o mundo real. Na programação orientada a objetos, implementa-se um conjunto de classes que definem os objetos presentes no sistema de software.

Classes

Em orientação a objetos, uma classe é uma estrutura que abstrai um conjunto de objetos com características similares. Em comparação com outras linguagens de programação, mecanismo de classe do Python adiciona as classes no mínimo com uma nova sintaxe e semântica. É uma mistura de mecanismos equivalentes encontrados em C + + e Modula-3. Classes Python fornecem todas as características padrão de Programação Orientada a Objetos: o mecanismo de herança de classe permite múltiplas classes base, uma classe derivada pode substituir os métodos de sua classe base ou classes, e um método pode chamar o método de uma classe base com o mesmo nome . Os objetos podem conter quantidades arbitrárias e tipos de dados. Como é o caso para os módulos, as classes participam da natureza dinâmica do Python: eles são criados em tempo de execução, e pode ser modificado ainda mais após a criação.

As definições de classe, como definições de funções (declarações def) devem ser executados antes que tenham qualquer efeito. (Você pode conseguir colocar uma definição de classe em um galho de uma instrução if ou dentro de uma função.)

Na prática, os comandos dentro de uma definição de classe será geralmente as definições de função, mas outras declarações são permitidas, e às vezes útil – nós vamos voltar a isso mais tarde. As definições de função dentro de uma classe normalmente têm uma forma peculiar de lista de argumentos, ditada pelas convenções de chamada para métodos – de novo, isso é explicado mais tarde.

Objeto Classe

Objetos de Classe suportam dois tipos de operações: referências a atributos e instanciação.

Atributo referências usam a sintaxe padrão utilizado para todas as referências a atributos em Python: obj.name. Nomes de atributos válidos são todos os nomes que estavam no namespace da classe quando o objeto classe foi criado. Assim, se a definição de classe ficou assim:

class MinhaClasse:
"""Um simples exemplo de classe"""
i = 12345 
def f(self):
return 'Olá Mundo'

Então MinhaClasse.i e MinhaClasse.f são referências a atributos válidos, retornando um inteiro e um objeto função, respectivamente. Atributos de classe também pode ser atribuído, de modo que você pode alterar o valor de MinhaClasse.i por atribuição. __doc__ também é um atributo válido, que retorna a docstring pertencente à classe: “Um simples exemplo de classe”.

Instanciação de classe usa a notação de função. Apenas finja que o objeto classe é uma função sem parâmetros que retorna uma nova instância da classe. Por exemplo:

x = MyClass()

cria uma nova instância da classe e atribui esse objeto para a variável local x.

A operação de instanciação (“chama” um objeto de classe) cria um objeto vazio. Muitas classes criam objetos com instâncias customizadas para um estado inicial específico. Portanto, uma classe pode definir um método especial chamado __ init__ (), assim:

class Complex:
      def __init__(self, realpart, imagpart):
          self.r = realpart
          self.i = imagpart

x = Complex(3.0, -4.5)
x.r, x.i

Exemplo de Classe

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

# Importa OS
import os

# Limpa a tela
os.system("clear")
# Classe comum para os empregados
class Empregados:
     empCount = 0
     def __init__(self, nome, salario):
        self.nome = nome
        self.salario = salario
        Empregados.empCount += 1
     def displayCount(self):
        print "Total de Empregados  %d" % Empregado.empCount
     def displayEmpregados(self):
        print "Nome : ", self.nome,  ", Salario: ", self.salario

# Cria o primeiro objeto da classe empregados
emp1 = Empregados("Patricia", 2000)

# Cria o segundo objeto da classe empregados
emp2 = Empregados("Augusto", 5000)
# Cria o terceiro objeto da classe empregados
emp3 = Empregados("Marcia",3000)

# Mostra os empregados
emp1.displayEmpregados()
emp2.displayEmpregados()
emp3.displayEmpregados()
# Imprime total de empregados
print ""
print "Total de empregados %d" % Empregados.empCount