JAVA IMEDIATO - SEU TUTORIAL JAVA

[14] Entendendo métodos - PARTE 1 DE 3

noreply@blogger.com (andrehbl) — Sat, 29 Mar 2008 03:26:00 +0000

Os métodos são as ações de uma classe. Até agora criamos métodos apenas para exibir mensagens no Console, e utilizamos alguns métodos já prontos de outras classes, como o nextInt() da classe Scanner, por exemplo. Neste Post vamos aprender um pouco mais sobre as estruturas dos métodos e como realizar cálculos matemáticos simples dentro dos métodos.

Estrutura básica de declaração de um método

MODIFICADOR DE ACESSO TIPO DO RETORNO IDENTIFICADOR (PARÂMETROS)

Observe esta declaração do método imprimir():

public void imprimir(){
   //seus comandos de impressão
}

public: é um dos quatro modificadores de acesso existentes na linguagem Java. Falaremos sobre modificadores de acesso em Posts posteriores.

void: é um tipo de retorno "vazio". Isto significa dizer que o método imprimir() não retornará nenhum valor. Entraremos em detalhes sobre os tipos de retorno adiante.

imprimir: identificador do método. É através do identificador que um método pode ser chamado. Por exemplo, para o método imprimir ser chamado teríamos o seguinte código deve ser chamado:

imprimir();

(): dentro dos parênteses devem ser informados quais parâmetros o método requer para que possa ser chamado. No caso do método imprimir(), nenhum parâmetro foi informado.

Tipos de retorno

Um método pode retornar valores tanto do tipo primitivo quanto valores do tipo referência. Além desses tipos, um método pode retornar um valor especial, que representa "vazio". Tal valor é representado pela palavra-chave void. Caso o tipo de retorno NÃO seja void, a palavra-chave return deve ser chamada. Esta palavra-chave encerra o método e retorna o valor desejado.

Embora um método possa conter mais de uma instrução return, apenas uma das instruções return será chamada (a primeira que o compilador encontrar, dependendo do fluxo de execução). Isso quer dizer que um método só retorna um valor a cada vez que ele é chamado.

Retornando void

Quando na declaração de um método está definido que ele retornará void, isso implica em dizer que tal método não retornará valor algum. Qualquer tentativa de retorno de valor causará um erro de compilação. Observe um exemplo válido de um método com tipo de retorno void:

public void imprimeNomes(){

 System.out.println("Java");
 System.out.println("Imediato");
 System.out.println("Seu tutorial Java");

}

Caso alguma tentativa de retorno ocorra, o compilador acusará um erro. Observe este exemplo:

public void imprimeNomes(){

 System.out.println("Java");
 System.out.println("Imediato");
 System.out.println("Seu tutorial Java");

   //retorno
   return 40;

}

O seguinte erro será acusado pelo compilador:

Exception in thread "main" java.lang.Error: Unresolved compilation problem:
Void methods cannot return a value

Quando o tipo de retorno do método é void, a instrução return pode ser utilizada para finalizar o método, mas não para retornar um valor. Observe este exemplo:

public void imprimeNomes(){

 System.out.println("Java");
 System.out.println("Imediato");
 System.out.println("Seu tutorial Java");
   return;

}

Este código está livre de erros. Quando o compilador ler a instrução return, ele vai simplesmente finalizar o método. Nenhuma ação funcional ocorrerá. Porém, se você inserir neste método alguma instrução abaixo do return, o compilador lhe exibirá a seguinte mensagem:

Exception in thread "main" java.lang.Error: Unresolved compilation problem:
Unreachable code

Isto quer dizer que há códigos no método que não podem ser alcançados. Isto ocorre porque o return finaliza o método, desde já não faria sentido para o compilador existir instruções que não serão alcançadas dentro do método.

Retornando Tipos Primitivos

Como visto no Post 11, os tipos primitivos são:

* char
* byte
* short
* int
* long
* float
* double
* boolean

Desde já um método pode retornar qualquer um desses tipos de acordo com sua finalidade. Observe este método que calcula a soma de 5 + 10:

public int somar(){

   return 5 + 10;

}

Note que a soma 5+10 retorna um número inteiro: 15. Logo, não seria viável, por exemplo, definir void como tipo de retorno do método somar() . Isto causaria o seguinte erro de compilação:

Exception in thread "main" java.lang.Error: Unresolved compilation problem:
Void methods cannot return a value

Observe agora o método a seguir. Ele retorna um valor do tipo boolean:

public boolean retornarVerdadeiro(){

   return true;

}

Qualquer outro valor retornado no método retornarVerdadeiro() que não seja do tipo boolean causará um erro de compilação, como no exemplo abaixo:

public boolean retornarVerdadeiro(){

   return 30606f;

}

O seguinte erro de compilação será acusado:

Exception in thread "main" java.lang.Error: Unresolved compilation problem:
Type mismatch: cannot convert from float to boolean

Retornando Tipos de Referência

Vimos no Post 12 que variáveis do tipo referência referenciam objetos, e é justamente um objeto que um método deve retornar caso seu tipo de retorno seja um tipo referência. Porém, o tipo de retorno especificado na declaração do método deve ser o tipo exato do objeto que o método deve retornar (ou subclasses do tipo informado. Estudaremos este detalhe em Posts posteriores).

Dada uma classe Pessoa:

public class Pessoa{

   //atributos
 String nome;
 String idade;

   //métodos
  public void imprimirNome(){
    System.out.println("NOME: "+nome);
 }

}

Vamos declarar em uma classe qualquer o seguinte método:

public Pessoa retornarPessoa(){

 Pessoa p = new Pessoa();
 p.nome = "ANDRÉ";
 p.idade = 23;

  return p;

}

Este método está declarado corretamente e compilará sem erros. Note que o tipo de retorno de retorno é Pessoa, classe que criamos anteriormente. Lembre-se, um tipo de referência é uma classe.

O seguinte método também é válido:

public String retornarString(){

   return "Uma string qualquer";

}

String também é um tipo, e "Uma string qualquer" é um objeto do tipo String. Mas, por favor, não se aborreça com este detalhe agora, pois estudaremos este detalhe em Posts Posteriores. Você pode iniciar uma pesquisa sobre isto para adiantar seus estudos. O seguinte método apresenta um erro. Tente identificá-lo antes de ler o comentário sobre ele:

public Pessoa retornarPessoa(){

 Pessoa p = new Pessoa();
 p.nome = "Juliana";
 p.idade = 27;

  return Pessoa;

}

Se você apontou que o erro está no momento do retorno, você está correto(a). O tipo de retorno deve ser um OBJETO Pessoa, e não a CLASSE Pessoa. Neste caso deveríamos retornar o objeto p para satisfazer o tipo de retorno exigido no método.

Bem, encerramos por aqui a primeira parte do tópico Entendendo métodos.

Um abraço e até a próxima

[13] Comentários em Java

noreply@blogger.com (andrehbl) — Fri, 07 Mar 2008 01:38:00 +0000

Neste Post vamos aprender a como fazer comentários na linguagem Java. Um comentário nada mais é do que um trecho no seu código que será ignorado pelo compilador. Você pode escrever comentários com diversas finalidades, como:

* Explicar trecho(s) de código
* Ignorar uma determinada linha de código
* Ignorar um bloco de código
* Escrever cabeçalhos de classes
* entre outros

Comentário de linha (//)

O comentário de linha faz com que tudo a direita do símbolo "//" seja ignorado pelo compilador.
Por exemplo:

public static void main(String[] args) {
//System.out.println("Java imediato");
}

Este programa não imprimirá a frase "Java imediato", pois a linha de comando System.out.println("Java imediato"); está sendo ignorada pelo compilador.

Observe um outro exemplo:

public static void main(String[] args) {
System.out.println("Java"); //System.out.println("imediato");
}

A saída deste programa será:

Java

Também podemos utilizar o comentário simples para escrever curtas observações:

//classe Player
public class Player{

//atributos
int id;
String name;
String IP;

//métodos
public void conectar(){
//implementar este método
}

}

Comentário de bloco (/* */)

O comentário de bloco permite que mais de uma linha sejam comentadas de uma só vez. Para isto abrimos o comentário de bloco com o símbolo "/*" e definimos o fim do comentário usando o símbolo "*/". Observe este exemplo de uso de comentário composto:

/* Classe Player Esta classe tem a finalidade de permitir que um jogador se conecte a um determinado servidor */
public class Player{

//atributos
int id;
String name;
String IP;

//métodos /* Este método ainda será implementado. */
public void conectar(){
//implementar este método
}

}

Como você deve ter percebido, não há problemas em haver mais de um tipo de comentário em uma classe.

Bem, neste Post encerramos por aqui. Um abraço e até a próxima

[12] Tipos de variáveis: tipos de referência

noreply@blogger.com (andrehbl) — Fri, 07 Mar 2008 01:37:00 +0000

Os tipos de referência se diferem dos tipos primitivos porque os tipos primitivos armazenam valores, e os tipos de referência referenciam objetos. A declaração de uma variável local ou atributo de tipo de referência é semelhante ao de um tipo primitivo. Observe:

TIPO nomeDaVariavel;

Aos poucos vamos migrando nosso vocabulário, desde já daqui por diante vamos nos adaptar a outra palavra: identificador. Em vez de "nome de um atributo" ou "nome de uma classe", de agora em diante chamaremos "identificador de um atributo" e "identificador de uma classe".

Porém, em vez de o tipo ser algo como int, float ou char, por exemplo, será uma classe - em Posts posteriores veremos que tipos de referência pode referenciar algo mais além do que uma classe comum. Observe esta linha de código:

Scanner entrada;

No Post 9 nós tinhamos então uma variável de referência do tipo Scanner. Scanner é uma classe e "entrada" é o identificador da variável. Neste caso, significa dizer que "entrada" está pronto para referenciar um objeto do tipo Scanner, porém até agora não o faz. Caso não se lembre, para começarmos a utilizar um objeto do tipo Scanner codificamos o comando:

Scanner entrada = new Scanner(System.in);

Esta linha faz com que "entrada" referencie um objeto do tipo Scanner. Um objeto Scanner, assim como qualquer outro objeto, é criado efetivamente quando usamos a palavra-chave new seguida do construtor do tipo do objeto - aprenderemos sobre construtores em Posts posteriores. Logo, podemos imaginar que a nossa linha de comando resultou no seguinte esquema:Vejamos este trecho de código:

Scanner e1;
e1 = new Scanner(System.in);
e1 = new Scanner(System.in);

A representação gráfica deste código resultaria em algo como:

Uma variável de referência referencia apenas 1 único objeto por vez, assim como as variáveis de tipos primitivos referenciam apenas 1 valor por vez. No caso da figura anterior, o primeiro objeto Scanner criado era referenciado pela variável "e1", ou seja, a única maneira de se acessar o primeiro objeto Scanner seria através da variável "e1". Como "e1" só pode referenciar um objeto Scanner por vez e na linha 3 ele passa a referenciar outro objeto, logo o primeiro objeto Scanner é perdido na memória e estará disponível para ser coletado pelo Garbage Collector - ou GC - da JVM.
Também é possível que mais de uma variável de referência referencie um mesmo objeto. Vamos antes criar uma classe Pessoa e exemplificar como um único objeto pode ser acessado por várias variáveis de referência:

public class Pessoa{
String nome;
int idade;
float peso;
float altura;

public static void main(String[] args){

Pessoa p1 = new Pessoa();
Pessoa p2 = p1;
Pessoa p3 = p2;
}

}

Quando o arquivo Pessoa.java for executado, o esquema gráfico do nosso código ficará da seguinte maneira:

Lembre-se, variáveis de referência armazenam simplesmente "referências a objetos", ou seja, se uma variável de referência referencia outra, então ambas referenciarão o mesmo objeto ou null.

Referência null
Quando não queremos que uma variável de referência referencie um objeto, podemos fazer com que ela referencie null.

null é uma palavra-chave para fazer com que uma variável de referência não referencie nenhum objeto.

Observe o exemplo:

Pessoa pes = new Pessoa();
pes = null; Resultado:

Variáveis de referência locais

Todos os exemplos de variáveis de referências citados anteriormente são declarados e imediatamente inicializados. Toda variável declarada precisa referenciar algo caso seja utilizada. No caso das variáveis de referências, deve referenciar ou o valor null ou um objeto. Por exemplo:

public void metodoQualquer(){

Pessoa p;

}

Será compilado sem erros. Contudo, por enquanto, a variável "p" está inutilizada. Observe o exemplo a seguir:

public void metodoQualquer(){

Pessoa p;
p.nome = "Pollyana";

}

A variável "p" está sendo utilizada. Por estar sendo utilizada sem referenciar algum valor, o compilador acusará o seguinte erro:

The local variable p may not have been initialized

O próximo exemplo não possui erros de compilação:

public void metodoQualquer(){

Pessoa p = null;
p.nome = "Pollyana";

}

As variáveis de referência que são atributos de uma classe são inicializadas automaticamente com null, caso você as programar para receberem um objeto. Aprenderemos sobre inicialização de atributos em Posts posteriores.

NullPointerException

Se você ainda se deparou com esta exceção, sua hora chegará. Uma exceção NullPointerException ocorrerá quando você tentar acessar um objeto que não existe - frequentemente fazemos isso porque pensamos que tal objeto existe. Em IDEs como Eclipse, por exemplo, ao pressionar Ctrl+Espaço após o operador ponto"." de uma variável, automaticamente se abrirá uma caixa de seleção com atributos e métodos pertencentes ao tipo da classe em questão, como na imagem abaixo:

Isto muita vezes nos induz a acessar métodos, por exemplo, de objetos que não existem. Por exemplo:

Pessoa p;
p.nome = "André";

Seria como se na linha 1, você dissesse ao compilador: "Compilador, estou declarando uma variável do tipo Pessoa, e ela se chamará p", e na linha 2 você dissesse: "Compilador, quero que o atributo "nome" do objeto que minha variável p referencia tenha seu valor alterado para "André" ".

Logo, se este trecho de código for executado, uma exceção NullPointerException será lançada:

java.lang.NullPointerException

O seguinte trecho também gera exceção de NullPointerException:

Scanner entrada = new Scanner(System.in); Scanner entrada2 = entrada; entrada = null;
entrada.nextInt();

A variável "entrada" referenciava um objeto, logo em seguida a variável "entrada2" passou a referenciar o objeto de "entrada". Na linha 3, "entrada" passou a ter referência para null, e finalmente na linha 4 tentou-se acessar o método nextInt() através da variável de referência "entrada", que não mais referencia qualquer objeto. Analisemos o nome da exceção: NullPointerException. Sua tradução significa algo como: "Exceção de ponteiro nulo". Isto significa dizer que tentou-se acessar algo de uma referência de objeto que não existe.

Bem, ficamos por aqui. Mais um abraço e bons estudos!

[11] Tipos de variáveis: tipos primitivos

noreply@blogger.com (andrehbl) — Fri, 29 Feb 2008 03:09:00 +0000

Vamos aprender um pouco mais sobre os tipos de variáveis existentes no Java: tipos primitivos e tipos de referência. Porém, neste Post daremos ênfase aos tipos primitivos.

Variáveis de tipos primitivos

Uma vez que uma variável é definida como um tipo primitivo, seu tipo não pode ser alterado. Isso implica dizer que ao declarar uma variável de tipo primitivo como a variável "velocidade" abaixo como tipo int, ela não pode, dentro do mesmo escopo, ser redefinida para o tipo float, por exemplo:

int velocidade;
float velocidade;

Cada variável de um tipo primitivo armazena apenas um valor por vez do seu tipo. Os tipos primitivos da linguagem Java são: char, byte, short, int, long, float, double e boolean. Veremos a seguir características e um exemplo de uso para cada tipo primitivo:

_______________________________________________________

char

O tipo char é utilizado para armazenar em uma variável caracteres individuais, tais como: 'A', 'G' ou 'U'. Cada caracter a ser atribuído a uma variável do tipo char deve ser escrito entre aspas simples:

char letra = 'A';
System.out.println("LETRA INICIAL: " + letra);
letra = 'E';
System.out.println("NOVA LETRA: " + letra);

Certamente os valores a serem exibidos após a execução do código acima são:

LETRA INICIAL: A
NOVA LETRA: E

Uma variável do tipo char também pode receber entre aspas simples um valor Unicode:

char caracterUnicode = '\u0041';
System.out.println("Caracter unicode: " + caracterUnicode);

E será exibido na tela:

Caracter unicode: A

Pois o código 0041 na tabela unicode pertence ao caracter 'A', assim como o código 0030 pertence ao número zero e o código 0032 pertence ao número 2.

_______________________________________________________

byte

O tipo byte armazena um valor inteiro de -128 a 127, inclusive:

byte pequenoNumero = 30;
byte outroNumero = 50;
byte soma = pequenoNumero + outroNumero;
System.out.println("Soma: " + soma);

O valor exibido no console é:

Soma: 80

_______________________________________________________

short

O tipo short armazena um valor de -32.768 a 32.767, inclusive:

short valor1 = -1000;
short valor2 = 20600;
short valor3 = valor2 - valor1;
System.out.println("Valor 3: " + valor3);

Saída:

Valor 3: 19600

_______________________________________________________

int

O tipo primitivo int armazena um valor inteiro entre -2.147.483.648 e 2.147.483.647, inclusive:

int idade = 0;
int anoNascimento = 2009;
int saldoNegativo = -3200;

_______________________________________________________

long

O tipo primitivo long armazena um valor inteiro entre -9.223.372.036.854.775.808 e 9.223.372.036.854.775.807. Para deixar explícito que um valor deve ser interpretado como long, é comum que se digite a letra L, minúscula ou maiúscula:

long numeroGrande = 1300333030;
long outroNumeroGrande = 1300333030l;
long maisUmNumeroGrande = 1300333030L;

Todas as variáveis declaradas acima têm o mesmo valor e são do tipo long, porém note que as variáveis "outroNumeroGrande" e "maisUmNumeroGrande" possuem as letras l e L, respectivamente, ao final dos valores atribuídos. O uso da letra L é útil apenas para diferenciar que o valor em questão será armazenado em uma variável do tipo long, e não int, por exemplo. O valor não sofre quaisquer alterações após o uso da letra.

_______________________________________________________

float

Uma variável do tipo primitivo float armazena um número real de 32 bits segundo o padrão IEEE 754. Para deixar explícito que o valor em questão é do tipo float, usa-se a letra F ao final do valor.

float altura = 1.87f;
float peso = 71.5F;
float juros = 1.5;

O valor não sofre quaisquer alterações após o uso da letra.

_______________________________________________________

double

O tipo de dado double é ponto-flutuante de dupla precisão de 64 bits segundo o padrão IEEE 754:

double superValor = 121313.4;
System.out.println("Super valor: " + superValor);

O valor exibido é:

Super valor: 121313.4

_______________________________________________________

boolean

O tipo boolean - ou booleano - só pode receber dois tipos de valores: true ou false:

boolean isOpened = true;
System.out.println("IS OPENED (antes): "+ isOpened);
boolean flag = false;
isOpened = false;
System.out.println("IS OPENED (depois): "+ isOpened);
System.out.println("flag: "+ flag);

A saída exibida será:

IS OPENED (antes): true
IS OPENED (depois): false
flag: false

_______________________________________________________

Cuidado ao tentar atribuir um valor maior do que um tipo de variável pode suportar, como por exemplo:

byte valorPequeno = 12340;

int valorNaoLong = 2980928320213L;

12340 é considerado como valor inteiro, desde já não é possível atribuir tal valor a uma variável do tipo byte, pois o tipo byte suporta valores inteiros entre -128 a 127, apenas.

E caso o valor 2980928320213 inão seja seguido pela letra L, o compilador tentará, por padrão, entendê-lo como um valor do tipo int, e como os valores int devem estar entre -2147483648 e 2147483647, o valor 2980928320213 excede esse limite, a compilação falhará e dará a seguinte mensagem:

The literal 2980928320213 of type int is out of range

Cuidado também ao tentar atribuir valores que são incompatíveis ao tipo em questão:

char letra = 1243f;
int number = 1243f;

Estas atribuições causam erro de compilação e geram as seguintes mensagens:

Type mismatch: cannot convert from float to char
Type mismatch: cannot convert from float to int

Os indicadores de tipos primitivos são palavras-chave, desde então você não pode criar identificadores com o mesmo nome que eles. Como, por exemplo, criar uma variável chamada "int" ou "float". Palavras-chave são palavras reservadas.

Vale também ressaltar que os tipos primitivos também podem ser chamados de tipos predefinidos.

Bem, neste Post ficamos por aqui. Na próxima postagem aprenderemos sobre os tipos de referência do Java. Um abraço e até logo.

[10] Ponto-e-vírgula, escopo e variáveis locais

noreply@blogger.com (andrehbl) — Wed, 13 Feb 2008 15:27:00 +0000

Neste Post vamos aperfeiçoar um pouco os nossos conhecimentos sobre o que vimos até o momento. Entenderemos o motivo do uso do símbolo ";" após a invocação de comandos, entenderemos também do que se trata um escopo e variáveis locais.

PONTO-E-VÍRGULA (;)

Cada comando deve ser finalizado com ponto-e-vírgula (;). Em Posts anteriores já trabalhamos com mais de um comando, por exemplo:

System.out.println(" Primeiro comando ");
System.out.println(" Segundo comando ");

O mesmo acontece com a criação de objetos e chamadas a métodos - se você ainda não sabe, "println()" é um método. Supondo que exista uma classe chamada Porta, onde seus métodos são abrir() e fechar(), veremos o uso de ponto-e-vírgula no final das chamadas:

Porta p = new Porta();
System.out.println("O método abrir() será chamado");
p.abrir();
System.out.println("O método fechar() será chamado");
p.fechar();

E para que não reste mais dúvidas sobre o uso de ponto-e-vírgula, este símbolo também é usado na declaração de atributos:

public class Porta{

boolean estaAberta;
String tipoPorta;

}

ESCOPO

Um escopo delimita o "tempo de vida" de uma variável, seja ela de referência ou de um tipo primitivo. Esta delimitação é definida através dos símbolos "{" e "}", que são equivalentes às instruções "Begin" e "End", respectivamente, em linguagens como Pascal. O espaço delimitado pelos símbolos "{" e "}" é denominado bloco.

Observe a classe Livro abaixo:

public class Livro {
String titulo;
String autor;
int qtdPaginas;
}

Isso significa dizer que os atributos titulo, autor e qtdPaginas de um objeto do tipo Livro existirão enquanto o objeto existir, pois seu escopo está definido para toda a classe. Observe o escopo do método escreverQuantidadePaginas() da classe abaixo:

public class Livro {

String titulo;
String autor;
int qtdPaginas;

public void escreverQuantidadePaginas(){
int quantidade = qtdPaginas;
System.out.println("QUANTIDADE DE PAGINAS: ");
System.out.println(quantidade);
}

}

O escopo da variável "quantidade", está limitado ao método escreverQuantidadePaginas(). Isso implica dizer que quando o método escreverQuantidadePaginas() for encerrado a variável "quantidade" já não mais poderá ser referenciada.

Um ponto importante a se ressaltar é que "quantidade" estará acessível apenas dentro do método escreverQuantidadePaginas(). Porém, note que a variável "qtdPaginas" está sendo acessada de dentro do método escreverQuantidadePaginas(), isso é possível porque o escopo de "qtdPaginas" foi definido para toda a classe, e o método escreverQuantidadePaginas() pertence à classe. Desde já o atributo "qtdPaginas" pôde ser acessado através do método.

Para melhor compreensão vamos instanciar um objeto do tipo Livro:

public static void main(String[] args){
Livro livro = new Livro();
}

Você pode livremente acessar os atributos do objeto livro como atribuir valores e exibí-los.

public static void main(String[] args){

Livro livro = new Livro();
livro.autor = "André Leitão";
livro.qtdPaginas = 100;
System.out.println("QUANTIDADE PÁGINAS: ");
System.out.println(livro.qtdPaginas);

}

Mas você não pode acessar a variável "quantidade", pois seu tempo de vida está delimitado pelo escopo do método escreverQuantidadePaginas(). Desde já seria um erro codificar:

public static void main(String[] args){
Livro livro = new Livro();
livro.qtdPaginas = 100;
livro.quantidade = 20;
}

A funcionalidade da linha 4 insinua algo como: "atribua o valor 10 à variável quantidade, que pertence ao objeto livro". E esta atribuição não será possível porque "quantidade" não será reconhecida como um atributo do objeto livro.

Observe a figura abaixo:

ATRIBUTOS SÃO VARIÁVEIS?

Atributos são variáveis, pois armazenam valores e estes valores podem ser alterados e/ou obtidos.

A diferença básica entre um atributo e uma variável local é que o escopo de um atributo é delimitado pelo bloco de sua classe, e o escopo de uma variável local é delimitado por um outro bloco qualquer.

VARIÁVEIS LOCAIS

Uma variável local não pode ser acessada por toda a classe, apenas dentro do bloco em que foi declarada. Por exemplo:

public class CalculadoraParaSoma(){
int operando1;
int operando2;
public void calcular(){
int resultado = operando1 + operando2;
System.out.println("RESULTADO: ");
System.out.println(resultado);
}
}

Note que na linha 66 uma variável local foi declarada. A variável local resultado receberá a soma dos atributos "operando1" e "operando2". Logo em seguida o resultado da soma é exibido.

"resultado" não estará acessível para toda a classe. Apenas para o método em que ela foi declarada. Portanto seria um erro codificar:

public static void main(String[] args){
CalculadoraParaSoma calc = new CalculadoraParaSoma();
calc.operando1 = 2;
calc.operando2 = 6;
calc.resultado = operando1 + operando2;
}

Ao tentar compilar este código, o compilador exibirá a seguinte mensagem de erro:

"calc.resultado cannot be resolved or is not a field"

Isto é, "resultado" não é reconhecido como membro do objeto calc. "resultado" é acessível apenas dentro do bloco onde foi declarado. No caso, o método calcular().

Várias variáveis locais de diferentes tipos podem ser declaradas dentro um método, e não obrigatoriamente elas precisam ser inicializadas. Observe um bloco qualquer abaixo:

{
int valor1;
int valor2 = 50;
String nome = "Java";
double altura;
altura = 3.4;
valor1 = 8;
}

Este bloco funcionará sem problemas. No total ele tem 4 variáveis locais, o que implica dizer que elas poderão ser acessadas até que o bloco se finalize.

Tente usar o conteúdo deste bloco em algum método como o main, por exemplo - não se esqueça de que main também é um método - e imprima os valores das variáveis locais.

Este Post fica por aqui. Um abraço

[9] Lendo dados a partir do teclado com Scanner

noreply@blogger.com (andrehbl) — Fri, 01 Feb 2008 14:16:00 +0000

Até o momento só utilizamos o console para exibir saídas como mensagens de "Hello World" ou valores de um objeto. Agora vamos aprender a ler dados a partir do teclado e exibí-los. Para isto, vamos fazer uso de nossa primeira classe da API do Java: a classe Scanner.

Embora ler dados do teclado não seja a única especialidade da classe Scanner, a utilizaremos apenas para este propósito.

Localizando a classe Scanner

Afinal, se a classe Scanner não foi criada por nós, então onde ela se encontra? Como foi dito anteriormente, Scanner é uma classe da API do Java. Mas como teremos acesso à API do Java? Simples, ao criar um projeto no Eclipse, note que "anexado" ao seu projeto se encontra a JRE System Library, que contém todas as classes da Java API.

A API organiza suas classes por pacotes, e toda classe da API está dentro de um pacote. A API Java é muito rica e extensa, desde já é possível que haja classes com nomes iguais. Então, para se utilizar uma determinada classe devemos especificar, em código, em qual pacote a classe se encontra. Com o Scanner não será diferente. Seu caminho é: java->util->Scanner. Isto quer dizer que a classe Scanner está dentro do pacote util, que por sua vez está contido no pacote java.

Ao ato de "usar" uma classe de um pacote externo chamamos de importação de pacotes. Para importar uma classe em Java utilizamos a palavra-chave import seguida do caminho da classe. Logo para importar Scanner usaremos o código:

import java.util.Scanner;

Criando um objeto do tipo Scanner

O procedimento para se criar uma instância de Scanner é semelhante à criação do objeto Window - classe em que trabalhamos no Post anterior.

Para exemplificar vamos criar um objeto do tipo Scanner que se chamará "entrada":

Scanner entrada = new Scanner(System.in);

Não se preocupe com o trecho: new Scanner(System.in);
Mantenha em mente que um objeto do tipo Scanner está sendo criado e que devemos nos concentrar apenas em ler dados a partir do teclado.

Criando a classe EntradaDados

Antes de mais nada, para rodarmos um programa Java lembre-se de que precisamos de uma classe que contenha o método main. Então, vamos criar uma classe chamada EntradaDados, e logo em seguida implementamos o método main dentro dela:

public class EntradaDados {

public static void main(String[] args) {

}

}

Esquecemos apenas de inserir o código de instanciação do objeto "entrada" dentro do método main. Inserindo-o teremos:

public class EntradaDados {

public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
}

}

O código acima falhará no processo de compilação, pois Scanner é reconhecido como um símbolo estranho, ou seja, o javac não reconhecerá Scanner como uma classe, pois você não a importou. Para resolver o problema importaremos a classe Scanner antes da declaração da classe EntradaDados. Observe o código resultante:

import java.util.Scanner;

public class EntradaDados {

public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
}

}

Agora seu programa pode ser compilado e executado sem erros. Porém, sua única funcionalidade é criar um objeto do tipo Scanner e encerrar sua execução.

Scanner também contém métodos

Ora, se Scanner é uma classe que lê dados - observe a ação: LER - então ela possui métodos que possibilitam esta ação. O que difere uma classe de outra, do ponto de vista genérico, são as funcionalidades de seus métodos.

Através do objeto "entrada", que é do tipo Scanner, temos acesso a diversos métodos para leitura de teclado. São alguns deles:

* next() : para ler textos
* nextInt() : para ler números inteiros
* nextFloat() : para ler números reais - ou números de ponto flutuante.
* nextDouble() : para ler números reais - ou números de ponto flutuante com dupla precisão

Lendo um texto com Scanner

Vamos fazer com que nosso programa leia e escreva o nome do usuário. Logo após a criação do objeto entrada inclua o código:

System.out.println("Digite seu nome: ");
String nome = entrada.next();
System.out.println("Seu nome: ");
System.out.println(nome);

Note que ao executar o programa, a seguinte saída será exibida no console:

Digite seu nome:

Este é o momento em que o usuário deve digitar seu nome no console. Após a digitação, ela deve ser confirmada com o pressionamento da tecla Enter. Logo, a seguinte saída será mostrada:

Digite seu nome:
Schneider
Seu nome:
Schneider

Ao digitar o nome e pressionar teclar Enter, o valor do nome é armazenado em uma variável local chamada "nome", e logo o valor contido na variável "nome" é usado para ser exibido.

Lendo um número inteiro com Scanner

Vamos agora criar um programa que leia a idade do usuário e a exiba:

System.out.println("Digite sua idade: ");
int idade = entrada.nextInt();
System.out.println("Sua idade é: ");
System.out.println(idade);

Assim como o método next(), o método nextInt() também aguardará uma entrada do usuário e o pressionamento da tecla Enter para que o programa prossiga sua execução. Porém, o método nextInt exige que o usuário digite apenas números, nada de letras ou caracteres especiais.

VARIÁVEIS LOCAIS...

As variáveis locais serão melhor abordadas no próximo Post. Como você deve ter percebido, uma variável local armazena um valor, assim como um atributo de uma classe. Na verdade, um atributo é uma variável, porém pertencente à classe em questão, diferentemente de uma variável local, que possui tempo de vida limitado e não pertence a uma classe.

RESUMO

* Scanner pertence ao pacote java.util
* Você aprendeu a criar um objeto do tipo Scanner:

Scanner entrada = new Scanner(System.in);

* Para capturar uma entrada de texto do teclado usa-se o método next():

entrada.next();

* Para capturar uma entrada numérica usa-se:

entrada.nextInt() para capturar números inteiros
entrada.nextFloat() para capturar números reais
entrada.nextDouble() para capturar números reais com dupla precisão

Exercícios

1. Construa um programa que leia o nome e a idade do usuário e exiba-os logo em seguida.

2. Construa um programa que leia o nome e o sobrenome do usuário e exiba-os logo em seguida.

3. Construa um programa que leia a altura do usuário e exiba-a na tela.

Ficamos por aqui. Até a próxima

[8] Criando o primeiro objeto

noreply@blogger.com (andrehbl) — Mon, 21 Jan 2008 12:02:00 +0000

No Post anterior tivemos nosso primeiro contato formal com a Programação Orientada a Objetos. Aprendemos um pouco sobre abstração de classes a partir de uma entidade do mundo real ou uma entidade criada por nós baseada em conceitos do mundo real. Neste Post aprenderemos a como implementar classes e a como criar objetos em Java.

Criando a primeira classe em código

Se você não percebeu ainda, desde o primeiro código-fonte do nosso tutorial que já trabalhamos com, no mínimo, uma classe. Se não te recordas, o arquivo HelloWorld.java tem o seguinte conteúdo:

public class HelloWorld{

 public static void main(String[] args){
  System.out.println("Hello World");
 }

}

HelloWorld é uma classe, você a declarou. A classe HelloWorld não tem atributos, e tem apenas um método: main. O método main é um método especial, reservado pela JVM para que um programa Java possa ser executado. Falaremos sobre ele adiante.

Para escrevermos, ou melhor, para declararmos nossa primeira classe pós-HelloWorld vamos resolver o exercício do Post anterior, que seria modelar uma classe baseada em uma janela do Windows. Chamaremos nossa classe de "Window":

Window

Atributos:

- largura
- altura
- posicaoX
- posicaoY
- estaMaximizada

Métodos:

- abrir
- fechar
- minimizar
- restaurar
- mover

A próxima fase de nossa abstração será adaptar a modelagem à linguagem Java. Devemos prosseguir com as seguintes premissas:

* todo atributo tem um tipo
* todo método tem um retorno.

Os tipos dividem-se em: tipos primitivos e tipos de referência. Para o exemplo da classe Window, faremos uso apenas de tipos primitivos, ou seja, tipos que não são classes. São exemplos de tipos primitivos: números inteiros, números reais e valores booleanos - true ou false. Os tipos primitivos são representados por palavras-chaves específicas. Por exemplo, para indicar que um atributo armazenará um valor que seja um número inteiro, utilizamos a palavra chave int.

Vamos começar a implementar a classe Window:

public class Window{

 int largura;
 int altura;
 int posicaoAncoramentoX;
 int posicaoAncoramentoY;
 int posicaoX;
 int posicaoY;
 boolean estado;

}

Note que apenas os atributos da classe Window foram declarados, restando ainda a implementação de seus métodos.

Métodos são declarados para executarem ações referentes à classe em questão. Após executar todas suas linhas de comando um método é finalizado.

Um método é executado a partir do momento em que ele é chamado, e todo método retorna algum valor, seja ele um tipo primitivo, um tipo de referência ou até mesmo void. Tenha em mente que void representa um valor vazio, mas é um valor, o que é diferente de não ter um valor.

Nesta classe especificaremos que cada um dos métodos da classe Window retornará "vazio", usando a palavra-chave void. Faremos uma melhor explanação sobre métodos em Posts posteriores.

Observe como a classe Window será implementada com a inclusão de seus métodos:

Teoricamente a classe Window, até o momento, não possui funcionalidade alguma, pois seus métodos não possuem códigos a serem executados.

Criando um objeto do tipo Window

Antes de criar um objeto do tipo Window você precisa fazer o que se pede:

* Crie uma nova classe chamada Window no seu ambiente de programação e cole nela o conteúdo do código da classe Window exibido acima
* Codifique os 5 métodos da classe Window com comandos System.out.println(). Escreva mensagens como "A JANELA FOI MINIMIZADA" para o método minimizar(); "A JANELA FOI RESTAURADA" para o método restaurar(), e assim por diante. Observe como ficaria com o método mover():

public void mover(){
 System.out.println("A Janela teve sua posição modificada");
}

Por fim, sem método main nossa classe não pode ser testada. Para provar que a classe Window não necessariamente precisa ser composta por um método main para ser testada, vamos criar outra classe chamada WindowTest:

public class WindowTest{

 public static void main(String[] args){

 }

}

Agora temos duas classes: Window e WindowTest. A classe WindowTest não tem nenhum atributo e apenas um método, que é o método main. Como já foi dito, o método main é a porta de entrada para que seu programa seja executado. Porém, precisamos codificar algo dentro dele, caso contrário a JVM não terá o que executar no nosso programa. Criaremos então nosso primeiro objeto em Java. Como já sabemos que todo objeto tem um tipo, criaremos um objeto do tipo Window.

A princípio você deve seguir a seguinte sintaxe para a criação de objetos em Java:

public void mover(){
 System.out.println("A Janela teve sua posição modificada");
}

TIPO_DO_OBJETO NOME_DO_OBJETO = new TIPO_DO_OBJETO ( ) ;

O parâmetro TIPO_DO_OBJETO nada mais é que a classe que você queira criar objetos derivados dela. Em outras palavras, de que tipo será seu objeto. No nosso caso o objeto será do tipo Window.

O parâmetro NOME_DO_OBJETO depende apenas de você. Você nomeará o objeto que está sendo criado como desejar - com algumas exceções que veremos em Posts posteriores, claro.

= é nada mais que um operador binário utilizado para atribuições. Ele é um operador binário por precisar de dois operandos: um à sua esquerda, outro à sua direita. Seu funcionamento consiste em atribuir o valor do operando à direita para o operando à esquerda.

new é uma palavra-chave da linguagem Java que criará o objeto de fato. Na vida real é mais comum que você encontre o termo instanciar uma classe do que "criar um objeto".

TIPO_DO_OBJETO ( ) é o que chamamos de construtor. Falaremos melhor sobre construtores em Posts posteriores.

Nosso código dentro do método main ficará da seguinte maneira:

Window objetoWindow = new Window();

Já que agora temos um objeto "concreto", podemos manipulá-lo sem problemas. Lembre-se que dentro de métodos os comandos são lidos da esquerda para a direita e de cima para baixo. Então logo após a criação do objeto objetoWindow vamos fazer algumas modificações nos seus atributos:

objetoWindow.largura = 300;
objetoWindow.altura = 300;
objetoWindow.posicaoX = 25;
objetoWindow.posicaoY = 100;
objetoWindow.estaMaximizada = true;

Logo em seguida insira os comandos:

System.out.println(objetoWindow.largura);
System.out.println(objetoWindow.altura);
System.out.println(objetoWindow.posicaoX);
System.out.println(objetoWindow.posicaoY);
System.out.println(objetoWindow.estaMaximizada);

Execute seu programa e você verá no console os seguintes resultados impressos na tela:

300
300
25
100
true

Observe que os valores exibidos são os mesmos que você atribuiu no início do código. Esta é uma das funções de um atributo: armazenar valores.

Já que conseguimos testar uma das funcionalidades dos atributos de uma classe, vamos testar agora os métodos do objeto objetoWindow:

objetoWindow.mover();
objetoWindow.restaurar();

O console deverá exibir algo como - dependendo do que você escreveu:

A Janela teve sua posição modificada
A Janela foi restaurada

Parabéns, você criou seu primeiro objeto em Java e até o manipulou alterando e exibindo os valores de seus atributos e chamou seus métodos. Para fixar sua compreensão faça os exercícios abaixo:

EXERCÍCIOS

1. Ainda no objeto objetoWindow, escolha um de seus atributos e codifique uma seqüência de comandos como:

* alterar o valor do atributo
* imprimir valor do atributo
* alterar o valor do atributo
* imprimir valor do atributo
* alterar o valor do atributo
* imprimir valor do atributo

2. Crie um segundo objeto, e manipule e imprima os valores de seus atributos.

Ficamos por aqui. Um abraço e até a próxima

[7] Introdução à Programação Orientada a Objetos

noreply@blogger.com (andrehbl) — Sun, 13 Jan 2008 17:11:00 +0000

Do que se trata a POO - Programação Orientada a Objetos

A Programação Orientada a Objetos é um paradigma de programação em que os problemas computacionais são resolvidos através da modelagem e a criação de objetos, e a troca de mensagens entre eles. Através da abstração de objetos e problemas do mundo real é possível modelar classes de forma com que complexos sistemas possam ser construídos de forma mais robusta e confiável do que outros paradigmas de programação.

Se você ainda não compreende o que são classes e objetos, não se preocupe. Leia este Post e mostre a si mesmo que você sabe mais sobre classes e objetos do que imagina.

Objetos são a chave da POO

Você está neste exato momento olhando para a tela do seu monitor. Observe todos os detalhes que nele existem: botões, letras e adesivos; e logo em seguida retome sua leitura.

Tenho certeza que seu monitor possui características próprias e nele podemos fazer algumas ações. São algumas características do monitor: cor, largura, altura, marca, modelo, etc. E são algumas ações: ligar, desligar, reajustar tamanho de tela, desmagnetizar, etc. Desde já o seu monitor é um objeto que possui as características e ações descritas acima.

Agora vamos analisar uma lâmpada: ela possui basicamente uma voltagem específica e um estado - que pode ser "ligado" ou "desligado". Através dela as seguintes ações podem ser feitas: ligar e desligar. A lâmpada também é um objeto. Se imaginarmos ela acesa, seu estado será "ligado". E caso ela esteja apagada, seu estado será "desligado". Então note que a voltagem específica e o estado da lâmpada também são características - como no exemplo anterior, mas essas características também podem ser chamadas de estados.

Entendemos até agora que um objeto possui características/estados e ações.

Em termos de Orientação a Objetos não há diferenças técnicas entre os termos característica e estado. Porém, entre os programadores o termo atributo é o mais comumente utilizado.

Em termos de Orientação a Objetos, para designar as ações de um objeto é comum também que se utilize o termo comportamento, mas o termo método é mais freqüentemente utilizado.

Então aprendemos até agora que:

* Um objeto é composto por características e ações;
* característica = estado = atributo
* ação = comportamento = método

Logo, a seguinte sentença também é verdadeira:

* Um objeto é composto por atributos e métodos

Java é uma linguagem Orientada a Objetos

Como uma boa linguagem moderna, Java é uma linguagem Orientada a Objetos. Isto significa dizer que todo nosso ciclo de programação nesta linguagem envolverá manipulação de objetos. Como já dito anteriormente, um objeto Java é composto por atributos e métodos. Posteriormente aprenderemos a criar e manipular objetos em código Java.

Entendendo o que são Classes

Cada objeto presente em sua volta teve sua origem através de um modelo específico. No caso de uma caneta de marca, por exemplo, existem várias canetas iguais a ela. Outras da mesma marca são quase idênticas, mudando apenas a cor de sua tinta. Então, você já parou para pensar sobre como inúmeras canetas da mesma marca podem ser tão semelhantes? Elas seguem um modelo de criação em comum que especifica quantos centímetros as canetas terão; a moldagem e a cor da tampa; se a tinta será azul, vermelha ou preta, etc.
Em Orientação a Objetos, este "modelo de criação" se chama classe, e os modelos que são concretizados chamam-se objetos.

Imagine uma classe como um molde, um projeto. Uma classe não possui uma forma "concreta", digamos assim. Os objetos sim são concretos. Não existe objeto sem classe, pois uma classe é um modelo para a criação de um ou vários objetos.

Entendendo atributos e métodos com 3 classes:

CLASSE 1 - Mouse

É sempre um ótimo exercício abstrair atributos e métodos de objetos do "mundo real". Neste primeiro exemplo escolhemos o objeto Mouse. Obviamente não especificaremos absolutamente todos os seus atributos e métodos, mas apenas os principais, sem detalhes aprofundados.

Atributos:

* marca
* cor
* modelo
* botão esquerdo
* botão direito
* botão central

Métodos:

* mover cursor
* clicar com botão esquerdo
* clicar com botão direito
* clicar com botão central
* segurar botão esquerdo
* segurar botão direito
* soltar botão esquerdo
* soltar botão direito

-- comentário --

Agora, vários objetos derivados da classe Mouse podem ser criados. Todos os objetos derivados de Mouse terão: uma marca, uma cor, um modelo, um botão esquerdo, um botão direito e um botão central, sem exceções.

Todas as operações básicas que um mouse faria estão listadas como métodos da classe Mouse. Você precisa ter em mente que, na lógica orientada a objetos você precisa pensar da seguinte maneira: o que acontece quando o método "mover cursor" for chamado? Se o usuário mover o mouse para frente, o cursor do mouse deve ir para cima. Se o usuário mover o mouse para esquerda, o cursor do mouse deve ir para esquerda. O mesmo tipo de pensamento deve ocorrer não só com os métodos de movimento e clique do mouse, mas com qualquer método de qualquer classe.

Para que um método de uma classe seja executado, ele precisa ser chamado/invocado. No nosso caso, que temos um objeto do tipo Mouse, ao usuário clicar no botão esquerdo do mouse, por exemplo, um sinal elétrico pode ser disparado para o programa em questão, e desde então o método "clicar com botão esquerdo" deve ser chamado, logo o código que estiver dentro do método "clicar com botão esquerdo" será executado.

CLASSE 2 - Usuário

Tenho certeza absoluta que ao menos uma vez você se cadastrou em algum site, seja ele um fórum, um servidor de e-mails, ou qualquer outra coisa. No formulário de cadastro você encontra alguns campos a serem preenchidos como: nickname, login, senha, etc. Preenchidos esses dados - que são um molde para um usuário do site - um novo objeto do tipo Usuário será criado. Analisemos então, em um site qualquer, os atributos e métodos da classe Usuário, melhor dizendo, qual as características de cada usuário cadastrado no site e o que cada um deles pode fazer.

Atributos:

* nome completo
* nickname
* login
* password
* e-mail

Métodos:

* alterar nome
* alterar password

-- comentário --

Talvez você tenha se surpreendido com o pouco número de métodos existentes na classe Usuário. Você pode se questionar também sobre a ausência de métodos como: postar no fórum, deletar conta e convidar um amigo. Mas será que realmente a funcionalidade de postar de fórum, por exemplo, pertence a um usuário, ou será que o usuário apenas usa conta para usufruir da funcionalidade de postar no fórum, que na realidade pertence ao sistema do site em si?

A modelagem de classes varia de caso para caso, de modelador para modelador. Não há regras fixas quanto ao seu planejamento.

CLASSE 3 - Ball

Se você estiver programando um jogo onde uma pequena bola se movimenta em uma posição aleatória na tela em uma determinada velocidade, e que ao colidir com qualquer borda da tela ela é rebatida para outra direção como no vídeo abaixo:

Logo, a classe Ball será composta por:

Atributos:

* imagem
* posicaoX
* posicaoY
* velocidade

Métodos:

* mover
* parar
* rebater

-- comentário --

Talvez este exemplo seja o mais próximo da prática real da POO, pois se trata de uma abstração de um objeto que não existe fisicamente, mas que é composto por conceitos existentes do mundo real que são aplicados para se obter um objeto virtual perfeitamente manipulável com características e comportamentos próprios.

Analisemos a justificativa de seus atributos: cada objeto do tipo Ball move-se pela tela nos eixos X e Y. Logo, um objeto Ball tem os atributos posicaoX e posicaoY, para armazenar sua posição atual nos eixos X e Y, respectivamente. Um objeto Ball também tem uma velocidade, que pode ser reajustada quando necessário - hora pode se movimentar mais lentamente pelos eixos X e Y, hora pode se movimentar de forma mais rápida. Um objeto do tipo Ball também possui uma imagem, para que este possa ser visualizado pelo jogador.

Na modelagem da classe Ball decidimos criar 3 métodos: mover, parar e rebater; que na verdade são as ações do objeto. Ao invocar o método mover, o objeto Ball se movimentará pela tela. Já ao método "parar" ser chamado, o objeto Ball parará de se deslocar. E quando o método rebater foi invocado, o objeto Ball mudará sua direção de movimento.

RESUMO:

* Você aprendeu que uma classe é composta por atributos e métodos
* Você aprendeu que uma classe é um modelo para a criação de um ou vários objetos
* Se um objeto é derivado de uma classe X, pode-se dizer que este objeto é do tipo X
* Os métodos geralmente são nomeados com verbos, pois representam ações do objeto

ATENÇÃO

Você deve se manter atento no momento de modelagem de suas classes, pois elas devem ser moldadas de forma com que um determinado problema computacional seja resolvido. Independente de os exemplos citados neste Post, que são baseados em objetos do mundo real, serem úteis para resolver problemas reais de programação, eles são mais do que tudo uma boa forma de exercitar sua capacidade de abstração, sua forma de pensar orientada a objetos.

EXERCÍCIOS:

1. Abstraia uma classe a partir de uma porta, que é um objeto do mundo real. Não se prenda a detalhes profundos, apenas molde suas características e comportamentos básicos.

2. Abstraia uma classe a partir de uma janela comum do Windows, independente do programa que nela estiver sendo rodado.

3. Abstraia uma classe a partir de um personagem de um simples jogo 2D de plataforma.

Bem, ficamos por aqui. Um abraço e até a próxima

[6] Hello World no Eclipse

noreply@blogger.com (andrehbl) — Wed, 09 Jan 2008 01:21:00 +0000

Já que aprendemos a executar o Hello World manualmente, vamos aprender a executar o Hello World no IDE Eclipse, cujo processo é relativamente mais simples. Acompanhando esta seção, também faremos um rápido Tour pelo Eclipse para que possamos se situar melhor sobre o que iremos fazer.

Primeiro contato com o Eclipse

A primeira tela que você verá do Eclipse será esta:

O que o Eclipse lhe requisita é o diretório que você deseja trabalhar, isto é, o diretório que você armazenará seu(s) projeto(s). Clicando em "Browse..." você vê uma tela semelhante a essa:

Nesta janela você deve especificar o caminho onde ficarão armazenados o(s) seu(s) projeto(s). Se você deseja criar uma nova pasta para isto, clique no botão "Criar nova pasta".

Tendo escolhido seu diretório de trabalho, vá adiante clicando em OK. Você deve ser recepcionado pelo Eclipse com uma tela como esta:

Feche esta janela e você se deparará com a face do Eclipse - que a princípio pode chegar a assustar um pouco por ser aparentemente carregada:

Criando um novo projeto

No Eclipse, antes de criar um arquivo .java - que posteriormente chamaremos de Classe - devemos criar um projeto. Para isto percorreremos o seguinte caminho no menu principal: File->New->Java Project., como na figura abaixo:

Se preferir outra maneira, em vez de selecionar diretamente "Java Project", selecione a opção "Other" e em seguida opte por "Java Project":

Ambos os passos levam ao mesmo caminho: a criação de um novo projeto. Um janela com título "New Java Project" deve ser exibida e a única coisa que você precisa especificar no momento é o nome do seu projeto, como na imagem a seguir:

Logo, seu projeto será criado:

Criando uma classe

Agora que temos um projeto poderemos criar uma classe. Para isto você deve seguir o caminho no menu principal: File -> New -> Class. Observe a imagem adiante:

O nome da classe deve ser HelloWorld, do mesmo jeito que fizemos no Post anterior quando criamos o arquivo chamado HelloWorld.java:

Após clicar em "Finish" a estrutura do projeto deverá ficar da seguinte maneira:

A primeira facilidade que o Eclipse nos oferece ao criar uma classe é fornecer seu cabeçalho. Desde já precisamos apenas criar o conteúdo da classe HelloWorld. Então digite o código a seguir entre as chaves - "{" e "}":

public static void main(String[] args) {
 System.out.println("Hello World");
 System.out.println("Estou no Eclipse");
}

O código completo da classe deve ser o seguinte:

public class HelloWorld {

 public static void main(String[] args) {

  System.out.println("Hello World");
  System.out.println("Estou no Eclipse");

 }

}

Para executar o código no Eclipse não precisamos mais acionar diretamente os comandos javac e java. O próprio Eclipse se encarrega disso. No tópico Entendendo como o Java funciona - Parte 2 entendemos que antes de gerar os bytecodes, o compilador verifica se o código é compilável, isto é, o código não deve conter erros sintáticos ou semânticos, caso contrário a compilação falhará e a causa do erro deve ser exibida pelo javac. Pois bem, de tempos em tempos o Eclipse se encarrega de chamar o javac enquanto você digita seu código. Você entendeu corretamente: enquanto você digita seu código, seu código está sendo compilado. Isto é permitido porque o javac é um compilador JIT - Just-In-Time. Experimente digitar seu nome em qualquer trecho do código - exceto entre aspas dentro do comando System.out.println(). O compilador o sublinhará com cor vermelha, informando que há um erro sintático no código ao você pôr o cursor do mouse sobre ele.

Para executar seu programa, vá até o arquivo HelloWorld.java através do Eclipse, clique com o botão direito do mouse e siga o caminho: Run As -> Java Application.

Em vez de usar a "tela preta" do Prompt do MS-DOS, agora você pode enxergar seu programa rodando através do console, dentro do próprio Eclipse.

Hello World em outros IDEs

Se você não estiver usando o Eclipse, por favor, tente um dos links abaixo:

NetBeans IDE - Clique aqui
JCreator - Clique aqui (em inglês)

Missão cumprida!

Espero que a execução do seu programa no Eclipse tenha obtido sucesso. Em Post posteriores certamente veremos mais dicas e particularidades do Eclipse, e do próprio Java, é claro.

Um abraço.

Até a próxima

[5] Hora do Hello World

noreply@blogger.com (andrehbl) — Fri, 04 Jan 2008 02:39:00 +0000

Hello World

Agora podemos escrever nosso primeiro programa em Java: o tradicional Hello World. O código é bastante simples, mas se você não o entende não se preocupe, pois breve breve isso será possível. Copie o código abaixo, ele será útil:

public class HelloWorld {

 public static void main(String[] args) {
  System.out.println("Hello World");
 }

}

Este é nosso primeiro programa. Como você já deve ter percebido, ele fará com que a mensagem "Hello World" apareça na tela do computador. Aprenderemos a executar este código de forma manual, isto é, sem auxílio de um IDE como Eclipse.

Executando o programa Hello World manualmente

Siga os passos abaixo:

Escolha um diretório no seu computador para escrever seu primeiro programa - neste exemplo usaremos C:\PrimeiroPrograma;
Dentro de C:\PrimeiroPrograma crie um arquivo de texto com o nome HelloWorld que conterá o código do programa HelloWorld mostrado anteriormente;
Converta a extensão do seu arquivo de texto para extensão .java;
Abra o Prompt do MS-DOS;
Vá até o diretório C:\PrimeiroPrograma;
Agora você vai compilar seu código, como discutido no Post anterior. Para isto você deverá invocar o javac - o compilador padrão do Java, e a sintaxe básica que precisamos para compilar nosso primeiro programa é a seguinte: javac . Logo entraremos com o seguinte comando no Prompt: javac HelloWorld.java;
Note que no diretório C:\PrimeiroPrograma foi gerado um novo arquivo: HelloWorld.class. Um arquivo de extensão .class contém os bytecodes gerados pelo compilador, que permitem que seu programa seja executado em diversas plataformas. Logo, para executarmos nosso programa, ainda no mesmo diretório, invocaremos o comando java para executarmos o programa. Portanto entraremos com o comando: java HelloWorld, para que o arquivo HelloWorld.class seja executado.
A mensagem "Hello World" deve ser exibida com sucesso como na imagem abaixo:

Já que aprendemos a compilar e a executar nosso primeiro programa manualmente e termos aprendido melhor sobre como funcionam as etapas para execução de um programa Java - discutidas no Post anterior, de agora por diante executaremos nossos códigos com base no IDE Eclipse.

RESUMO:

* Você aprendeu a executar seu primeiro programa em Java manualmente
* Você aprendeu que o código fonte deve ser digitado em um arquivo de extensão .java
* Você também aprendeu que os bytecodes são armazenados em um arquivo de extensão .class, e é o arquivo de extensão .class que deve ser executado pela JVM

EXERCÍCIOS:

1. Exibir mais de uma frase na execução do programa;
2. Compilar e executar mais de um programa Java, ou seja, não se prender somente ao arquivo HelloWorld.java;

DICA DO EXERCÍCIO:

Se você criar um novo arquivo de extensão .java com o nome Programa, por exemplo, você deve modificar seu código. No caso do código HelloWorld exibido no início do Post precisaríamos modificar o código

public class HelloWorld {

 public static void main(String[] args) {
  System.out.println("Hello World");
 }

}

para

public class Programa {

 public static void main(String[] args) {
  System.out.println("Uma outra mensagem qualquer");
 }

}

Este Post fica por aqui. Parabéns pelo seu primeiro programa, resolva os exercícios e fique atento aos próximos Posts do Java Imediato.

Um abraço

[4] Entendendo como o Java funciona - PARTE 2 de 2

noreply@blogger.com (andrehbl) — Tue, 25 Dec 2007 05:32:00 +0000

Máquina Virtual Java - Java Virtual Machine (JVM)

Não se pode falar em portabilidade do Java sem envolver o principal aliado da linguagem: sua máquina virtual. A Máquina Virtual Java - ou JVM - permite que Java seja uma linguagem multiplataforma, isto é, permite que o conceito Write Once, Run Everywhere seja aplicado à prática - com as restrições que vimos no Post anterior, é claro.

Para que você compreenda um pouco sobre o funcionamento da JVM, é necessário que tenha ao menos um conhecimento superficial sobre qual a utilidade de um compilador. Se você é programador de primeira viagem, não se preocupe. Faremos uma breve explanação para que comecemos a entender como um compilador e a JVM funciona.

Compilador

Imagine que a terra foi invadida por alienígenas, e desde então 5 anos se passaram. Logo, alguns poucos seres humanos adquiriram a habilidade de se comunicar, via escrita, em idioma terráqueo e em idioma alienígena. Se comunicar diretamente com um alienígena não era uma tarefa fácil, pois mesmo na forma escrita, a comunicação era bastante complexa para seres humanos. Desde já, a ajuda dos tradutores era indispensável para uma boa comunicação entre uma pessoa e um e.t.

Os tradutores são exigentes. Mesmo para uma simples frase que você queira enviar para um alenígena, eles além de exigirem que você escreva corretamente as palavras, exigem também que você obedeça a um conjunto de regras semânticas pré-estabelecidas para que a tradução seja bem sucedida.

Se queremos enviar uma mensagem para alguém devemos tornar esta mensagem entendível para o receptor, para que este compreenda o que queremos dizer. Como todos sabemos, para se enviar uma mensagem, não basta escrever corretamente, mas também escrever de forma que você consiga se expassar a mensagem que você quer.

Para nos comunicarmos com um computador, precisamos da ajuda de um tradutor - como na pequena ficção acima. A este tradutor chamamos de compilador. Uma linguagem de programação permite que os programadores enviem instruções para os computadores de uma maneira mais amigável, mais entendível aos seres humanos. Porém, os computadores não entendem o que está escrito de forma "amigável" aos seres humanos, pois eles possuem sua própria linguagem, a linguagem de máquina.

Observe a figura abaixo:

* Na etapa 1, seu código, de uma linguagem de programação qualquer, foi digitado e está disponível para ser compilado por um compilador da linguagem em questão.
* Na etapa 2, seu código-fonte será convertido em código de máquina pelo compilador, e este estará pronto para ser executado em um determinado Sistema Operacional.

O compilador da linguagem Java

O JDK inclui o compilador da linguagem, que podemos chamá-lo de javac. Porém, em vez de trabalhar como os compiladores usuais, melhor dizendo, em vez de converter o código-fonte diretamente em código de máquina, o javac o converte em bytecodes, que são códigos que não serão executados diretamente pelo processador de uma máquina, mas por uma máquina virtual.

Supondo que você queira executar um programa Java cujo código esteja escrito em um único arquivo, observe o esquema abaixo para compreender o percurso escrita do código --> execução:

* Na etapa 1, seu código foi digitado e está disponível para ser compilado.

* Na etapa 2, o javac - compilador da linguagem Java - foi acionado, e este por sua vez verificará, como todo compilador, se o código está escrito corretamente, ou seja, se o código é compilável. Estando o código sem erro sintático ou semântico algum, este será convertido em bytecodes, que serão interpretados pela JVM. Caso contrário o processo de compilação será interrompido e o motivo da interrupção deverá ser exibido.

* Na etapa 3, a Máquina Virtual Java - JVM - se encarrega de interpretar os bytecodes gerados pelo javac para que seu código seja executado. No caso da plataforma J2SE, o código compilado neste exemplo deverá rodar em Windows, Linux e Solaris.

NÃO ENTENDEU PARA QUÊ SERVEM OS BYTECODES E A JVM?

Não se preocupe. O esquema mostrado acima reflete a capacidade multiplataforma do Java. Veja, uma vez que um código-fonte Java é compilado, este é transformado em bytecodes. E estes bytecodes são códigos independentes de plataforma, isto é, os bytecodes gerados pelo javac podem ser interpretados por uma JVM do Linux, uma JVM do Windows, ou outra JVM de outro SO. A função da JVM é executar os bytecodes em uma determinada plataforma, melhor dizendo, não importa em que Sistema Operacional os bytecodes foram gerados, porém, se seu programa precisa rodar em uma máquina com SO Linux, esta máquina deve possuir uma JVM instalada para que a mesma possa interpretar os bytecodes e executar o programa neste computador.

Java é uma linguagem compilada ou interpretada?

Java é uma linguagem compilada por ter seu código compilado antes de ser executado. E Java também é uma linguagem interpretada por ter seus bytecodes interpretados por uma máquina virtual.

Entendendo o que é JRE

Para desenvolver seu programa Java com certeza você teve de baixar o JDK, correto? O JDK é um kit completo para desenvolvimento, que inclui uma máquina virtual - JVM; um compilador - que acabamos de abordar; uma imensa e rica API e toda sua documentação.

Imagine que você queira distribuir sua aplicação para 10 clientes, todos eles com diferentes máquinas e diferentes Sistemas Operacionais. De imediato você pode pensar:

"não há problemas. Em cada máquina eu instalo uma JVM para rodar meu programa e problema resolvido.".

Este tipo de pensamento está correto, porém um pouco ingênuo. Lembre-se de que a JVM é apenas um complemento do JDK. Daí outra idéia pode surgir:

"se a JVM é um complemento do JDK, então vou instalar o JDK nas máquinas de todos os clientes."

Se você pensou assim, parabéns! Esta é uma solução, mas infelizmente não é a mais eficiente. O motivo é simples: você por acaso se lembra de quantos megabytes, aproximadamente, são o instalador do JDK? Nada minúsculo, não é? E por acaso você já verificou o tamanho do Java já instalado no seu computador? Algo perto de 200 MB, no caso do Java 5. Porém, há um detalhe que não foi citado ainda: a instalação do JDK implica também na instalação do JRE - Java Runtime Environment. O JRE é tudo o que você precisa instalar nas máquinas dos 10 clientes. E o melhor é que o JRE pode ser baixado e instalado individualmente, sem a necessidade instalar também o JDK. O peso do JRE é muito inferior ao peso do JDK. Desde já é mais vantajoso instalá-lo nas máquinas que irão rodar seu programa, em vez de instalar o JDK inteiro. Seria um desperdício de memória instalar um Kit completo de desenvolvimento de programas Java em máquinas que deveriam apenas executar um programa Java.

JRE em Websites

Talvez algum dia você se depare com um website que requeira exibir um Applet. Se você não tiver uma JRE instalada, você não conseguirá executá-lo em seu browser. A partir do momento em que você instala o JDK ou o JRE, automaticamente os plugins do JRE são instalados em alguns browsers.

ATENÇÃO!

Lembre-se de que o Java tem várias versões, e a cada nova versão ele inclui novos recursos e mantém* os recursos da versão anterior. Então, se os bytecodes possuem código do Java 5, estes deverão ser interpretados por uma JRE do Java 5 ou superior. Não é possível executar um código de Java 5 em uma JRE 1.4 ou inferior. E assim será também para as versões posteriores.

* ao decorrer das versões alguns recursos são depreciados - em inglês: deprecated - por terem se tornado obsoletos.

Bem, este Post encerra por aqui. Breve breve estaremos aprendendo a escrever e executar nosso primeiro programa .

Tenha um bom dia.

[3] Entendendo como o Java funciona - PARTE 1 de 2

noreply@blogger.com (andrehbl) — Thu, 20 Dec 2007 00:54:00 +0000

Java, uma linguagem multiplataforma (cross-platform)

Você provavelmente já ouviu falar que Java é uma linguagem multiplataforma. Antes do seu nascimento como linguagem de programação, seus criadores, visando o futuro, planejavam um projeto que interligaria computadores a outros equipamentos eletrônicos freqüentemente utilizados pelas pessoas, tais como: televisores, geladeiras, controles remotos, etc. Tal projeto resultou na criação de uma linguagem baseada em C++, a linguagem Oak. Isso mesmo, Oak era o nome da linguagem Java até descobrirem que já existia uma linguagem de programação com tal nome.

O grande lema da linguagem Java é: Write once, run everywhere! - Escreva uma vez, rode em qualquer lugar. E seu lema não é esse por acaso, pois seu significado teórico defende que uma vez que um programa foi escrito na linguagem Java, este programa pode ser executado em qualquer aparelho eletrônico que suporte Java, seja ele um celular, uma torradeira ou até mesmo um tênis - quem sabe um dia. Porém, infelizmente não é assim que funciona na prática. Java é uma linguagem multiplataforma, mas não de forma tão genérica como seria o ideal.

Como foi dito no primeiro Post do Java Imediato, Java se divide em 3 edições: J2SE, J2EE e J2ME. Em uma breve explanação sobre cada uma delas foi afirmado que a plataforma J2ME é voltada para dispositivos de memória limitada em relação aos PCs. Pare e pense sobre quantos dispositivos eletrônicos de alta tecnologia com "memória limitada" existem no mundo à fora hoje e quantos novos mais existirão daqui a alguns meses ou anos. Sem falar que a maior parte desses dispositivos possuem diferentes implementações, diferentes limitações, diferentes Sistemas Operacionais, etc. Já pensou que loucura seria desenvolver um código totalmente específico para cada um desses dispositivos? A palavra-chave para a solução deste problema chama-se portabilidade.

Java é uma linguagem portável, isto é, o código-fonte de uma aplicação Java escrita para uma plataforma específica pode ser utilizado também para uma outra plataforma. Em outras palavras, vamos supor que você construiu um jogo para o celular Nokia 6600, e que você também deseja que seu jogo funcione em um celular Sony Ericsson K310i. Não será necessário que você reescreva completamente o jogo para que ele funcione em outro celular. A solução para este problema seria reutilizar o código original, realizando alguns ajustes como tamanho da tela - pois ambos possuem tamanhos de tela diferentes -, os sons a serem tocados - esses dois celulares podem não conseguir reproduzir o mesmo formato de som-, etc. Portanto perceba desde já o porquê de Java não ser genericamente multiplataforma, pois de plataforma para plataforma geralmente há uma mínima diferença entre elas, que "obrigam" o programador a fazer pequenas adaptações no seu aplicativo.

Assim como para dispositivos móveis, o conceito multiplataforma para Desktops também existe. Ou seja, uma vez que seu aplicativo Desktop é escrito, é possível que ele rode nos Sistemas Operacionais Windows, Mac OS, Linux e Solaris. Porém, dependendo da situação, seu programa talvez precise sofrer alterações para que
ele funcione como esperado em todos os SO's - Sistemas Operacionais.

Bem, este é o fim da parte 1 do tópico Entendendo como o Java funciona. Próximo Post vamos entender melhor como o Java torna possível esta "mágica" da portabilidade.

Só para complemento, se você quer saber mais sobre J2ME, pode procurar pelo livro Programação JAVA para WIRELESS, de Érico Tavares de Mattos pela editora Digerati. O livro faz uma ótima explanação sobre as características do J2ME, além de também ensinar a como programar nesta plataforma.

Um abraço. Até a próxima

[2] Configurando o Java e o Eclipse

noreply@blogger.com (andrehbl) — Wed, 12 Dec 2007 02:46:00 +0000

Olá! Neste Post vamos aprender como configurar o Java no ambiente Windows e o que fazer para iniciar o Eclipse. São passos simples e rápidos. Vamos lá?

Configurando o Java

Como você pôde perceber, não há mistérios na instalação do SDK do Java no Windows. Sua instalação quase que é apenas Next, Next, Next... porém, é necessário fazer uma configuração antes de você iniciar sua Jornada Java. Mais uma vez não há mistérios. Faça os passos abaixo:

No ícone Meu Computador - que deve estar no seu desktop ou na barra de tarefas, abra suas propriedades - clique com botão direito em cima do ícone -> Propriedades:
A seguir, clique na aba "Avançado" e logo em seguida clique em "Variáveis de Ambiente":
Em "Variáveis de ambiente", clique no botão "Nova" no grupo das variáveis do sistema:
Dê o nome "JAVA_HOME" à nova variável de sistema como seu valor e especifique o diretório de instalação do seu JDK:
Após a criação da variável JAVA_HOME, ainda no grupo de variáveis do sistema, procure pela variável "Path" e clique em "Editar":
Após o último ponto-e-vírgula, aponte para a pasta "bin" do JDK instalado na sua máquina:

Não entendeu bem como o passo 6 funciona? Tudo bem. Supomos que no campo "Valor da variável" existisse o valor: "C:\oracle\bin; C:\System32\sys;". Logo, adicionando o diretório da pasta "bin" do seu JDK no campo "Valor da variável", seu novo valor seria: "C:\oracle\bin; C:\System32\sys; C:\Arquivos de Programas\Java\jdk1.5.0\bin;". Cada variável é separada pelo delimitador ponto-e-vírgula ";".

Bem, seguindo os passos anteriores, você acabou de configurar o Java para o deixar pronto para uso. Para conferir se a instalação foi bem sucedida, abra uma janela do Prompt do MS-DOS e digite "Java" . Uma tela semelhante a essa deve ser exibida:

Se o Prompt do MS-DOS não reconhecer o comando "Java", verifique se os passos descritos anteriormente foram executados corretamente. Se o problema persistir, tente reiniciar sua máquina.

Executando o Eclipse

Seu Eclipse veio em forma de arquivo .zip, correto? Você o abre e encontra apenas uma pasta chamada "Eclipse". Você a abre e encontra mais pastas, alguns arquivos e nenhum instalador. Você não baixou o arquivo errado, tá? A explicação para isso é que o Eclipse não precisa ser instalado através de um Setup, como de costume. Para começar a usá-lo, transfira a pasta "Eclipse" que está dentro do arquivo .zip para algum local do seu computador e abra o executável Eclipse.exe. Sugestão: arraste-a para o diretório raiz de sua unidade de disco. Exemplo: "C:\".

Não sei se foi seu caso, mas muitas pessoas tentam executar o Eclipse antes de configurar o Java corretamente - passos anteriores. O resultado é uma bela mensagem de erro e uma "não-execução do Eclipse".

Ao abrir o Eclipse, a primeira tela exibida é chamada "Workspace Launcher". Como será explicado posteriormente em outro Post, esta tela exige que você especifique o seu "local de trabalho" para que você construa e manipule seus projetos. Você pode usar um diretório já existente ou criar um novo, fica a seu gosto. Você pode criar quantos Workspaces você quiser.

Com relação a configuração do ambiente Java e da IDE Eclipse, encerramos por aqui. No próximo Post vamos nos aprofundar um pouco sobre a linguagem Java para entendermos o porquê de algumas coisas que fizemos até o momento e de algumas coisas que faremos.

Um abraço

[1] Bem vindo ao Java

noreply@blogger.com (andrehbl) — Sun, 09 Dec 2007 03:46:00 +0000

Bem, se você é "Javeiro" de primeira viagem, você está no lugar certo. Neste Post vamos aprender um pouco sobre a tão famosa linguagem Java.

Java é uma linguagem de programação bastante saudável de se aprender, porém vai exigir de você um bom esforço para que você a domine, assim como toda linguagem. O que eu recomendo para que seus estudos Java dêem certo: um bom livro, internet, fazer perguntas - muitas perguntas - e pôr os neurônios para trabalhar em frente a um computador - ou até mesmo deitado na cama, quem sabe.

Algo que você precisa saber é que o Java em si se divide em três edições diferentes: J2SE, J2ME e J2EE. Todos as três são centradas em objetivos diferentes, são eles:

J2SE (Java 2 Standard Edition) : destinado a aplicações desktop, das mais simples como um programinha que gerencia cadastros de pessoas em uma academia de ginástica, até as mais complexas como: jogos 3D, chats, editores gráficos, etc.

J2ME (Java 2 Micro Edition): bem, se a tecnologia do seu celular é GSM, você provavelmente já jogou alguns joguinhos nele, não!? Pois é, existe 98% de chance de que o jogo que você jogou foi criado com tecnologia J2ME. Esta edição do Java é destinada não só para celulares, mas para "pequenos dispositivos" em geral, que possuem quantidade de memória bastante limitada em relação a um PC, tais como: torradeiras, PDAs, relógios, entre outros. Mas Java ME - um apelido para J2ME - também não é limitado a jogos. Você pode por exemplo construir um programa de video conferência, ou até mesmo um programa que lhe mantenha diariamente atualizado com o valor atual do dólar e do euro.

J2EE (Java 2 Enterprise Edition): para não estender muito sua finalidade, esta edição é destinada a aplicações de grande porte com arquitetura cliente-servidor. Construir uma aplicação com J2EE possui uma série de benefícios, entre eles o reuso de componentes.

O foco do nosso tutorial será no J2SE (Standard Edition), pois ele é o mais indicado para o aprendizado da linguagem - e com toda razão.

JAVA 1.4... JAVA 1.5... JAVA 5... JAVA 6... por quê tantas versões?

Bem, como Java é uma linguagem viva e em constante atualização, obviamente sua versão é incrementada de tempos em tempos. Entretanto é relevante saber que a cada nova versão do Java grandes mudanças ocorrem. Isso não significa dizer que você terá que reaprender a como programar em Java a cada nova versão, muito pelo contrário, você vai aprender novos recursos que a nova versão disponibiliza.

Em suas primeiras versões, Java era bastante criticada por ser uma linguagem lenta. E infelizmente era mesmo. Seu desempenho melhorou muito em sua versão 1.4, mas foi com a chegada da versão 1.5, ou 5.0, que seu desempenho obteve uma melhora espetacular e funcionalidades bastantes interessantes foram adicionadas à linguagem. Java 5 possui o codinome TIGER, desde já não estranhe se por acaso você encontrar a expressão Java Tiger. Agora você já sabe que estão se referindo ao Java 5.

A versão mais atual do Java é 1.6, ou 6.0 - codinome Mustang. Porém, vamos iniciar nosso tutorial com o Java 5, pois temos ainda muito o que aprender com esta versão.

QUER PROGRAMAR AGORA? ENTÃO PREPARE-SE...

Para começar a programar você precisa fazer um checklist do que você tem em mãos:

* Um computador com Sistema Operacional Windows, Linux ou Mac instalado
* SDK da linguagem Java
* Uma IDE, de preferência. Se não quiser programar em bloco de notas...

Não sabe o que diabos é SDK? SDK (Software Development Kit) é um kit de desenvolvimento que lhe possibilita desenvolver aplicações em uma determinada linguagem de programação, no nosso caso: Java. Fique atento e não confunda-se, pois você pode encontrar a sigla JDK (Java Development Kit) ou até mesmo JSDK (Java System Development Kit), que no final significam SDK da linguagem Java.

Já um(a) IDE (Integrated Development Environment) é um ambiente de desenvolvimento que vai lhe ajudar bastante no momento da programação. Uma IDE possui uma interface gráfica intuitiva para que o programador facilmente detecte e corrija erros de compilação, crie novos projetos, automatize tarefas, etc.

E então, vamos começar a baixar?

Baixando o SDK

Aqui vai o endereço do SDK do Java 5 que você precisa fazer o download:

http://java.sun.com/javase/downloads/index_jdk5.jsp

Após clicar em Download, você aceita os acordo de licença, aguarda um instante e escolhe a versão do seu Sistema Operacional + o tipo de instalação que você quer.

Após a seleção, clique em "Download selected with Sun Download Manager". Agora é só baixar.

Baixando uma IDE

Você pode escolher uma ou mais IDEs entre as mais variadas existentes. São algumas delas: Eclipse, Netbeans, JEditor, JGrasp, BlueJ e GEL. Todas elas são gratuitas. Não seria muito produtivo se a cada Post eu desse suporte a cada uma dessas IDEs, desde já recomendo que você baixe a IDE Eclipse, cujo release mais recente chama-se Eclipse Europa. Você pode baixar o Eclipse em: http://www.eclipse.org/downloads/ clicando em "Eclipse IDE for Java Developers".

Bem, por esse Post é só. Continue a ler o Java Imediato para que vejamos como configurar o ambiente Java no Windows e a entender melhor como essa fantástica linguagem funciona.

Um abraço. Até a próxima