Java com café

ProgressBar dentro de uma ActionBar - Android

2013-03-21T15:21:00.001-03:00

Olá! Hoje vou mostrar como adicionar uma progressbar dentro de uma actionbar. Um bom exemplo de implementação deste recurso é o aplicativo do Gmail, onde você tem um item de menu (usado para atualizar seus e-mails) que quando clicado, é substituído pela progressbar até o procedimento ser concluído e então volta novamente a ser o item.

Para utilizar este recurso, a versão mínima requerida do sdk é a 11. Você também vai precisar dos ícones, que podem variar de acordo com o tema (baixe o pacote neste link). Para o exemplo estarei utilizando estes que são adequados para o tema Holo Light:

res/drawable-mdpi

res/drawable-hdpi

res/drawable-xhdpi

Para começar salve os ícones nas respectivas pastas de acordo com as legendas nas imagens. Agora vamos precisar de dois arquivos xml, um para o item de menu e outro para a progressbar. Para o item, dentro da pasta res/menu, crie um arquivo chamado atualizar.xml com o seguinte conteúdo:

<menu xmlns:android="http://schemas.android.com/apk/res/android" >
    <item
        android:id="@+id/action_atualizar"
        android:icon="@drawable/ic_menu_refresh"
        android:showAsAction="always"
        android:title="Atualizar"/>
</menu>

E na pasta res/layout o arquivo actionbar_atualizar.xml:

<?xml version="1.0" encoding="utf-8"?>
<ProgressBar xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="wrap_content"
    android:layout_height="30dp"
    android:layout_gravity="right"
    android:paddingRight="5dp" />

Para controlar quando vai aparecer o item ou a progressbar, a estrutura da classe deverá ser parecida com a que segue (odeio colar trechos muito grandes de código no site, mas paciência que vou explicar tudo lá embaixo):

import android.app.Activity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.Toast;

public class MainActivity extends Activity {

 private boolean atualizando = false;
 private Menu mOptionsMenu;

 @Override
 protected void onCreate(Bundle savedInstanceState) {

  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);
  getActionBar().setDisplayHomeAsUpEnabled(true);

 }

 @Override
 public void onBackPressed() {

  if (atualizando == true) {
   Toast.makeText(this, "Aguarde...", Toast.LENGTH_LONG).show();
  } else {
   super.onBackPressed();
  }

 }

 private void atualizar() {

  atualizando = true;
  setAtualizando(atualizando);

  new Operacao().execute();

 }

 @Override
 public boolean onOptionsItemSelected(MenuItem item) {

  switch (item.getItemId()) {

  case android.R.id.home:
   onBackPressed();
   break;

  case R.id.action_atualizar:
   atualizar();
   break;

  }

  return true;

 }

 @Override
 public boolean onCreateOptionsMenu(Menu menu) {

  super.onCreateOptionsMenu(menu);
  mOptionsMenu = menu;
  getMenuInflater().inflate(R.menu.atualizar, menu);
  // atualizar();
  return true;

 }

 public void setAtualizando(boolean atualizando) {

  if (mOptionsMenu == null) {
   return;
  }

  MenuItem atualizarItem = mOptionsMenu.findItem(R.id.action_atualizar);

  if (atualizarItem != null) {

   if (atualizando) {
    atualizarItem.setActionView(R.layout.actionbar_atualizar);
   } else {
    atualizarItem.setActionView(null);
   }

  }

 }

 class Operacao extends AsyncTask<Void, Void, Void> {

  Exception exception = null;

  @Override
  protected Void doInBackground(Void... params) {

   try {

    // Neste bloco vocẽ executa suas operações
    Thread.sleep(2000);

   } catch (Exception e) {
    exception = e;
   }

   return null;

  }

  @Override
  protected void onPostExecute(Void result) {
   super.onPostExecute(result);

   if (exception == null) {
    atualizando = false;
    setAtualizando(atualizando);
   } else {
    Toast.makeText(MainActivity.this,
      "Ocorreu um erro: " + exception.getMessage(),
      Toast.LENGTH_LONG).show();
   }

  }

 }

}

Bom, no começo temos duas variáveis: atualizando e mOptionsMenu. A primeira é simplesmente para identificar se a atualização está ocorrendo ou não em determinado momento. A segunda receberá o menu assim que ele for criado e permitirá a troca entre o item e a progressbar quando necessário.

Em seguida temos os seguintes métodos:

onCreate: Não tem nada de especial além do comando getActionBar().setDisplayHomeAsUpEnabled(true), que adiciona o item "voltar" na actionbar.

onBackPressed: É tratado se a atualização está ocorrendo e não permitirá voltar se for verdade.

atualizar: Configura a barra com o setAtualizando e executa a tarefa que executará as operações de atualização. Falo sobre a classe que executa a tarefa logo abaixo.

onOptionsItemSelected: Verifica qual item do menu foi clicado e executa a ação correspondente.

onCreateOptionsMenu: A variável recebe o menu e caso queira que a Activity já inicie atualizando, basta descomentar o comando atualizar().

setAtualizando: É o responsável por mostrar o item ou a progressbar na actionbar.

Por fim temos a classe interna Operacao, uma subclasse de AsyncTask que nos permite executar tarefas em background e atualizar a interface sem precisar de threads. Não vou entrar em detalhes sobre este tipo de classe, apenas saiba que o método doInBackground é usado para executar as operações (no exemplo chamei Thread.sleep(2000) apenas pra simular um procedimento rápido) e onPostExecute é executado quando doInBackground finalizar. E temos a variável exception que é usada pelos métodos para descobrir se a operação finalizou com sucesso.

Qualquer dúvida deixe nos comentários!

Android + ksoap2: Recebendo um Array de Objetos

2013-01-18T13:23:00.000-02:00

Neste tutorial pretendo mostrar de forma simples como criar um Web Service em Java utilizando o NetBeans e uma aplicação cliente para consumir o serviço no Android. O Web Service vai implementar uma operação que deverá retornar um array de objetos. Na aplicação Android esse array será recebido e utilizado para preencher uma lista de itens (ListView).

Ferramentas utilizadas:

NetBeans 7.1 + Tomcat 7 (servidor)
Eclipse + ADT - Android Developer Tools v21.0.1-543035 (cliente)

Criando o Web Service

Não vou entrar em detalhes sobre a criação da aplicação no NetBeans porque já existe um bom tutorial disponível aqui. Após criar o projeto, crie também uma classe para o objeto que será retornado. Para fins de exemplo vou utilizar a seguinte classe:

public class Fornecedor {

    int codigo;
    String razaoSocial;
    String cpfCnpj;

    public Fornecedor() {
    }

    public Fornecedor(int codigo, String razaoSocial, String cpfCnpj) {
        this.codigo = codigo;
        this.razaoSocial = razaoSocial;
        this.cpfCnpj = cpfCnpj;
    }

    public int getCodigo() {
        return codigo;
    }

    public void setCodigo(int codigo) {
        this.codigo = codigo;
    }

    public String getCpfCnpj() {
        return cpfCnpj;
    }

    public void setCpfCnpj(String cpfCnpj) {
        this.cpfCnpj = cpfCnpj;
    }

    public String getRazaoSocial() {
        return razaoSocial;
    }

    public void setRazaoSocial(String razaoSocial) {
        this.razaoSocial = razaoSocial;
    }

    @Override
    public String toString() {
        return getCodigo() + ". " + getRazaoSocial();
    }
}

É importante que sua classe tenha um construtor padrão, sem argumentos. Pode parecer inútil mas o Tomcat não vai implantar o projeto sem ele. O método toString deverá ser sobrescrito na classe, mas isto será útil apenas na aplicação cliente ao preencher a lista, pois será utilizada a mesma classe.

Seguindo o tutorial que foi sugerido, você deve criar uma operação que não receberá parâmetros e que a saída será do tipo List<Fornecedor>. Para o exemplo vou chamar esta operação de getFornecedores. O código deverá ser parecido com este:

@WebService(serviceName = "GetFornecedores")
public class GetFornecedores {

    @WebMethod(operationName = "getFornecedores")
    public List<Fornecedor> getFornecedores() {

        List<Fornecedor> listFornecedores = new ArrayList<Fornecedor>();

        listFornecedores.add(new Fornecedor(1, "Fornecedor 1", "0123456789"));
        listFornecedores.add(new Fornecedor(2, "Fornecedor 2", "0123456789"));
        listFornecedores.add(new Fornecedor(3, "Fornecedor 3", "0123456789"));

        return listFornecedores;

    }
    
}

Após implantar e executar o projeto, o arquivo wsdl pode ser acessado através do browser, de acordo com suas configurações:

http://localhost:8080/TestWSApp/GetFornecedores?wsdl

Com o projeto rodando vamos para a segunda parte.

Criando o cliente Android

Crie um projeto no Eclipse com uma Activity principal e adicione a lib ksoap2 no Build Path. Copie a classe Fornecedor citada anteriormente e cole no pacote do projeto. Então crie uma classe chamada ConexaoWS com o seguinte código:

import org.ksoap2.SoapEnvelope;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;

public class ConexaoWS {

 private static final String NAMESPACE = "http://testws.me.org/";
 private static final String METHOD_NAME = "getFornecedores";
 private static final String SOAP_ACTION = "http://testws.me.org/getFornecedores";
 private static final String URL = "http://10.1.0.116:8080/TestWSApp/GetFornecedores?wsdl";

 public Fornecedor[] getFornecedores() throws Exception {

  SoapObject request = new SoapObject(NAMESPACE, METHOD_NAME);

  SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
  envelope.dotNet = true;
  envelope.setOutputSoapObject(request);

  HttpTransportSE ht = new HttpTransportSE(URL);
  ht.call(SOAP_ACTION, envelope);

  SoapObject response = (SoapObject) envelope.bodyIn;

  Fornecedor[] fornecedores = new Fornecedor[response.getPropertyCount()];

  for (int c = 0; c < fornecedores.length; c++) {

   SoapObject soapObject = (SoapObject) response.getProperty(c);

   Fornecedor f = new Fornecedor();
   f.codigo = Integer.parseInt(soapObject.getProperty(0).toString());
   f.cpfCnpj = soapObject.getProperty(1).toString();   
   f.razaoSocial = soapObject.getProperty(2).toString();
   fornecedores[c] = f;

  }

  return fornecedores;

 }

}

As principais alterações a serem feitas são nas constantes:

NAMESPACE: Pode ser encontrado no arquivo wsdl, mas normalmente é "http://" + pacote + "/"
METHOD_NAME: Mesmo nome dado a operação
SOAP_ACTION: NAMESPACE + METHOD_NAME
URL: Endereço do arquivo wsdl (nos meus testes a conexão foi recusada quando utilizei localhost ou 127.0.0.1, portanto use o IP real da sua máquina)

Com isto fica faltando o layout da aplicação e a chamada do método. Para o layout utilize a seguinte definição:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity" >

    <ListView
        android:id="@android:id/list"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:layout_alignParentTop="true" >

    </ListView>

</RelativeLayout>

E para a classe principal utilize o seguinte código:

public class MainActivity extends ListActivity {

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);

  // Operações de rede não podem ser realizadas na thread principal
  new MyAsyncTask().execute();

 }

 @Override
 public boolean onCreateOptionsMenu(Menu menu) {
  getMenuInflater().inflate(R.menu.activity_main, menu);
  return true;
 }

 private class MyAsyncTask extends AsyncTask<Void, Void, Fornecedor[]> {

  boolean erro = false;

  private final ProgressDialog dialog = new ProgressDialog(
    MainActivity.this);

  @Override
  protected void onProgressUpdate(Void... values) {

   this.dialog.setMessage("Aguarde...");
   this.dialog.show();

  }

  @Override
  protected Fornecedor[] doInBackground(Void... params) {

   Fornecedor[] retorno = null;

   try {

    ConexaoWS conexao = new ConexaoWS();
    retorno = conexao.getFornecedores();

   } catch (Exception e) {
    erro = true;
    e.printStackTrace();
   }

   return retorno;

  }

  @Override
  protected void onPostExecute(Fornecedor[] result) {

   if (this.dialog.isShowing()) {
    this.dialog.dismiss();
   }

   if (erro == false) {

    List<Fornecedor> listaFornecedores = Arrays.asList(result);
    ArrayAdapter<Fornecedor> adapter = new ArrayAdapter<Fornecedor>(
      MainActivity.this, android.R.layout.simple_list_item_1,
      listaFornecedores);
    setListAdapter(adapter);

   } else {
    
    Toast.makeText(MainActivity.this,
      "Ocorreu um erro ao acessar o Web Service.",
      Toast.LENGTH_LONG).show();
    
   }

  }

 }

}

Se você é leigo em programação para Android, recomendo que procure entender como funcionam as classes ListActivity e AsyncTask para melhor compreensão do exemplo. O resultado da aplicação será este:

Espero que tenham gostado. Qualquer dúvida deixe nos comentários.

Os sistemas legados

2012-09-19T17:32:00.002-03:00

É muito comum hoje em dia o profissional da área de sistemas passar anos na faculdade estudando linguagens modernas e quando entra no mercado de trabalho se vê diante de tecnologias totalmente obsoletas. Muitas empresas ainda mantém sistemas antigos rodando e pode ser difícil encontrar um lugar para trabalhar com tecnologias novas.

É notável a velocidade em que as coisas caminham no mundo da informática. Uma das "leis" na programação de computadores diz que Qualquer dado programa, quando rodando, é obsoleto. Mas mesmo com todas atualizações, novas versões com mais recursos e facilidades, as empresas ainda mantém seus antigos sistemas rodando por vários anos.

Por que as empresas mantém sistemas legados?

Muitas empresas acreditam que não devem trocar o sistema simplesmente porque ele está funcionando, mas na verdade é importante avaliar as desvantagens de mantê-lo como por exemplo a dificuldade na integração. Desvantagem esta que foi observada após a obrigatoriedade de emitir nota fiscal eletrônica, visto que muitos sistemas não possuem recursos para comunicação via web. Ainda nesse aspecto, com o avanço no desenvolvimento de dispositivos móveis e a alta disponibilidade de serviços de internet, esses sistemas não estão preparados para aproveitar tais recursos. Mesmo que apresentem soluções para contornar estes problemas, o resultado final não é dos mais elegantes.

Outro motivo pelo qual as empresas optam por não trocam o sistema é o alto custo despendido com o desenvolvimento de um novo sistema. Sim, existem soluções prontas a todos custos mas é preciso que a empresa veja isso como um investimento e entenda a importância de ter um sistema que realmente atenda suas necessidades.

Compensa trabalhar com uma tecnologia obsoleta?

O importante é ter conhecimento e não ficar fora do mercado, independente da tecnologia. As empresas tem dificuldade de encontrar profissionais para trabalhar com determinados sistemas e geralmente são vagas com uma boa remuneração.
É necessário se manter atualizado pois muitos sistemas estão sendo construídos e outros sendo migrados, mas acredito que é preciso saber aproveitar as oportunidades e fazer o que tem que ser feito.

Cantada Nerd

2012-09-04T08:38:00.001-03:00

Window Function - PostgreSQL

2012-09-02T12:31:00.000-03:00

Window function é um recurso muito útil porque nos permite realizar cálculos que antes só poderiam ser feitos com functions ou subquerys, assim podemos escrever menos código e evitar joins. Uma window function consegue particionar as linhas de uma consulta e fazer cálculos dentro destas partições. É como fazemos com funções agregadas, porém sem agrupar e mantendo as linhas separadas. Pra começar, disponibilizo as sentenças para criar e popular uma tabela com dados que vão servir de exemplo:

CREATE TABLE formula1
(
  posicao integer NOT NULL,
  piloto character varying(100),
  equipe character varying(100),
  pontos integer,
  CONSTRAINT pk_formula1 PRIMARY KEY (posicao)
);

INSERT INTO formula1 VALUES (1, 'FERNANDO ALONSO', 'FERRARI', 164);
INSERT INTO formula1 VALUES (2, 'MARK WEBBER', 'RED BULL', 124);
INSERT INTO formula1 VALUES (3, 'SEBASTIAN VETTEL', 'RED BULL', 122);
INSERT INTO formula1 VALUES (4, 'LEWIS HAMILTON', 'MCLAREN', 117);
INSERT INTO formula1 VALUES (5, 'KIMI RAIKKONEN', 'LOTUS', 116);
INSERT INTO formula1 VALUES (6, 'NICO ROSBERG', 'MERCEDES BENZ', 77);
INSERT INTO formula1 VALUES (7, 'JENSON BUTTON', 'MCLAREN', 76);
INSERT INTO formula1 VALUES (8, 'ROMAIN GROSJEAN', 'LOTUS', 76);
INSERT INTO formula1 VALUES (9, 'SERGIO PEREZ', 'SAUBER', 47);
INSERT INTO formula1 VALUES (10, 'KAMUI KOBAYASHI', 'SAUBER', 33);

Fazendo um simples select temos o seguinte resultado:

 posicao |      piloto      |    equipe     | pontos 
---------+------------------+---------------+--------
       1 | FERNANDO ALONSO  | FERRARI       |    164
       2 | MARK WEBBER      | RED BULL      |    124
       3 | SEBASTIAN VETTEL | RED BULL      |    122
       4 | LEWIS HAMILTON   | MCLAREN       |    117
       5 | KIMI RAIKKONEN   | LOTUS         |    116
       6 | NICO ROSBERG     | MERCEDES BENZ |     77
       7 | JENSON BUTTON    | MCLAREN       |     76
       8 | ROMAIN GROSJEAN  | LOTUS         |     76
       9 | SERGIO PEREZ     | SAUBER        |     47
      10 | KAMUI KOBAYASHI  | SAUBER        |     33

Analisando os dados, imagine uma forma de inserir mais uma coluna que mostrará a soma de pontos por equipes. Poderia usar uma subquery:

SELECT *, 
 (SELECT SUM(pontos) FROM formula1 aux
 WHERE formula1.equipe = aux.equipe
 GROUP BY equipe) AS pontos_equipe
FROM formula1
ORDER BY posicao

Poderia usar uma function também, mas fica melhor com uma window function:

SELECT *, SUM(pontos) OVER (PARTITION BY equipe) AS pontos_equipe 
FROM formula1
ORDER BY posicao

 posicao |      piloto      |    equipe     | pontos | pontos_equipe 
---------+------------------+---------------+--------+---------------
       1 | FERNANDO ALONSO  | FERRARI       |    164 |           164
       2 | MARK WEBBER      | RED BULL      |    124 |           246
       3 | SEBASTIAN VETTEL | RED BULL      |    122 |           246
       4 | LEWIS HAMILTON   | MCLAREN       |    117 |           193
       5 | KIMI RAIKKONEN   | LOTUS         |    116 |           192
       6 | NICO ROSBERG     | MERCEDES BENZ |     77 |            77
       7 | JENSON BUTTON    | MCLAREN       |     76 |           193
       8 | ROMAIN GROSJEAN  | LOTUS         |     76 |           192
       9 | SERGIO PEREZ     | SAUBER        |     47 |            80
      10 | KAMUI KOBAYASHI  | SAUBER        |     33 |            80

A chamada da função deve vir acompanhada da cláusula OVER. É isto que determina quais linhas estarão disponíveis para o processamento da função. A outra instrução, PARTITION BY, divide as linhas em grupos para que a função seja aplicada sobre elas. Também podemos definir a ordem que as linhas serão processadas pela função usando ORDER BY. A window function processa as linhas independente da ordem em que estão sendo exibidas, portanto deve-se ter cuidado para que os dados sejam processados na ordem desejada. Suponhamos que queremos saber quem é o piloto número 1 e 2 de cada equipe, sendo o número 1 com a maior quantidade de pontos:

SELECT *, row_number() OVER (PARTITION BY equipe ORDER BY posicao) AS numero_piloto
FROM formula1
ORDER BY posicao

 posicao |      piloto      |    equipe     | pontos | numero_piloto 
---------+------------------+---------------+--------+---------------
       1 | FERNANDO ALONSO  | FERRARI       |    164 |             1
       2 | MARK WEBBER      | RED BULL      |    124 |             1
       3 | SEBASTIAN VETTEL | RED BULL      |    122 |             2
       4 | LEWIS HAMILTON   | MCLAREN       |    117 |             1
       5 | KIMI RAIKKONEN   | LOTUS         |    116 |             1
       6 | NICO ROSBERG     | MERCEDES BENZ |     77 |             1
       7 | JENSON BUTTON    | MCLAREN       |     76 |             2
       8 | ROMAIN GROSJEAN  | LOTUS         |     76 |             2
       9 | SERGIO PEREZ     | SAUBER        |     47 |             1
      10 | KAMUI KOBAYASHI  | SAUBER        |     33 |             2

A ordenação foi necessária neste caso porque apesar da consulta ser ordenada pela posição, a window function processa os dados de acordo com sua própria ordenação.

Nesta última query temos o uso da função row_number, que é uma window function embutida. Funções deste tipo devem ser chamadas somente usando a sintaxe da window function (onde a cláusula OVER é obrigatória).

Tanto as funções embutidas quanto as de agregação podem ser usadas como window functions, mas as de agregação somente se comportam como window functions quando chamadas com a cláusula OVER, caso contrário serão apenas funções de agregação regulares. Outras funções embutidas podem ser encontradas aqui, mas vou apresentar algumas:

lag(coluna, deslocamento) - Usada para retornar valores de linhas anteriores onde o deslocamento determina quantas linhas antes.
lead(coluna, deslocamento) - Parecida com a função anterior, mas para linhas posteriores.
first_value(coluna) - Retorna o valor da primeira linha.
last_value(coluna) - Retorna o valor da última linha.

E pra finalizar, caso uma query tenha mais de uma window function com o mesmo comportamento, é possível utilizar uma cláusula WINDOW que será referenciada em OVER:

SELECT *, row_number() OVER w AS numero_piloto
FROM formula1
WINDOW w AS (PARTITION BY equipe ORDER BY posicao)
ORDER BY posicao

Referência: http://www.postgresql.org/docs/9.1/static/tutorial-window.html

Exemplo de função no PostgreSQL

2012-06-29T16:39:00.002-03:00

Esta semana precisei criar uma função no banco de dados PostgreSQL que me retornasse o menor valor dentre outros cotados. Nesta função eu passo dois parâmetros: codigo do material e codigo da cotação (ambos do tipo inteiro).

A função me retorna um tipo NUMERIC(20, 2), que é o tipo no qual venho trabalhando com valores monetários pois segundo a própria documentação do PostgreSQL:

It is especially recommended for storing monetary amounts and other quantities where exactness is required.

Outro detalhe importante que podemos observar é que na query, os valores contidos nos parâmetros são lidos utilizando $1 e $2 respectivamente. Vejamos:

CREATE FUNCTION func_menor_valor(codigo_material INT, codigo_cotacao INT)
RETURNS NUMERIC(20, 2) AS $$ 

 SELECT MIN(valor_total) AS menor_valor FROM view_cotacoes
 WHERE codigo_material = $1 AND codigo_cotacao = $2
 GROUP BY codigo_material;

$$ LANGUAGE SQL;

Enfim, isso é apenas um exemplo básico de função. Mais informações podem ser encontradas na documentação. Também é importante lembrar que a versão do PostgreSQL utilizada foi a 9.1.

JTable - Selecionar todo texto quando editar uma célula

2012-06-22T15:57:00.000-03:00

Olá, hoje vou dar início a uma série de postagens rápidas. Normalmente quando abordo um assunto, sempre procuro introduzir os conceitos e explicar detalhadamente cada passo para realizar o procedimento. Mas como não estou tendo tempo pra fazer estas postagens mais elaboradas, resolvi mudar o estilo e tornar esse blog em algo parecido com um depósito de códigos. Assim mantenho o blog ativo e mantenho uma biblioteca com meus códigos pra quem quiser copiar (as vezes eu mesmo preciso de um código que fiz e não acho).

Então vamos ao que interessa.

Quando temos uma célula editável numa JTable e clicamos na mesma para fazer a edição, normalmente temos que selecionar e apagar o valor presente na célula para entrar com outro. Para melhorar isto e já selecionar todo conteúdo da célula quando ela entrar em edição, sobrescrevemos o método changeSelection da JTable conforme abaixo:

tbExemplo = new javax.swing.JTable()
{
    // Selecionar o conteúdo da célula quando editar
    public void changeSelection(int row, int column, boolean toggle, boolean extend)
    {
        super.changeSelection(row, column, toggle, extend);

        if (editCellAt(row, column))
        {
            Component editor = getEditorComponent();
            editor.requestFocusInWindow();

            if (editor instanceof JTextComponent){
                ((JTextComponent) editor).selectAll();          
            }
        }
    }
};

P.S.: Todos códigos foram testados por mim e são funcionais. Qualquer dúvida pergunte nos comentários.

Como limitar um JTextField

2012-03-09T12:47:00.001-03:00

É muito comum encontrar nos fóruns especializados em Java a seguinte questão: "Como eu faço para limitar o tamanho de um JtextField?". Ocorre um certo desapontamento dos iniciantes na linguagem por não haver um método chamado setMaxLenght(x). Ou ainda com os que trabalham visualmente, procurar a propriedade no componente que limitaria o tamanho máximo de caracteres e não encontrar. Aí programadores que vieram do Delphi por exemplo dizem "O Delphi é muito melhor, blablabla...". Só digo uma coisa: Revejam seus conceitos sobre o que é Java.

A verdade é que o componente JTextField é definido sobre um modelo de documento que por padrão é chamado PlainDocument. Portanto, para para ter o controle sobre o JTextField devemos criar uma sub classe de PlainDocument, sobrescrever alguns métodos dela e trocar o modelo do JTextField para este novo.

Minha intenção não é entrar a fundo neste assunto, mas sim dar uma solução principalmente pra quem está trabalhando visualmente e não quer ficar editanto código a todo momento.

Então vamos lá, primeiramente crie a seguinte classe no seu projeto:

import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.PlainDocument;

public class JTextFieldLimit extends PlainDocument {

    private int limit;
    // optional uppercase conversion
    private boolean toUppercase = false;
    
    private int maximo = 500;

    public JTextFieldLimit(int limit) {
        super();
        if (limit == 0)
            this.limit = maximo;
        else
            this.limit = limit;
    }

    public JTextFieldLimit(int limit, boolean upper) {
        super();
        if (limit == 0)
            this.limit = maximo;
        else
            this.limit = limit;
        toUppercase = upper;
    }

    @Override
    public void insertString(int offset, String str, AttributeSet attr)
            throws BadLocationException {
        if (str == null) {
            return;
        }

        if ((getLength() + str.length()) <= limit) {
            if (toUppercase) {
                str = str.toUpperCase();
            }
            super.insertString(offset, str, attr);
        }
    }
}

Esta classe não é nenhuma novidade e pode ser encontrada em vários sites pela internet (na verdade fiz algumas mudanças nela). O que ela faz é permitir a limitação de caracteres e opcionalmente fazer a conversão para maiúsculas. Mas o problema é que pra cada JTextField criado, temos que chamar o método setDocument passando essa classe e os parâmetros. Então para resolver este problema, crie o seguinte método na classe onde estão seus campos de texto:

    public void preparaForm() {

        // JTextFields limitados e com maiúsculas
        for (Component c : this.getComponents()) {
            if (c instanceof JTextField) {
                ((JTextField) c).setDocument(new JTextFieldLimit(((JTextField) c).getColumns(), true));
            }
        }
        
    }

Este método deve ser chamado sempre antes de exibir o seu formulário. Ele vai verificar cada componente do formulário e caso este seja do tipo JTextField, será configurado para utilizar o modelo de documento apresentado. Mas onde vou definir o limite de caracteres para cada campo? Observe que o primeiro parâmetro passado para o documento é: ((JTextField) c).getColumns(). Visualmente você poderá definir este número na propriedade column do componente. Mas porque essa propriedade? Isto está parecendo uma bela gambiarra... Fique tranquilo, a propriedade column é apenas um número usado para calcular o tamanho preferido para a largura do campo. Se ele for zero, o tamanho preferido será qualquer um dependendo da implementação do objeto. Isto é, você define a largura visualmente utilizando seu gerenciador de layout preferido e pouco importará o valor definido para a propriedade column.

Enfim, trabalhando desta forma você não precisará ficar escrevendo código para configurar o documento e limite de caracteres para cada campo de texto. Isto não é problema se o projeto é simples, mas se estiver desenvolvendo vários formulários, não é muito produtivo.

Observação: O método só funciona caso esteja trabalhando com JInternalFrames e caso não esteja, pode haver alguma diferença no método que retorna os componentes (this.getComponents). Se for um JDialog por exemplo, ficaria assim:
this.getRootPane().getContentPane().getComponents().

Por hoje é só! Qualquer dúvida deixe nos comentários.

Editado em 17/12/2012:

Devido a alguns JTextFields estarem dentro de JPanels e JTabbedPanes, desenvolvi um método recursivo que poderá ser chamado dentro do método preparaForm citado anteriormente:

 
    private void preparaJTextFields(Object obj) {

        if (obj instanceof JTextField) {
            ((JTextField) obj).setDocument(new JTextFieldLimit(((JTextField) obj).getColumns(), true));
        }
       
        if (obj instanceof JPanel) {
            for (Component c : ((JPanel) obj).getComponents()) {
                preparaJTextFields(c);
            }
        }

        if (obj instanceof JTabbedPane) {
            for (Component c : ((JTabbedPane) obj).getComponents()) {
                preparaJTextFields(c);
            }
        }

    }

E a chamada pode ser feita assim:

 
    public void preparaForm() {

        //Centraliza o JInternalFrame
        Dimension d = this.getDesktopPane().getSize();
        this.setLocation((d.width - this.getSize().width) / 2, (d.height - this.getSize().height) / 2);

        //JTextFields limitados
        preparaJTextFields(this.getContentPane());
        
    }

E aproveito ainda para mostrar como não permitir acentuação nos JTextFields, basta trocar a linha super.insertString(offset, str, attr); da classe JTextFieldLimit por:

 
//super.insertString(offset, str, attr);
            
// Sem acentos
String unaccented = Normalizer.normalize(str, Normalizer.Form.NFD);
unaccented = unaccented.replaceAll("[^\\p{ASCII}]", "");
super.insertString(offset, unaccented, attr);

Como listar todos itens de um JMenuBar

2012-03-08T12:26:00.000-03:00

Hoje vou ensinar como retornar todos os objetos JMenuItems contidos num JMenuBar. Eventualmente você pode querer retornar também os objetos JMenu, então fica livre para fazer sua implementação do método.

O método que vou apresentar pode ser muito útil para fazer o controle de acesso da aplicação, permitindo que o item de menu seja exibido ou não de acordo com as permissões de cada usuário.

A estrutura de menus em Java é basicamente a seguinte:

JMenubar
   |
   |__ JMenu
   |    |
   |       |__JMenuItem
   |
   |__JMenu
           |
           |__JMenu
                  |
                  |__JMenuItem

Como podemos observar, temos uma barra de menu e dentro dela temos 2 menus. No primeiro menu temos um item e no segundo temos um sub menu e dentro deste outro item. Então para recuperar todos itens, considerando que podem existir itens dentro de sub menus, devemos utilizar a recursividade.

Resumidamente, um método recursivo é um método que faz chamadas a ele mesmo. Certos problemas, como o apresentado, exigem esta abordagem, pois os elementos estão dispostos numa estrutura do tipo árvore que pode ter várias ramificações. Sendo assim, segue abaixo uma possível implementação do método que resolve este problema.

    /**
     * Retorna todos JMenuItems de um JMenuBar.
     *
     * @param obj Uma variável do tipo JMenuBar.
     * @return void
     */
    public void getMenuItems(Object obj) {

        if (obj instanceof JMenuBar) {

            for (Component c : ((JMenuBar) obj).getComponents()) {
                getMenuItems(c);
            }
        }

        if (obj instanceof JMenu) {

            for (Component c : ((JMenu) obj).getMenuComponents()) {
                getMenuItems(c);
            }
        }

        if (obj.getClass() == JMenuItem.class) {
            System.out.println("JMenuItem: " + ((JMenuItem) obj).getName());
        }

    }

Fiquem a vontade para modificar e utilizar. Até a próxima!

Como vincular dados a um JComboBox

2012-03-07T12:20:00.002-03:00

Atualmente estou trabalhando num projeto no qual utilizo o framework JPA. Então a cada dia que passa eu acabo aprendendo algo novo sobre esta API e espero com essa experiência poder ajudar os que estão começando agora.

Hoje vou falar um pouco sobre como vincular dados que se encontram em uma tabela do banco a um componente JComboBox. A vinculação é simples de se fazer, mas a exibição da propriedade desejada é um pouco mais complicada como veremos adiante. Vou apresentar um passo a passo que traduzi do site netbeans.org, mas com algumas correções (o exemplo de código do site na parte "To render the combo box propertly" não funciona).

Vamos ao que interessa:

1. Clique com o botão direito no combo box e escolha Bind > elements (Vincular > elements).

2. Clique em Import Data to Form (Importar dados para o Formulário...). Selecione a conexão e tabela que voce deseja vincular o combo box. Clique em OK.

3. No combo From the Binding Source (Origem da vinculação), selecione o item que representa o result list da entidade. Por exemplo, se a entidade se chama Cliente.java, o objeto da lista deve ser gerado como clienteList.

4. Deixe o valor em Binding Expression (Expressão de vinculação) como null e clique em OK.

5. Clique com o botão direito no combo box novamente e escolha Bind > selectedItem (Vincular > selectedItem). Vincule a propriedade que será afetada pela selecão do usuário e clique em OK (normalmente o result list escolhido no passo 3).

Até aqui já temos os dados vinculados ao combo box, porém se executar o programa verá que o combo mostrará dados da entidade selecionada convertida em String (objeto.toString()) e não uma propriedade específica:

Isto acontece porque, segundo o próprio site do NetBeans, a biblioteca Beans Binding não tem uma classe DetailBinding que permite especificar os valores exibidos no JComboBox.

Uma forma de resolver isto é escrever um código personalizado para mostrar a propriedade que queremos:

1. Selecione o combo box.

2. Na aba Propriedades da Janela de Propriedades, selecione a propriedade render.

3. Clique no botão ...

4. No combo na parte superior do editor de propriedades, selecione Custom Code (Código personalizado).

5. Na área de texto, entre com um código parecido com o que segue abaixo onde Usuario é o nome da sua entidade e getUsuario é a propriedade que retorna o valor a ser vinculado.

new DefaultListCellRenderer() {

    @Override
    public Component getListCellRendererComponent(
            JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
        super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
        if (value instanceof Usuario) {
            Usuario usuario = (Usuario) value;
            setText(usuario.getUsuario());
        }
        return this;
    }
}

Feito isso, o valor selecionado deverá aparecer no combo:

Uma outra abordagem mais simples para resolver o problema é sobrescrever o método toString da entidade em questão:

    @Override
    public String toString() {
        return getUsuario();
    }

Basta fazer com que o método retorne o valor que você deseja mostrar no combo box. É isso aí! Espero que tenham gostado.

Introdução aos Design Patterns

2012-02-01T00:07:00.000-02:00

Padrões de projeto são sempre bem vindos quando o assunto é Engenharia de Software. Existe uma variedade deles, mas pra este post teremos apenas uma introdução para entender melhor o que são e pra que servem. Vamos começar com uma definição resumida da Wikipédia:

"Um Padrão de Projeto (Design Pattern) descreve uma solução geral reutilizável para um problema recorrente no desenvolvimento de sistemas orientados a objetos. Não é um código final, é um modelo de como resolver um problema que pode ser usado em muitas situações diferentes. Os Padrões de Projeto definem as relações e interações entre as classes ou objetos, sem especificar os detalhes das classes ou objetos envolvidos, ou seja, estão num nível de generalidade mais alto."

Os conceitos de padrões de projeto vem sendo discutidos ao longo dos anos e se tornou mais popular depois do lançamento do livro Design Patterns: Elements of Reusable Object-Oriented Software em 1995. Então os autores do livro (Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides) ficaram conhecidos como sendo a Gangue dos Quatro (Gang of Four) ou simplesmente GoF.

Outra definição interessante veio de Christopher Alexander cujo seus estudos contribuíram para a utilização de padrões geométricos e matemáticos no urbanismo e arquitetura:

“Cada padrão descreve um problema que ocorre freqüentemente em seu ambiente, e então descreve o núcleo de uma solução para o problema, de maneira que você possa usar esta solução um milhão de vezes, sem fazê-la do mesmo jeito duas vezes.”

Mas o que um cara urbanista e arquiteto está fazendo aqui? Você já deve ter percebido que padrões de projeto não estão ligados apenas a engenharia de software mas também a outras engenharias, como a civil por exemplo. Imagina se você entraria num prédio cujo projeto foi na base do "codifica-conserta"? Você se sentiria seguro? Neste caso é ainda mais crítico porque vidas estariam em risco. De qualquer forma precisamos de boas soluções para nossos projetos e ter padrões já experimentados e aprovados é uma ótima ajuda. Foi com base nos estudos de Alexander que cientistas da computação desenvolveram padrões de projetos usados na engenharia de software.

Dando continuidade ao que interessa, atualmente os padrões são divididos em 3 categorias:

Criacionais: Diz respeito a criação de objetos;
Comportamentais: Diz respeito a maneira que objetos e classes distribuem suas responsabilidades para realizar uma tarefa
Estruturais: Diz respeito a maneira como classes e objetos são organizados estruturalmente

Existem 23 padrões de projetos oficiais que se encaixam nestas categorias. Digo oficiais porque eles são os padrões documentados pela GoF. Existem diversos outros padrões e qualquer pessoa pode criar um, desde que tenha a solução para um problema comum e siga o modelo de documentação. Para documentar um padrão, deve-se definir alguns elementos:

Nome e classificação
Problema
Solução
Consequências
Casos de uso

Estes são os principais elementos a serem documentados. Pode não parecer importante mas, sem uma forma de documentar os padrões, eles não existiriam ou poderiam até existir mas seriam um monte de diagramas e textos soltos. Foi o próprio Alexander que definiu em seu livro Notes on the Synthesis of Form, The Timeless Way of Building e A Pattern Language, como os padrões devem ser descritos.

Bom pessoal, por hoje é só e espero falar mais sobre alguns padrões em posts futuros.

Introdução ao J2ME

2010-10-28T08:52:00.000-02:00

Olá! No post de hoje pretendo mostrar como iniciar no desenvolvimento de aplicações para dispositivos móveis. Vou mostrar como preparar o ambiente de desenvolvimento e também como fazer um pequeno programa.

O Ambiente

A primeira coisa a se fazer é baixar o Sun Java Wireless Toolkit, também conhecido como J2ME Wireless Toolkit. Esse kit de ferramentas é utilizado para criar aplicações que serão executadas em dispositivos móveis com a tecnologia Java. A instação do toolkit não tem segredo, é só na base do next next finish...
O próximo passo é instalar a IDE. Para o exemplo que vou mostrar, vamos utilizar o Eclipse 3.5. Espero que já esteja familiarizado com ele.
E para integrar o toolkit e a IDE vamos utlizar o plugin EclipseME. A instalção do plugin é simples:

Feche o Eclipse caso esteja aberto;
Descompacte o arquivo do plugin;
Recorte as pastas features e plugins que foram descompactadas;
Cole as pastas na pasta onde encontra-se o eclipse.exe (vai perguntar se quer mesclar as pastas, responda sim);

Aliás, esses passos servem para instalação offline de qualquer plugin para Eclipse.
Pronto, agora só mais algumas configurações e o ambiente estará preparado. Como essas configurações dependem da criação de um novo projeto, vamos pra próxima parte!

Criando um projeto

Abra o Eclipse. Clique com o botão direito dentro do Package Explorer e New > Other...

Na janela que abrir navegue por J2ME e escolha J2ME Midlet Suite, então clique em Next:

Agora escolha o nome do projeto e clique em Next novamente:

Neste momento será solicitado que configure o dispositivo que será usado para executar a aplicação. Então clique em Manage Devices...

Outra janela será aberta, porém ainda sem nenhum dispositivo. Clique em Import...

Agora clique em Browse... e selecione a pasta WTK2.5.2_01 (ou outra versão disponível) que se encontra na raiz do disco (geralmente em C:, só não estará neste local se você tiver mudado durante a instalação). Clique em OK:

De volta na janela Import Devices clique em Refresh. Uma pesquisa será feita na pasta do toolkit e alguns dispositivos devem aparecer na lista:

Clique em Finish e voltamos na janela de gerenciamento com um dispositivo padrão selecionado:

Somente um dispositivo pode ser selecionado. Deixe o padrão e clique em OK. Então voltamos na janela de propriedades do projeto, mas agora com os dois combobox preenchidos:

Em device podemos selecionar DefaultGrayPhone ou DefaultColorPhone. Deixe o padrão que é DefaultGrayPhone e clique em Finish.

Pronto, agora temos um projeto criado e podemos iniciar o desenvolvimento.

Programando em J2ME

Vamos criar nosso primeiro programa. Abra a pasta do projeto no Package Explorer e clique com o botão direito no pacote src, escolha New > Other...

Dentro de J2ME escolha J2ME Midlet e clique em Next. Digite o nome HelloWorld e clique em Finish. Então será criada uma classe parecida com esta:

import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

public class HelloWorld extends MIDlet {

public HelloWorld() {
}

protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
}

protected void pauseApp() {
}

protected void startApp() throws MIDletStateChangeException {
}

}

O que é MIDlet? MIDlet é como são chamados os aplicativos em J2ME. Aplicativos Java para web são Applets, para servidores são Servlets e para dispositivos móveis são MIDlets. Na verdade as coisas são um pouco mais complicadas, mas a grosso modo podemos definir assim.
Observe que nossa classe estende MIDlet e por isso foram herdados 3 métodos:

startApp: É chamado quando se inicia a aplicação (equivalente ao main em J2SE). Também é chamado quando a aplicação é despausada.
pauseApp: É chamado quando o aplicativo fica em segundo plano (por exemplo, quando o usuário atende uma ligação)
destroyApp: É executado quando o aplicativo é finalizado e pode ser usado para liberar recursos, entre outras coisas.

Também temos o construtor que é uma espécie de método chamado quando a classe é instanciada (você já deve saber disto). Mas vamos ao que interessa. Declare a seguinte variável de instância:

Display d;

Deve aparecer um erro devido ao import, apenas peça que o Eclipse corrija pra você.

Cada MIDlet deve ter uma referência a uma variável do tipo Display. Este objeto pode recuperar informações sobre a tela (ex. quantidade de cores) e também é usado para exibir objetos.
No J2ME temos uma superclasse chamada Displayable da qual todos os outros objetos estendem. Objetos como Alert, Form ou TextBox estendem de Displayable, portanto eles SÃO Displayable. O objeto Display pode exibir qualquer tipo de Displayable. Veja como é a hierarquia destas classes:

Somemte um objeto Displayable pode ser exibido por vez. Então usamos o objeto Display para decidir o que será exibido na tela. Para fazer isto primeiro temos que pegar o Display atual do MIDlet. Faça a chamada dentro do construtor:

d = Display.getDisplay(this);

Veja que o construtor configura a variável d com o atual Display do MIDlet. Display não foi instanciado, em vez disto usamos o método estático para selecionar o Display atual. Agora dentro de startApp coloque o seguinte código:

Alert mensagem = new Alert("Primeiro MIDlet", "Hello World!", null, AlertType.INFO);
d.setCurrent(mensagem);

Nesse trecho de código criamos um objeto do tipo Alert e depois solicitamos que fosse exibido na tela. O código final ficou assim:

import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.AlertType;
import javax.microedition.lcdui.Display;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;

public class HelloWorld extends MIDlet {

Display d;

public HelloWorld() {
d = Display.getDisplay(this);
}

protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
}

protected void pauseApp() {
}

protected void startApp() throws MIDletStateChangeException {
Alert mensagem = new Alert("Primeiro MIDlet", "Hello World!", null, AlertType.INFO);
d.setCurrent(mensagem);
}

}

Para executar clique com o botão direito na classe, Run As > Emulated J2ME MIDlet. O resultado deverá ser algo parecido com isto:

Bom, por hoje é só. Isto foi apenas uma pequena introdução ao J2ME. Espero que apartir daí você possa pesquisar mais sobre o assunto e desenvolver aplicações mais sofisticadas. Eu acredito que qualquer linguagem que aprendemos iniciando no famoso Hello World, temos chances de prosperar. Mas se você tentar aprender alguma linguagem e seu primeiro programa não for o Hello World, certamente irá fracassar. Enfim, isto é apenas uma superstição boba mas eu prefiro não contrariar :)

Bons estudos!!

Garbage Collector - Java

2010-10-21T14:29:00.000-02:00

Olá! Hoje vou falar sobre um assunto muito interessante: Coleta de lixo. Uma pergunta muito comum quando falamos de coleta de lixo é "How many objects are eligible for the garbage collector?". Como saber quantos objetos são elegíveis a serem descartados? Vamos descobrir como responder esta questão e também aprender sobre um conceito importante conhecido por Island of Isolation ou Ilha de Isolamento. Antes de continuar vamos ver algo sobre atribuições.

Atribuições

Quando atribuímos um objeto a uma variável, o objeto não é armazenado na variável em si, mas sim no heap. O heap é um espaço na memória onde todos os objetos ficam alocados durante a execução de um programa. As variáveis de instância também residem no heap.
Quando atribuímos um primitivo a uma variável, ela realmente armazena o padrão de bits que representa o valor sendo atribuído a ela, mas se tratando de objetos, a variável armazena o endereço do objeto no heap. Por isto esse tipo de variável que faz referência a objetos é chamada de variável de referência. Abaixo temos um exemplo de código e em seguida uma representação visual:

Object objeto1 = new Object();
Object objeto2 = new Object();
Object objeto3 = new Object();

O resultado disto é:

Garbage Collector

O propósito da coleta de lixo é descartar os objetos que não podem mais ser acessados. Isto é uma forma de gerenciar a memória e evitar que os programas fiquem sem espaço para continuar sua execução.
Quando algum objeto no heap não pode mais ser mais alcançado por ninguém (por nenhum thread ativo), ele é elegível a coleta de lixo. Isto pode acontecer de duas formas:

A variável passa a fazer referência a null:

objeto1 = null;

O resultado disto é:

A outra forma é fazer a variável referenciar outro objeto:

objeto1 = objeto2;

O resultado é:

Qualquer uma das formas tornaria o objeto1 qualificado para coleta.
Suponhamos que o objeto1 esteja "solto" no heap. Posso resolver descartá-lo quando quiser? Não. Somente a JVM pode decidir quando isso deve ser feito, mas como bom programador você pode recomendar que a coleta seja feita. E para fazer isto basta usar a instrução:

System.gc();

Não há garantia de que a coleta seja feita, mas geralmente a JVM atende o pedido.
É importante lembrar que um objeto só existirá no heap caso ele tenha sido inicializado (pela keyword new). Portanto a seguinte declaração não cria nenhum objeto no heap:

Object o = null;

Se o objeto nunca foi criado então não existe objeto a ser coletado.

O Método finalize()

A classe Object possui um método chamado finalize(). Como todas classes são filhas de Object, implícita ou explicitamente, todas herdam tal método. Este método é chamado pelo coletor de lixo quando não há mais referências ao objeto. Mas lembre-se que: se não há garantia que a coleta seja executada quando você solicitar, finalize() pode não ser executado.
O método finalize() de Object não executa nenhuma ação, mas pode ser sobrescrito para que faça algo antes que o objeto seja coletado. Pode ser feito uma liberação de recursos, como fechar um arquivo, finalizar uma conexão, etc. Também podemos usá-lo para salvar o objeto da coleta, daqui a pouco explico melhor.
O método finalize() dá ao programador o poder sobre a vida e a morte dos objetos. Para entender melhor essa afirmação, veja dois conceitos importantes sobre o método:

finalize() só é chamado uma única e exclusiva vez para qualquer objeto durante a coleta.
Chamar finalize() pode salvar o objeto da coleta.

A primeira afirmação significa que se você chamar finalize() por conta própria, ele não será chamado novamente quando a coleta for executada. E a segunda significa que podemos inserir algum código em finalize() para fazer que o objeto tenha uma nova referência e não seja coletado. Mas ressucitar um objeto não é tão simples assim. Abaixo temos um pequeno exemplo de como isto é feito:

public class Objeto{

// Sobrescreve finalize
public void finalize(){
// Da uma nova referência para objeto1
objeto1 = new Objeto();
}

// Objeto que vai ressuscitar
static Objeto objeto1 = new Objeto();

public static void main(String[] args) {

objeto1 = null; // Elegível a coleta

System.gc(); // Chama finalize como consequência

// Aqui faz o thread dormir um pouco
// enquanto a coleta é feita (espero que seja)
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}

objeto1.go(); // Não deveria causar um NullPointerException?

}

void go(){
System.out.println("Estou vivo!");
}
}

Veja que quando main começar a ser executado, objeto1 faz referência a null, se tornando elegível a coleta. Então é solicitado que a coleta seja feita (reze pra JVM aceitar o pedido). Logo após fazemos o thread main descançar um pouco... Há muitas incertezas neste momento. Desejamos que a coleta seja feita e que isso aconteça enquanto main tira um cochilo. Primeiro não sabemos se a JVM vai nos atender e muito menos se isso será feito num segundo. Mas com sorte tudo vai correr bem. Nos meus testes a JVM respondeu bem e a saída foi:

Estou vivo!

Uma parte importante do código é o cochilo de main. Como main e o coletor de lixo rodam em threads separados, não sabemos quem vai tomar o processador primeiro. (mais sobre threads aqui). Pelo que eu percebi, o coletor sempre fica pra depois e isso é compreensível, porque senão ele poderia prejudicar o desempenho do programa. Se o trecho de código onde main fica em espera for removido, antes que o coletor seja executado o método go() será chamado e causará um NullPonterException. Isso mostra que chamar o coletor não garante que ele seja executado naquele exato momento.
Continuando... Agora vamos praticar um pouco. Veja uma questão que tem grandes chances de aparecer no exame SCJP:

Given:

interface Animal {
void makeNoise();
}

class Horse implements Animal {
Long weight = 1200L;

public void makeNoise() {
System.out.println("whinny");
}
}

public class Icelandic extends Horse {
public void makeNoise() {
System.out.println("vinny");
}

public static void main(String[] args) {
Icelandic i1 = new Icelandic();
Icelandic i2 = new Icelandic();
Icelandic i3 = new Icelandic();
i3 = i1;
i1 = i2;
i2 = null;
i3 = i1;
} //Line 14
}

When line 14 is reached, how many objects are
eligible for the garbage collector?

A. 0
B. 1
C. 2
D. 3
E. 4
F. 6

Analisando o código vemos que existem algumas coisas querendo nos desviar do foco principal: Interface e sobrescrição de métodos. Horse implementa o médodo de Animal corretamente e declara uma variável do tipo Long (Long não é long, isso fará diferença no resultado). Depois Icelandic, que é subclasse de Horse, sobrescreve o método makeNoise corretamente. Tirando essas distrações, entramos na execução do código:

Icelandic i1 = new Icelandic();
Icelandic i2 = new Icelandic();
Icelandic i3 = new Icelandic();

A melhor coisa a se fazer é desenhar o esquema:

Note que cada objeto Icelandic possui uma variável weight, herdada de Horse.
Então continuando no programa temos i3 fazendo referência a i1:

i3 = i1;

Neste momento já temos 2 objetos qualificados pra coleta. Porque 2? Lembra da variável Long? Pois então, Long é uma classe wrapper e portanto é um objeto no heap (variáveis de instância residem do heap). Continuando no progama temos:

i1 = i2;

Aqui não temos muitas mudanças, nenhum objeto é qualificado. i1 faz referência ao objeto de i2, mas o objeto que i1 referenciava ainda é acessível através de i3. Continuando:

i2 = null;

Neste momento i2 passou a referenciar null, mas o objeto que era referenciado por ele anteriormente ainda é referenciado por i1. E finalmente temos:

i3 = i1;

Novamente i3 faz referencia a i1, só que agora i1 faz referência ao objeto que era referenciado por i2. Isso torna o objeto (que antes era referenciado por i1 e depois por i3), qualificado para coleta.
Ufa! Mas enfim quantos objetos se tornaram elegíveis a coleta? Quatro. Dois objetos do tipo Icelandic e dois do tipo Long. Geralmente esse tipo de pergunta inclui essas variáveis de instância que são tipos de classe wrapper só pra confudir.
Um modo de saber quantos objetos foram descartados é sobrescrever finalize() para que mostre alguma mensagem. Veja o código:

public class Icelandic {
Long x;

public void finalize() {
System.out.println("tchau");
}

public static void main(String[] args) {
Icelandic i1 = new Icelandic();
Icelandic i2 = new Icelandic();
Icelandic i3 = new Icelandic();

i3 = i1;
i1 = i2;
i2 = null;
i3 = i1;

System.gc();
}
}

A saída deste código é:

tchau
tchau

Quatro objetos foram coletados. Note que a classe tem uma variável de instância Long.

Ilhas de Isolamento

Ilhas de isolamento ocorrem quando variáveis de instância fazem referência umas as outras formando um circuito fechado. Então se as referência a seus referências forem anuladas, os objetos perderão seu vínculo com elas e terão referências apenas uns dos outros. Analise o código:

public class Icelandic {

// Variável de instância
Icelandic i;

public void finalize() {
System.out.println("tchau");
}

public static void main(String[] args) {

Icelandic i1 = new Icelandic();
Icelandic i2 = new Icelandic();

// Variáveis de instância apontam uma para outra
i1.i = i2;
i2.i = i1;

// As variáveis locais perdem a referência
i1 = null;
i2 = null;

System.gc();
}
}

O cenário inicial deste código é representado abaixo:

Depois das declarações a variavel de instância i de i1 (i1.i) faz referência a i2. E a variável de instância i de i2 (i2.i) faz referência a i1:

Logo depois i1 e i2 passam a referenciar null:

Consegue sentir como é dramático este cenário? Embora os objetos tenham variáveis que fazem referência entre eles, nenhum thread ativo pode alcançá-los. Não importa se eles podem acessar um ao outro, de fora ninguém pode acessá-los. Portanto estão qualificados a coleta de lixo.

Conclusão

Sei que esse assunto é um pouco confuso, mas basta fazer os desenhos pra exergar a solução. Bons estudos e até a próxima!

Regras de Cast - Java

2010-10-18T10:08:00.000-02:00

Olá! Hoje vamos nos aprofundar um pouco mais nas conversões de tipos. Num outro post eu cheguei a abordar o assunto, porém faltou um esclarecimento maior sobre erros que podem ocorrer. Conversões de tipos no Java podem ser um pouco confusas, pois temos regras para tempo de compilação e de execução. Por exemplo, temos duas classes:

public class Veiculo {

public static void main(String[] args) {

}

}

class Carro extends Veiculo {

}

Um dos casos mais comuns é a conversão ampliadora ou upcasting, onde um tipo mais genérico pode referenciar outro mais específico (um subtipo):

Veiculo v = new Carro();

Temos uma variável de referência do tipo Veiculo que aponta para um objeto do tipo Carro. Sabemos que o contrário não pode ser feito e causa erro de compilação, porque Carro É-UM Veiculo, mas Veiculo NÃO-É-UM Carro.
A conversão ampliadora é totalmente segura, não causará erros de compilação nem execução. E também não exige nenhuma declaração explícita. Simplesmente fazemos a referência e o compilador entenderá que é seguro uma variável do tipo Veiculo referenciar um objeto Carro, pois Veiculo pode fazer coisas que Carro faz. Isso porque Carro herdou estes comportamentos. Na verdade Carro pode fazer ainda mais coisas, porém como Veiculo não sabe dessas coisas, esse tipo de conversão limita os comportamentos de Carro. Agora somente métodos de Veiculo podem ser chamados. Lembre-se que a variável de referência é quem diz quais métodos poderão ser chamados.

Vamos continuar e ver uma conversão redutora, ou downcasting:

Carro c = v;

Veja que estamos indo pra baixo na árvore de herança agora. Tentamos fazer com que a variável de refência do tipo Veiculo (usada anteriomente para referenciar Carro), seja atribuída a outra variável do tipo Carro, fazendo com que as duas apontem para o mesmo objeto. Um pouco confuso mas veja como funciona:

Antes fizemos isto:

Veiculo -> Carro

Agora estamos tentando isto:

Carro = Veiculo -> Carro

Essa conversão não pode ser feita implicitamente, como no upcasting. O código anterior não compila, mas como sabemos que a variável v aponta pra um objeto do tipo Carro, podemos fazer a conversão explicitamente:

Carro = (Carro)Veiculo -> Carro

Isto é:

Carro c = (Carro)v;

Isto funcionou porque v faz referência a um objeto Carro. Então é seguro a referência Veiculo para Carro. Lembre-se que o tipo de objeto sendo refenciado é que determina se a conversão poderá ser feita. Mas e se o objeto referenciado não fosse Carro? Agora fica interessante porque o compilador lava suas mãos. Portanto, o seguinte código vai compilar:

Veiculo v1 = new Veiculo(); //Objeto Veiculo

Carro c1 = (Carro)v1;

Mas como o que estamos tentando fazer é isto:

Carro = (Carro)Veiculo -> Veiculo!!

Quando executamos o código, a seguinte mensagem será exibida:

Exception in thread "main" java.lang.ClassCastException:
Veiculo cannot be cast to Carro

Outros códigos serão executados normalmente, mas quando tentar a conversão acima, a exceção vai finalizar o programa. Isso nos mostra que só podemos fazer downcasting se o objeto sendo refenciado for do tipo da variável que vai fazer a referência. O compilador não sabe se estamos fazendo isso errado, mas podemos nos prevenir de duas formas. Uma é usando o operador instanceof:

Veiculo v1 = new Veiculo();

if (v1 instanceof Carro) {
    Carro c1 = (Carro) v1;
}else
    System.out.println("Não foi possível...");

Outra é tratando a exceção:

try{
    Carro c1 = (Carro)v1;
}catch (ClassCastException e) {
    System.out.println("Não foi possível...");
}

Com isso espero ter esclarecido dúvidas sobre erros de compilação e execução causados pelas conversões.
Por hoje é só pessoal! Bons estudos..

Sobrescrita e Exceções

2010-10-15T10:31:00.000-03:00

Introdução

Hoje vou escrever sobre um assunto que está presente no objetivo 1.5 da SCJP. O objetivo determina que o candidato saiba identificar se a sobrescrição de um método está correta. Eu já falei sobre sobrescrita num outro post, mas fiquei devendo uma explicação melhor sobre exceções.

Exceções Verificadas (checked)

As exceções verificadas são exceções que devem ser tratadas por você no seu código. O compilador irá forçá-lo a lidar adequadamente com essas exceções. Você pode capturar essas exceções ou declará-las na cláusula throws do método.
Geralmente, as exceções verificadas ocorrem devido a condições fora de seu controle, como IOException ou uma falha na conexão de rede. Mas sua aplicação deve prever essas condições e tratá-las corretamente para que não venha travar. É por isso que você é forçado pelo compilador a lidar com essas exceções. Se a conexão de rede é interrompida durante uma transferência de arquivo, o aplicativo deve lidar com isso e permitir que o usuário tente novamente.

Exceções Não verificadas (unchecked)

Por outro lado, exceções não-verificadas ocorrem devido a erros de codificação por parte do programador. Como uma exceção NullPointerException que pode ser evitada através de uma verificação para saber se a referência é nula.
Existem também algumas exceções unchecked que podem ocorrer que não são culpa do programador. Estas são as exceções que são subclasses da classe java.lang.Error. Quando essas exceções ocorrem, não há muito o que fazer, então você não é obrigado a lidar com elas já que não pode prever quando irão ocorrer. Como um OutOfMemoryError pode ocorrer a qualquer momento que um objeto é instanciado, você não pode colocar cada instanciação de objeto em blocos try-catch.

Exemplos

Vamos criar um exemplo para ver como o compilador nos força a tratar exceções verificadas.

class ExcecaoNaoTratada {
public static void main(String[] args) {
 throw new Exception();
}
}

O código acima não vai compilar porque não estamos tratando a exceção verificada. Para tornar o código compilável podemos colocar a instrução num bloco try-catch afim de capturá-la ou declarar a exceção numa cláusula throws do método main que irá lançá-la.

No caso de exceções não verificadas, se o método lançar uma exceção não verificada, o compilador não vai reclamar se ela não for tratada. Então o seguinte código compila normalmente:

class ExcecaoNaoTratada {
public static void main(String[] args) {
 throw new RuntimeException();
}
}

Hierarquia de classes

A classe java.lang.Throwable é uma exceção verificada. A API Java define duas subclasses de Throwable. Estes são java.lang.Exception e java.lang.Error. Error é uma classe de exceção não verificada, enquanto Exception é uma exceção verificada. A classe Exception em si tem a subclasse java.lang.RuntimeException (não verificada). As exceções não verificadas como NullPointerException, ClassCastException etc, são todas as sub-classes de RuntimeException. Todas as subclasses de RuntimeException e Error são exceções não verificadas. Outras classes são exceções verificadas.

Se você criar sua própria classe de exceção, se ela é verificada ou não, depende de qual classe Exception ela é subclasse. Se a sua classe estende uma classe de exceção verificada, então sua classe será uma exceção verificada. E se a sua classe estende uma classe de exceção não verificada, então a sua classe será uma exceção não verificada.

Existe uma regra com exceções verificadas que às vezes confunde as pessoas. Se no seu bloco catch você está capturando uma exceção verificada, então deve haver a possibilidade de sua ocorrência no bloco try. Assim, o código a seguir não vai compilar:

try {
System.out.println("...");
} catch(java.io.IOException ioe) {
}

O compilador irá informar que IOException nunca é lançada no bloco try, então você não pode capturá-la. Esta regra não se aplica às exceções não verificadas. Se você está capturando uma exceção não verificada, que não é lançada no bloco try, o compilador não vai reclamar. Agora fica um pouco confuso com as classes Exception e Throwable. Ambas são classes de exceções verificadas, mas você pode capturá-las sem qualquer exceção sendo lançada no bloco try. Então, esse código será compilado sem erros:

try {
System.out.println("...");
} catch(Exception ex) {
}

As regras são diferentes para Throwable e Exception e outras classes de exceção verificada. Isto porque tanto Exception e Throwable tem exceções não verificadas como subclasses. Assim, o compilador permite capturá-los pensando que você pode estar tentando pegar uma exceção não verificada. Lembre-se que o compilador não está preocupado com as exceções não verificadas. RuntimeException é uma subclasse de Exception e Error é uma subclasse de Throwable, e ambos RuntimeException e Error são classes de exceção não verificada. Então, quando escrever o código:

try {
System.out.println ("...");
} Catch (Exception ex) {
}

O compilador não vai reclamar porque Exception também pode capturar exceções não verificadas (RuntimeException e suas subclasses). Da mesma forma o código a seguir é permitido porque Throwable pode capturar exceções não verificadas (RuntimeException e Error e suas subclasses).

try {
System.out.println ("...");
} Catch (Throwable ex) {
}

Regras

Antes de continuar quero adiantar que os tópicos anteriores foram traduzidos deste site. Na verdade isso fugiu um pouco ao objetivo do exame mas serve como um esclarecimento sobre exceções. Agora vejamos ao que realmente importa no exame:

O método novo não pode lançar exceções verificadas novas ou mais abrangentes;
O método novo pode lançar exceções verificadas mais restritivas ou menos abrangentes;
O método novo pode lançar qualquer exceção não verificada;

A maioria dos programadores Java utilizam alguma IDE para desenvolver. É muito mais produtivo. As vezes utilizamos Notepad só para fazer alguns testes, mas normalmente alguém em boas condições mentais não programaria no bloco de notas. As IDE´s quase sempre sabem quando estamos fazendo algo errado. Aí então damos um clique e está resolvido. As regras acima são exemplos de coisas que podemos deixar por conta da IDE, mas no exame não! Para o exame você deve ter um compilador rodando em seu cérebro. A cada código analisado, você deverá saber se está certo ou não. Então vamos treinar um pouco pra isso.

A primeira regra diz que os métodos novos não podem lançar excessões novas ou mais abrangentes (menos restritivas). Abaixo temos um código que será usado como exemplo, nele temos uma sobrescrição simples:

public class Excecoes extends Exemplo{

void A (){
// Sobrescreveu..
}

}

class Exemplo{

void A (){

}

}

A primeira coisa é que não se pode fazer isso:

void A () throws Exception {
// Sobrescreveu..
}

O método novo tentou lançar uma exceção verificada nova. O código não compila. Agora analise este caso:

import java.io.IOException;

public class Excecoes extends Exemplo{

void A () throws Exception { //Tentou lançar uma exeção mais abrangente...
// Sobrescreveu..
}

}

class Exemplo{

void A () throws IOException{

}

}

O código acima também não compila. O método novo tentou lançar uma exceção mais abrangente. Com isso vimos como funciona a primeira regra. Vamos agora pra segunda:

import java.io.IOException;

public class Excecoes extends Exemplo{

void A () throws IOException { //Excesão menos abrangente e mais restritiva
// Sobrescreveu..
}

}

class Exemplo{

void A () throws Exception{

}

}

O código acima compila. O novo método lançou uma exceção que é subclasse de Exception, por isso ela é menos abrangente. O método sobrescrito se arrisca a lançar qualquer tipo de Exception, mas o método novo não precisa declarar nada que nunca lançará.
E a terceira e última regra diz que o método novo pode lançar qualquer exceção não verificada. Isso significa que o seguinte código é válido:

public class Excecoes extends Exemplo{

void A () throws RuntimeException {
// Sobrescreveu..
}

}

class Exemplo{

void A (){

}

}

Outro detalhe importante também é que o método novo pode resolver não lançar nenhuma exceção. Portanto, se ver um método sendo sobrescrito e não lançar nenhuma exceção (mesmo que o método da superclasse o faça) saiba que isto é válido.

Conclusão

Espero ter deixado mais claro este assunto que é muito importante não só pra quem vai tirar uma certificação mas também pra quem está programando no dia a dia e sabe que o negócio não é só ficar lançando exceção ou capturando sem nenhuma codificação no bloco Catch.

Até a próxima!

Inserindo labels dinamicamente

2010-10-13T10:15:00.000-03:00

Olá! Caro leitor. Hoje pela manhã estive olhando uns fóruns sobre Java quando me deparei com a seguinte pergunta: Como posso inserir labels dinamicamente em um JPanel? Então eu com meu espírito de colaborador, desenvolvi um pequeno código para responder a pergunta do indivíduo. Este código pode ser encontrado aqui.
Mas o que me inspirou mesmo fazer esta postagem não foi exatamente isto. Foi que me veio a cabeça modificar esse código e fazer com que ele mostrasse miniaturas de imagens, isto é, thumbnails. Sabemos que JLabels podem ser usados para exibir imagens num aplicativo, então bastava buscar as imagens num diretório e mostrá-las na tela. Portanto é isso que eu pretendo mostrar agora.
Primeiramente vamos ver o código básico para mostrar uma janela. Estou utilizando Swing pra fazer isso:


import java.awt.Component;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.io.File;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.WindowConstants;


public class LabelDinamico {

public static void main(String[] args) {

 JFrame janela = new JFrame("Inserindo labels dinamicamente");
 janela.setBounds(0, 0, 500, 500);
 janela.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
 janela.setLayout(null);

 //Códigos legais aqui...

 janela.setVisible(true);
}
}

Não temos nada demais aí. Alguns imports, uma classe com o método main, instanciamos e mostramos uma janela. Agora vamos aos códigos legais! Duas coisas básicas antes de inserir os labels:


 // Diretório contendo as imagens
 File diretorio = new File("C:\\imagens");
 File[] arquivos = diretorio.listFiles();

 // Posicionamento dos labels
 int boundX = 10; 
 int boundY = 10;

Primeiro pegamos o caminho do diretório que contém as imagens a serem mostradas. Se esse diretório tiver outro tipo de arquivo que não seja imagem, serão mostrados espaços vazios. Seria interessante um filtro para mostrar somente imagens, mas isso fica pra depois. Então um vetor de arquivos contém a lista das imagens. Logo em seguida declaramos variáveis que vão auxiliar no posicionamento dos labels. Isso porque os labels deverão ficar em colunas e quando chegar na largura da janela, outra fila deverá ser formada. Você vai entender melhor adiante.
Então finalmente teremos um pouco de ação! Veja como percorrer o vetor de arquivos e inserir as imagens na janela:


 // Adicionando labels dinamicamente
 for (int x = 0; x /* sinal de menor aqui */ arquivos.length; x++){
 
  // Declara uma imagem com o arquivo na posição do vetor
  final ImageIcon imagem = new ImageIcon(((File)arquivos[x]).getAbsolutePath());
 
  // Declara o label
  JLabel lbImagem = new JLabel()
  // Esse bloco é para inserir a imagem
  // e esticar de acordo com o tamanho label
  {
   public void paintComponent (Graphics g) {
   super.paintComponent (g);
    // Esses 5 sendo subtraídos é pra dar um espaço entre as imagens
       g.drawImage (imagem.getImage(), 0, 0, getWidth() - 5, getHeight() - 5, null);
   }
  };

  // Posiciona a imagem
  lbImagem.setBounds(boundX, boundY, 70, 70);
 
  // Seta o nome com o caminho da imagem
  // Será usado depois para retornar o caminho quando clidado
  lbImagem.setName(((File)arquivos[x]).getAbsolutePath());

  // Adiciona um listener
  lbImagem.addMouseListener(new MouseListener() {
   public void mouseReleased(MouseEvent arg0) {}
   public void mousePressed(MouseEvent arg0) {}
   public void mouseExited(MouseEvent arg0) {}
   public void mouseEntered(MouseEvent arg0) {}
   public void mouseClicked(MouseEvent arg0) {
   
    // Pega o label que foi clicado
    JLabel lb = (JLabel) arg0.getSource();
    // Mosta o caminho da imagem clicada
    JOptionPane.showMessageDialog(null, "O caminho da imagem é " + lb.getName(), "Imagem", JOptionPane.INFORMATION_MESSAGE);
   }
  });
 
  // Prepara a posição x do próximo label
  boundX += 70;
 
  // Verifica se estourou o limite
  if (boundX /* sinal de maior ou igual aqui */ janela.getWidth() - 70)
  {
   // Desce uma fila
   boundY += 70;
   boundX = 10;
  }

  //Adiciona o label
  janela.add(lbImagem);
 }

O código está bem comentado, mas ainda assim vou fazer mais algumas considerações:

Note que primeiramente percorremos o vetor dos arquivos utilizando um for (tive que retirar o sinal de menor pq o blogger não entende isso...)
Então inicialmente criamos um ImageIcon que contém a imagem do arquivo que está no vetor daquela posição.
Logo depois declaramos o label e utilizamos paintComponent para desenhar a imagem no label. Isto é usado para que a imagem fique do tamanho do label. A imagem será esticada (pra mais ou pra menos), para caber no label.
Em seguida é feito o posicionamento e a propriedade name é configurada com o caminho do arquivo. Isso é porque depois usaremos esta mesma propriedade para retornar o caminho quando a imagem for clicada. De outra forma não teria como saber qual imagem está desenhada no label. Poderíamos criar uma subclasse de label e adicionar uma ou mais propriedades adequadamente, mas deixaremos assim mesmo por enquanto.
Um listener é criado para mostrar a propriedade configurada anteriormente quando a imagem for clicada. Poderemos desejar fazer alguma coisa com isto depois.
Finalmente a posição é configurada, levando em conta o tamanho da janela. O label é adicionado na janela.

Vejamos como ficou:

Outra coisa que podemos fazer é pegar todos os componentes da janela (no caso, os labels) e exibir suas propriedades ou modificar alguma coisa. Veja como fazer isto:


 for (int x = 0; x /* sinal de menor aqui */ labels.length; x++){
  if (labels[x] instanceof JLabel)
  {
   // Mostra todos o name dos labels
   System.out.println(((JLabel)labels[x]).getName());
  }
 }

Bom, é isso que eu tinha pra passar pra vocês hoje. O código completo você encontra aqui. Sei que falta muita coisa ainda pra que esse código se torne um componente de verdade e possa ser reutilizado mas o primeiro passo está dado. Espero que tenham gostado e até a próxima!

Introdução ao JavaScript - Parte 2

2010-10-12T18:55:00.000-03:00

Depois de algum tempo sem postar aqui, devido a projetos pessoais e faculdade, estou de volta para mostrar mais algumas coisas sobre JavaScript como havia prometido. Então vamos lá!

O Objeto document

Document é um objeto usado para modificar ou obter propriedades da página que está sendo exibida. Ele é um container com todos objetos que estão na página HTML.
Vamos começar com um simples exemplo de como esse objeto pode ser usado:

Neste exemplo usamos o método write e a propriedade location de document para escrever na página e mostrar qual a atual URL sendo exibida.
Outro caso simples de uso seria para alterar a cor de fundo da página:

Obviamente o objeto document possui muitos outros métodos e propriedades, mas não vou abordar todos aqui, caso queira saber mais entre aqui.

Outros objetos

Existem outros objetos que também são importantes no JavaScript:

Window
Navigator
Screen
History
Location

Uma propriedade do objeto navigator muito utilizada serve para retornar o navegador utilizado:

Aqui segue uma boa referência dos objetos usados no JavaScript.

Semelhanças entre Java e JavaScript

Esse tópico não é sobre características nem finalidades das linguagens, mas sim sobre semelhanças em sua sintaxe. Vamos começar com os operadores.
Os operadores no Java são praticamente os mesmos do JavaScript:

Aritméticos: +, -, *, /, %, ++, --
Atribuição: +=, -=, *=, /=, %=
Comparação: ==, !=, >, >=, <, <=
Lógicos: &&, ||, !

JavaScript não suporta o operador instanceof. Outra coisa importante sobre operadores é que strings devem ser comparadas utilizando ==, veja:

O resultado é true. Porém se uma string for inicializada assim:


var x2 = new String("teste");
var x3 = new String("teste");

A comparação deve ser feita deste modo:


if(x2.toString() == x3.toString())
 document.write("true");
else
 document.write("false");

Achei essa dica aqui...
Com isso também podemos ver que a estrutura de comparação if é a mesma nas duas linguagens.

Agora vamos para a estrutura de seleção switch:


switch (variável)
{
 case 'valor 1': 
 {
  //bloco de comandos;
  break;
 }
 case 'valor2':
 {
  //bloco de comandos;
  break;
 }
 default:
 {
  //comando alternativo;
 }
}

Aqui temos uma estrutura básica. Temos duas diferenças da linguagem Java. Uma são as chaves entre os blocos e outra é o tipo de dados. No Java o switch trabalha com os tipos primitivos byte, short, char, e int (existem algumas exceções mas basicamente é isso). Já no JavaScript podemos trabalhar com strings também. Continuando o exemplo anterior:


switch (x1)
{
 case 'texto': 
 {
  document.write("Ok!");
  break;
 }
 case 'valor':
 {
  //bloco de comandos;
  break;
 }
 default:
 {
  document.write("Nenhum!");
 }
}

Veja também que tanto faz usar aspas simples ou duplas. Outra coisa é que os comentários podem ser feitos da mesma forma que o Java (//... ou /* ... */ ).

Agora vamos para estruturas de repetição. No JavaScript temos 3 tipos delas, for, while e do while. Alguns dizem que são 4 estruturas, contando que existem 2 tipos de for (for normal e for in). Exceto o for in, as outras funcionam da mesma forma nas duas linguagens:

Assim como no Java, o JavaScript também aceita as instruções break e continue.
Agora o for in. O for in funciona como o for each do Java. Temos um array com elementos e usamos o for in para percorrê-lo:


var x;
var carros = new Array();
carros[0] = "Ferrari";
carros[1] = "Lamborghini";
carros[2] = "Porsche";

for (x in carros)
{
 document.write(carros[x] + "
");
}

Conclusão

Finalizo essa introdução ao JavaScript e espero que possam ter tirado algum proveito das informações contidas aqui. Sei que é pouca coisa mas dá pra começar. Tem um site muito bom que tenho usado como referência: w3schools. Esse site tem muito conteúdo, não so de JavaScript mas outras linguagens também.

Bons estudos!

Introdução ao JavaScript - Parte 1

2010-08-23T10:08:00.000-03:00

Hoje teremos um post sobre JavaScript pra variar um pouco. Farei este post em duas partes. Na primeira vou fazer uma introdução sobre a linguagem dando alguns conteitos básicos e também falarei sobre variáveis e eventos. Na próxima parte teremos objetos importantes, suas propriedades e também sobre semelhanças com a linguagem Java.

O que é JavaScript?

De acordo com a famosa enciclopédia digital "JavaScript é uma linguagem de programação criada por Brendan Eich para a Netscape em 1995, que a princípio se chamava LiveScript. A Netscape, após o sucesso inicial desta linguagem, recebeu uma colaboração considerável da Sun, a qual possibilitou posteriormente dizer que o JavaScript é uma linguagem compatível com a linguagem Java, por esta razão, a semelhança dos nomes."

Pontos importantes sobre JavaScript quanto aos tipos:

fraca - sua tipagem é mutável;
dinâmica - uma variável pode assumir vários tipos diferentes durante a execução;
implícita - as variáveis são declaradas sem tipo.

Porque usar JavaScript? JavaScript permite tornar páginas HTML mais dinâmicas. Usamos a linguagem para interagir com a página, validar formulários, etc. Vamos ao que interessa.

10 Perguntas básicas sobre JavaScript

Estas perguntas foram baseadas num quiz disponível aqui. É necessário obter 100% pra dizer que se tem um conhecimento básico sobre JavaScript.

1. Qual elemento é utilizado para os scripts?

Em uma página HTML colocamos os códigos JavaScript dentro de tags script, como mostra o exemplo:

2. Qual é o lugar correto para inserir JavaScript?

Os scripts podem ser inseridos tanto no cabeçalho(head) quanto no corpo(body) da página.

3. Qual a sintaxe para fazer referência a um script externo?

Scripts externos devem ser salvos com a extenção js e podem ser referenciados utilizando o parâmetro src:

4. Arquivos JavaScript externos precisam ter a tag script?

Não, somente códigos.

5. Como escrever um texto na página?

Para escrever na página usa-se document.write:


document.write("Hello World");

6. Como mostrar mensagens utilizando uma caixa de alerta?

Mensagens podem ser exibidas numa caixa de alerta simplesmente chamando:


alert("Hello World");

7. Como criar uma função?

Funções podem ser criadas utilizando a palavra function, veja:


function myFunction()
{
//Códigos da função
}

8. Como chamar uma função?

Funções podem ser chamadas simplesmente digitando seu nome:


myFunction()

9. Como abrir uma janela?

Pode-se abrir uma janela chamando window.open:


window.open("http://marciosouzajunior.blogspot.com");

10. Como colocar uma mensagem de status no navegador?

Mensagens de status são uma propriedade do objeto window e podem ser modificadas diretamente:


window.status = "Mensagem";

Obviamente existe muito mais sobre JavaScript que você deveria saber. Essas perguntinhas foram apenas pra você poder falar com os amigos que sabe alguma coisa de JavaScript. E também se algum dia for fazer uma prova que caia JavaScript, não passe em branco. Vamos ver outras coisas importantes agora.

Variáveis

JavaScript possui 3 tipos de dados: número, caractere e booleano. Não tem segredo. Como já foi dito, as variáveis podem ser declaradas sem um tipo específico. A simples associação de um valor faz com que a variável passe a existir:


x = 2;

E seu tipo pode mudar como quiser:


var x = 2;
alert(x);
x = "texto";
alert(x);

Usar a palavra var é opcional. Usamos apenas quando queremos declarar a variável sem um valor inicial. Se fizermos isto o seu valor será undefined. Também podemos associar um valor null, que é quase a mesma coisa que undefined.
Não tem muito o que falar sobre variáveis em JavaScript, os criadores da linguagem deixaram as coisas bem simples de trabalhar.

Eventos

Eventos são coisas que podem acontecer durante a execução de um programa (neste caso da página). Um clique de mouse, uma caixa que perde o foco, são eventos que podem ocorrer a qualquer momento. Podemos desejar que esses eventos disparem alguma ação. Logo abaixo temos uma lista de eventos que o JavaScript pode capturar e quando eles acontecem:

onLoad: Quando a página é carregada.
onUnload: Quando a página é fechada.

Esses dois eventos só ocorrem no body, portanto poderiam chamar alguma ação da seguinte forma:


<_body onload="alert('Oi');">

Todos sabemos que body não tem underline, mas sou obrigado a escrever assim porque mais uma vez o blogger está confundindo as coisas. Espero que todos tenham entendido. Continuando...Agora vamos ver 3 eventos que podem ocorrer em objetos text, select e textarea:

onChange: Acontece quando o objeto perde o foco e houve mudança de conteúdo.
onBlur: Acontece quando o objeto perde o foco, independente de ter mudado o conteúdo.
onFocus: Quando o objeto ganha o foco.

Aqui temos um exemplo:

O próximo evento pode ser usado para text e textarea:

onSelect: Ocorre quando seleciona parte ou todo texto do objeto.

Os próximos eventos tem a ver com o mouse:

onClick: Quando o objeto é clicado. Pode acontecer nos objetos button, checkbox, radio, link, reset e submit.
onMouseOver: Quando passa o mouse sobre o objeto.
onSubmit: Quando clica no botão submit. Váido somente para forms.

Exemplo:


 Blog do Márcio

Certamente numa prova de JavaScript teria pelo menos uma questão sobre esses eventos. Principalmente sobre o evento onBlur, porque facilmente alguém acreditaria que um suposto evento onLostFocus estaria certo.

Fim da Parte 1

Bom, ficamos por aqui com esta introdução ao JavaScript. Espero que você possa ter tirado algum proveito do material. Em breve teremos a segunda parte com mais informações sobre os objetos document, window e também sobre semelhanças com a o Java.

Bons estudos!

Enums - Java

2010-08-13T17:03:00.000-03:00

Enums são um tipo de classe Java que quase nunca utilizamos. Acredito que muita gente nem imagina que esse tipo de classe existe. Diferente de classes comuns e interfaces, o Enum foi inserido na versão 5 do Java. Ele permitie enumerar uma quantidade de valores pré-definidos que podem ser aceitos para uma variável.
Vamos a um exemplo prático. Precisamos de uma variável que só aceite 3 valores: maçã, pera e uva. Então declaramos:

enum Frutas { MAÇÃ, PERA, UVA }; //É opcional colocar ponto-e-vírgula

Obs.: Por convenção as constantes são escritas em maiúsculas. Um Enum é constituido basicamente por suas constantes, mas logo veremos que podem existir outras coisas a mais. Eles podem ser declarados como membro de uma classe ou fora da classe, mas nunca dentro de métodos (inclusive o main). Outro ponto importante é que os Enums só aceitam os modificadores default e public (não aceita private, protected, final, abstract nem static). Veja um exemplo de declaração fora da classe:

enum Frutas { MAÇÃ, PERA, UVA }

public class Run {

 Frutas tipo; //Run tem uma variável de instância do tipo Frutas

 public static void main(String[] args) {
 
     Run r = new Run();
     r.tipo = Frutas.MAÇÃ;
 
 }
}

Enums não são do tipo String ou de outro tipo. Eles são do seu próprio tipo, neste caso Frutas. MAÇÃ, PERA ou UVA são tipos de Frutas. Se fizermos o teste:

if (Frutas.MAÇÃ instanceof Frutas)
 System.out.println("Maçã é do tipo Fruta");

O resultado será: Maçã é do tipo Fruta

Então sabemos o que são Enums, como e onde declará-los. E também sabemos que por ser uma classe, tem seu próprio tipo. Agora vamos ver umas coisas mais interessantes.

Construtores, Métodos e Variáveis em um Enum

Como os Enums são um tipo especial de classe, eles podem ter construtores, variáveis e até um corpo de classe para as constantes (mais adiante explico o que é essa coisa bizarra). Vamos ver como funcionam esses membros passando um parâmetro para cada constante:

 MAÇÃ("vermelha"), PERA("verde"), UVA("roxa");

Cada tipo de fruta agora recebe um parâmetro do tipo String, como numa chamada de método normal (poderíamos ter outros tipos, dependendo do construtor). De acordo com os argumentos, neste caso teríamos o seguinte construtor:

 Frutas(String cor){
     this.Cor = cor;
 }

Sendo assim, devemos ter uma variável de instância para receber a cor:

 private String Cor;

E ainda um método para retornar a cor da fruta escolhida:

 void getCor(){
     System.out.println("A cor da fruta escolhida é " + Cor);
 }

O Enum completo ficaria assim:

enum Frutas {

 //Passando parâmetros a cada constante
 MAÇÃ("vermelha"), PERA("verde"), UVA("roxa");

 //Construtor
 Frutas(String cor){
     this.Cor = cor;
 }
 //Variavel de instância
 private String Cor;

 //Método que mostra a cor da fruta escolhida
 void getCor(){
     System.out.println("A fruta escolhida é " + Cor);
 }

}

Observe que quando temos mais membros além das constantes é obrigatório o ponto-e-vírgula após as constantes.
Agora modifique a classe Run para que fique parecida com esta:

public class Run {

 Frutas nome;

 public static void main(String[] args) {
 
     Run r = new Run();
     r.nome = Frutas.MAÇÃ;
     r.nome.getCor();
 }
}

A saída será: A fruta escolhida é vermelha

Sobre o construtor do Enum devemos saber que ele nunca poderá ser invocado diretamente. Ele só pode ser chamado pelo próprio Enum, ou melhor, por cada constante. Os construtores também podem ser sobrecarregados, como no exemplo:

 MAÇÃ("vermelha"), PERA("verde"), UVA("roxa", "verde");

 Frutas(String cor){
     this.Cor = cor;
 }
 //Construtor sobrecarregado
 Frutas(String cor, String cor2){
 }

Corpo de Classe específico da constante

Como eu mencionei anteriormente, os Enums podem possuir uma coisa estranha chamada corpo de classe específico da constante. Esse corpo é um bloco de código que podemos definir para cada constante. Usamos esse corpo para substituir um método definido dentro do Enum. Vamos ver na prática:

enum Frutas {

 MAÇÃ,
 PERA,
 UVA{
     //Corpo da constante UVA
     //Códigos legais aqui...
 };

 void getFoo(){
     System.out.println("Frutas são saudáveis.");
 }

}

Observe que se chamarmos por r.nome.getFoo(), independente de qual fruta tenha sido escolhida, sempre teremos a saída: Frutas são saudáveis. Porém agora vamos sobrescrever o método dentro do corpo da constante UVA:

enum Frutas {

 MAÇÃ,
 PERA,
 UVA{
     void getFoo(){
         System.out.println("BAD FRUIT!!!");
     }
 };

 void getFoo(){
     System.out.println("Frutas são saudáveis.");
 }

}

E então chamamos:

     r.nome = Frutas.UVA;
     r.nome.getFoo();

A saída será: BAD FRUIT!!!

Ok, mas pra que fazer isso? Imagine que todos os elementos do Enum tenham uma propriedade, um código por exemplo. Mas um determinado elemento não pode ter aquele código. Então usamos o corpo da constante para definir um comportamento especial pra ele. É realmente difícil imaginar uma aplicação para isso, mas apenas saiba como funciona que será o bastante para passar no exame! E por hoje é só.

Bons estudos!

Menu Dinâmico - Java

2010-08-11T11:40:00.000-03:00

Olá! Hoje vou mostrar como implementar um menu dinâmico. Na verdade eu usei esta aplicação para gerar um menu com todos os LookAndFeels disponíveis. Criar menus ou qualquer outro tipo de objeto dinâmico significa que ele é criado em tempo de execução. Mas pra que fazer isso? Por exemplo, num sistema ERP cada usuário tem um nível de acesso, então dependendo de quem logar no sistema, determinados itens no menu estarão disponíveis ou não. O sistema verifica no banco de dados quais as permissões daquele usuário e monta o menu em tempo de execução.
Mas no exemplo que vou mostrar não usa banco de dados, mas seria interessante implementar alguma forma de salvar o LookAndFeel selecionado. Porque fazer isto dinamicamente? Neste caso o menu teria que ser dinâmico porque os LookAndFeels podem ser instalados ou removidos da JRE.
Também vou mostrar como escrever um ActionListener que será usado ao acionar os eventos dos itens no menu.

Utilizando LookAndFeels

Antes de mais nada vamos fazer os seguintes imports:


import javax.swing.UIManager;
import javax.swing.UIManager.LookAndFeelInfo;

E também declarar uma variável de instância:


static LookAndFeelInfo skins[] = UIManager.getInstalledLookAndFeels();

Agora temos um array com os LookAndFeels disponíveis. Deixaremos como static para não ter que instanciar depois quando for preciso chamar no Listener (mais adiante você vai entender).

Montando o Menu

Para montar o menu eu criei um método que retorna um tipo JMenuBar. Para adicionar o menu na sua aplicação simplesmente chame o método dentro do construtor:


super.setJMenuBar(montaMenu());

O método é algo parecido com isto:


JMenuBar montaMenu(){

//Cria a barra
JMenuBar barraMenu = new JMenuBar();

//Cria o menu
JMenu menuSkins = new JMenu("Skins");

/*Aqui vamos adicionar os itens dinamicamente no menu Skins
Mas por enquanto um pouco de suspense....*/

//Adiciona o menu na barra
barraMenu.add(menuSkins);

//Retornamos a barra prontinha
return barraMenu;

}

Bom, agora só falta adicionar os itens no menu Skins. Esta parte pode parecer um pouco confusa a primeira vista mas não é!
Primeiramente vamos criar um array do tipo JMenuItem do tamanho de skins.length, isto é, com quantas posições forem necessárias para acomodar todos os LookAndFeels instalados.


JMenuItem itemSkin[] = new JMenuItem[skins.length];

Agora criamos outro array do tipo myListener (???) para os ActionListeners dos itens declarados acima. Calma que logo veremos essa classe myListener. O tamanho do array segue o mesmo exemplo mostrado.


myListener [] eventosMenu = new myListener[skins.length];

Agora vai ficar bom! Vamos entrar num for passando por todos skins:


for (int skin = 0; skin /*sinal de menor aqui*/ skins.length; skin++)
{
 itemSkin[skin] = new JMenuItem(skins[skin].getName());
 eventosMenu[skin] = new myListener(skin);
 itemSkin[skin].addActionListener(eventosMenu[skin]);
 menuSkins.add(itemSkin[skin]);
}

O que acontece? Primeiro o array itemSkin recebe um item com o nome do LookAndFeel. Então um Listener é criado no array e recebe como parâmetro o número daquele skin (mais adiante explico porque). Depois o ActionListener é adicionado ao item. Por último o item é adicionado ao menu. Nao esqueça de colocar o sinal de menor no for onde está comentado, se eu colocar o Blogger pensa que é uma tag e atrapalha tudo! Se alguém souber como desativar essa verificação me avise!
O método deverá ficar assim:


JMenuBar montaMenu(){

//Cria a barra
JMenuBar barraMenu = new JMenuBar();

//Cria o menu
JMenu menuSkins = new JMenu("Skins");
 
for (int skin = 0; skin /*sinal de menor aqui*/ skins.length; skin++)
{
 itemSkin[skin] = new JMenuItem(skins[skin].getName());
 eventosMenu[skin] = new myListener(skin);
 itemSkin[skin].addActionListener(eventosMenu[skin]);
 menuSkins.add(itemSkin[skin]);
}

//Adiciona o menu na barra
barraMenu.add(menuSkins);

//Retornamos a barra prontinha
return barraMenu;

}

Escrevendo um Listener

Para acionar os eventos do menu, o autor achou que seria interessante implementar um Listener personalizado. Isto porque o Listener deveria conter o número do LookAndFeel que ele gostaria de mostrar naquele momento. Para escrever um Listener, implemente a classe ActionListener e o método actionPerformed:


import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JOptionPane;
import javax.swing.UIManager;

public class myListener implements ActionListener{
private int skin = 0;

public myListener(int newSkin) {
this.skin = newSkin;
}

public void actionPerformed(ActionEvent arg0) {
try{
UIManager.setLookAndFeel(Principal.skins[skin].getClassName());
JOptionPane.showMessageDialog(null, "Seu skin foi alterado para " + Principal.skins[skin].getName() + ".\nCaso tenha janelas internas em execução, reinicie-as para aplicar as alterações.", "Skins", JOptionPane.INFORMATION_MESSAGE);
}catch(Exception e)
{
e.printStackTrace();
}
}
}

Veja que a classe possui um construtor que recebe o LookAndFeel a ser mostrado. Por isso que passamos como parâmetro quando estamos criando os objetos Listener. Dentro do actionPerformed chamamos o método que configura o LookAndFeel recebido e mostra uma mensagem. Coloquei esta mensagem porque estou trabalhando com InternalFrames e eles precisam ser reabertos para que as aplicações ocorram. Lembrando que as duas classes estão no mesmo pacote.
Veja o resultado final:

Agora é só implementar mais alguma coisa pra salvar o LookAndFeel selecionado.
Espero que tenham gostado!

Eclipse - Visual Editor - MySQL

2010-08-09T17:18:00.000-03:00

Introdução

Olá! No post de hoje pretendo mostrar como iniciar no desenvolvimento de aplicações gráficas que utilizem banco de dados em Java. Será mostrado como criar um simples banco de dados e fazer a conexão através do programa. Também ensinarei como instalar o Visual Editor que é usado criar a parte gráfica. Então finalmente veremos como inserir dados no banco.
O que me motivou a criar este tutorial é que tenho visto muito material sobre, porém coisas sem pé nem cabeça, códigos que não compilam, trabalho mal feito. Como eu odeio coisas mal feitas, fiz este post bem didático. Vou mostrar desde a instalação e configuração das feramentas até os testes finais. Todos os códigos foram testados pelo autor.

O Ambiente

Primeiramente vamos preparar o ambiente de desenvolvimento. Logo abaixo você encontra as ferramentas necessárias. Recomendo que utilize as ferramentas nas versões citadas.

Eclipse Galileo (3.5)

O Eclipse é uma IDE muito popular no mundo Java, por isto estarei utilizando-a neste exemplo. Nada impede que se utilize outra IDE, algumas coisas mudam mas os códigos são os mesmos.

Como instalar?

Ele não precisa de ser instalado, depois de baixar é só descompactar. No primeiro uso ele vai pedir o caminho do Workspace, que é a pasta padrão para os seus projetos. Escolha uma pasta de sua preferência e marque a caixa Use this as the default... para ele não perguntar novamente. Se futuramente quiser mudar vá em File > Switch Workspace.
Obs.: Versões superiores a esta ainda não são compatíveis com o Visual Editor, que atualmente está na versão 1.4.0 (hoje é 10/8/2010). Não tente instalar essa versão no Eclipse 3.6 ou superior.

Visual Editor 1.4

O Visual Editor é um framework para desenvolver a parte gráfica dos programas. O Eclipse não é como o Visual Basic que você instala e já tem tudo lá prontinho pra você começar a arrastar os botões, labels, textboxs.. No Eclipse você tem que instalar o Visual Editor à parte.

Como instalar?

Existem duas formas de instalar: online e offline. Aqui vou mostrar só online: Vá no Eclipse em Help > Install New Software... > Add... Em Name você coloca Visual Editor. Em Location cole o endereço:
http://download.eclipse.org/tools/ve/updates/1.4/.
Após alguns segundos vai aparecer uma árvore de pacotes com a raiz VE 1.4.0 R200.... Dentro da árvore existem vários pacotes e somente o pacote cujo nome é Visual Editor deverá ser marcado. Se marcar outros poderá causar conflitos. Então clique em Next. Ele vai fazer o download e quando estiver pronto clique em Finish para iniciar a instalação. Depois de alguns minutos você deve ser questionado se confia no certificado do Eclipse.org, pode confiar. Depois ele vai perguntar se deseja reiniciar o Eclipse. Você vai dizer que sim e pronto! Depois de reiniciar, vá em Help > About Eclipse > Installation Details. Na aba Features o Visual Editor deve estar presente. Se tiver dificuldade, veja este vídeo.

MySQL Server

O MySQL é o servidor de banco de dados open source mais popular do mundo (pelo menos de acordo com a definição dos seus desenvolvedores). Faça o download do arquivo: Windows (x86, 32-bit), MSI InstallerEssentials (mysql-essential-5.1.49-win32.msi) ou o 64-bit de acordo com seu sistema. Também faça o download do MySQL Workbench (mysql-workbench-gpl-5.2.26-win32.msi) para ter acesso as ferramentas gráficas SQL Development (antigo MySQL Query Browser) e Database Administration (antigo MySQL Administrator).

Como instalar o MySQL Server?
Next >
Complete > Next >
Install > (Windows Seven pede permissão)
Next > Next > Finish.
Configuração:
Next >
Standart COnfiguration > Next >
Install As Windows Service > Next >
Escolha a senha >
Execute.

Se quiser mudar a configuração posteriormente ou remover a instância execute o MySQL Server Instance Config Wizard que é criado pelo MySQL no Iniciar > Programas > MySQL > MySQL Server 5.1
ATENÇÃO: Quando for escolher a senha tome muito cuidado para não errar ou esquecer porque depois vai dar trabalho remover a instância do MySQL sem saber a senha. Recomendo que coloque a senha root para o usuário root se estiver apenas aprendendo e a segurança não for importante.

Como instalar o Workbench?
Next >
Complete > Next >
Install >
Finish.

Connector/J 5.1.13

MySQL Connector/J é o driver JDBC oficial para o MySQL. Ele permitirá que nosso aplicativo Java se conecte com o MySQL.
JDBC ou Java Database Connectivity é um conjunto de classes e interfaces (API) escritas em Java que fazem o envio de instruções SQL para qualquer banco de dados relacional, neste caso o MySQL.

Como instalar?

Por enquanto você vai apenas descompactar o arquivo. O driver é inserido diretamente nas bibliotecas de cada projeto. Portanto o procedimento será mostrado mais adiante na criação do projeto.

O Projeto

O exemplo que pretendo apresentar aqui é bem simples: Uma agenda de telefones. O banco vai conter nada mais que o nome e telefone da pessoa. Vamos criar uma tabela chamada Pessoa e nela teremos 2 campos, nome e telefone. O propósito não é mostrar aspectos do banco de dados como relacionamentos, consultas, etc. Apenas será mostrado como se conectar ao banco e inserir um registro. Sabendo disto, você pode pesquisar mais sobre o assunto depois e incrementar sua aplicação.

O Banco de Dados

O banco de dados é a base do seu projeto. Se o banco é mal projetado, isso vai refletir negativamente no projeto inteiro, porque quase toda a aplicação vai trabalhar em cima dele. Por este motivo o banco deve ser bem projetado. Deve ser desenvolvido com base em informações sólidas sobre o modelo do negócio que se deseja implementar para evitar problemas futuros. É claro que neste exemplo mostrado aqui não teria muitos problemas, o reparo seria simples. Mas essa advertência é válida para que todos saibam a importância dessa parte do projeto. Então vamos criar o banco.

Execute o Workbench.
Clique no menu File > New Model.

No menu Database clique em Query Database...Uma Janela Connect to Database irá aparecer. Clique em OK. Se a instância do MySQL estiver instalada e executando vai pedir a senha.

Entre com a senha e OK.
Na aba SQL Query cole o seguinte código:


CREATE DATABASE AGENDA;
USE AGENDA;

CREATE TABLE PESSOA(
 Nome VARCHAR(100),
 Telefone VARCHAR(100),

 PRIMARY KEY(Nome)

)

Clique no ícone Execute SQL Script in Connected Server:

Se tudo der certo, na aba Output vai aparecer a mensagem:
0 row(s) affected.
Se não der vai aparecer um erro parecido com este:

Error Code: 1064 You have an error in your SQL syntax; ...
Clique com o botão direito na parte Object Browser e Refresh All. O novo banco deve aparecer.

Pronto. Criamos um simples banco de dados chamado Agenda e dentro dele somente uma tabela chamada Pessoa com dois campos para nome e telefone, sendo o nome a chave primária (campo que identifica cada registro unicamente e não pode ser duplicado).

A Parte Gráfica

Abra o Eclipse e na parte Package Explorer clique com o botão direito e New > Java Project. Em Project Name digite "ProjetoExemplo" e Finish. No menu do Eclipse tem um botão chamado New Java Class, clique nele e depois em Visual Class:

Na janela que aparecer será solicitado o nome da classe em Name, digite Principal. Ainda nesta janela mais embaixo tem uma parte chamada Style. Nesta parte navegue por Swing > Frame. Ao lado marque a caixa public static void main(String[] args). Sua janela deverá ficar igual a esta (clique para ampliar):

Clique em Finish.
No meio da interface do Eclipse teremos uma divisão entre a parte visual e a parte dos códigos. Tudo que é feito em um reflete no outro. Pode-se alternar as partes utilizando as setas como mostra o círculo entre elas:

A seta indicada pelo outro círculo mais acima abre a paleta de objetos:

Antes de começar a colocar os objetos vamos definir o tipo de layout. Clique no meio do frame como botão direito e vá em Set Layout > null. Este layout nos dá mais liberdade para posicionar os itens no frame. Os outros tipos colocam os objetos em partes pré-definidas para que não se desorganizem quando a tela for maximizada. Opcionalmente também pode-se fazer com que os objetos se alinhem à grade, para isto clique novamente no frame com o botão direito e Snap To Grid.
Para colocar os objetos no frame basta clicar no objeto desejado e depois clicar no frame onde quiser colocá-lo. Quando clicar no frame para inserir o objeto, ele vai perguntar qual nome queremos dar a ele. Use nomes com prefico lb para labels, tx para textfields e bt para botões. Depois do prefixo use um substantivo iniciando com letra maiúscula que identifique aquele objeto. Usar estes padrões de nomeação é importante e ajuda bastante na hora de chamar os objetos via código.
Então vamos criar 2 jLabels, 2 jTextFields e um jButtton. Para os jLabels use lbNome e lbTelefone. Para os jTextFields use txNome e txTelefone. E para o botão use btSalvar. Você deverá ter algo parecido com isto:

Mas nossos labels e o botão ainda estão sem um nome. Para dar um rótulo a eles clique com o botão direito em cada um e depois em Set Text. Pronto! Agora sim:

Cada uma destas propriedades que configuramos para os objetos pode ser modificada através da aba Properties:

Basta clicar no objeto que suas propriedades serão mostradas. Cada uma delas também pode ser acessada via código para fazer alterações como mudar o tamanho, cor, rótulo, desativar, esconder, etc.
Dica: Quando levar seu projeto para outro computador ou se tiver que instalar o Eclipse novamente e depois importar o projeto pode ser que as classes visuais não abram com Visual Editor, e apenas mostrem a parte do código. Neste caso clique com o botão direito na classe e Open With > Visual Editor.
Bom, agora a parte visual do nosso projeto está concluída. Mas antes de continuar vamos dar uma breve explicação sobre o que é o MVC e porque devemos utilizá-lo.

MVC

MVC ou Model View Controller é um padrão de desenvolvimento onde seu projeto é dividido em 3 partes: Model, View e Controller.
Primeiro vou falar da parte View que é a mais simples. View é a visão. View é a parte visual do projeto, ou seja, é a parte que acabamos de ver no capítulo anterior. É a interface, as janelas, botões, figuras, etc. Nada de código aqui, só visual.
Ok, agora vamos ver Model. Model vem de modelo. Model é a parte do seu projeto onde se modela os dados. Vou dar um exemplo bem prático: Num cadastro de clientes temos um modelo de cliente. Não é nada mais do que uma classe que possui os atributos desejados para aquele objeto (e métodos para acessá-los e alterá-los). Os atributos são os mesmos que encontramos na tabela cliente do banco de dados. Se não entendeu, tudo bem, fique tranquilo que daqui a pouco quando desenvolver esta parte vai ficar mais claro.
Por último temos o Controller. O Controller é o cara que faz acontecer. Ele valida os dados e faz a ligação entre View e Model. No final das contas ele que é o responsável por fazer as operações no banco de dados, caso tudo esteja bem.
Com isto vimos que o modelo MVC separa as partes do projeto e deixa cada uma a cargo de determinada tarefa. Isso é bom porque tudo fica mais organizado, erros são isolados e tratados, a manutenção é feita com mais facilidade.

Model

Segundo o modelo MVC vamos criar uma classe para representar a entidade Pessoa que está em nosso banco de dados. Vamos criar um modelo que represente uma unidade desta entidade, este tipo de classe é normalmente chamada de Bean ou JavaBean. Vamos ver um pouco de ação. Clique com o botão direito em cima do nosso projeto e New > Package. Dê o nome a este pacote de beans. Clique agora no pacote com o botão direito e New > Class. Dê o nome a esta classe de Pessoa. Implemente a classe desta forma:


public class Pessoa {
// Atributos
private String Nome;
private String Telefone;
}

Veja que temos os mesmos atributos do banco de dados. Esses atributos devem ser encapsulados para maior segurança e por isso precisamos criar os métodos para manipulá-los. Vamos fazer isto automaticamente: Clique com o botão direito dentro da classe onde se deseja criar os métodos e Source > Generate Getters and Setters. Clique em Select All e OK. Pronto, agora teremos algo parecido com isto:


package beans;

public class Pessoa {
// Atributos
private String Nome;
private String Telefone;

// Construtor sem parâmetro
public Pessoa() {
}

// Construtor que já inicializa recebendo nome e telefone
public Pessoa(String nome, String telefone) {
super();
Nome = nome;
Telefone = telefone;
}

// Getters e Setters
public String getNome() {
return Nome;
}

public void setNome(String nome) {
Nome = nome;
}

public String getTelefone() {
return Telefone;
}

public void setTelefone(String telefone) {
Telefone = telefone;
}
}

Veja também que temos dois construtores: um sem parâmetro e outro com. Você pode gerar estes construtores em Source > Generate Constructor using Fields. O construtor com parâmetros permite já inicializar o objeto passando os atributos de uma vez. O outro permite que inicialize o objeto e depois passe os atributos através dos métodos Getters e Setters. Lembre-se que se não criar nenhum construtor, o Java criará um sem parâmetros automaticamente. Mas se criar um com parâmetro, o Java não criará outro. Veja mais sobre construtores aqui.
Com isto temos nosso modelo pronto e podemos passar para o Controller, mas antes vamos ver como se conectar ao banco.

Conexão com o Banco

Clique com o botão direito no projeto e Build Path > Configure Build Path. Clique em ADD External JARs... e selecione o arquivo mysql-connector-java-5.1.13-bin.jar que se encontra dentro da pasta do driver que você baixou. Clique em OK. Agora o driver já está instalado no projeto. Para conectar crie uma classe dentro do pacote default com o nome Conexao e implemente conforme este exemplo:


package Principal;

import java.sql.*;
import javax.swing.JOptionPane;

public class Conexao {
public static Connection getConnection() throws SQLException {
try {
 Class.forName("com.mysql.jdbc.Driver");// Registrando o driver
 // Retorna a conexão
 return DriverManager.getConnection(
   "jdbc:mysql://localhost:3306/agenda", "root", "senha");
} catch (ClassNotFoundException e) {
 JOptionPane.showMessageDialog(null,
   "Não foi possível se conectar ao banco!\nInformações sobre o erro: "
     + e, "Conexao", JOptionPane.ERROR_MESSAGE);
 return null;
}
}
}

Na linha onde retorna a conexão você deve mudar a senha. Geralmente as classes de conexão tem outras coisas a mais. Esta aí é bem simples e por enquanto dá pro gasto, mas seria interessante que você fizesse uma pesquisa para saber mais sobre. Vamos deixar essa classe aí e continuar com o projeto.

Controller

Esta parte do projeto é onde "conversamos" com o banco de dados. Geralmente chamamos as classes que fazem este papel de DAO ou Data Access Object, porque são objetos que acessam os dados. DAO é um padrão para persistência de dados que separa regras de negócio das regras de acesso ao banco de dados. No MVC, todas as funcionalidades do bancos de dados devem ser feitas por classes DAO.

Então crie um pacote chamado DAO (você já deve ter percebido que criar pacotes para cada parte do MVC é uma boa prática). Dentro do pacote crie uma classe chamada PessoaDAO, que deverá ter o corpo parecido com isto:


package DAO;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.List;
import javax.swing.JOptionPane;
import beans.Pessoa;
//Import que precisa ser corrigido
import Principal.Conexao;

public class PessoaDAO {

// Cria uma conexao
private Connection con;

// Inicializa a conexão no construtor
public PessoaDAO() throws SQLException {
con = Conexao.getConnection();
}

public void remove(Pessoa pessoa) {
}

public List/*Pessoa*/ retrieveAll() {
return null;
}

public Pessoa retrieveByID(String nome) {
return null;
}

public void update(Pessoa pessoa) {
}

public void save(Pessoa pessoa) {
// Aqui vamos fazer coisas legais!!!
}
}

A princípio esta classe poderá causar alguns erros. No início criamos a classe de conexão no pacote default, porém agora para importá-la precisamos que ela esteja em algum pacote. Então crie um pacote chamado Principal e arraste as classes Principal e Conexao para este novo pacote. Outra coisa a ser corrigida é na linha 25 onde tem o método retrieveAll veja que o tipo da lista está comentado /*Pessoa*/ mas deveria estar sem comentar e entre os sinais de maior e menor como pede a sintaxe. Tive que deixar assim porque o blog estava achando que era uma tag de html e causando erro no código.
Esta classe tem vários métodos para manipular os registros do banco de dados. Observe que todos eles utilizando o bean Pessoa como parâmetro. Neste exemplo não vou mostrar como implementar todos eles, mas somente o save (no código que vou disponibilizar para download possui o remove também). Os outros métodos, depois você conseguirá fazer seguindo o mesmo exemplo do save e com mais algum conhecimento em linguagem SQL. Vejamos como ficará o nosso método save então:


public void save(Pessoa pessoa) {
 // Pega a conexão estabelecida
 Connection conn = this.con;
 // Cria um PreparedStatement
 PreparedStatement pstm = null;

 try {
  // Monta a string sql
  String sql = "Insert into Pessoa(Nome,Telefone) values(?,?);";

  /*
   * Lembrando que esta string pode ser montada diretamente com os
   * valores recebidos de pessoa por exemplo:
   * "Insert into Pessoa(Nome,Telefone) values(" + pessoa.getNome() +
   * "... mas usamos os ? ? para uma maior segurança.
   */

  // Passa a string para o PreparedStatement
  pstm = conn.prepareStatement(sql);

  // Coloca os verdadeiros valores no lugar dos ?, ?
  pstm.setString(1, pessoa.getNome());
  pstm.setString(2, pessoa.getTelefone());
  // Executa
  pstm.execute();
  // Retorna uma mensagem
  JOptionPane.showMessageDialog(null, "Dados salvos com sucesso!",
    "Salvar", JOptionPane.INFORMATION_MESSAGE);
 } catch (SQLException e) {
  // Retorna uma mensagem informando o erro
  JOptionPane.showMessageDialog(null,
    "Não foi possível salvar os dados!\nInformações sobre o erro: "
      + e, "Salvar", JOptionPane.ERROR_MESSAGE);
  e.printStackTrace();
 }
}

Dica: Para achar o método olhe a parte direita na interface do Eclipse chamada Outline e procure por main (serve pra encontrar outros métodos ou variáveis também).
Agora sempre que o programa for iniciado uma conexão será aberta (e na finalização seria interessante fechar esta conexão mas por hoje não vou mostrar como fazer).

Inserindo Dados

A inserção de dados deverá ocorrer sempre que o botão salvar for acionado. Então vamos chamar o código sempre que este evento acontecer. Para isto clique com o botão direito no botão salvar e Events > actionPerformed. Será gerado um código igual a este:


  btSalvar.addActionListener(new java.awt.event.ActionListener() {
   public void actionPerformed(java.awt.event.ActionEvent e) {
    System.out.println("actionPerformed()"); // TODO Auto-generated Event stub actionPerformed()
   }
  });

Sempre que o botão for clicado este método será executado. No código gerado ele cria um System.out.println("actionPerformed()"); como padrão. Apague esta linha e coloque o seguinte código no lugar:


//Criamos um bean
    Pessoa pessoa = new Pessoa(txNome.getText(), txTelefone.getText());
   
    /* Passou os parâmetros pelo construtor mas
     * poderia ter um construtor vazio e passar
     * por metodo set.
     */
    //Vai criar o DAO e inserir
    try {
    
     PessoaDAO pessoaDAO = new PessoaDAO();
     pessoaDAO.save(pessoa); //Aqui é o pulo do gato
    
     //Limpa as caixas
     txNome.setText("");
     txTelefone.setText("");
     //Nome pede o focus
     txNome.requestFocus();
    
    } catch (SQLException e1) {
     // TODO Auto-generated catch block
     e1.printStackTrace();
    }

O código poderá apresentar alguns erros devidos aos imports, neste caso verifique se no canto esquedo da linha que causa o erro mostra um pequeno ícone com uma lâmpada e um X. Clique neste ícone e um menu com soluções vai aparecer, então dê dois cliques na primeira solução que será 'Import PessoaDAO' (DAO). Veja:

Feito isto finalmente podemos executar nossa aplicação. Clique com o botão direito no código e Run As > Java Application 1.
Se tudo ocorrer bem o programa irá rodar e se conectar ao banco. Para testar digite dados nos campos e clique em salvar. Se os dados forem salvos uma mensagem será mostrada informando o sucesso da operação:

Mas os campos não limparam depois de salvar. Para fazer isto coloque dentro do seu try logo após chamar o save, o código:


//Limpa as caixas
txNome.setText("");
txTelefone.setText("");
//Nome pede o focus
txNome.requestFocus();

Como ter certeza que os dados foram inseridos no banco? Para saber se os dados foram todos salvos volte ao Workbench, vá em File > New Script Tab. Vamos utilizar uma simples sentença de pesquisa:


SELECT * FROM PESSOA;

Mande executar. Se a inserção funcionou então deveremos ver os dados retornados como na figura:

Se por algum motivo os dados não forem salvos, possivelmente será mostrada uma mensagem com informações relevantes sobre o erro ocorrido. Se por acaso não salvar e mesmo assim nenhuma mensagem de erro não aparecer tente verificar se a sentença SQL está correta. Para fazer isto coloque o comando abaixo antes que o execute seja chamado no DAO:


JOptionPane.showMessageDialog(null, pstm);

Fazendo isto você vai mostrar uma mensagem com a string SQL antes de executar e poderá verificar se tem algo de errado com ela. No exemplo mostrado dificilmente você vai errar porque tem poucos parâmetros mas em programas maiores é sempre bom conferir se a montagem está correta.
Agora tente executar uma nova inserção com o mesmo nome. Uma mensagem de erro será mostrada:

Como o campo nome foi definido como PRIMARY KEY (chave primária) e houve uma tentativa de violar a chave, uma exceção foi lançada.

Conclusão

Sei que é muita informação para um post só mas é isso aí. Tentei passar de uma forma bem simples e espero ter contribuído. Aqui vai o código fonte do projeto pra quem quiser dar uma olhada. Até a próxima!

Threads - Java

2010-07-30T12:57:00.000-03:00

Olá, tudo bem?

Hoje vou tratar de um assunto muito interessante: Threads. Mas antes quero comentar outra coisa: Tenho desenvolvido uma forma bem legal de estudar para a certificação e creio que possa se aplicar a outros campos também. Funciona da seguinte maneira: Você vai lendo até chegar numa parte que o assunto ficou cansativo, então pule para outro capítulo que ache interessante. Isso proporciona uma visão global do assunto quando voltar aos primeiros capítulos e te mantém interessado nos estudos.

Mas vamos ao que interessa. Pra começar, o que são threads???

Threads são linhas de execução de um processo. É a maneira de um processo se dividir em duas ou mais partes para que possam ser executadas "ao mesmo tempo". Nem sempre é ao mesmo tempo porque na maioria das vezes temos somente uma CPU disponível. Então alguém fica a cargo de dividir as fatias de tempo entre os concorrentes. Embora quase sempre, mesmo com apenas uma CPU, temos a impressão de que tudo está sendo feito ao mesmo tempo. Mas não está! A CPU está processando um pouco de cada coisa pra te dar essa impressão. Este assunto é bem vasto, mas vamos nos ater aos threads.
Um processo no contexto que estou falando seria o programa. Poderíamos desejar que o programa faça várias coisas ao mesmo tempo. Por exemplo, um browser: Quando o browser carrega uma página com muitas imagens, ele se conecta a vários links para baixar as imagens ao mesmo tempo. Ele não abre uma por uma, existe um thread para cada tarefa de forma que todas são executadas ao mesmo tempo. Lembre-se que "ao mesmo tempo" nem sempre é verdade, mas vamos acreditar que seja.
Em Java, podemos implementar threads instanciando a classe java.lang.Thread. Um objeto do tipo Thread é um objeto como qualquer outro, possui métodos e variáveis. A grande diferença é que ele pussui sua própria pilha de chamada (falei da pilha nesse post sobre construtores). O método main é responsável por iniciar todo o processamento, portanto ele é considerado o thread principal.
As perguntas sobre thread no exame são consideradas a mais difíceis! Portanto é bom praticar muito.

Vamos ver um pouco de ação:

class MyRunnable implements Runnable /*ou extends Thread*/{

public void run() {
  System.out.println("Rodando meu Thread");
}

}

Como você pode ver, temos uma classe que implementa Runnable. Existem duas formas de se trabalhar com threads, implementando Runnable ou estendendo Thread. Você deve conhecer estas duas formas para o exame, mas geralmente a melhor prática é implementar, pois assim fica livre para estender outra classe.
Quando implementamos Runnable devemos sobrescrever o método run. Dentro do método run colocamos todo o trabalho que desejamos executar concorrentemente. Se por acaso tivéssemos escolhido estender Thread, o método run deveria ser sobrescrito da mesma forma.
Mas esta classe não faz nada ainda. Apenas estamos dizendo que o código dentro de run deverá ser executado por um thread. Agora realmente vamos ter um pouco de ação:

public class MyThread {

public static void main(String[] args) {

  MyRunnable mr = new MyRunnable();
  Thread t = new Thread(mr);
  t.start();

}
}

Em uma outra classe instanciamos MyRunnable. Criamos um objeto tipo Thread e passamos como parâmetro a variável que faz referência a MyRunnable. Então iniciamos o thread. O resultado é:

Rodando meu Thread.

Sempre devemos deixar o código do trabalho a ser feito pelo thread separado do código que vai chamá-lo, da maneira como foi mostrado. Em uma classe escrevemos o que era pra ser feito, em outra pedimos pra fazer.
Também é importante lembrar que o thread sempre espera que sua classe tenha um método run sem parâmetros. Se este método for sobrecarregado, o thread não vai chamá-lo, e mesmo que você chame-o, a execução não será a esperada de um thread. A execução acontecerá na mesma pilha de main.

Instanciando um thread

Podemos instanciar um thread de duas formas. A primeira acontece quando estendemos Thread:

class MyRunnable extends Thread{

public void run() {
  System.out.println("Rodando meu Thread");
}
}

public class MyThread{

public static void main(String[] args) {

  MyRunnable mr = new MyRunnable();
  //Thread t = new Thread(mr);
  mr.start();

}
}

Veja que esta forma é mais simples, pois MyRunnable já estendeu Thread. Então precisamos somente instanciar para executar. Mas temos implicações, pois não podemos estender outras classes. A segunda forma é a que foi mostrada primeiramente, onde implementamos Runnable. Primeiro precisamos instanciar MyRunnable e depois Thread:

MyRunnable mr = new MyRunnable();
Thread t = new Thread(mr);

Também poderíamos passar MyRunnable para diferentes threads, de modo que todos eles executem a mesma tarefa:

MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr);
Thread t2 = new Thread(mr);
Thread t3 = new Thread(mr);

t1.start();
t2.start();
t3.start();

Outra observação válida para o exame é que podemos passar um thread ao construtor de outro thread. Suponhamos que neste caso MyRunnable estende Thread, portanto ela É-UM thread. Então podemos passá-la a um construtor de outro thread:

Thread t = new Thread(new MyRunnable());

Isso é possível porque Thread possui vários construtores sobrecarregados e um deles aceita objetos Runnable. Então como Thread implementa Runnable, podemos passar tanto um Runnable quanto um Thread. Mas passar um Thread é totalmente desnecessário porque cria um novo thread sendo que o ideal é passar somente um Runnable.
Tenha em mente também que chamar o método run diretamente de uma classe que implementa Runnable é válido, porém não significa que vai se comportar como um thread:

MyRunnable mr = new MyRunnable();
mr.run();

A chamada entrará na pilha local, pois sempre que quisermos executar com thread devemos instanciar Thread. Lembre-se que o método que inicia o thread é start() e não run.
Até agora estamos indo bem, mas não tiramos proveito do recurso em momento algum. Como saberemos se os threads estão sendo executados ao mesmo tempo? Como poderemos ter certeza que eles não estão sendo executados um após o outro em sequência? Vamos modificar a classe MyRunnable:

class MyRunnable implements Runnable{
public void run() {
  System.out.println("Meu nome é: " + Thread.currentThread().getName());
}
}

Agora cada thread que executar terá que mostrar seu nome. Não se preocupe em não ter uma instância de Thread na classe pois o método chamado é estático. Ele retorna uma referência ao thread em execução e depois pega o nome dele. Agora vamos executar:

public class MyThread{

public static void main(String[] args) {

  MyRunnable mr = new MyRunnable();
  Thread t1 = new Thread(mr);
  Thread t2 = new Thread(mr);
  Thread t3 = new Thread(mr);

  t1.start();
  t2.start();
  t3.start();
}
}

A saída será parecida com a seguinte:

Meu nome é: Thread-0
Meu nome é: Thread-2
Meu nome é: Thread-1

E se mandar executar outra vez?

Meu nome é: Thread-2
Meu nome é: Thread-0
Meu nome é: Thread-1

E em cada execução o resultado poderá ser diferente. Não podemos prever a ordem que eles serão executados. Não há garantia nenhuma. O mecanismo responsável por alocar os threads (agendador) é quem decide quem vai entrar em execução (ou sair, ou esperar). A única coisa que podemos ter certeza é que cada thread será iniciado e executado até a sua conclusão.
Vamos ver mais um exemplo pra fechar o post. Faça a seguinte mudança no método run:

public void run() {
    for(int x = 0; x /* sinal de menor aqui */ 100; x++){
System.out.println("Meu nome é: " + Thread.currentThread().getName() + " e x = " + x);
}

A saída que eu obtive em uma das execuções foi:

Meu nome é: Thread-0 e x = 0
Meu nome é: Thread-0 e x = 1
Meu nome é: Thread-0 e x = 2
Meu nome é: Thread-1 e x = 0
Meu nome é: Thread-1 e x = 1
Meu nome é: Thread-1 e x = 2
Meu nome é: Thread-1 e x = 3
Meu nome é: Thread-1 e x = 4
Meu nome é: Thread-1 e x = 5
Meu nome é: Thread-0 e x = 3
Meu nome é: Thread-0 e x = 4
Meu nome é: Thread-0 e x = 5
...

Veja que Thread-0 toma a CPU e conta até 2, então sai de cena. Entra Thread-1. Por algum motivo que não sabemos explicar, a CPU permitiu que Thread-1 contasse até 5. Então a "bola" volta pra Thread-0 que continua. E Thread-2? Até o momento ainda não recebeu sua parcela da CPU, coitado!

Então finalizo este post e aproveito para dizer que o conteúdo passado aqui é somente o básico, tem muito mais sobre threads do que você imagina. Se possível outro dia volto a falar mais sobre o assunto.

Bons estudos!

Tipos Primitivos - Java

2010-07-28T17:51:00.000-03:00

Hoje vou falar sobre tipos primitivos em Java. Veremos uma breve introdução sobre variáveis e em seguida detalhes sobre cada tipo.

Variáveis

Variáveis são espaços na memória onde podemos guardar informações. Provavelmente todos programas que você escrever vão usar variáveis, seja para guardar um nome, o caminho de uma pasta, etc. Também, como o próprio nome diz, elas podem variar, ter seu valor modificado durante a execução do programa.
Variáveis são nada mais que depósitos de bits. Cada valor é convertido para binário e então pode ser colocado na memória. Usamos o nome da variável para acesar o valor. O nome da variável é apenas o endereço para acessar o valor atribuído a ela.
As variáveis possuem tipos diferentes, dependendo da informação a ser armazenada. Por exemplo: Podemos ter um depósito tipo short que nos dará um espaço para guardar qualquer valor que convertido em binário possua 16 bits (65535 valores possíveis).
Em Java temos os seguintes tipos primitivos:

Tipo      Bits      Bytes
___________________________
byte     8         1
short    16        2
int      32        4
long     64        8
float    32        4
double   64        8
char     16        2
boolean  -         -

Eles são chamados de tipos primitivos porque são tipos já pre definidos pela linguagem e seus nomes são palavras reservadas. Eles não são como os objetos. Objetos são um tipo de dado criado pelo usuário que possuem um estado e tem métodos. Primitivos não possuem estados nem métodos. Objetos podem mudar de tipo, mas os primitivos não. Uma vez declarado o tipo, assim ele será e somente o valor poderá mudar.

Os primitivos apenas determinam o tipo e o tamanho da informação a ser guardado. Vou fazer um breve comentário sobre os tipos primitivos disponíveis em Java:

byte: O byte aceita até 256 valores. Eles podem estar compreendidos entre -128 <= x <= 127. Porque alguém usaria um tipo desses? Poderia usar para salvar bytes num grande vetor, como uma memória virtual.
short: O tipo short suporta valores entre -32,768 <= x <= 32,767. Ele possui o dobro de tamanho do byte e sua aplicação poderia ser a mesma. Não se preocupe em decorar esses intervalos. Apenas o intervalo do tipo byte é bom saber mas os outros saiba apenas o número de bits de acordo com a tabela.
int: O tipo int está compreendido entre -2,147,483,648 <= x <= 2,147,483,647. Geralmente esse tipo é usado como padrão para valores inteiros. E muitas vezes, para os valores que seu programa usará, este tipo dá e sobra!
long: Um valor do tipo long pode estar entre 9,223,372,036,854,775,808 <= x <= 9,223,372,036,854,775,807. Como você pode ver, este tipo é usado quando precisar guardar valores realmente grandes que o int não poderia fazê-lo.
float: O intervalo de números deste tipo é complicado de determinar, apenas saiba que ele possui 32 bits de precisão. Ele é usado para representar os números reais, não só inteiros mas também os fracionários. O formato desse tipo de número é normalmente chamado de floating point ou ponto flutuante. Eles podem representar números com uma boa precisão fornecendo uma aproximação para valores imensos. A forma como são representados pela linguaguem é um assunto muito interessante, recomendo que você procure algo sobre se ainda não conhece. Obs.: Este tipo nunca deve ser usado para valores realmente precisos, como moeda por exemplo. Para isto use a classe java.math.BigDecimal.
double: Assim como o float, o double representa números floating point. A diferença é que ele possui 64 bits de precisão. Para valores decimais (não inteiro) esse tipo é a melhor escolha. Como mencionado anteriormente, ele também não pode ser usado para representar valores de moeda.
char: O tipo char representa um único caractere Unicode. Unicode é um padrão para representar caracteres utilizando números inteiros de 16 bits (sem sinal). Assim ele pode armazenar o mesmo tamanho de informação que um short poderia, exceto que ele sua faixa é apenas números positivos. Pode-se digitar valores Unicode utilizano o prefixo "\u".
boolean: Esse tipo de dado só tem duas possibilidades: false ou true. Ele representa um bit de informação, embora seu "tamanho" não é algo precisamente definido. Desta forma valores booleanos podem ser somente uma das possibilidades citadas, nunca tente usar 0 ou 1! Outras linguagens como c++ aceitam isto, mas Java não.

É importante saber a sequência: byte, short, int, long, float, double. Lembre que double é maior que float, o próprio nome diz que é o dobro de precisão.
Outro detalhe é que todos tipos numéricos possuem sinal, isto é, podem ser tanto positivos quanto negativos e que isto afeta seu intervalo.
Como disse no começo do tópico, os valores são guardados em formato binário (001011...), sendo assim precisamos de um desses bits para definir o sinal do número. Este bit será o que se encontra mais a esquerda do número. Por exemplo: Temos um byte 00010011. O primeiro zero a esquerda representa o sinal. Sobram sete bits para representar o número, ou seja, 2^7 = 128 possibilidades.
Portanto, o byte pode representar valores entre -128 <= x <= 127, ou melhor: de -128 a -1 e de 0 a 127. Também podemos dizer que há 256 valores aí, metade negativa e metade -1 positiva. Menos um porque os positivos começam pelo zero, e ele é considerado um binário positivo.
A fórmula para calcular o intervalo mínimo (negativo) é -2^(bits - 1) e o máximo (positivo) é 2^(bits - 1) - 1.
Lembrando também que em Java não existe a palavra unsigned como em c++. Isto que dizer que todos valores devem respeitar as faixas permitidas como foi mostrado anteriormente. Não tente fazer algo como byte b = 128; sem fazer nenhuma conversão.

Bom, por hoje é só e bons estudos!

Sobrescrita / Sobercarga (Overriding / Overloading) - Java

2010-07-23T17:02:00.001-03:00

O assunto de hoje é sobre o objetivo 1.5 e 5.4 do exame SCJP. Os objetivos são basicamente determinar se um método esta corretamente sendo sobrescrito ou sobrecarregado e sobre os tipos de retorno válidos para o método.

Também fala sobre desenvolver código que declare e chame métodos sobrescritos ou sobrecarregados, e códigos que chamem construtores da superclasse sendo eles sobrescritos ou sobrecarregados.

Métodos sobrescritos

Sempre que herdamos um método da superclasse, podemos sobrescrevê-lo. Fazendo isto temos a oportunidade de determinar um comportamento específico do método para a subclasse. Então estamos dizendo "Sei que existe um método genérico herdado da superclasse para fazer isto, mas este método não me serve e quero que esta subclasse tenha o seu próprio". Tudo bem, mas não esqueça que métodos marcados como final, private ou static não são herdados e por este motivo não podem ser sobrescritos.

Para demonstrar como os métodos são sobrescritos vou usar o mesmo código que usei no tópico sobre casting:

//Superclasse
public class Animal {

void comer(){
 System.out.println("Animal comendo...");
}

}
//Subclasse
class Dog extends Animal{

void rolar(){
 System.out.println("Dog rolando...");
}
//Dog sobrescreveu o método comer
void comer(){
 System.out.println("Dog comendo...");
}
}

Dog herdou o método comer de animal mas por algum motivo teve que escrever seu próprio método comer. Então se num determinado momento quisermos chamar:

new Dog().comer();

Teremos o resultado Dog comendo.... Sem problemas.

Vamos analisar alguns casos agora. Se você herdou métodos abstratos de uma classe abstrata, então é obrigatório sobrescrevê-los (na prática você estaria implementando porque não tem nada pra sobrescrever). Mas se sua classe também for abstrata não precisa, você pode simplente "passar a vez" para a última classe concreta da árvore. Só não esqueça que em algum momento você será obrigado a sobrescrever os métodos abstract.

Uma questão interessante que também foi abordada no post sobre casting é a seguinte: Quando sobrescrevemos um método e depois fazemos o upcast, qual método será chamado? Seguindo o mesmo exemplo do código acima, se fizermos a seguinte chamada:

Animal a = new Dog();
a.comer();

Qual versão do método será executada? Sabemos que quando convertemos pra cima da árvore de herança, os métodos do subtipo são perdidos mas neste caso a versão executada será a do subtipo. Porque? O compilador só verifica o tipo da variável e não da da instância. A referência é do tipo Animal? Então só métodos de Animal poderão ser executados. Mas em tempo de execução, o objeto real que está sendo executado é Dog, então o método de Dog será chamado.

Parece confuso mas pense: Estamos criando uma referência Animal para Dog. O que o compilador vai fazer? Ele vai pensar "Vou criar um objeto tipo Dog na memória e uma variável x tipo Animal que aponte pra este objeto." A variável sendo do tipo Animal não tem conhecimento dos métodos em Dog. Acontece que quando o programa for executado a JVM vai pensar "A variável x está chamando o método em Animal, mas o objeto sobrescreveu? Então execute o método do objeto!".

Outro ponto importante é que os métodos sobrescritos não podem declarar um modificador de acesso mais restritivo do que o que foi sobrescrito. Por exemplo:

//Superclasse
public class Animal {

protected void comer(){
 System.out.println("Animal comendo...");
}

}
//Subclasse
class Dog extends Animal{

void comer(){ //Problema!!!
 System.out.println("Dog comendo...");
}
}

Declaramos o método como protected mas depois tentamos deixá-lo default. Isto não compila porque default é mais restritivo que protected. Como expliquei antes, em tempo de execução, a JVM chama a versão do método sobrescrito, e o modificador de acesso ficou mais restrito. Se ele estivesse em um pacote diferente não poderia ser chamado.

Vamos ver agora umas regras importantes:

A lista de argumentos deve se manter a mesma!. Se ela mudar o método não será mais sobrescrito e sim sobrecarregado. Lembre-se que sobrescrever não é nada mais que usar o mesmo nome do método herdado.

O modificador de acesso do novo método não pode ser mais restritivo (menos pode). Já falei sobre isto!

Métodos só podem ser sobrescritos se forem herdados. Ou seja, métodos final, private ou static não podem. E classes fora do pacote só podem sobrescrever métodos public ou protected (métodos protected são herdados).

O tipo de retorno deve ser o mesmo ou um subtipo do método original. Isto chama-se retornos covariantes ou covariant returns. Este é um assunto a parte mas apenas lembre-se que o tipo de retorno pode ser o mesmo ou um subtipo. Não tem problema em retornar um subtipo porque com certeza ele "cabe" no supertipo.

O método que sobrescreveu pode lançar qualquer exceção de tempo de execução (não verificada / unchecked), mesmo que o método original não tenha lançado.

O método que sobrescreveu não pode lançar exceções verificadas (checked) novas ou mais abrangentes que as declaras pelo método original. Este é um assunto para outro post.

Pra finalizar a parte de sobrescrita vou fazer só mais duas observações importantes: Podemos chamar a versão da superclasse do método usando a palavra chave super:

//Superclasse
public class Animal {

void comer() {
 System.out.println("Animal comendo...");
}

public static void main(String[] args) {
 Dog g = new Dog();
 g.comer();
}
}

// Subclasse
class Dog extends Animal {

void rolar() {
 System.out.println("Dog rolando...");
}

// Dog sobrescreveu o método comer
void comer() {
 super.comer(); //Chamou a versão da superclasse
 System.out.println("Dog comendo...");
}

}

E outra, mesmo não tento falado sobre exceções vou insistir em colocar uma questão aqui que poderá cobrada no exame:

//Superclasse
public class Animal {

void comer() throws Exception {
 //Lança uma exceção
}
public static void main(String[] args) {
 Animal a = new Dog(); //Referência polimórfica
 a.comer();
}
}

// Subclasse
class Dog extends Animal {

void rolar() {
 System.out.println("Dog rolando...");
}

// Dog sobrescreveu o método comer
void comer() {
 System.out.println("Dog comendo...");
}
}

Um método foi sobrescrito, mas está sendo chamado através de uma referência polimórfica (do superclasse) para apontar para o objeto do subtipo. Como vimos o compilador vai pensar que você está chamando a versão da superclasse. Mas a JVM em tempo de execução vai chamar a versão da subclasse. A versão da superclasse declarou uma exceção, mas a do subtipo não. O código não compila devido a exceção declarada. Mesmo que a versão usada em tempo de execução seja a do subtipo.

Métodos Sobrecarregados

Metodos sobrecarregados tem uma diferença básica dos métodos sobrescritos: Sua lista de argumentos DEVE ser alterada. Por este motivo, os métodos sobrecarregados permitem que se utilize o mesmo nome do método numa mesma classe ou subclasse e isto pode ser usado para dar mais opções a quem for chamar o método. Por exemplo, podemos ter um método que receba uma variável int e outro que receba double, e a pessoa que for chamar não precisará se preocupar com fazer nenhuma conversão.

Diferente dos métodos sobrescritos, os sobrecarregados podem mudar o tipo de retorno e o modificador de acesso sem restrições. Eles também podem lançar exceções verificadas novas ou mais abrangentes.

Os métodos sobrecarregados podem ser declarados na mesma classe ou na subclasse. Saber diferenciar métodos sobrecarregados dos sobrescritos é importante pra não cair em pegadinhas como:

public class Animal {

public void comer(int x, String s) {
 System.out.println("Animal comendo...");
}
}

class Dog extends Animal {

protected void comer(int x, float s) {
 System.out.println("Dog comendo...");
}
}

O código acima pode parecer violar uma das regras de sobrescrita (modificador mais restritivo) porém ele está é sobrecarregando pois houve mudança na lista de argumentos.

Uma questão importante em métodos sorbrecarregados é: Qual método será chamado? Isso vai depender exclusivamente dos argumentos passados. Por exemplo, no caso anterior se você chamar:

new Dog().comer(2, "a");

Vai retornar Animal comendo.... Mas e se usarmos argumentos de objetos ao invés de tipos primitivos?

public class Animal {

void teste(Animal a) {
 System.out.println("Animal");
}


public static void main(String[] args) {
 new Dog().teste(new Dog()); //Chamou passando um Dog
 new Dog().teste(new Animal()); //Chamou passando um Animal
}
}

class Dog extends Animal {

void teste(Dog d) {
 System.out.println("Dog");
}
}

A saída será normal, executou o método de acordo com o tipo passado:
Dog
Animal

Mas e se a referência usada fosse polimórfica:

Animal a = new Dog();
a.teste(a);

Qual versão será executada? Você poderia pensar que seria a versão de Dog, porque estamos passando uma referência ao objeto Dog. Mas não é, a saída seria Animal pois mesmo sabendo que em tempo de execução o objeto utilizado será um Dog e não um Animal, quando o método é sobrecarregado isto não é decidido em tempo de execução. Então lembre-se: Quando o método é sobrecarregado, apenas o tipo da referência importa para saber qual método será chamado.

Resumindo, o método sobrescrito a ser chamado é definido em tempo de execução e o sobrecarregado no tempo de compilação.

Então pra fechar o tópico vou dar mais uma dica: Fique atento aos métodos que parecem ser sobrescritos mas estão sendo sobrecarregados:

public class Animal {

void teste() { }

}

class Dog extends Animal {

void teste(String s) {}

}

A classe Dog tem dois métodos: A versão teste sem argumentos que herdou de Animal e a versão sobrecarregada. Um código que faz referência a Animal pode chamar somente teste sem argumentos mas uma referência a Dog pode chamar qualquer um.

Dever de casa
Dado:

class Plant{

String getName() { return "plant"; }
Plant getType() { return this; }

}

class Flower extends Plant{

 //Insira o código aqui

}

class Tulip extends Flower { }

Quais instruções, inseridas na linha comentada, irão compilar? (Marque todas corretas)

A. Flower getType() { return this; }
B. String getType() { return "this"; }
C. Plant getType() { return this; }
D. Tulip getType() { return new Tulip(); }

Conversão de Tipos ou Casting - Java

2010-07-22T09:58:00.000-03:00

Não sei se alguem já notou mas as anotações sobre Java que estou postando aqui são apropriadas para quem vai prestar o exame SCJP (Sun Certified Java Programmer). Como também pretendo ser um programador certificado pela Sun, estou estudando e quero aproveitar para compartilhar com você meus resumos.

Hoje vou falar sobre o objetivo 5.2 do exame que é sobre Conversão de Variáveis de Referência (também conhecido por Cast ou Casting de tipos):

Dado um cenário, desenvolver código que demonstre o uso do polimorfismo. Além disso, determinar quando a conversão será necessária e saber diferenciar erros de compilação de erros de tempo de execução relacionados a conversão de referências a objetos.

Temos 2 pontos principais neste objetivo: Uso do polimorfismo e saber diferenciar erros de compilação e de tempo de execução. Veja também que no final está "referências a objetos". Isto quer dizer que esse tipo de conversão não é como conversão entre tipos primitivos (que não será abordado neste post).

Vamos começar analisando o código:

//Superclasse
public class Animal {
 
 void comer(){
  System.out.println("Animal comendo...");
 }
 
}
//Subclasse
class Dog extends Animal{
 
 void rolar(){
  System.out.println("Dog rolando...");
 }
}

Upcasting ou Conversão ampliadora

Considerando o código acima poderíamos naturalmente fazer as seguintes declarações:

Animal animal; //Declarou um tipo genérico
animal = new Dog(); //Apontou para um mais específico
//Ou simplesmente:
Animal animal = new Dog();
//Ou ainda:
Animal animal = (Animal)new Dog(); //Conversão explícita

Porque? Tipos genéricos podem apontar para tipos mais específicos. Isto chama-se upcasting ou conversão ampliadora. Esta conversão é sempre segura, pois estamos indo de um tipo mais específico para um mais genérico (de baixo pra cima na árvore de herança) e sabemos que a superclasse poderá fazer tudo que a subclasse fazia pois herdou dela. Mas fazendo isto estamos perdendo os métodos de Dog.

Nesse caso a variável de referência animal que é do tipo Animal faz referência a Dog e isto é possível porque Dog É-UM Animal (Este relacionamento É-UM significa que Dog extends Animal).

Por estes motivos o compilador permite fazer o cast sem nenhuma notação especial nem nada explícito.

Até aqui tudo bem, mas e se tentar realizar um comportamento mais específico? Por exemplo, tentar chamar um método que só existe em Dog? Não pode porque só comportamentos de Animal serão aceitos:

animal.rolar(); //Problema! Método não definido para o tipo Animal

O código não compila porque animal não tem o método rolar(). Entenda que estamos transformando um Dog num tipo mais genérico e que ele agora só poderá executar ações deste novo tipo. Ele perdeu os comportamentos específicos que tinha.

Mas um coisa interessante é que se Dog sobrescrever algum método de Animal, qual dos métodos será executado? Vamos modificar o código:

//Superclasse
public class Animal {
 
 void comer(){
  System.out.println("Animal comendo...");
 }
 
}
//Subclasse
class Dog extends Animal{
 
 void rolar(){
  System.out.println("Dog rolando...");
 }
 //Dog sobrescreveu o método comer
 void comer(){
  System.out.println("Dog comendo...");
 }
}

Suponhamos que faça a seguinte chamada:

Animal animal = new Dog();
animal.comer();

Quem vai comer? Animal ou Dog? Neste caso o método em Dog seria executado porque ele sobrescreveu. Então quando fazemos o upcasting perdemos os métodos do subtipo mas se algum for sobrescrito a versão a ser executada é a do subtipo. Muito louco isso não é?

Downcasting

Seguindo a raciocínio do upcasting, se quisermos "voltar" um tipo genérico para o mais específico (conversão redutora), devemos fazer a conversão explicitamente:

Dog dog = (Dog) animal;
dog.comer();

Veja que mudamos apenas o tipo da variável, não o tipo da referência. Então esta conversão se torna possível pois animal faz referência a Dog.

Então você se pergunta: Porque o upcasting é automático e o downcasting não? Agora chegamos num ponto interessante: No upcasting a conversão nunca falha. No downcasting, nem sempre teremos esta certeza. No exemplo citado acima, a conversão deu certo porque animal fazia referência a Dog mas e se não fizesse? Se animal fizesse referência a Animal mesmo?

Animal animal = new Animal();
Dog dog = (Dog) animal;

Como isso poderá ser feito se Animal não é um Dog? Animal nem sabe da existência de Dog. A conversão não pode ser feita porque os tipos são incompatíveis.

Só que o mais intrigante vem agora: O código compila!

Se você usa o Eclipse vá em Project > Clean..., selecione seu projeto e veja se apareceu algum erro em Problems? Não vai aparecer nada, porque pro compilador está tudo bem, ele não sabe e nem quer saber se animal faz referência a Animal ou Dog. Mas quando tentar executar:

Exception in thread "main" java.lang.ClassCastException: Animal cannot be cast to Dog
at Animal.main(Animal.java:46)

Então não tente converter um objeto para um tipo que ele não é. Mas lembre-se que o compilador não sabe se você vai tentar isto.

Para saber se dada conversão é aceita devemos usar o operador instanceof. Este operador retorna true ou false para uma comparação entre tipos:

 if (dog instanceof Animal)
 {
  System.out.println("dog é um Animal.");
 }

Na IDE Eclipse, quando começar a digitar "ins" e pressionar Ctrl + Barra de espaço ele já sugere o operador, então pressionando Enter ele já vai preencher um bloco de código igual a este:

 if (name instanceof type) {
  type new_name = (type) name;
  
 }

Aí é só você ir dando TAB e preenchendo os campos. Ele faz isso porque sabe que quase sempre que usamos o instanceof é pra saber se um objeto é de determinado tipo, e sendo positivo, já queremos que o objeto seja convertido neste tipo.

Aproveitando que já dei essa dica, tem outras duas que eu também uso muito para criar o método main e pro comando System.out.println: Para o main apenas digite main e Ctrl + Barra de espaço, para o println digite sysout Ctrl + Barra de espaço.

Só por curiosidade: Podemos converter qualquer objeto no tipo Object, como já falei no outro post, o Object é como uma classe "mãe" no Java:

Object obj = (Object)new Animal();

Mas essa conversão não tem muita utilidade pois faz com que animal perca todos seus métodos como já foi explicado. Por hoje é só!

Bons estudos e boas conversões!