hebdomadarium

December 30, 2013

Laço for e suas variações…

Filed under: Java, P.O.O e seus acessórios — Tags: , , , , , , , , , — Pedro Paulo Oliveira @ 2:36 am

O laço for é uma das instruções mais versáteis da linguagem Java, porque sendo o Java um linguagem fortemente tipada, e cheia de protocolos, este laço permite muitas variações… Considere o seguinte:


public class For {

   public static void main(String[] args) {

      int i, j;

      for (i = 0, j = 10; i < j; i++, j--) {

         System.out.println("i e j: " + i + " " + j);

      }

   }

}

Nesta forma de escrever o laço for, a vírgula separa as duas instruções de inicialização e as duas expressões de iteração. Esta pratica limitada até no máximo duas instruções ainda é legível, e mesmo podendo ter qualquer número de instruções de inicialização e iteração, creio que tal prática resulta na ilegibilidade do código.

A condição que controla Laço for pode ser qualquer expressão booleana válida. No código abaixo o laço é repetidamente executado até que o usuário digite a letra P:


import java.io.IOException;

public class For {

   public static void main(String[] args) throws IOException {
   // TODO Auto-generated method stub

      int i;

      System.out.println("Digite P para parar...");
      for (i = 0; (char) System.in.read() != 'P'; i++) {
         System.out.println("Passou #" + i);
      }
   }
}

É permitido no laço for deixar algumas ou todas as partes referentes a inicialização, iteração ou condição em branco…

Com a iteração dentro da instrução do laço for:


import java.io.IOException;

public class For {

   public static void main(String[] args) {

      int i;

      //com a iteração dentro da instrução do for

      for (i = 0; i < 3;) {
         System.out.println("Passou: #" + i);
         i++;
      }
   }
}

Saída:

Passou: #0
Passou: #1
Passou: #2

Retirando agora mais uma parte, a inicialização passará a ocorrer fora do loop:


import java.io.IOException;

public class For {

   public static void main(String[] args) {

      int i = 0;
      for (; i < 3;) {
         System.out.println("Passou: #" + i);
         i++;
      }
   }
}

Saída:

Passou: #0
Passou: #1
Passou: #2

O laço (loop) infinito podemos criar da seguinte maneira:


import java.io.IOException;

public class For {

   public static void main(String[] args) {

      for (;;) {
      }
   }
}

Este laço pode ser interrompido com o uso da palavra reservada abaixo:

break

Podemos ainda criar um laço for com o corpo vazio. Estes laços costumam ser bem úteis… no trecho de código abaixo podemos verificar a soma dos números de 1 a 5:

import java.io.IOException;

public class For {

   public static void main(String[] args) {

      int i;
      int soma = 0;

      for (i = 1; i <= 5; soma += i++);
         System.out.println("Soma: " + soma);
      }
   }
}

Saída:

Soma: 5

Se dividirmos o programa acima em partes, podemos dizer o seguinte: “Adicione a soma o valor de soma mais i e depois incremente i…”

Geralmente a variável que controla um laço for só é necessária para fins do laço não sendo utilizada em nenhum outro lugar. No código abaixo o programa calcula tanto a soma quanto o fatorial dos números de 1 a 5:

public class For {

   public static void main(String[] args) {
   // TODO Auto-generated method stub

      int soma = 0;
      int fatorial = 1;

      for (int i = 1; i <= 5; i++) {
         soma += i;
         fatorial += 1;
      }
     System.out.println("Soma: " + soma);
     System.out.println("Fatorial: " + fatorial);
   }
}

Recentemente foi adicionado ao Java um nova forma de escrever o for, conhecido como “melhorado”. O for melhorado fornece uma maneira mais elegante de percorrer um array por exemplo:

public class ForEach {

   public static void main(String[] args) {
   // TODO Auto-generated method stub

      int numeros[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
      int soma = 0;

      for (int i : numeros) {
         System.out.println("Valores: " + i);
         soma += i;
      }

      System.out.println("Soma: " + soma);
   }
}

Esta forma de for, conhecida como “for-each”, percorre um conjunto de objetos (array), de maneira rigorosamente sequencial, do início ao fim. Originalmente o Java não fornecia esse tipo de laço for, mas a partir da JDK5 o laço foi melhorado para contemplar esta opção.

December 22, 2013

Formatando datas em Java

Em se tratando de datas em Java, todos que um dia precisaram manipulá-las, enfrentaram algum tipo de problema para formatá-las contemplando de maneira adequada o escopo da aplicação. Atualmente a classe Date está anotada como Deprecated, ou seja, a Oracle não fornece mais atualizações e/ou manutenções. Se fossemos instanciar um Date e imprimir no console teríamos que escrever um código parecido com este:

import java.util.Date;

public class Main {

   public static void main(String[] args) {
   // TODO Auto-generated method stub

   Date date = new Date(1982, 5, 02);
   System.out.println(date);

   }

}

E no console, teríamos a seguinte  saída:


Fri Jun 02 00:00:00 BRT 3882

Note que o ano impresso é o de 3882… mas a data que foi definida no construtor da classe Date é a de 02/06/1982… algo não saiu como o esperado! Para formatar a data como desejado, existe uma classe muito útil em java que é a SimpleDateFormat e que ao instanciarmos a referida classe e chamarmos o método format, passando como parâmetro a data do tipo Date, teremos uma data formatada nos padrões que estamos acostumados…

import java.text.SimpleDateFormat;
import java.util.Date;

public class Main {

 public static void main(String[] args) {
 // TODO Auto-generated method stub

  Date date = new Date(82, 5, 02);
  SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
  System.out.println(sdf.format(date));

 }

}

Definimos o padrão brasileiro de datas, que poder ser visto na String (“dd/MM/yyyy”). Ainda se olharmos na documentação da Classe Date o ano deverá ser subtraído de 1900, ou seja, o construtor da classe Date receberá o ano – 1900 = (82, 5, 02) e o mês sempre iniciará no 0 (0 = janeiro…).

Assim a saída ficou bem mais “amigável”, e agora a data está formatada corretamente conforme o esperado:

02/06/1982

Mas o que mais podemos fazer com Datas em Java???

Uma vez que a Classe Date está deprecada, podemos trabalhar com a Classe abstrata Calendar do java.util.

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;

public class Main {

 public static void main(String[] args) {
 // TODO Auto-generated method stub

  Calendar date = new GregorianCalendar(1982, 5, 02);

  SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
  System.out.println(sdf.format(date.getTime()));

 }

}

Saída


02/06/1982

Podemos verificar que nada foi mudado, apenas utilizamos a classe abstrata Calendar ao invés da Classe Date, instanciamos a Classe GregorianCalendar e no parâmetro do método format, passamos o objeto date invocando o getTime().

Avançando… suponha agora que em dado momento você queira imprimir uma data de um determinado País, como por exemplo a dos Estados Unidos… eu poderia mudar o parâmetro da Classe SimpleDateFormat para o padrão americano (“MM-dd-yyyy”), só que imagine a quantidade de ifs que eu teria que colocar no meu código?!?!… “if(Brasil…) faça tal coisa, if(EUA…) faça outra coisa…”, pois para cada país eu teria que fazer um verificação e imprimir a data desejada.

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;

public class Main {

 public static void main(String[] args) {
 // TODO Auto-generated method stub

  Calendar date = new GregorianCalendar(1982, 5, 02);

  if(EUA...) { faça alguma coisa...} if(Brasil...) {faça outra coisa...}
  SimpleDateFormat sdf = new SimpleDateFormat("MM-dd-yyyy");
  System.out.println(sdf.format(date.getTime()));

 }

}

//saída no padrão americano

06-02-1982

Para simplificar esta tarefa existe uma outra Classe chamada DateFormat que facilita bastante a maneira de formatar a data de um determinado País.

import java.text.DateFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Locale;

public class Main {

 public static void main(String[] args) {
 // TODO Auto-generated method stub

  Calendar date = new GregorianCalendar(1982, 5, 02);

  Locale ingles = new Locale("en");
  DateFormat formatador = DateFormat.getDateInstance(DateFormat.SHORT, ingles);
  System.out.println(formatador.format(date.getTime()));

 }

}

Veja que instanciamos um objeto (ingles) do tipo Locale, definindo o padrão americano new Locale (“en”) e foi passado para o DateFormat como parâmetro, passando também o tamanho da data = SHORT (poderia ser MEDIUM ou LONG).

Veja a saída:

6/2/82

Caso queira uma data por extenso, basta mudar o tamanho para LONG


import java.text.DateFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Locale;

public class Main {

 public static void main(String[] args) {
 // TODO Auto-generated method stub

  Calendar date = new GregorianCalendar(1982, 5, 02);

  Locale ingles = new Locale("en");
  DateFormat formatador = DateFormat.getDateInstance(DateFormat.LONG, ingles);
  System.out.println(formatador.format(date.getTime()));

 }

}

Saída:

June 2, 1982

e no padrão português brasileiro, basta alterar o Locale para new Locale (“pt”, “br”)…

import java.text.DateFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Locale;

public class Main {

 public static void main(String[] args) {
 // TODO Auto-generated method stub

  Calendar date = new GregorianCalendar(1982, 5, 02);

  Locale portuguesBrasileiro = new Locale("pt", "br");
  DateFormat formatador = DateFormat.getDateInstance(DateFormat.LONG, portuguesBrasileiro);
  System.out.println(formatador.format(date.getTime()));

 }

}

e a saída:


2 de Junho de 1982

Sabemos que em Java comumente precisamos converter uma String para Date para ser gravada em um sistema (Banco de Dados). Com isso, para ler uma String e transformá-la em Date basta chamar o método parse do formatador (DateFormat) Ex.: formatador.parse(“??/??/????”)

import java.text.DateFormat;
import java.text.ParseException;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

public class Main {

 public static void main(String[] args) throws ParseException {
 // TODO Auto-generated method stub

  Calendar date = new GregorianCalendar(1982, 5, 02);

  DateFormat formatador = DateFormat.getDateInstance();
  System.out.println(formatador.format(date.getTime()));

  Date dataParsesada = formatador.parse("01/12/2013");
  System.out.println(dataParseada);

}

}

Saída:


02/06/1982
Sun Dec 01 00:00:00 BRST 2013

E se for o inverso… dado um Date me retorne uma String, basta invocar o método format:

import java.text.DateFormat;
import java.text.ParseException;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

public class Main {

 public static void main(String[] args) throws ParseException {
 // TODO Auto-generated method stub

  Calendar date = new GregorianCalendar(1982, 5, 02);

  DateFormat formatador = DateFormat.getDateInstance();
  System.out.println(formatador.format(date.getTime()));

  Date dataParseada = formatador.parse("01/12/2013");
  //abaixo será impresso a data formatada em String
  System.out.println(formatador.format(dataParseada));

 }

}

Saída:

02/06/1982
01/12/2013

November 24, 2013

DAO Genérica com JPA

Filed under: Java, P.O.O e seus acessórios — Tags: , , , , , , — Pedro Paulo Oliveira @ 3:28 pm

Uma tarefa um tanto quanto trabalhosa em Java é implementar o pattern DAO, se utilizando de  JDBC. Por exemplo, suponha que você queira trazer uma lista de objetos do Banco de Dados, para que isso aconteça você precisaria criar um classe de conexão com o Banco de Dados, e logo após, você precisaria ainda escrever um quantidade considerável de códigos para criar a Classe e o método que seria responsável por listar tais objetos.

Assim sendo, considere o cenário abaixo:

Criamos a Classe ContatoTO, é ela que queremos listar no banco de dados (obs.: ela estende UsuarioTO, pois um contato também é um usuário da Aplicação):

import java.io.Serializable;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.FetchType;
import javax.persistence.ManyToOne;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

import com.fis.enumeration.Tipo;

@Entity
@Table(name = "TB_CONTATO")
@SequenceGenerator(name = "seqContato", sequenceName = "SEQ_CONTATO", allocationSize = 1)
public class ContatoTO extends UsuarioTO implements Serializable {

private static final long serialVersionUID = 1L;

@Column(name = "nm_contato")
private String nome;

@Column(name = "email")
private String email;

@Column(name = "telefone")
private String telefone;

@Enumerated(EnumType.STRING)
@Column(name = "tipo")
private Tipo tipo;

@Column(name = "observacao")
private String observacao;

@ManyToOne(targetEntity = RedeSocialTO.class, cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private RedeSocialTO redeSocialTO;

//getters e setters ocultados

Abaixo um exemplo de Classe para conexão com o banco de dados MySql

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class MysqlConnectionFactory {

 public Connection getConnection() throws SQLException {

 try {
  Class.forName("com.mysql.jdbc.Driver");
 } catch (Exception e) {
  e.printStackTrace();
  throw new RuntimeException("Ocorreu um erro ao registrar o Driver!", e);
}
 try {
  return DriverManager.getConnection("jdbc:mysql://localhost/cont o_bd", "root","senha");
 } catch (SQLException e) {
  e.printStackTrace();
  throw new RuntimeException(
  "Ocorreu um erro ao conectar com Banco de Dados Mysql", e);
 }
}

}

E finalmente a Classe e o método que será responsável por listar todos os contatos no banco de dados MySql

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class MysqlContatoDAO implements ContatoDAO {

  private Connection conexao;

  public MysqlContatoDAO() throws SQLException {
   this.conexao = new MysqlConnectionFactory().getConnection();
  }

  private static final String LISTAR_CONTATO = "SELECT * FROM tb_contato ORDER BY nome";

  @Override
  public List<Contato> listar() throws SQLException {

   String sql = LISTAR_CONTATO;

   try {
   PreparedStatement stmt = conexao.prepareStatement(sql);
   ResultSet rs = stmt.executeQuery();
   List list = new ArrayList();

   while (rs.next()) {

    Contato contato = new Contato();
    contato.setId(rs.getLong("id_contato"));
    contato.setNome(rs.getString("nome"));
    contato.setTelefone(rs.getString("celular"));
    contato.setEmail(rs.getString("email"));
    contato.setObservacao(rs.getString("observacao"));

    list.add(contato);

   }

  rs.close();
  stmt.close();

  return list;

  } catch (SQLException e) {
   e.printStackTrace();
   throw new RuntimeException("Erro ao listar Contatos!", e);

  } finally {
   if (conexao != null) {
   conexao.close();
  } else
   conexao = null;
 }

}

Imaginemos que para cada classe de negócio da aplicação, precisássemos escrever todos esses códigos, sem dúvida a chance de errarmos na hora de criar tais classes é um tanto quanto grande… e mais, quanto tempo levaria para criá-las?. Para solucionar este problema, foi desenvolvido o conceito de DAO Genérica, que funciona como uma espécie de modelo, para que todas as classes que estenda e implemente a Classe Abstrata e a Interface genérica, respectivamente, com extrema facilidade herdaria os métodos básicos, como adicionar, listar, atualizar e remover objetos da base. Para tal, o 1º passo é criar uma Classe que fará a conexão com o banco de dados

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class JPAUtil {

  private static EntityManagerFactory emf = Persistence
   .createEntityManagerFactory("CONTATOS");

  public static EntityManager getEntityManager() {
   return emf.createEntityManager();
  }
}

//o atributo CONTATOS, deverá copiado e colado no persitence.xml

//<persistence-unit name="CONTATOS" transaction-type="RESOURCE_LOCAL">

Depois criaremos uma Interface IDAO, que será responsável por fazer com que as classes que a implementem possuam os métodos básicos de interação com o banco de dados:


public interface IDAO<T, K> {

 void adiciona(T entity);

 T lista();

 void atualiza(T entity);

 void remove(T entity);

}

Feito isso, devemos criar um Classe Abstrata, a qual deverá implementar a Interface criada anteriormente (IDAO), ficando desta forma, a obrigatoriedade de sobrescrever todos os seus métodos.


import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaQuery;

import com.fis.interfaces.IDAO;
import com.fis.util.JPAUtil;

public abstract class DAO<T, K> implements IDAO<T, K> {

  private final Class classe;
  protected EntityManager em;

  public DAO(Class classe) {
   this.classe = classe;
  }

  public void adiciona(T entity) {
   em = JPAUtil.getEntityManager();
   em.getTransaction().begin();
   em.persist(entity);
   em.getTransaction().commit();
   em.close();
  }

  @SuppressWarnings("unchecked")
  public T lista() {
   em = JPAUtil.getEntityManager();
   CriteriaQuery query = em.getCriteriaBuilder().createQuery(classe);
   query.select(query.from(classe));
   return (T) em.createQuery(
   "SELECT o FROM " + classe.getSimpleName() + " o")
   .getResultList();
  }

  public void atualiza(T entity) {
   em = JPAUtil.getEntityManager();
   em.getTransaction().begin();
   em.merge(entity);
   em.getTransaction().commit();
   em.close();
  }

  public void remove(T entity) {
   em = JPAUtil.getEntityManager();
   em.getTransaction().begin();
   em.remove(em.merge(entity));
   em.getTransaction().commit();
   em.close();
  }

}

Por fim devemos criar as classes de nossa aplicação a qual será a responsável por interagir com o banco de dados

Interface IContato, que terá só as assinaturas dos metódos de responsabilidade de ContatoTO


public interface IContato {

 public Long somaQuantidadeDeContatos();

//demais assinaturas de métodos de responsabilidade de ContatoTO

}

E a classe DAO responsável por Interagir com o MySql, listando todos os contatos. O método listar() é acessível pois a Classe MySqlContatoDAO é filha da Classe Abstrata DAO, portanto toda vez que ele for instanciada esse método poderá ser chamado.


import javax.persistence.EntityManager;
import javax.persistence.Query;
import javax.persistence.TypedQuery;

public class MySqlContatoDAO extends DAO<contatoto, long=""> implements IContato {

  public MySqlContatoDAO(Class classe) {
   super(classe);
   // TODO Auto-generated constructor stub
  }

  @Override
  public Long somaQuantidadeDeContatos() {
   // TODO Auto-generated method stub
   EntityManager em = JPAUtil.getEntityManager();
   Query query = em.createQuery("SELECT COUNT(id) FROM ContatoTO",
   Long.class);
   return (Long) query.getSingleResult();
  }

Agora, qualquer Classe futura da aplicação, pode facilmente ter seu DAO criado, fazendo apenas com que esta nova Classe, estenda DAO<t, k=””> e implemente IClasseQualquer.

October 7, 2012

Certificações Java Oracle

Filed under: Java, P.O.O e seus acessórios — Tags: , , , , , , — Pedro Paulo Oliveira @ 3:45 am

Desde o início de minha investida no desenvolvimento Java, sabia o quão se fazia importante ser um profissional certificado. Sabia também que o que valia era ter um certificado emitido pela empresa criadora e responsável por administrar a linguagem Java, no caso a Sun, empresa que recentemente foi comprada por alguns bilhões de dólares pela gigante Oracle. A pergunta que eu me fazia era, qual certificação deveria obter, são inúmeras, mas cada uma representa uma área (desktop, web, dispositivos móveis), ou um nível de conhecimento da linguagem. Ter certificações, todo nós sabemos, que é um excelente diferencial na hora de concorrer a uma vaga de emprego, ou mesmo para efeito de promoção e ou até uma melhor remuneração. Pesquisei em vários blogs e sites na internet e nunca achei um que explicasse de fato qual o caminho a ser traçado para obter as certificações uma a uma; desde a de iniciante, até a de avançado. Por esse motivo resolvi publicar aqui no Blog alguns tópicos de uma famosa revista da área de tecnologia, o qual esclarece bem como fazer para conquistar sua certificação, seus entraves, e algumas novidades:

Java SE (Java Platform Standard Edition)

Aplicações para ambiente corporativo:

  • Oracle Certified Associate – Java SE 5/SE6
  • Oracle Certified Associate – Java SE 7 Programmer
  • Oracle Certified Master – Java SE 6 Developer
  • Oracle Certified Professional – Java SE 7 Programmer
  • Oracle Certified Professional – Java SE 5 Programmer
  • Oracle Certified Professional – Java SE 6 Programmer

Nesta plataforma a primeira certificação é conhecida como Associate, ou OCA – Oracle Certified Associate. Esta categoria é obrigatória para os profissionais que desejam avançar para os demais níveis.

Java EE (Java Platform Enterprise Edition)

Aplicações para desenvolvimento WEB e aplicações corporativas

  • Oracle Certified Expert Java EE 6 Enterprise JavaBeans Developer
  • Oracle Certified Expert Java EE 6 Java Persistence API Developer
  • Oracle Certified Expert Java EE 6 Web services Developer
  • Oracle Certified Expert Java Platform EE 6 Web Component Developer
  • Oracle Certified Master Java EE 5 Enterprise Architect
  • Oracle Certified Professional Java EE 5 Business Component Developer
  • Oracle Certified Professional Java EE 5 Web Component Developer
  • Oracle Certified Professional Java EE 5 Web Services Developer

Essas certificações não são novidades para ninguém, o que tem de novo é que para conquistar a Certificação Master, a Oracle modificou um pouco e hoje é obrigatório fazer um curso, ministrado pela própria Oracle

Java ME (Java Platform Micro Edition)

Aplicações destinadas a dispositivos móveis, PDAs, celulares dentre outros

  • Oracle Certified Professional Java ME 1 Mobile Application Developer

Atualmente para fazer a prova para obter essas duas certificações (abaixo), a Oracle exigi que se faça um curso, ministrado por ela própria, o curso pode ser presencial ou online:

  • Oracle Certified Master, Java SE 6
  • Oracle Certified Expert, Java EE 5 Enterprise Architect

Essas são as certificações disponibilizadas pela Oracle, agora basta escolher a área desejada, estudar um pouquinho, e se preparar para o Exame – Boa sorte!

mais informações acesse: http://www.oracle.com/br/index.html

Imagem

The Shocking Blue Green Theme. Create a free website or blog at WordPress.com.

Follow

Get every new post delivered to your Inbox.