Você está aqui: Java ::: Projetos Java Completos - Códigos Fonte Completos Java ::: Projetos Java Programação Orientada a Objetos - Exemplos Java

Sistema para Biblioteca usando Programação Orientada a Objetos em Java - Projeto completo com código fonte - Versão console

Quantidade de visualizações: 536 vezes
Sistema para Gestão de Biblioteca usando Programação Orientada a Objetos em Java - Projeto completo com código fonte - Versão console

Controle de Biblioteca - Sobre este projeto Java



Nesta dica apresento a idéia de um Controle de Gestão de Biblioteca em Java usando Programação Orientada a Objetos. Trata-se de um programa com código fonte em duas versões console.

Na primeira versão temos os dados sendo gerenciados por objetos ArrayList. Na segunda versão nós tiramos proveito dos métodos dos métodos readObject() e writeObject() e da interface Serializable para implementar a serialização de objetos em Java. Dessa forma, os dados do sistema podem ser salvos e carregados todas as vezes que o sistema for iniciado.

Um Controle de Gestão de Biblioteca é um projeto ideal para dominar a programação orientada a objetos em Java, além de permitir colocar em prática várias coisas que estudamos na linguagem e não temos a oportunidade de implementar. Assim, este código, se bem estudado e bem entendido, pode render um controle de biblioteca pronto para ser vendido no mercado ou implementado em sua própria escola ou faculdade. Basta conectar as funcionalidades das classes a um banco de dados tal como o MySQL e adicionar mais alguns pequenos detalhes.

O Diagrama de Classes Java

Antes de falarmos mais sobre o projeto do Sistema de Biblioteca, dê uma boa olhada no seu diagrama de classes:



Como a aplicação está estruturada?

Como podemos ver no diagrama de classes, todo o controle do sistema é feito a partir da classe Biblioteca, que contém objetos da classe ArrayList para guardar objetos das classes Usuario, Autor, Editora, Livro, Emprestimo e Multa.

O relacionamento entre os objetos das classes envolvidas está bem definido no código fonte, com comentários e menus individuais para o gerenciamento de cada parte que compõe o controle de biblioteca apresentado.

Um empréstimo envolve um livro e um usuário, e pode gerar uma multa caso a devolução seja feita fora do prazo. A multa é gerada somente na devolução. Em sistemas reais, o usuário não pode fazer uma nova locação caso a multa não seja paga. Deixamos como sugestão e desafio, essa implementação no código. No entanto, já fizemos todo o restante do cálculo para você, ou seja, fizemos a diferença entre a data do empréstimo e sua devolução e geramos a multa, se houver, já com o devido valor a ser pago.

Um livro está relacionado a um autor e a uma editora. Inicialmente o livro é cadastrado como disponível. Porém, esse status é alterado para indisponível quando ele está envolvido em um empréstimo, e novamente disponível quando é feita a devolução.

Tudo isso é feito por meio de vários menus de opções, como mostro a seguir.

As opções de menu para o gerencimento do sistema da biblioteca

O menu principal foi escrito usando-se o seguinte código:

// método que exibe o menu principal do sistema
public void menuPrincipal(){
  Scanner entrada = new Scanner(System.in);
    
  while(true){  
    limparTela();
    System.out.println("\n:: B I B L I O T E C A ::\n");
    System.out.println("Bem-vindo(a) ao sistem. 
      Escolha a opção desejada");
    System.out.println("1 - Livros");
    System.out.println("2 - Autores");
    System.out.println("3 - Editoras");
    System.out.println("4 - Usuários");
    System.out.println("5 - Empréstimos");
    System.out.println("6 - Multas");
    System.out.println("7 - Sair");
    System.out.print("Sua opção: ");
    // lê a opção do usuário 
    int opcao = Integer.parseInt(entrada.nextLine()); 
    
    switch(opcao){
      case 1:
        // chama o menu de gerenciamento de livros
        menuGerenciarLivros(); 
        break;
      
      case 2:
        // chama o menu de gerenciamento de autores
        menuGerenciarAutores(); 
        break;
      
      case 3:
        // chama o menu de gerenciamento de editoras
        menuGerenciarEditoras();
        break;
      
      case 4:
        // chama o menu de gerenciamento de usuários
        menuGerenciarUsuarios(); 
        break;
      
      case 5:
        // chama o menu de gerenciamento de emprestimos
        menuGerenciarEmprestimos();
        break;
        
      case 6:
        // chama o menu de gerenciamento de multas
        menuGerenciarMultas();
        break;
      
      case 7:
        System.out.println("\nObrigado por usar o 
          Sistema de Biblioteca\n");  
        System.exit(0);
    }
  }
}


Note que cada case do switch do menu principal chama um método que será responsável por exibir um menu individual para o gerencimento da classe correspondente.

Veja, por exemplo, o menu para cadastrar um novo usuário na biblioteca:

// menu para cadatrar, listar, pesquisar, excluir 
// e atualizar os usuários da biblioteca
public int menuGerenciarUsuarios(){ 
  Usuario temp; // serve para várias operações neste menu
  // serve para as pesquisas dos usuários
  String pesquisaUsuario;
  Scanner entrada = new Scanner(System.in);
    
  // mostra o menu de forma repetitiva até o usuário 
  // usar a opção de sair
  while(true){
    // tire caso não funcionar no seu sistema operacional
    limparTela();
    System.out.println("\n:: G E R E N C I A R   U S U Á R I O S ::\n");
    System.out.println("Escolha a opção desejada");
    System.out.println("1 - Novo Usuário");
    System.out.println("2 - Listar Usuários");
    System.out.println("3 - Pesquisar Usuário");
    System.out.println("4 - Excluir Usuário");
    System.out.println("5 - Atualizar Usuário");
    System.out.println("6 - Voltar Menu Anterior");
    System.out.print("Sua opção: ");
    // lê a opção do usuário
    int opcao = Integer.parseInt(entrada.nextLine()); 
    
    switch(opcao){
      case 1: // vamos cadastrar um novo usuário
        System.out.print("\nNome: ");
        String nomeUsuario = entrada.nextLine();
        System.out.print("Idade: ");
        int idadeUsuario = Integer.parseInt(entrada.nextLine());
        System.out.print("Sexo: ");
        char sexoUsuario = entrada.nextLine().charAt(0);
        
        // vamos incrementar o contador de usuários
        Usuario.contadorUsuarios++;
        
        // agora vamos criar um novo objeto da classe Usuario
        Usuario u = new Usuario(Usuario.contadorUsuarios,
          nomeUsuario, idadeUsuario, sexoUsuario);
        // e o adicionamos no ArrayList de usuários
        usuarios.add(u);
        
        // e finalmente mostramos uma mensagem de sucesso.
        System.out.println("\nO usuário foi cadastrado com sucesso");
        salvarDadosArquivo(); // salva os dados no arquivo
        
        break;
        ... 


Devo usar ArrayList do Java para desenvolver o sistema?

Sim, objetos da classe ArrayList são perfeitos quando precisamos representar relacionamentos um para muitos e muitos para um. É claro que poderíamos usar vetores de objetos (usando array), mas ficaríamos restritos a tamanhos fixos, enquanto o ArrayList nos permite cadastrar quantos usuários, livros, editoras, autores e empréstimos nós quisermos.

Dessa forma, veja, por exemplo, o trecho de código que registra um novo empréstimo:

case 1: // vamos cadastrar um novo empréstimmo
  // para registrar um novo empréstimo nós precisamos 
  // de um usuário
  // o usuário que será relacionado a este empréstimo
  Usuario usuario = null;
  while(usuario == null){
    System.out.print("\nInforme o id ou nome do usuário: ");
    String pesquisaUsuario = entrada.nextLine();
    // chamamos o método que pesquisa o usuario
    usuario = pesquisarUsuario(pesquisaUsuario);
    if(usuario == null){ // usuario não encotrado
      System.out.print("\nUsuário não 
       encontrado.\n\nDigite 1 para pesquisar 
       novamente ou 2 para voltar ao menu anterior: ");
      int opcaoTemp = Integer.parseInt(entrada.nextLine());
      if(opcaoTemp == 2){
        return 1; // saímos daqui e voltamos para o menu anterior  
      }
    }
  }
  System.out.println("Usuário selecionado: " + usuario.getNome());
  // fim para registrar um novo empréstimo nós 
  // precisamos de um usuário
          
  // para registrar um novo empréstimo nós precisamos 
  // de um livro
  Livro livro = null; // o livro que será relacionado 
  // a este empréstimo
  while(livro == null){
    System.out.print("Informe o id, título ou ISBN do livro: ");
    String pesquisaLivro = entrada.nextLine();
    // chamamos o método que pesquisa o livro
    livro = pesquisarLivro(pesquisaLivro);
    // livro não encontrado ou indisponível
    if((livro == null) || (!livro.isDisponivel())){
      System.out.print("\nLivro não encontrado 
       ou indisponível.\n\nDigite 1 para 
       pesquisar novamente ou 2 para voltar ao 
       menu anterior: ");
      int opcaoTemp = Integer.parseInt(entrada.nextLine());
      if(opcaoTemp == 2){
        return 1; // saímos daqui e voltamos para o menu anterior  
      }
    }
  }
  System.out.println("Livro selecionado: " + livro.getTitulo());
  // fim para cadastrar um novo empréstimo nós 
  // precisamos de um livro
 
  try{          
    System.out.print("Data do Empréstimo: ");
    String dataEmprestimo = entrada.nextLine();
    Date dataEmprestimoDate = 
      new SimpleDateFormat("dd/MM/yyyy").parse(dataEmprestimo);
    System.out.print("Data de Devolução: ");
    String dataDevolucao = entrada.nextLine();
    Date dataDevolucaoDate = 
      new SimpleDateFormat("dd/MM/yyyy").parse(dataDevolucao);
          
    // a data de devolução é menor que a data de empréstimo?
    if(dataDevolucaoDate.getTime() <= dataEmprestimoDate.getTime()){
      System.out.println("\nA data de devolução 
        deve ser maior que a data de empréstimo.\n");
    }
    else{
      // vamos incrementar o contador de empréstimos
      Emprestimo.contadorEmprestimos++;
        
      // vamos marcar o livro escolhido como indisponível
      livro.setDisponivel(false);
              
      // agora vamos criar um novo objeto da classe Emprestimo
      Emprestimo emprestimo = new Emprestimo(usuario,
        livro, Emprestimo.contadorEmprestimos, 
        dataEmprestimoDate, dataDevolucaoDate, 
        null, false);
      // e o adicionamos no ArrayList de empréstimos
      emprestimos.add(emprestimo);
        
      // e finalmente mostramos uma mensagem de sucesso.
      System.out.println("\nO empréstimo foi registrado com sucesso");
      salvarDadosArquivo(); // salva os dados no arquivo
    }
  }
  catch(ParseException e){
    System.out.println("\nAs datas informadas são inválidas.\n");
  }
            
  break;


Note que este trecho de código é parte do case da opção Novo Empréstimo do menu Gerenciar Empréstimos. Veja como usamos uma variável estática contadorEmprestimos da classe Emprestimo para criarmos um valor inteiro auto-incremento que nos permite identificadores únicos para cada empréstimo da biblioteca.

Viu que código mais lindo? Note como a Programação Orientada a Objetos em Java nos permite desenvolver idéias de forma bem parecida mesmo ao mundo real.

Como posso obter este código fonte?

O código fonte desta aplicação é fornecido em duas versões:

1) SBIBLIOJCNB-A - Sistema de Gestão de Biblioteca em Java com Código Fonte Versão Console - NetBeans IDE ou Eclipse.

2) SBIBLIOJCNB-B - Sistema de Gestão de Biblioteca em Java com Código Fonte Versão Console - Lê e salva os dados em arquivo usando serialização (Serializable), ou seja, os métodos readObject() e writeObject() - NetBeans IDE ou Eclpse.

Para adquirir, entre em contato conosco usando o WhatsApp ou e-mail indicados na lateral do site. Podemos combinar alterações e a adição de novas funcionalidades.

Não se esqueça: Uma boa forma de estudar o código é fazendo pequenas alterações e rodando para ver os resultados. Outra opção é começar um projeto Java do zero e ir adicionando trechos do código fonte para melhor entendimento de suas partes.


Java ::: Fundamentos da Linguagem ::: Tipos de Dados

Java para iniciantes - Como usar o tipo de dados long da linguagem Java

Quantidade de visualizações: 11876 vezes
O tipo de dados long pode ser usado quando queremos armazenar valores inteiros na faixa -9.223.372.036.854.775.808 até 9.223.372.036.854.775.807. Veja um exemplo:

public class Estudos{
  static long valor = 545L; 
  
  public static void main(String args[]){
    System.out.println("O valor da variável é: "
      + valor);
    System.exit(0);
  }
}

Observe o uso do caractere "L" após o valor literal que atribuímos à variável. Isso é feito para que o compilador trate o literal como long e não como int. Você pode usar o "L" minúsculo, mas este se parece muito com o número um, o que torna seu uso pouco recomendável.

O tipo de dados long pode ser convertido (sem a necessidade de cast) para os seguintes tipos:

long -> float -> double

Se precisarmos converter o tipo int para os tipos char, byte, short ou int, teremos que lançar mão de uma coerção (cast). Veja:

byte valor2 = (byte)(valor);



Java ::: Lista de Exercícios Resolvidos (Algorítmos Resolvidos) ::: Laços

Laços - Exercícios Resolvidos de Java - Ex. 16 - Escreva um programa (algorítmo) Java que usa o laço for para exibir uma tabela de conversões de milhas para quilômetros

Quantidade de visualizações: 1391 vezes
Pergunta/Tarefa:

Escreva um programa (algorítmo) Java que usa o laço for para exibir uma tabela de conversões de milhas para quilômetros. Sabendo que uma milha equivale a 1.609 quilômetros, seu programa deverá exibir uma saída parecida com:



Resposta/Solução:

Veja a resolução comentada deste exercício usando Java console:

package estudos;

public class Principal {
  public static void main(String[] args){
    System.out.println("Milhas\t\tQuilômetros");
    System.out.println("-------------------------------");

    // um laço for que repetirá 10 vezes
    for (int i = 1; i <= 10; i++){
      // usamos a variável de controle do laço para o cálculo
      System.out.println(i + "\t\t" + (i * 1.609));
    }
  }
}



Java ::: Fundamentos da Linguagem ::: Estruturas de Controle

Tutorial de Java - Como usar a instrução condicional if e if...else do Java

Quantidade de visualizações: 51670 vezes
Instruções if e if...else permitem executar trechos de códigos baseado em condições. Veja um exemplo:

public class Estudos{
  public static void main(String args[]){
    int valor = 5;
    
    if(valor > 3)
      System.out.println("Valor maior que 3");
  }
}

Neste programa, a instrução

System.out.println("Valor maior que 3");

será executada somente se o teste (valor > 3) for verdadeiro. Observe que a expressão de teste deverá sempre ser do tipo boolean (true ou false).

Neste exemplo temos apenas uma instrução a ser executada. Isso dispensa o uso das chaves ao redor do bloco de códigos. Se o bloco contiver mais de uma instrução, as chaves são necessárias. Veja:

public class Estudos{
  public static void main(String args[]){
    int valor = 5;
    
    if(valor > 3){
      System.out.println("Valor maior que 3");
      System.out.println("O valor é: " + valor);
    }
  }
} 

A instrução if...else (se...senão) é usada quando queremos fornecer um caminho alternativo ao código. Veja:

public class Estudos{
  public static void main(String args[]){
    int valor = 1;
    
    if(valor > 3)
      System.out.println("Valor maior que 3");
    else
      System.out.println("Valor menor que 3");
  }
}

Você pode ainda usar if...else if...else (se...senão se...senão). Veja:

public class Estudos{
  public static void main(String args[]){
    int valor = 3;
    
    if(valor > 3)
      System.out.println("Valor maior que 3");
    else if(valor < 3)
      System.out.println("Valor menor que 3");
    else
      System.out.println("Valor é igual a 3");
  }
} 



Java ::: Java + MySQL ::: Metadados da Base de Dados (Database Metadata)

Java MySQL - Como obter os tipos de dados suportados pelo MySQL e seus correspondentes JDBC usando o método getTypeInfo() da interface DatabaseMetaData

Quantidade de visualizações: 4893 vezes
Em algumas situações precisamos obter os tipos de dados suportados pelo MySQL e mapeá-los para seus correspondentes JDBC. Esta não é uma tarefa fácil, mas que, com uma pequena ajuda dos recursos de reflexão do Java, pode ser realizada depois de algumas xícaras de café.

O primeiro passo é obter os tipos de dados suportados pelo MySQL com uma chamada ao método getTypeInfo() da interface DatabaseMetaData. Os campos do ResultSet que nos interessam são TYPE_NAME e DATA_TYPE. TYPE_NAME traz o nome do tipo de dados no MySQL enquanto DATA_TYPE traz o tipo JDBC correspondente como um inteiro. Assim, o que temos que fazer é usar reflexão para obter todos os campos da classe java.sql.Types e efetuar um mapeamento entre os tipos.

Veja o código completo para o exemplo:

package estudosbancodados;

import java.lang.reflect.Field;
import java.sql.*;
import java.util.HashMap;
import java.util.Map;

public class EstudosBancoDados{
  static Map mapa; // usado para mapear os tipos JDBC
  
  public static void main(String[] args) {
    // strings de conexão
    String databaseURL = "jdbc:mysql://localhost/estudos";
    String usuario = "root";
    String senha = "osmar1234";
    String driverName = "com.mysql.jdbc.Driver";

    try {
      Class.forName(driverName).newInstance();
      Connection conn = DriverManager.getConnection(databaseURL, usuario, senha);

      // vamos obter um objeto da classe com.mysql.jdbc.DatabaseMetaData
      DatabaseMetaData dbmd = conn.getMetaData();

      // vamos obter os tipos de dados suportados por esta versão do MySQL
      // e seus correspondentes JDBC
      ResultSet tiposDados = dbmd.getTypeInfo();
      while(tiposDados.next()){
        System.out.println("MySQL: " + tiposDados.getString("TYPE_NAME") + " - JDBC: " 
          + getJdbcTypeName(Integer.parseInt(tiposDados.getString("DATA_TYPE"))));
      }
      
      // vamos fechar o ResultSet
      tiposDados.close();
    }
    catch (SQLException ex) {
      System.out.println("SQLException: " + ex.getMessage());
      System.out.println("SQLState: " + ex.getSQLState());
      System.out.println("VendorError: " + ex.getErrorCode());
    }
    catch (Exception e) {
      System.out.println("Problemas ao tentar conectar com o banco de dados: " + e);
    }
  }

  // Este método retorna o nome de um tipo JDBC
  // O retorno é null se o tipo JDBC não puder ser reconhecido
  public static String getJdbcTypeName(int jdbcType){
    // vamos usar reflection para mapear valores inteiros a seus nomes
    if(mapa == null) {
      mapa = new HashMap();

      // vamos obter todos os campos da classe java.sql.Types
      Field[] campos = java.sql.Types.class.getFields();
      
      // vamos percorrer os campos
      for(int i = 0; i < campos.length; i++){
        try{
          // vamos obter o nome do campo
          String nome = campos[i].getName();

          // vamos obter o valor do campo
          Integer valor = (Integer)campos[i].get(null);

          // vamos adicionar ao mapa
          mapa.put(valor, nome);
        }
        catch(IllegalAccessException e){
          System.out.println("Ops: " + e.getMessage());
        }
      }
    }

    // vamos retornar o nome do tipo JDBC
    return (String)mapa.get(new Integer(jdbcType));
  }
}

O resultado da execução deste código foi:

MySQL: BIT - JDBC: BIT
MySQL: BOOL - JDBC: BIT
MySQL: TINYINT - JDBC: TINYINT
MySQL: TINYINT UNSIGNED - JDBC: TINYINT
MySQL: BIGINT - JDBC: BIGINT
MySQL: BIGINT UNSIGNED - JDBC: BIGINT
MySQL: LONG VARBINARY - JDBC: LONGVARBINARY
MySQL: MEDIUMBLOB - JDBC: LONGVARBINARY
MySQL: LONGBLOB - JDBC: LONGVARBINARY
MySQL: BLOB - JDBC: LONGVARBINARY
MySQL: TINYBLOB - JDBC: LONGVARBINARY
MySQL: VARBINARY - JDBC: VARBINARY
MySQL: BINARY - JDBC: BINARY
MySQL: LONG VARCHAR - JDBC: LONGVARCHAR
MySQL: MEDIUMTEXT - JDBC: LONGVARCHAR
MySQL: LONGTEXT - JDBC: LONGVARCHAR
MySQL: TEXT - JDBC: LONGVARCHAR
MySQL: TINYTEXT - JDBC: LONGVARCHAR
MySQL: CHAR - JDBC: CHAR
MySQL: NUMERIC - JDBC: NUMERIC
MySQL: DECIMAL - JDBC: DECIMAL
MySQL: INTEGER - JDBC: INTEGER
MySQL: INTEGER UNSIGNED - JDBC: INTEGER
MySQL: INT - JDBC: INTEGER
MySQL: INT UNSIGNED - JDBC: INTEGER
MySQL: MEDIUMINT - JDBC: INTEGER
MySQL: MEDIUMINT UNSIGNED - JDBC: INTEGER
MySQL: SMALLINT - JDBC: SMALLINT
MySQL: SMALLINT UNSIGNED - JDBC: SMALLINT
MySQL: FLOAT - JDBC: REAL
MySQL: DOUBLE - JDBC: DOUBLE
MySQL: DOUBLE PRECISION - JDBC: DOUBLE
MySQL: REAL - JDBC: DOUBLE
MySQL: VARCHAR - JDBC: VARCHAR
MySQL: ENUM - JDBC: VARCHAR
MySQL: SET - JDBC: VARCHAR
MySQL: DATE - JDBC: DATE
MySQL: TIME - JDBC: TIME
MySQL: DATETIME - JDBC: TIMESTAMP
MySQL: TIMESTAMP - JDBC: TIMESTAMP


Java ::: Pacote java.awt.event ::: KeyEvent

Java Swing - Como detectar as teclas Insert ou Delete usando o método getKeyCode() da classe KeyEvent do Java

Quantidade de visualizações: 2173 vezes
Em algumas situações nós precisamos detectar o pressionamento das teclas Insert ou Delete. Para isso podemos usar o método getKeyCode() da classe KeyEvent e testar se o código equivale a uma das constantes KeyEvent.VK_INSERT (Ins) ou KeyEvent.VK_DELETE (Del).

Veja um trecho de código no qual testamos se alguma destas duas teclas foi pressionada:

package estudos;

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JFrame;
import javax.swing.JOptionPane;

public class Janela extends JFrame implements KeyListener{
  public Janela(){
    super("Eventos do Teclado");
    Container c = getContentPane();
    FlowLayout layout = new FlowLayout(FlowLayout.LEFT);
    c.setLayout(layout);
    
    // vamos adicionar o objeto listener 
    addKeyListener(this);

    setSize(350, 250);
    setVisible(true);
  }
    
  @Override
  public void keyPressed(KeyEvent e){
    // a tecla Insert foi pressionada?
    if(e.getKeyCode() == KeyEvent.VK_INSERT){
      JOptionPane.showMessageDialog(null, "A tecla Insert foi pressionada");
    }
    // a tecla Enter Delete pressionada?
    else if(e.getKeyCode() == KeyEvent.VK_DELETE){
      JOptionPane.showMessageDialog(null, "A tecla Delete foi pressionada");
    }
    else{
      JOptionPane.showMessageDialog(null, "Outra tecla foi pressionada");  
    }
  }
    
  @Override
  public void keyReleased(KeyEvent e){
    // sem implementação
  }

  @Override
  public void keyTyped(KeyEvent e){
    // sem implementação
  }   
  
  public static void main(String args[]){
    Janela j = new Janela();
    j.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

É importante observar que as teclas Insert e Delete podem ser detectadas somente nos eventos keyPressed e keyReleased.


Veja mais Dicas e truques de Java

Dicas e truques de outras linguagens

Quem Somos

Osmar J. Silva
WhatsApp +55 (062) 98553-6711

Goiânia-GO
Full Stack Developer, Professional Java Developer, PHP, C/C++, Python Programmer, wxWidgets Professional C++ Programmer, Freelance Programmer. Formado em Ciência da Computação pela UNIP (Universidade Paulista Campus Goiânia) e cursando Engenharia Elétrica pela PUC-Goiás. Possuo conhecimentos avançados de Java, Python, JavaScript, C, C++, PHP, C#, VB.NET, Delphi, Android, Perl, e várias tecnologias que envolvem o desenvolvimento web, desktop, front-end e back-end. Atuo há mais de 15 anos como programador freelancer, atendendo clientes no Brasil, Portugal, Argentina e vários outros paises.
Entre em contato comigo para, juntos, vermos em que posso contribuir para resolver ou agilizar o desenvolvimento de seus códigos.
José de Angelis
WhatsApp +55 (062) 98243-1195

Goiânia-GO
Formado em Sistemas de Informação pela Faculdade Delta, Pós graduado em Engenharia de Software (PUC MINAS), Pós graduado Marketing Digital (IGTI) com ênfase em Growth Hacking. Mais de 15 anos de experiência em programação Web. Marketing Digital focado em desempenho, desenvolvimento de estratégia competitiva, analise de concorrência, SEO, webvitals, e Adwords, Métricas de retorno. Especialista Google Certificado desde 2011 Possui domínio nas linguagens PHP, C#, JavaScript, MySQL e frameworks Laravel, jQuery, flutter. Atualmente aluno de mestrado em Ciência da Computação (UFG)
Não basta ter um site. É necessário ter um site que é localizado e converte usuários em clientes. Se sua página não faz isso, Fale comigo e vamos fazer uma analise e conseguir resultados mais satisfatórios..

Linguagens Mais Populares

1º lugar: Java
2º lugar: C#
3º lugar: PHP
4º lugar: Delphi
5º lugar: Python
6º lugar: JavaScript
7º lugar: C
8º lugar: C++
9º lugar: VB.NET
10º lugar: JSP (Java Server Pages)



© 2021 Arquivo de Códigos - Todos os direitos reservados | Versión en Español | Versão em Português