JAVA

Break e Continue

2013-10-02T07:00:00.000-03:00

Break e continue são instruções utilizadas nos comandos de repetição for, while ou do while.

Break:

A instrução break é utilizada em comando de repetição para que o laço seja “abortado”, ou seja, faz com que o código pule para a instrução seguinte ao fechamento da chave do bloco de código do laço, ou seja após a instrução break ser executada não é feita mais nenhuma iteração.

Continue:

A instrução continue faz com que a expressão do comando de repetição do laço seja pulada para próxima iteração do laço.

Vamos à prática:

Até o próximo post.

Comandos de repetição: For

2013-10-01T07:00:00.000-03:00

No laço for uma determinada expressão será repetida até que a condição do for não seja mais satisfeita. Este tipo de loop é utilizado para realizarmos iterações simples onde repetimos certa operação por um numero de vezes previamente conhecido.

Sintaxe:

for ([inicialização];[teste];[incremento]){

//comandos

}

for ([inicialização];[teste];[incremento])

//único comando;

Inicialização:

É uma expressão que inicializa o loop. Esta operação será executada uma única vez.

Normalmente utilizamos o bloco de inicialização para atribuirmos um valor inicial que contará o numero de vezes que a expressão será executada.

Nele, podemos declarar e inicializar uma variável, estando disponível somente para o bloco de código do laço for.

Teste

O teste deve, obrigatoriamente, ser uma expressão booleana. O teste é a condicional de termino do loop.

Incremento

A expressão especificada no incremento será executada a cada ciclo realizado.

Vamos à prática:

* Os blocos de inicialização, teste e incremento não são obrigatórios, o que significa que todos os códigos acima são válidos.

Até o próximo post.

Comandos de repetição: while, do while.

2013-09-24T18:27:00.001-03:00

Utilizamos comandos de repetição para determinar de forma lógica quantas vezes desejamos executar um bloco de instruções.

While:

Sintaxe:

while (condição booleana){

//comandos

}

while (condição booleana)

//único comando;

Vamos à prática:

Do While:

O comando de repetição while, difere do comando do while, pois o bloco de código escrito para o laço do while, é executado pelo menos uma vez, mesmo que a condição do while seja falsa.

Sintaxe:

do {

// Conjunto de instruções

}while (condição booleana);

//uma única instrução

while(condição booleana);

Vamos à prática:

Até o próximo post.

Controle de fluxo: switch

2013-09-21T15:31:00.004-03:00

Utilizamos comandos condicionais para controlar o fluxo que nosso programa deve seguir. Uma instrução switch funciona como vários if, elseif, sendo que, neste caso, é utilizado uma variável e para cada case é feito uma comparação.

Sintaxe:

switch(<variavel>){

case <valor> : //faça algo

default <valor> : //faça algo

}

A variável a ser avaliada no case deve ser um tipo char, byte, short ou int, sendo necessário ter o tipo compatível com o tipo da variável passada no switch.

Quando um case verdadeiro é encontrado, o programa segue executando até que seja encontrado uma instrução break, ou seja o fim do bloco switch.

Vamos à prática:

Executando com dia da semana = 1:

Executando com dia da semana = 6:

Opa não era isso que queria? Isso aconteceu porque ao chegar 21 é encontrado o case que será executado porem dentro do bloco de instruções deste case não existe o comando break e o código segue executando até o fim do switch, para resolver adicione o comando break após as linhas 24 e 27.

Execute novamente:

Até porque você não vai querer que os dias de festejar passem rápidos.

Até o próximo post.

Controle de Fluxo: if, else

2013-09-20T21:23:00.000-03:00

Utilizamos comandos condicionais para controlar o fluxo que nosso programa deve seguir. Uma instrução if deve sempre avaliar uma variável ou retornar um valor true.

Sintaxe:

If (<expressão boleana ou variável boleana>){

}

Este é um exemplo de uma sintaxe de if simples pode ser “traduzido” para:

se (<expressão booleana ou variável boleana> = verdadeiro) {

faça isso

}

Muitas vezes necessitamos que algo seja executado quando a expressão avaliada não for verdadeira para isso utilizamos o else.

Sintaxe:

If (<expressão boleana ou variável boleana>){

}else {

}

Este é um exemplo de uma sintaxe de if pode ser “traduzido” para:

se (<expressão booleana ou variável boleana> = verdadeiro) {

faça isso

}senão {

faça isso

}

Diferente de outras linguagens no Java else if é escrito separadamente:

If (<expressão boleana ou variável boleana>){

}else if(<expressão boleana ou variável boleana>){

}else {

}

Este é um exemplo de uma sintaxe de if pode ser “traduzido” para:

se (<expressão booleana ou variável boleana> = verdadeiro) {

faça isso

}senão se (<expressão booleana ou variável boleana> = verdadeiro) {

faça isso

}senão {

}

Vamos à prática:

class ControleFluxoIf{

public static void main(String args[]){

boolean meuBolean = true;

if (meuBolean){

System.out.println("If mais simples do mundo!");

}

if (20 == 20){

System.out.println("20 == 20");

}

if (20 == 20 && 20 == 30){

System.out.println("20 == 20 e 20 == 30");

}else {

System.out.println("20 != 20 ou 20 != 30");

}

if (20 == 20 && 20 == 30){

System.out.println("20 == 20 e 20 == 30");

}else if(20 == 20) {

System.out.println("20 == 20");

}else if(20 == 30) {

System.out.println("20 == 30");

}else {

System.out.println("20 != 20 ou 20 != 30");

}

Até o próximo post.

Operador Ternário: ?

2013-09-19T22:18:00.002-03:00

O operador ternário é um modo de fazer um teste condicional simples substituído o if. Exemplo:

int meuInt = 2;

int meuIntB = 3;

int meuIntC = 4;

meuInt = meuIntB>meuIntC ? meuIntB : meuIntC;

A expressão que fica ao lado esquerdo do ? é avaliada (meuIntB>meuIntC), se meuIntB maior que meuIntC então meuInt = meuIntB senão meuInt é igual meuIntC, está operação poderia ser substituída por:

if (meuIntB>meuIntC){

meuInt = meuIntB;

}else {

meuInt = meuIntC;

}

Vamos à prática:

class OperadorTernario{

public static void main(String args[]){

int meuInt = 2;

int meuIntB = 3;

int meuIntC = 4;

meuInt = meuIntB>meuIntC ? meuIntB : meuIntC;

System.out.println("meuInt = " + meuInt);

String retorno;

int meuPrimeiro = 20;

int meuSegundo = 23;

retorno = (meuPrimeiro % 2 == 0) ? "Par" : "Impar";

System.out.println("meuPrimeiro e " + retorno);

retorno = (meuSegundo % 2 == 0) ? "Par" : "Impar"; System.out.println("meuSegundo e " + retorno);

}

Até o próximo post.

Operadores de Atribuição: =, +=, -=, *=, /= e %=

2013-09-19T21:47:00.005-03:00

Operadores de atribuição são operadores que atribuem (obvio) novos valores as variáveis ou expressões. Existem dois tipos de atribuições:

- Atribuição simples. x = 7;

- Atribuição composta. x += 7 é igual a x = x +7;

A atribuição composta incrementa o valor da variável x por exemplo com o operando ou expressão do lado direito + 7. O operando composto funciona para muitos outros operadores tais como:

-= Subtração

+= Adição

*= Multiplicação

/= Divisão

%= Resto

Vamos à prática:

class OperadorAtribuicao{

public static void main(String args[]){

int meuInt = 10;

System.out.println("Valor Atual de meuInt: " + meuInt);

//Atribuido + 5

meuInt += 5; // = meuInt = menuInt + 5;

System.out.println("Valor de meuInt += 5: " + meuInt);

//Subtraindo + 5

meuInt -= 5; // = meuInt = menuInt - 5;

System.out.println("Valor de meuInt -= 5: " + meuInt);

//Multiplicando * 5

meuInt *= 5; // = meuInt = menuInt * 5;

System.out.println("Valor de meuInt *= 5: " + meuInt);

//Dividindo / 5

meuInt /= 5; // = meuInt = menuInt / 5;

System.out.println("Valor de meuInt /= 5: " + meuInt);

//Resto % 5

meuInt %= 3; // = meuInt = menuInt % 3; Mudei para 3 para dar um resto se fosse 5 daria 0 porque 10\5 = 2 sem sobras

System.out.println("Valor de meuInt %= 3: " + meuInt);

}

Até o próximo post.

Operadores lógicos AND(&&, &), OR(||,|) XOR(^)

2013-09-17T19:09:00.000-03:00

Operadores lógicos são operadores utilizados quando existe a necessidade de se comparar mais de uma condição.

Estes operadores são aplicáveis somente entre operadores booleanos.

Quando utilizamos estes operadores é sempre realizada uma avaliação da primeira condição. Caso este resultado seja conhecido, a avaliação da segunda condição não será realizada.

AND(&&)

Se uma das condições for false, o resultado de AND será falso. Então, caso a primeira condição seja falsa a segunda condição não será avaliada.

Exemplo:

boolean meuBooleanAnd1 = 1==2 && 2==2;// retorna falso na primeira condição e não realiza a segunda. Tem como resultado false.

OR(||)

Se uma das condições for verdadeira, então o resultado do OR será verdadeiro. Então, caso a primeira instrução seja verdadeira a segunda não será avaliada.

Exemplo:

boolean meuBooleanOr1 = 1==1 || 2==1; retorna true na primeira condição e não realiza a segunda. Tem como resultado false.

Vamos à prática:

class OperadorLogicosAndOr{

public static void main(String args[]){

boolean meuBooleanAnd1 = 1==2 && 2==2;

boolean meuBooleanOr1 = 1==1 || 2==1

System.out.println("meuBooleanAnd1 " + meuBooleanAnd1);

System.out.println("meuBooleanOr1 " + meuBooleanOr1);

}

Operadores bit a bits (&, ^ e |)

Operadores de bits são aplicáveis a tipos inteiros e booleanos.

O resultado de uma operação entre bits é calculado comparando-se os operadores de bit.

& AND

Diferentemente do && o & compara bit a bit e no caso do & sempre é avaliado a segunda expressão mesmo a primeira sendo false.

Exemplo:

boolean meuBoolean1 = 1==2 & 1==1; retorna false na primeira expressão, mas mesmo assim executa a segunda. Resultado final false;

| OR

Diferentemente do || o | compara bit a bit e no caso do | sempre é avaliado a segunda expressão mesmo a primeira sendo true.

Exemplo:

boolean meuBoolean2 = 1==1 | 1==2; retorna true na primeira expressão, mas mesmo assim executa a segunda. Resultado final true;

^ XOR

O XOR conhecido como eXclusive Or faz com que uma expressão seja true somente se e somente um dos lados for verdadeiro.

Exemplo:

boolean meuBoolean3 = 1==1 ^ 1==2; retorna true na primeira expressão, e false na segunda dando como resultado final true;

boolean meuBoolean4 = 1==1 ^ 1==1; retorna true na primeira expressão, e true na segunda dando como resultado final false; O XOR só permite que uma expressão seja verdadeira e as outras falsas.

Vamos à prática:

class OperadorBits{

public static void main(String args[]){

boolean meuBoolean1 = 1==2 & 1==1;

boolean meuBoolean2 = 1==1 | 1==2;

boolean meuBoolean3 = 1==1 ^ 1==2;

boolean meuBoolean4 = 1==1 ^ 1==1;

System.out.println("meuBoolean1 " + meuBoolean1);

System.out.println("meuBoolean2 " + meuBoolean2);

System.out.println("meuBoolean3 " + meuBoolean3);

System.out.println("meuBoolean4 " + meuBoolean4);

}

Até o próximo post.

Operador de Comparação de Tipo: instaceof

2013-09-15T20:10:00.003-03:00

O operador de comparador de tipo instaceof verifica se um determinado objeto é uma instancia de uma determinada classe. O operador da esquerda deve ser uma variável do tipo reference, portanto não pode ser uma variável de tipo primitivo, enquanto o operador da direita deve ser uma class, interface ou um tipo array.

Vamos à prática:

class OperadorComparacaoTipos{

public static void main(String args[]){

String nome = "Diego";

Object objeto = new Object();

boolean resutado1 = nome instanceof String;

boolean resutado2 = objeto instanceof Object;

boolean resutado3 = objeto instanceof String;

System.out.println(nome + " instanceof String " + resutado1);

System.out.println(objeto + " instanceof Object " + resutado2);

System.out.println(objeto + " instanceof Object " + resutado3);

}

Até o próximo post.

Operadores de Comparação

2013-09-15T20:09:00.002-03:00

Operadores de comparação são amplamente utilizados na comparação de dois tipos primitivos tendo como retorno um boolean (true ou false).

- < menor que

- > maior que

- <= menor ou igual que

- >= maior ou igual que

- == igual

- != diferente

Vamos à prática:

class OperadorComparacao{

public static void main(String args[]){

int numero1 = 120;

int numero2 = 140;

byte numero3 = (byte)120;

boolean resutado1 = numero1 < numero3;

boolean resutado2 = numero1 > numero3;

boolean resutado3 = numero1 <= numero3;

boolean resutado4 = numero1 >= numero3;

boolean resutado5 = numero1 == numero3;

boolean resutado6 = numero1 != numero3;

boolean resutado7 = numero2 <= numero3;

boolean resutado8 = numero3 != numero2;

System.out.println(numero1 + " < " + numero3 + " " + resutado1);

System.out.println(numero1 + " > " + numero3 + " " + resutado2);

System.out.println(numero1 + " <= " + numero3 + " " + resutado3);

System.out.println(numero1 + " >= " + numero3 + " " + resutado4);

System.out.println(numero1 + " == " + numero3 + " " + resutado5);

System.out.println(numero1 + " != " + numero3 + " " + resutado6);

System.out.println(numero2 + " <= " + numero3 + " " + resutado7);

System.out.println(numero3 + " != " + numero2 + " " + resutado8);

}

Até o próximo post.

Operadores aritméticos: soma(+), divisão(-), multiplicação(*), divisão(/) e resto(%)

2013-09-15T20:07:00.001-03:00

Operadores aritméticos são operadores aplicados a dois ou mais números inteiros ou números de ponto flutuante.

Soma e subtração: + e -

Java não permite a sobrecarga de operadores. No entanto a própria linguagem sobrecarregou o + para quando aplicado em uma String fizesse concatenação.

O operador + quando aplicado a dois ou mais números inteiros ou de ponto flutuante, tem a função de somar estes números.

Exemplo:

int minhaSoma = 20 + 8; // Resultado 28

O operador - quando aplicado a dois ou mais números inteiros ou de ponto flutuante, tem a função de subtrair estes números.

int minhaSubtracao = 20 – 8; // Resultado 12

Multiplicação e divisão: * e /

Os operadores de multiplicação são aplicáveis a todos os tipos primitivos numéricos.

Existem algumas limitações impostas pela representação numérica do computador. Estas limitações ocorrem para todos os formatos numéricos, do byte ao double, mas são mais notáveis para os inteiros.

Se você multiplicar ou dividir dois inteiros, o resultado será calculado usando a aritmética de inteiros. Se o resultado for maior que o maior numero que pode ser armazenado o resultado final não fara sentido

O operador * quando aplicado a dois ou mais números tem a função de multiplicar estes números.

Exemplo:

int minhaMultiplicacao = 20 * 8; // Resultado 160

byte minhaMultiplicacao2 = (byte)20 * (byte)20; // O compilador informara um possível erro de precisão sendo necessário transformar a variável byte minhaMultiplicacao2 em int.

O operador - quando aplicado a dois ou mais números tem a função de dividir estes números.

int minhaDivisao = 20 / 8; // O resultado seria resultado 2.5 porem como estamos armazenando em um int o resultado será 2 porque 2.5 deveria ser armazenado em um float ou double;

int float minhaDivisaoF = 20f / 8f; // Faz o cast para os valores 20 e 8 serem considerados do tipo float e guarda o resultado em uma variável float o qual o resultado será 2.5;

Resto da divisão: %

O operador % quando aplicado a dois ou mais números inteiros ou de ponto flutuante, tem a retornar o resto da divisão destes números.

Exemplo:

int meuResto = 20 % 8; // Resultado 4

Porque 4 se o resultado da divisão é 2,5?

O que acontece aqui é simples o sistema divide 20/8 da seguinte maneira (voltando ao ensino fundamental) :

Quantas vezes 8 cabe dentro de 20?

2x é a resposta certa porque 2 x 8 = 16

Quanto é 20 – 16?

4 opa aqui esta o nosso resultado.

Resumindo é feito uma divisão direta ou seja divide um numero pelo outro e o que sobra não dividido novamente, o que sobra é chamado de resto.

Outros exemplos:

int meuResto2 = 20 % 3; // O resultado será 2 porque 3 * 6 = 18 e 20 – 18 é 2.

int meuResto3 = 20 % 5; // O resultado será 0. Porque 5 * 4 = 20 e 20 – 20 é 0;

Concluindo sugiro que sempre que trabalhar com divisão utilize float ou double para não ter perda de precisão e não se esqueça de fazer o cast dos valores divididos para float((float)valor ou valorf) ou double((double) valor).

Na multiplicação sempre tome cuidado com o possível resultado, pois a multiplicação de dois números do mesmo tipo pode resultar em numero que não cabe neste tipo.

Vamos à prática:

class OperadorAritimetico{

public static void main(String args[]){

int minhaSoma = 20 + 8;

int minhaSubtracao = 20 - 8;

int minhaMultiplicacao = 20 * 8;

int minhaMultiplicacao2 = (byte)20 * (byte)20;

int minhaDivisao = 20 / 8;

float minhaDivisaoF = 20f / 8f;

int meuResto = 20 % 8;

int meuResto2 = 20 % 3;

int meuResto3 = 20 % 5;

System.out.println("minhaSoma = " + minhaSoma);

System.out.println("minhaSubtracao = " + minhaSubtracao);

System.out.println("minhaMultiplicacao = " + minhaMultiplicacao);

System.out.println("minhaMultiplicacao2=" + minhaMultiplicacao2);

System.out.println("minhaDivisao = " + minhaDivisao);

System.out.println("minhaDivisaoF = " + minhaDivisaoF);

System.out.println("meuResto = " + meuResto);

System.out.println("meuResto2 = " + meuResto2);

System.out.println("meuResto3 = " + meuResto3);

}

Até o próximo post.

Operadores Unários: Negação !, Pré e pós incremento ++, Pré e pós decremento --, Sinal positivo +, Sinal negativo -, Inversão de bits ~, Cast ()

2013-09-14T13:10:00.002-03:00

Operadores unários são operadores que envolvem apenas um operando, tais como:

- Negação !

- Pré e pós incremento ++

- Pré e pós decremento --

- Sinal positivo +

- Sinal negativo -

- Inversão de bits ~

- Cast ()

Operador de negação: !

É utilizado para inverter o valor de uma expressão booleana, ou seja uma expressão !true retorna false e uma expressão !false retorna true.

Vamos à prática:

class OperadorNegacao{

public static void main(String args[]){

boolean verdadeiro = true;

System.out.println("Verdadeiro = " + verdadeiro);

System.out.println("!Verdadeiro = " + !verdadeiro);

}

Operador de incremento e decremento: ++,--

Estes operadores modificam o valor de uma expressão adicionando ou subtraindo 1. Os operadores de incremento e decremento podem ser:

- Pós-fixados: O incremento ou decremento é feito após o uso da variável.

- Pré-fixados: O incremento ou decremento é feito antes do uso da variável.

Vamos à prática:

class OperadorIncrementoDecremento{

public static void main(String args[]){

int incremento = 5;

int decremento = 8;

System.out.println("Pos-fixados:");

System.out.println("incremento atual=" + incremento);

System.out.println("incremento++=" + incremento++); // primeiro exibe na tela depois adiciona 1

System.out.println("depois do incremento=" + incremento);

System.out.println("-----------");

System.out.println("decremento atual=" + decremento);

System.out.println("decremento--=" + decremento--); // primeiro exibe na tela depois tira 1

System.out.println("depois do decremento=" + decremento);

//Neste momento a variavel incremento é igual a 6

//Neste momento a variavel decremento é igual a 7

System.out.println("");

System.out.println("Pre-fixados:");

System.out.println("incremento atual=" + incremento);

System.out.println("++incremento=" + ++incremento); // primeiro adiciona 1 e depois exibe na tela

System.out.println("depois do incremento=" + incremento);

System.out.println("-----------");

System.out.println("decremento atual=" + decremento);

System.out.println("--decremento=" + --decremento); // primeiro tira 1 e depois exibe na tela

System.out.println("depois do decremento=" + decremento);

}

Operadores de representação de sinal: + e -

Os operadores unários + e – representam positivo e negativo respectivamente. O operador + não tem outra função a não ser deixar explicito que um numero é positivo (O operador mais quando utilizando com Strings serve como concatenação e quando utilizado com dois números como soma, porem para este tópico ele serve apenas para deixar explicito que um numero é positivo).

Exemplo:

int numeroNegativo = -12;

int numeroPositivo = +12; // numeroPositivo = 12 seria exatamente igual.

Operador de inversão: ~

Conhecido como Bitwise Inversion Operator (operador de inversão de bits) converte todos os bits 1 em 0 e todos os 0 em 1.

Exemplo:

int numeroInvertido = ~7 è numeroInvertido = 7 + 1 invertendo o sinal = - 8

int numeroInvertido = ~-20 è numeroInvertido = -20+1 invertendo o sinal = 19

Operador de conversão: Cast

O operador cast é utilizado para uma conversão explicita em uma expressão:

- Cast pode ser aplicado para trocar tipos de valores primitivos.

- Cast pode ser aplicado em referencia a objeto.

Existem dois tipos de cast:

- Cast explicito:

Quando queremos que uma variável de tipo maior seja convertida em um tipo menor. Exemplo quando queremos que double seja convertido em um byte, se não fizermos o cast explicitamente teremos um erro de compilação.

- Cast automatico:

Não precisamos fazer o cast explicito ou seja quando uma variável cabe em outra. Exemplo quando queremos colocar um byte em um short.

Agora como saber que uma variável cabe em outra? Abaixo segue uma ordem da esquerda para direita:

byte è short ou char è int è long è float è double

Ou seja um byte sempre cabe em um short, um short sempre cabe eu um int ou em um char e assim por diante, para estes casos podemos utilizar o cast automático, porem caso você queira colocar um int em short devera usar o cast explicito onde você estará informando ao compilador “Ei eu sei o que estou fazendo este valor de int cabe em short”. TENHA CERTEZA DO QUE ESTA FAZENDO, POIS O COMPILADOR IRÁ REMOVER OS BITS DO VALOR O QUE ACARRETARA EM UMA PERDA DE PRECISÃO.

Vamos à prática:

class OperadorConversao{

public static void main(String args[]){

byte meuByte = 123;

short meuShort = 1234;

int meuInt = 12345;

char meuChar = 'd';

long meuLong = 123456;

float meuFloat = 12.4567f; // adicionado o f para forçar float caso não coloque é considerado um double

double meuDouble = 123.456785;

System.out.println("Valores Atuais:");

System.out.println("meuByte = " + meuByte);

System.out.println("meuShort = " + meuShort);

System.out.println("meuChar = " + meuChar);

System.out.println("meuInt = " + meuInt);

System.out.println("meuLong = " + meuLong);

System.out.println("meuFloat = " + meuFloat);

System.out.println("meuDouble = " + meuDouble);

System.out.println("Cast automatico:");

meuShort = meuByte; // meuByte e menor meuShort cast automatico

meuInt = meuShort; // meuShort e menor meuInt cast automatico

meuLong = meuInt; // meuInt e menor meuLong cast automatico

System.out.println("meuShort = " + meuShort);

System.out.println("meuInt = " + meuInt);

System.out.println("meuLong = " + meuLong);

System.out.println("Cast Explicito:");

meuFloat = (float)meuDouble; // Double é maior que float por isso é necessario informar ao compilado "Ei sei o que estou fazendo! O valor da minha variavel double vai caber no float"

meuLong = 1231312312;

meuInt = (int)meuLong;

meuShort = (short)meuInt;

System.out.println("meuFloat = " + meuFloat);

System.out.println("meuLong = " + meuLong);

System.out.println("meuInt = " + meuInt);

System.out.println("meuShort = " + meuShort); // perceba que o valor mostrado é totalmente diferente ou seja foi feito um cast erroneamente pois o valor de int não cabe no short.

}

Com isso finalizo o post de operadores unários e fica a dica: Tome cuidado com cast explicito tenha certeza do que esta fazendo pois pode ocorrer perda de precisão.

Até o próximo post.

Variáveis na Prática

2013-09-10T20:32:00.001-03:00

O objetivo deste post é mostrar na prática o que foi explicado no post de variáveis na teoria.

Tipos primitivos:

class VariaveisPrimitivas{

public static void main(String args[]){

boolean blnMeuBooleano = true;

boolean blnMeuOutroBooleano = false;

byte meuByte = (byte) 123;

short meuShort = (short) 1234;

int meuInt = 0;

char meuChar = 'd';

char meuCharAsc = 64;

char meuCharUnicode = '\u0000';
long meuLong = 921l;
float meuFloat = 10.28f;
double meuDouble = 12345678.97;

System.out.println("blnMeuBooleano: " + blnMeuBooleano);
System.out.println("blnMeuOutroBooleano: " + blnMeuOutroBooleano);
System.out.println("meuByte: " + meuByte);
System.out.println("meuShort: " + meuShort);
System.out.println("meuInt: " + meuInt);
System.out.println("meuChar: " + meuChar);
System.out.println("meuCharAsc: " + meuCharAsc);
System.out.println("meuCharUnicode: " + meuCharUnicode);
System.out.println("meuLong: " + meuLong);
System.out.println("meuFloat: " + meuFloat);
System.out.println("meuDouble: " + meuDouble);
}
}

Tipos primitivos:

class VariaveisReference{

public static void main(String args[]){

String minhaString = new String();

String minhaString2 = "Teste";

Object meuObjeto = new Object();

Object meuObjeto2 = null;

System.out.println("minhaString: " + minhaString);

System.out.println("minhaString2: " + minhaString2);

System.out.println("meuObjeto: " + meuObjeto);

System.out.println("meuObjeto2: " + meuObjeto2);

}
}

Variáveis locais:

class VariaveisLocais{

public static void main(String args[]){

//variavel local meuNome tipo String inicializado com Diego

String meuNome = "Diego";

//variavel local meuNumero tipo int inicializado com 123

int meuNumero = 123;

//variavel local meuNumero2 tipo int não inicializado

int meuNumero2;

System.out.println("meuNome: " + meuNome);

System.out.println("meuNumero: " + meuNumero);
System.out.println("meuNumero2: " + meuNumero2);
}
}

Este erro ocorre porque variáveis declaradas dentro de métodos ou blocos de códigos devem ser inicializadas. Para este código funcionar devemos alterar o código:

int meuNumero2;

Para:

int meuNumero2 = 1234;

Escopo:

class VariaveisEscopo{

public static void main(String args[]){

{

//as variaveis declaradas dentro deste escopo não podem ser

//acessadas de fora

String meuNome = "Diego";

}

System.out.println("meuNome: " + meuNome);

}

Este erro de compilação ocorre porque estamos tentando acessar uma variavel que não esta no mesmo escopo. Para resolvermos Temos duas opções:

Colocar o print dentro das chaves da declaração da variável:

class VariaveisEscopo{

public static void main(String args[]){

{

//as variaveis declaradas dentro deste escopo não podem ser

//acessadas de fora

String meuNome = "Diego";

System.out.println("meuNome: " + meuNome);

}

}
}

Colocar a declaração da variável no mesmo nível do print:

class VariaveisEscopo{
public static void main(String args[]){
String meuNome = "Diego";
System.out.println("meuNome: " + meuNome);

}
}

Até o próximo post.

Variáveis

2013-09-10T19:51:00.000-03:00

O objetivo deste post é dar uma explicação teórica de variáveis java, se você já entende o conceito veja aqui o post de variáveis na prática.

Variáveis representam um espaço de memória para armazenar um valor, os programas não fariam sentido se trabalhassem sempre com os mesmos valores. Uma variável em Java é representada por um nome (identificador) e o tipo de valor a ser armazenado. As variáveis são classificadas em:

Tipo primitivo (Numérico, Caracter e Booleanos(verdadeiro ou falso));
Tipo reference (Armazenam o endereço de memória estendida de um determinado objeto).
Arrays.

Tipos primitivos:

Sintaxe para declaração e inicialização de tipos primitivos:

<tipoDeVariavel> <nomeDaVariavel> = valor;

Exemplos Numéricos:

byte meuByte = (byte) 123; *

short meuShort = (short) 1234; *

int meuInt = 0;

char meuChar = 'd';

long meuLong = 921l; **

float meuFloat = 10.28f; ***

double meuDouble = 12345678.97;

* Para forçar um número byte ou short, devemos utilizar a técnica de casting (modificadores de tipo).

** Todo número inteiro escrito em Java é tratado como int, desde que o valor esteja na faixa de valores do int. Para forçar um número long utilizamos a letra “L” ou “l” no final do número: 10L. Apesar de “caber” em um int, o L vai forçar para que este número ocupe um espaço equivalente a um long.

*** Todo número com ponto flutuante por default é double. Para indicarmos que um número é do tipo float, devemos utilizar o caractere “F” ou “f” no final do número.

Exemplos Caracteres:

char meuChar = ‘d’;

char meuCharAsc = 64;

char meuCharUnicode = ‘\u00000’;

Os caracteres são representados pelo tipo primitivo char e são utilizados para expressar uma tecla. Devido a utilização do Unicode, cada char ocupa 2 bytes na memória, o que permite expressar caracteres “double byte” como japonês, chinês, entre outros.

Exemplos Booleanos:

boolean blnMeuBooleano = true;

boolean blnMeuOutroBooleano = false;

Diferentemente de outras linguagem o boolean só trabalha com os valores true ou false e não aceita inteiro como entrada.

Tipo reference:

Sintaxe para declaração e inicialização de uma variável de tipo reference:

<tipoDeVariavel> <nomeDaVariavel> = new <tipoDeVariavel>();

Variáveis do tipo de reference podem conter os seguintes valores:

· null

· referência para qualquer objeto cuja classe é de um tipo compatível ao declarado.

· referência para um array.

Exemplos:

String minhaString = new String();

String minhaString2 = “Teste”;

Object meuObjeto = new Object();

Object meuObjeto2 = null;

Variáveis locais:

Variáveis declaradas dentro de métodos ou blocos de códigos são definidas como locais. Este tipo de variável não possui valor de inicialização padrão, portanto, devemos indicar um valor, caso contrário, recebemos um erro de compilação.

Escopo:

O escopo define em qual parte do programa a variável estará acessível.

Até o próximo post.

System.out.print, System.out.println, System.out.printf e Caracteres de Escape

2013-09-07T13:39:00.000-03:00

No Java existem varias maneiras de se exibir uma saída de texto cada uma com suas particularidades entre elas estão:

System.out.print;
System.out.println;
System.out.printf;

System.out.print:

O método System.out.print(“”) instrui o computador a imprimir um valor String passada entre as aspas, na tela.

A primeira coisa a fazer é criar uma pasta onde seu programa será criado, no meu caso criei em “C:\Blog”, após a criação do diretório crie o arquivo prints.java na pasta, conforme a imagem abaixo (ignore os outros arquivos são de outros exemplos):

Após a criação do arquivo abra o arquivo com o bloco de notas.

Digite o seguinte código:

class prints {

public static void main (String args[]){

System.out.print("Eu sou um print");

System.out.print(" sem quebra linha.");

}

No prompt de comando compile e execute o arquivo o resultado será:

System.out.println:

O método System.out.println(“”) instrui o computador a imprimir um valor String passada entre as aspas, na tela e quebra uma linha ao final.

Vamos alterar o codigo anterior para utilizar o println no local do print conforme abaixo:

class prints {

public static void main (String args[]){

System.out.println("Eu sou um println, ");

System.out.println(" eu quebro linha.");

}

No prompt de comando compile e execute o arquivo o resultado será:

System.out.printf:

O método System.out.printf instrui o computador a imprimir um valor na tela de maneira formatada(por isso o f no final). Diferentemente dos outros métodos print o printf trabalha com dois argumentos:

- O primeiro argumento é a string de formato que pode consisitir em texto fixo e especificadores de formato (Os especificadores de formato iniciam com % seguidos por um caractere que representa o tipo de dados).

- O segundo argumento pode ser ser uma lista de argumentos, estes argumentos passam os valores a serem substituidos no lugar dos especificadores de formato do primeiro argumento, estes argumentos devem ser separados por virgula e são conhecidos como lista separada por virgulas.

Vamos alterar o codigo anterior para utilizar o printf no local do println conforme abaixo:

class prints {

public static void main (String args[]){

System.out.printf("Eu sou um %s eu sou %s.", "printf", "formatado");

}

No prompt de comando compile e execute o arquivo o resultado será:

Sequencias de escape:

O Java tabalha com caracteres de escape que podem ser inserido junto a uma String(dentro das “”) para melhor formatação o caractere que representa o escape é \ (barra invertida) isso indica aos metodos prints que um caractere especial deve ser impresso. Abaixo está a lista de sequencias de escape comuns e como elas afetam a exibição:

\n – Nova linha, posiciona o cursor de tela no inicio da proxima linha.

\t – Tabulação horizontal, Move o cursor de tela para a proxima para da tabulação.

\r – Retorno de carro, posiciona o cursor da tela no inicio da linha atual. Qualquer saida de caracteres depois do retorno de carro sobrescreve a saida anteriormente gerados na linha atual.

\\ - Barras invertidas. Utilizadas para imprimir um caractere de barra invertida.

\” – Aspas duplas. Utilizadas para imprimir um caractere de aspas duplas.

class prints {

Vamos alterar o codigo anterior para utilizar o printf no local do println conforme abaixo:

public static void main (String args[]){

System.out.print("Eu sou um print e \nquebrei a linha com \\n. \n");

System.out.println("Eu sou um println \t estou tabulado com \\t.");

System.out.println("Eu vou ser substituido \rEu vou substiuir o texto anterior com \\r.");

System.out.printf("Eu sou um %s \\ eu sou %s com aspas \" exibidas.", "printf", "formatado");

}

No prompt de comando compile e execute o arquivo o resultado será:

Os caracteres de escape podem ser utilizados com qualquer um dos métodos prints e podem ser misturados, fique a vontade para se divertir com eles.

Até o próximo post.

Modificadores de Acesso a Classes Java na Pratica

2012-10-27T17:50:00.000-02:00

Antes de começarmos a colocar a mão na massa é importante que você já tenha um conhecimento teórico sobre os modificadores de acesso a classes.

Criando Estrutura

No local onde você costuma desenvolver seu código crie as seguintes estruturas de diretório:

· ...\Modificadores\src\br\com\diego\pacote1

· ...\Modificadores\src\br\com\diego\pacote2

Está estrutura é conhecida como package(pacote) utilizado para organizar melhor o seu código JAVA e será utilizada para exemplificar todos os exemplos.

Default

Abaixo segue um exemplo de classe default que só pode ser acessada de dentro do mesmo pacote.

Dentro da pasta pacote1 criada acima crie o arquivo Banco.java.
Dentro da pasta pacote2 criada acima crie o arquivo Cliente.java.

Abra o arquivo Banco.java em uma IDE de sua preferencia coloque o código abaixo:

package br.com.diego.pacote1; // declaração da package(diretório a partir do diretório do projeto(Modificadores neste caso)).

class Banco {

}

Vamos acessar a classe Banco a partir de uma classe em outro pacote:

package br.com.diego.pacote2;

public class Cliente {

public static void main(String[] args) {

Banco banco = new Banco(); //Criando uma instancia do objeto Banco

}

Este código não compila e exibe a seguinte mensagem:

Exception in thread "main" java.lang.Error: Unresolved compilation problems:

Banco cannot be resolved to a type

at br.com.diego.pacote2.Cliente.main(Cliente.java:7)

Para conseguirmos compilar este código devemos copiar o arquivo Banco.java para o mesmo diretório do arquivo Cliente.java e alterarmos a primeira linha para package br.com.diego.pacote2; o código ficará conforme descrito abaixo:

package br.com.diego.pacote2; // declaração da package(diretório a partir do diretório do projeto(Modificadores neste caso)).

class Banco {

}

Para o modificador default só é permitido acesso entre classes no mesmo pacote.

Public (Publico)

Abaixo segue um exemplo de classe pública que pode ser acessado por qualquer outra classe independente do pacote.

Dentro da pasta pacote1 criada acima crie o arquivo Banco.java.
Dentro da pasta pacote2 criada acima crie o arquivo Cliente.java.

Abra o arquivo Banco.java em uma IDE de sua preferencia coloque o código abaixo:

package br.com.diego.pacote1; // declaração da package(diretório a partir do diretório do projeto(Modificadores neste caso)).

public class Banco {

}

Vamos acessar a classe Banco de uma classe em outro pacote.

Abra o arquivo Cliente.java e digite o código abaixo:

package br.com.diego.pacote2;

public class Cliente {

public static void main(String[] args) {

Banco banco = new Banco(); //Criando uma instancia do objeto Banco

}

Este código não compila e exibe a seguinte mensagem:

Exception in thread "main" java.lang.Error: Unresolved compilation problems:

Banco cannot be resolved to a type

at br.com.diego.pacote2.Cliente.main(Cliente.java:7)

Apesar do objeto Banco ser public ao tentar criar uma instancia a partir de uma classe que esta em outro pacote acontece erro de compilação, para solucionar este erro existem duas maneiras de resolver este problema.

A primeira maneira é fazer a mesma solução da classe default descrito acima e copiar a classe Banco para o mesmo diretório da classe Cliente.
Importar a classe Banco é a solução mais utilizada, para isso adicione o código import br.com.diego.pacote1.Banco; abaixo da declaração do pacote o código ficará como descrito abaixo:

package br.com.diego.pacote2;

import br.com.diego.pacote1.Banco;

public class Cliente {

public static void main(String[] args) {

Banco banco = new Banco(); //Criando uma instancia do objeto Banco

}

Final

Uma classe final não pode ser estendida ou seja a única maneira de acessar a classe Banco é instanciar está classe é usando o new.

Dentro da pasta pacote1 criada acima crie o arquivo Banco.java.
Dentro da pasta pacote2 criada acima crie o arquivo Cliente.java.

Abra o arquivo Banco.java em uma IDE de sua preferencia coloque o código abaixo:

package br.com.diego.pacote1; // declaração da package(diretório a partir do diretório do projeto(Modificadores neste caso)).

public final class Banco {

}

Vamos estender a classe Banco em Cliente.

Abra o arquivo Cliente.java e digite o código abaixo:

package br.com.diego.pacote2;

import br.com.diego.pacote1.Banco;

public class Cliente extends Banco {

public static void main(String[] args) {

}

Este código não compila e apresenta a seguinte mensagem de erro:

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

at br.com.diego.pacote2.Cliente.main(Cliente.java:7)

Uma classe final nunca pode ser estendida por isso o único meio de acessar é instanciado Banco(new) conforme descrito abaixo:

package br.com.diego.pacote2;

import br.com.diego.pacote1.Banco;

public class Cliente {

public static void main(String[] args) {

Banco banco = new Banco();

}

Abstract

Uma classe abstract só pode ser estendida ou seja nunca pode ser instanciada.

Dentro da pasta pacote1 criada acima crie o arquivo Banco.java.
Dentro da pasta pacote2 criada acima crie o arquivo Cliente.java.

Abra o arquivo Banco.java em uma IDE de sua preferencia coloque o código abaixo:

package br.com.diego.pacote1; // declaração da package(diretório a partir do diretório do projeto(Modificadores neste caso)).

public abstract class Banco {

}

Vamos instanciar a classe Banco em Cliente.

Abra o arquivo Cliente.java e digite o código abaixo:

package br.com.diego.pacote2;

import br.com.diego.pacote1.Banco;

public class Cliente {

public static void main(String[] args) {

Banco banco = new Banco();

}

Este código não compila e apresenta a seguinte mensagem de erro:

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

Cannot instantiate the type Banco

at br.com.diego.pacote2.Cliente.main(Cliente.java:9)

Uma classe abstrata nunca pode ser instanciada por isso o único meio de acessar a classe Banco é estendendo conforme descrito abaixo:

package br.com.diego.pacote2;

import br.com.diego.pacote1.Banco;

public class Cliente extends Banco {

public static void main(String[] args) {

}

Com este exemplo pratico finalizo a demostração dos modificadores de acesso a classes.

Qualquer problema, duvida, comentário ou caso tenham algo a acrescentar fiquem a vontade.

Grato pela atenção,

Att,

Diego

Modificadores de Acesso a Métodos e Variáveis Java

2012-10-24T21:33:00.002-02:00

Agora que você já conhece os modificadores de classe, veremos aqui como modificar uma declaração de método ou variável.

Os métodos e variáveis de instancias (não locais) são conhecidos coletivamente como membros.

Modificadores de Acesso

Os métodos e variáveis normalmente recebem o controle de acesso exatamente da mesma forma.

Enquanto uma classe só pode usar dois dos quatro níveis de controle de acesso (default ou public), os membros podem usar todos existentes listados abaixo:

public
protected
default
private

Membros Public (Público)

Quando um método ou variável é declarado public, isso significa que todas as outras classes, independente do pacote ao qual pertencem podem acessar o método ou variável em questão (assumindo-se que a classe esteja visível).

Membros Private (Privado)

Quando um método ou variável é declarado como private, isso significa que o método ou variável em questão não podem ser acessados por nenhuma outra classe que não seja a que esta variável ou método está declarado.

Membros Protected e Default

Os níveis de controle de acesso protected e default são quase idênticos, mas com uma diferença fundamental. Um membro default só pode ser acessado se a classe que o estiver acessando pertencer ao mesmo pacote, enquanto que um membro protected pode ser acessado através de herança por uma subclasse mesmo se a subclasse estiver em um pacote diferente.

Qualquer problema, duvida, comentário ou caso tenham algo a acrescentar fiquem a vontade.

Grato pela atenção,

Att,

Diego

Criando, compilando e executando (Olá mundo) Java

2012-10-17T22:12:00.001-03:00

Antes de começarmos a colocar a mão na massa é importante que você já tenha um ambiente Java configurado.

Criando

A primeira coisa a fazer é criar uma pasta onde seu programa será criado, no meu caso criei em “C:\Blog”, após a criação do diretório crie o arquivo OlaMundo.java na pasta, conforme a imagem abaixo:

Após a criação do arquivo abra o arquivo com o bloco de notas.

Digite o seguinte código:

public class OlaMundo {

public static void main(String[] args) {

System.out.println("Olá Mundo");

}

Abaixo segue explicação do código:

public class OlaMundo {

public

É um modificador de acesso java.

class

define que esta sendo criada uma classe.

OlaMundo é o nome da classe deve conter o mesmo nome do arquivo.java e seguir o padrão de Identificadores e JavaBeans.

public static void main(String[] args) {

Esta linha informa o ponto de partida do aplicativo Java, a JVM ao ser executada procura por está linha para iniciar a aplicação.

System.out.println("Olá Mundo");

Instrui o computador a imprimir a mensagem "Olá Mundo" na tela.

Compilando e executando

Abra uma janela de comando(cmd) e vá até o diretório onde o seu programa foi criado e execute os seguinte comandos:

cd "c:\blog"
javac OlaMundo.java

Neste momento se você voltar abrir a pasta “c:\blog”, irá notar um novo arquivo criado com nome OlaMundo.class que contem os bytecodes Java que representam nosso aplicativo.

java OlaMundo

Os bytecodes serão executados pela JVM.

A mensagem “Olá Mundo” será exibida.

Qualquer problema, duvida, comentário ou caso tenham algo a acrescentar fiquem a vontade.

Grato pela atenção,

Att,

Diego

Modificadores de Acesso a Classes Java

2012-10-17T20:15:00.002-03:00

O controle de acesso em Java é divido em quatro controles de acesso (níveis de acesso), mas apenas três modificadores de acesso (public, protect, private). O quarto nível de controle de acesso é o que você obtém quando não usa nenhum dos três modificadores de acesso (default). Toda classe, método e variável de instancia que você declarar tem um controle de acesso, porem no caso de classes utilizamos apenas os tipos default e public.

Acesso a classes

Quando dizemos que uma determinada classe A tem acesso a outra classe B isso que dizer que a classe A pode:

Criar uma instancia da classe B.
Estender a classe B.
Acessar métodos e variáveis da classe B dependendo do controle de acesso desses métodos e variáveis.

As classes só podem possuir ou acesso default ou publico:

Para declarar uma classe como default basta não especificar o modificador, está classe só poderá ser acessada por classes no mesmo pacote.

class Cachorro{...}

Para declarar uma classe como publica digite a palavra chave public antes do nome da classe, com isso todas as classe conseguem acessar está classe. Se a classe publica estiver em um pacote diferente da classe que tenta acessa-la não será necessário import da classe antes de acessa-la.

public class Cachorro{...}

Existem outros modificadores de classes que não são referentes a acesso esses modificadores de acesso existem e adição aos controladores de acesso.

final a palavra-chave final significa que a classe em questão não pode ser sub-classificada ou seja nenhuma outra classe pode estender(herdar) uma classe final. Você só deve marcar uma classe como final se tiver certeza que nunca os métodos dessa classe deverão ser substituído(Eu nunca criei uma classe como final).
abstract a palavra-chave abstract significa que a classe não pode ser instanciada(new) nunca o único propósito de uma classe abstrata é ser estendida. As classes abstratas são muito utilizadas para o polimorfismo e dão um maior grau de flexibilidade e extensibilidade.

Não é possível é possível marcar uma classe como abstract e final ao mesmo tempo, pois enquanto a classe final não pode ser sub-classificada, a classe abstract deve ser classificada.

Para concluir criei um post Modificadores de Acesso na pratica, que mostra como estes conceitos funcionam na pratica.

Para a declaração de modificadores de acesso de métodos e variáveis veja o post Modificadores de Acesso á Métodos e Variáveis

Qualquer problema, duvida, comentário ou caso tenham algo a acrescentar fiquem a vontade.

Grato pela atenção,

Att,

Diego

Identificadores e JavaBeans

2012-10-13T16:49:00.001-03:00

Este post irei explicar alguns conceitos referente às declarações, identificadores e nomeação JavaBeans.

Identificadores Java

Existem três tipos de identificadores Java que são:

Identificadores Legais trata-se das regras que o compilador usa para determinar se um determinado compilador é legal.
Convenções de Código Java da Sun trata-se das recomendações da Sun para nomeação de classes, variáveis e métodos estes identificadores não são obrigatórios e não geram erro de compilação, mas por boa prática e altamente recomendada a utilização.
Padrões de Nomeação JavaBeans trata-se dos requisitos de nomeação do da especificação JavaBeans.

Identificadores Legais

Tecnicamente os identificadores legais devem ser compostos apenas de caracteres Unicode, números, símbolos de moedas e caracteres de conexão (como underscore/underline) e seguir as seguintes regras:

Os identificadores devem começar com uma letra, um cifrão ($) ou um caractere de conexão. Nunca deve-se utilizar um número para começar o identificador.
Os identificadores Java são case-sensitive, ou seja, um identificador nome e um identificador Nome são totalmente diferentes.
Não se pode usar uma palavra chave Java como identificador.

Convenções de Código Java da Sun

A Sun criou um conjunto de padrões de programação para o Java e publicou esses padrões em documento que pode ser encontrado http://java.sun.com. Abaixo segue uma parte deste documento que trata sobre os padrões de nomeação.

Classes e interfaces a primeira letra deve ser maiúsculo e, se várias palavras forem escritas juntas para formar o nome, a primeira letra de cada palavra interna deve ser maiúscula este formato é conhecido como camelCase. Para classes os nomes devem ser normalmente substantivos abaixo seguem alguns exemplos:

Cachorro
Gato
Animal
Conta
Banco

Para interfaces os nomes devem normalmente serem adjetivos:

Executavel
Amavel
Adoravel

Métodos a primeira letra deve ser minúscula, e depois as regras camelCase normais devem ser usadas, além disso os nomes devem ser pares de verbo-substantivo tais como:

obterSaldo
fazerAndar
definirNome

Os nomes dos métodos em muitos códigos serão encontrados com o verbo em inglês, por exemplo os métodos acima poderiam ser encontrados da seguinte maneira:

obterSaldo -> getSaldo
fazerAndar -> doAndar
definirNome – setNome

Variaveis como no métodos, o formato camelCase deve ser usado, começando com uma letra minúscula. A Sun recomenda usar nomes curtos e significativos tais como:

tamanhoDoAnimal
saldoEmConta
nomePessoa

Contantes As constantes Java são criadas marcando-se variáveis como static e final. Elas devem ser nomeadas usando-se letras maiúsculas e com caracteres underscore como separadores tais como:

ALTURA_MINIMA
ALTURA_MAXIMA
SALDO_MINIMO

Padrões de Nomeação JavaBeans

Resumidamente JavaBeans são classes que contem propriedades(variáveis) private, esse tipo de propriedade só pode ser acessada de fora da classe através de métodos públicos. Os métodos responsáveis por modificar esse tipo de propriedade são chamados de setter os métodos reesposáveis por recuperar o valor desse tipo de propriedade são chamados de getter.

A especificação JavaBeans foi criada para ajudar os desenvolvedores a criarem componentes Java que possam ser facilmente usados por outros desenvolvedores em uma ferramenta de Ambiente de Desenvolvimento Integrado (“Integrated Development Environment, ou IDE”) como o Eclipse e o NetBeans.

Abaixo seguem as regras de nomeação do JavaBeans mais utilizadas:

Se a propriedade não for booleana, o prefixo do método getter deve ser get. Não é necessário ter uma propriedade para se ter um método getter(embora alguns IDEs esperam que você a tenha), o que você ira retornar no método getter fica a seu critério respeitando sempre o mesmo tipo do método set caso exista. Esses métodos devem sempre serem marcado como public.

public String getNome();
public int getTamanho();

Se o propriedade for booleana, o prefixo do método getter pode ser get ou is (utilizo este) este tipo de variável deve sempre retornar true ou false.

public boolean getAndando();
public boolean isAndando();

O prefixo de um método setter deve ser set, neste caso o método espera um valor para set adicionado a propriedade estes métodos devem ser marcadas como public com um tipo de retorno de void.

setNome(String nome);
setTamanho(int tamanho);

A primeira letra do nome da propriedade logo após o prefixo deve ser em maiúsculo e o restante deve ser o nome da propriedade completo.

Para uma propriedade “nome” o método get será getNome();
Para uma propriedade “idadeNascimento” o método get será getIdadeNascimento();

A especificação JavaBean tem suporte a evento que permitem aos componentes notificarem um ao outro quando algo acontece. Os objetos que recebem a informação de que ocorreu um dado evento são chamados de listener. Os métodos usados para adicionar ou remover listener de um evento devem seguir os seguintes padrões de nomeação.

Os nomes de métodos listeners usados para “registrar” um listener com uma fonte de eventos devem usar o prefixo add, seguido do tipo do listener.

public void addAcaoListener(AcaoListener l);
public void addMeuListener(MeuListener m);

Os nomes de métodos listener usados para remover um listener devem usar o prefixo remove seguido do tipo do listener.

public void removeAcaoListener(AcaoListener l);
public void removeMeuListener(MeuListener m);

Os nomes do métodos listener devem terminar com Listener;

Qualquer problema ou duvida ou caso tenham algo a acrescentar fiquem a vontade.

Grato pela atenção,

Att,

Diego

Conceitos JAVA

2012-10-12T20:29:00.000-03:00

Antes de começarmos a colocar a mão na massa segue alguns conceitos que serão uteis para iniciarmos a codificação esses conceitos levam em consideração que você já conheça orientação objeto.

Programa Java

Um programa Java é principalmente uma coleção de objetos falando com outros objetos através de métodos. Cada objeto é de um tipo, e esse tipo é definido por uma classe ou interface. A maioria dos programas em Java usa uma coleção de objetos de muitos tipos diferentes.

Classe é um modelo que descreve os tipos de estado e de comportamento que os objetos do seu tipo podem ser.
Objeto no momento da execução, quando a Maquina Virtual Java (Java Virtual Machine ou JVM) encontra a palavra new, ela usa a classe apropriada para criar o objeto que será uma instancia dessa classe. Esse objeto terá o seu próprio estado e terá acesso a todos os comportamentos definidos pela sua classe.
Estado (variáveis de instancias) cada objeto (instancia de uma classe) terá o seu conjunto único de variáveis de instancias conforme definido na classe. Coletivamente, os valores atribuídos as variáveis de instancia de um objeto compõem o estado do objeto.
Comportamento (métodos) quando um programador cria uma classe, ele cria métodos para essa classe. É nos métodos que a lógica da classe é armazenada. Nos métodos, o verdadeiro trabalho é realizado. É neles que os algoritmos são executados e que os dados são manipulados.

Identificadores e Palavras-chave

Todos os componentes Java (classes, variáveis, e métodos) precisam de nomes, esses nomes são conhecidos como identificadores e existem algumas regras para estes identificadores para mais detalhes sobre estas regras veja o post Identificadores e JavaBeans.

Herança

Fundamental para o Java e outras linguagens orientadas a objetos é o conceito de herança, que permite ao código definido em uma classe ser reutilizado em outras classes. Em Java, você pode definir uma superclasse geral (mais abstrata), e depois estendê-la com classes mais especificas. A superclasse não sabe nada sobre as classes que herdam dela, mas todas subclasses que herdam a superclasse devem declarar explicitamente a relação de herança. Uma subclasse que herda de uma superclasse recebe automaticamente as variáveis de instancias acessíveis e os métodos definidos pela superclasse, mas também é livre para substituir os métodos da superclasse podendo definir comportamentos mais específicos.

Interfaces

Um poderoso companheiro da herança é o uso de interfaces. A interface é uma espécie de superclasse 100% abstrata que define os métodos que uma subclasse deve suportar, mas não como esse suporte deve ser implementado. Em outras palavras, uma interface não oferece nenhuma lógica para os métodos, deixando a cargo das classes que implementam a interface a implementação destes métodos.

Qualquer problema ou duvida ou caso tenham algo a acrescentar fiquem a vontade.

Grato pela atenção,

Att,

Diego

Instalação JAVA 7 no Windows 7

2012-10-09T22:59:00.001-03:00

Neste post irei demostrar como instalar e configurar o Java 7 no Windows 7 para desenvolvimento de aplicações.

Pré Requisitos:

Verifique se o sistema atende aos requisitos mínimos de hardware ou se os excede:

Intel Pentium III de 800 MHz ou equivalente
512 MB de RAM.
750 MB de espaço disponível.
Privilégios de administrador no sistema.

Arquivos necessários para instalação:

JRE - Java Runtime Environment (http://www.java.com/inc/BrowserRedirect1.jsp?locale=pt_BR)
JDK 7 - (http://www.oracle.com/technetwork/java/javase/downloads/jdk7u7-downloads-1836413.html)

No sistema operacional Windows de 32 bits, o nome do arquivo do instalador é jdk-7u7-nb-7_2-windows-i586-ml.exe.
No sistema operacional Windows de 64 bits, o nome do arquivo do instalador é jdk-7u7-nb-7_2-windows-x64-ml.exe

Observação: O instalador utiliza o diretório %USERPROFILE%\Local Settings\Temp para armazenar os arquivos temporários.

Instalação JRE

Execute o arquivo .exe referente ao jre baixado.
A tela abaixo será exibida clique em Instalar >, aguarde a finalização e clique em Fechar.

Instalação JDK

Execute o arquivo .exe referente ao jdk baixado.
Clique em next, nas proximas telas até a finalização da instalação.
Após a instalação para efetuar o teste abra o prompt do DOS e digite java -version algo como a imagem abaixo deverá ser exibida confirmando o sucesso da instalação.

Configuração de Variáveis de Ambiente

Após a instalação do java para podermos executar aplicações em java é necessária a configuração do compilador o javac.

Clique com o botão direito em Meu Computador > Propriedades > Configurações Avançadas do Sistema.
Na aba Avançado clique em Variáveis de Ambiente...
Clique em Novo.
No campo Nome da variável digite JAVA_HOME.
No campo Valor da variável digite C:\Program Files\Java\jdk1.7.0_05 (ou caminho da instalação jdk).
Clique em OK.
Selecione a variável Path e clique em Editar, no valor da variável adicione ;C:\Program Files\Java\jdk1.7.0_05\bin.
Após a configuração para efetuar o teste abra o prompt do DOS e digite javac algo como a imagem abaixo deverá ser exibida confirmando o sucesso da configuração.

Pronto seu computador está configurado para execução de seus códigos java!

Caso queira criar sua primeira aplicação utilize o post Criando, compilando e executando (Olá mundo) Java

Qualquer problema ou duvida ou caso tenham algo a acrescentar fiquem a vontade.

Grato pela atenção,

Att,

Diego