sexta-feira, 26 de fevereiro de 2010

[Java] Expressões e controle de fluxo


Expressões são combinações de valores, operadores, parênteses e chamadas de métodos. Permitem realizar cálculos aritméticos, concatenar strings, comparar valores, realizar operações lógicas, manipular objetos entre outros. Sem as expressões uma linguagem de programação seria bastante pobre. Para a avaliação de uma expressão é observada a precedência dos operadores. Em Java a precedência de vários operadores idênticos se dá da mesma forma que na matemática. da esquerda para a direita. Assim x+y+z seria o mesmo que ((x+y)+z).

Além das expressões, Java possui a habilidade de controle de fluxo. Com controle de fluxo é possível ajustar a maneira como um programa realiza suas tarefas. Com a utilização de comandos as tarefas de um programa podem ser executadas seletivamente, repetidamente ou excepcionalmente. Graças ao controle de fluxo, programas Java podem executar mais do que uma sequência de tarefas e são portanto dinâmicos.

[Java] Modificar os valores de variáveis com os operadores (parte 4/4)



Depois de tanto ler sobre os operadores, nada melhor que uma pequena revisão. Os operadores são utilizados para modificar as variáveis e possuem uma ordem de precedência. A tabela abaixo mostra a ordem de precedência entre os operadores:

Operadores

Descrição

<variável>++

Pós-incremento unário

<variável>--

Pós-decremento unário

++<variável>

Pré-incremento unário

--<variável>

Pré-decremento unário

+

Positivo

-

Negativo

!

Negação lógica

~

Complemento sobre bits

*

Multiplicação

/

Divisão

%

Resto

+

Adição ou concatenação de Strings

-

Subtração

<<

Deslocamento de bits para a esquerda

>>

Deslocamento de bits para a direita com sinal

>>>

Deslocamento de bits para a direita sem sinal

<

Menor que

>

Maior que

<=

Menor ou igual que

>=

Maior ou igual que

Instanceof

Comparação de tipo

==

Igual a

!=

Diferente de

&

E sobre bits

^

OU EXCLUSIVO sobre bits

|

OU sobre bits

&&

E condicional

||

OU condicional

?:

Operador ternário condicional

=

Atribuição

+=

Atribuição de adição

-=

Atribuição de subtração

*=

Atribuição de multiplicação

/=

Atribuição de divisão

%=

Atribuição de resto

&=

Atribuição E sobre bits

^=

Atribuição OU exclusivo sobre bits

|=

Atribuição OU sobre bits

<<=

Atribuição de deslocamento para a esquerda de bits

>>=

Atribuição de bits com deslocamento para a direita com sinal

>>>=

Atribuição de bits com deslocamento para a direita sem sinal



quinta-feira, 25 de fevereiro de 2010

[Java] Modificar os valores de variáveis com os operadores (parte 3/4)


Operadores lógicos AND (&&) e OR (||)

Os operadores lógicos AND (&&) e OR (||) são utilizados apenas em variáveis boolean. O operador lógico AND funciona da mesma maneira que o operador "e" da lógica matemática e o operador OR da mesma forma que o operador "ou" da lógica matemática. Exemplo do uso dos operadores lógicos and e or:

boolean verd = true;
boolean fals = false;
boolean resul;
resul = verd && fals; //resul é false
resul = verd && 1==1; //resul é true
resul = fals || verd; //resul é true
resul = fals || 1!=1; //resul é false

Operador ternário

O operador ternário ? : recebe três operandos e por isso é chamado de ternário. O operador ternário ? : possui a seguinte extrutura: ?:, se o valor da condicional for verdadeiro, o primeiro valor será escolhido, senão o seguindo valor será escolhido. O exemplo abaixo ajuda a entender o uso do operador:

int valor1 = 1;
int valor2 = 2;
int resultado;
boolean condicao = true;
resultado = condicao ? valor1 : valor2; //resultado receberá o valor1 (1).

Operadores de atribuição

Os operadores de atribuição dentre todos os tipos são os que possuiem a menor precedência e serão sempre interpretados por último. Abaixo seguem exemplos do uso de cada um deles:
  • Atribuição: int i = 1; // i recebe 1
  • Atribuição de adição: i+=5; //i recebe i+5
  • Atribuição de subtração: i-=5; //i recebe i-5
  • Atribuição de multiplicação: i*=5; //i recebe i*5
  • Atribuição de divisão: i/=5; // i recebe i/5;
  • Atribuição de resto: i%=2; //i recebe i%2
  • Atribuição E sobre bits: i&=1; //i recebe i&1
  • Atribuição OU exclusivo sobre bits: i^=1; //i recebe i^1
  • Atribuição OU sobre bits: i|=1 //i recebe i|1
  • Atribuição de deslocamento para a esquerda de bits: i<<=1; //i rebece i<<1
  • Atribuição de bits com deslocamento para a direita com sinal: i>>=1; //i recebe i>>1
  • Atribuição de bits com deslocamento para a direita sem sinal: i>>>=1; //i recebe i>>>1

[Java] Modificar os valores de variáveis com os operadores (parte 2/4)


Operadores aditivos

Os operadores aditivos realizam operação de adição, assim como os operadores multiplicativos, esses podem ser utilizados em variáveis contanto que não sejam boolean e char. São considerados operadores aditivos a soma (+) e a subtração (-). Operadores aditivos também se encontram presentes em concatenação de Strings. Exemplo do uso de operadores aditivos:

int numero = 0; //variável numero é igual a 0
numero = 1 + 1; //numero vale 2
numero = 5 - 1; //numero vale 4
numero = numero + 4; //numero vale 8
numero = numero - 4; //numero vale 4
String nome = "Carina";
String sobrenome = "Calixto"
String espaco = " ";
String concatenado;
concatenado = nome + espaco + sobrenome; //concatenado será "Carina Calixto"

Vale lembrar que diferentemente dos operadores de incremento e decremento (tanto os prefixais quanto os sufixais), os operadores aditivos sozinhos não modificam o valor de uma variável, para que isso seja possível é necessário atribuir o valor do resultado na mesma variável. Veja abaixo a diferença:

int numero = 0;
++numero; //Adicionou em 1 a variável número
numero = numero + 1; //Adicionou em 1 a variável número.

Operadores de deslocamento de bits

Os operadores de deslocamento de bits são utilizados, como o próprio nome diz para deslocar bits de um número e assim modificar o seu valor. Os operadores de deslocamento de bits são: Shift para a direita (>>), o shift para a direita sem sinal(>>>) e o shift para a esquerda (<<). Shift para direita funciona. O shift para a direita desloca o padrão de bits do número disposta antes do operador no número de posições indicadas após o operador. O shift para a direita sem sinal tem a mesma função do shift para a direito com a exceção que remove a sinalização (se era um número negativo, após o shift sem sinal ficará positivo) do número. O shift para a esquerda da mesma forma que o shift para a direita, desloca um padrão de bits, porém para a esquerda. O shift para a direita funciona como uma divisão por 2n enquanto o shift para a esquerda funciona, para números pequenos, como uma multiplicação por 2n (onde n é o valor colocado após o operador), já o shift para a direita sem sinal quando o valor antes do operador for positivo, funcionará da mesma forma que o shift para a direita, porém quando for negativo irá ignorar o bit de sinalização (como uma sinalização) e retornará o número. Exemplo do uso dos operadores de deslocamento de bits:

int numero = -2;
//numero vale -2 : 11111111 11111111 11111111 11111110
numero = numero >> 1;
//numero vale -1 : 11111111 11111111 11111111 11111111
numero = numero << 1;
//numero vale -2 : 11111111 11111111 11111111 11111110
numero = numero >>> 1;
//numero vale 2147483647 : 11111111 11111111 11111111 1111111
numero = numero << 1;
//numero vale -2 : 11111111 11111111 11111111 11111110


Operadores comparativos

Os operadores comparativos são utilizados para comparar dois valores e retornar um valor boolean "true" ou "false". São muito usados na programação. São operadores comparativos os operadores maior que (>), menor que (<), maior ou igual que (>=) menor ou igual que (<=) e o comparativo de tipo instanceof. Os operadores maior que, menor que, maior ou igual que e menor ou igual que funcionam da mesma forma que os operadores comparativos da matemática, o único operador comparativo diferente é o instanceof. O operador instanceof compara um objeto para um tipo especificado. Você pode usá-lo para testar se um objeto é uma instância de uma classe, uma instância de uma subclasse, ou uma instância de uma classe que implementa uma interface em particular. Abaixo seguem exemplos do uso dos operadores comparativos.

boolean teste = true; //teste é verdadeiro
teste = 4>4;
//teste é falso
teste = 4<3; //teste é falso
teste = 4<=4; //teste é verdadeiro
teste = 4>=4; //teste é verdadeiro

veja o exemplo aqui para entender melhor como é utilizado o operador instanceof.

Operadores de igualdade

Os operadores de igualdade, de forma semelhante aos operadores comparativos, são utilizados para verificar se um valor é igual a outro. Retornam valores boolean "true" ou "false" dependendo se o valor for ou não igual a outro. Como operadores de igualdade tem-se igual a (==) e diferente de (!=), podem ser utilizados a qualquer tipo de variável com tanto que os tipos sejam iguais. Exemplo do uso dos operadores de igualdade:

boolean teste;
char c1 = 'a';
char c2 = 'a';
teste = (c1==c2); //teste = true
teste = (c1!=c2); //teste = false
int i1 = 23;
int i2 = 0;
teste = (i1==i2); //teste = false
teste = (i1!=i2); //teste = true
boolean b1 = true;
boolean b2 = true;
teste = (b1==b2); //teste = true
teste = (b1!=b2); //teste = false

Operadores lógicos bit a bit

Os operadores bit a bit realizam suas operações sobre cada bit do valor apresentado antes e após do operador. Existem 3 operadores lógicos bit a bit e a ordem de precedência entre eles é variada.

  • Operador and bit a bit (&): Este operador, entre os operadores bit a bit é o que possue a maior precedência. Ele funciona como o operador "e" da lógica matemática e atua bit a bit entre dois valores.
  • Operador ou exclusivo bit a bit (^): É o de segunda ordem de precedência entre os operadores lógicos bit a bit. Funciona da mesma forma que o operador "ou exclusivo" da lógica matemática.
  • Operador ou bit a bit (|): É o de menor ordem de precedência entre os operadores lógicos bit a bit. Funciona da mesma forma que o operador "ou" da lógica matemática.
Exemplo de uso dos operadores bit a bit:

int numero;
numero = 34&435; //34:000100010 AND 435:110110011 = 000100010
numero = 34^46; //34:000100010 XOR 46:100010 = 001100
numero = 436|547; //436:0110110100 OR 547:1000100011 = 1110110111

sexta-feira, 19 de fevereiro de 2010

[Java] Modificar os valores de variáveis com os operadores (parte 1/4)


Em programação, variáveis são modificadas e comparadas umas com as outras ou com valores por meio dos operadores. Existem vários tipos de operadores e eles possuem uma precedência, quando em uma mesma linha de instrução, serão executados os operadores respeitando a ordem decrescente de precedência entre eles. Vale lembrar que esta ordem de precedência entre eles pode ser "quebrada" com a utilização de parênteses. Os operadores dentro de parênteses mesmo que com uma precedência baixa será executado primeiramente (obedecendo as mesmas regras de parênteses da matemática).Abaixo serão mostrados os operadores e a ordem de precedência decrescente entre eles.

Operadores sufixais

Operadores sufixais são unários (atuam em apenas uma variável) posicionados na parte sufixal da variável. Os operadores sufixais são o incremento (++) e o decremento (--). O operador incremento adiciona +1 a uma variável, enquanto o decremento diminui -1 de uma variável inteira. Não podem ser usados em estruturas do tipo float, double, boolean ou char. Por exemplo:

int numero = 1; // valor da variável numero é 1.
numero++; // valor da variável numero é 2.
numero--; // valor da variável numero é 1.

Vale lembrar que os operadores sufixais apesar de terem a maior precedência, quando utilizados, retornam o valor da variável e posteriormente realizam a operação. O exemplo abaixo ajuda a entender.

int numero = 1; // valor da variável numero é 1.
int teste = 0;
system.out.println(numero++); // valor da variável numero é 2, porém irá imprimir 1.
system.out.println(numero); // valor da variável numero é 2 e será impresso 2.
teste = numero++; // variável teste receberá o valor 2 e numero será igual a 3.

Operadores prefixais

Operadores prefixais assim como os operadores sufixais também são unários, porém são encontrados na porção prefixal de uma variável. Os operadores prefixais são incremento (++), decremento (--), positivo (+), negativo(-), negação lógica (!) e complemento sobre bits (~). Os operadores prefixais de incremento e decremento acrescentam e subtraem, respectivamente, em 1 as variáveis inteiras, os operadores positivo e negativo são usados para modificar o sinal de uma variável. O operador positivo não modifica o valor da variável a seguir, enquanto o operador negativo altera o sinal da variável (os operadores positivo e negativo não podem ser utilizados em variáveis boolean ou char). O operador negação lógica é utilizado para alterar o valor da variável boolean, se um valor de uma variável boolean era antes falso, após o uso do operador negação lógica será verdadeiro e vice versa. O operador complemento sobre bits inverte um padrão de bits. Pode ser aplicado a qualquer dos tipos integrais (vale lembrar que o operador ~ retorna um valor int, assim se for necessário armazenar em uma variável byte será necessário o uso de cast), fazendo cada "0" ser um "1" e cada "1" um "0". Por exemplo, aplicar este operador para um valor cujo padrão de bits é "00000000" iria mudar o seu padrão de "11111111". Para ficar mais simples de entender o resultado, podemos ver o operador complemento sobre bits (~) como um incremento seguido de inversão de sinal. Exemplos do uso dos operadores prefixais:

int numero = 1; //numero vale 1
boolean switch = "false"; //switch é "falso"
++numero; //numero agora vale 2
--numero; //numero vale 1 novamente
numero=+numero; //numero continua valendo 1
numero=-numero; //numero agora vale -1
numero=~numero; //numero passa a valer 0
switch=!switch; //switch é "verdadeiro" agora

Diferentemente dos operadores sufixais, os prefixais primeiramente realizam a operação e posteriormente retornam o resultado.

Operadores multiplicativos

Operadores multiplicativos são aqueles que realizam uma operação multiplicativa. Tem-se como operadores multiplicativos a multiplicação (*), a divisão (/) e o resto (%). A mutiplicação realiza a multiplicação entre dois valores (ou variáveis). A divisão realiza a divisão inteira entre os valores (o primeiro valor dividido pelo segundo valor). O operador de resto retorna o resto da divisão entre o primeiro valor dividido pelo segundo valor. Todos os operadores multiplicativos podem ser realizados sobre valores inteiros, ou seja, não sejam do tipo boolean ou char. Exemplo da utilização dos operadores multiplicativos:

int numero = 5; // A variável numero vale 5
numero = numero/2; //numero vale 2
numero = numero*2; //numero vale 4
numero = numero%2; //numero vale 0

[Java] Declaração, Inicialização e Uso de variáveis


Declaração

Declarar uma variável consiste em definir e informar ao sistema de que se irá usar uma variável com o identificador indicado. O processo de declarar variável faz com que seja separado um espaço de memória (de acordo com o tamanho necessário pelo tipo) para a variável declarada ser utilizada.

Inicialização

Inicializar significa atribuir um valor inicial à variável. Para as variáveis de referência, inicializar significa criar um objeto a aquela referência.

Uso de variáveis


Variáveis podem ser usadas para guardar valores e podem seus valores podem ser modificados com a utilização de operadores (matemáticos, incremento e decremento e lógicos). Este assunto será explicado posteriormente. Variáveis de referência podem ser utilizadas para guardar a referência de um determinado objeto e permitir o acesso de seus métodos. Para acessar os métodos utiliza-se o nome da referência + “.” + método.

[Java] Definição dos termos 'variável primitiva' e 'variável de referência'


Como dito anteriormente, a inicialização de variáveis com tipos primitivos, não é necessária a palavra new. Isto acontece porque tipos primitivos são tipos especiais de dados incorporadas a linguagem, não são objetos criados a partir de uma classe. variáveis primitivas são aquelas que contêm valores do tipo primitivo. As variáveis de referência são aquelas que guardam um endereço de memória (referenciam) para um objeto criado, ou seja, indicam através de um endereço de memória, onde está localizado o objeto.

A declaração de variáveis de referência basicamente é a mesma coisa. Declara-se o tipo do Objeto a referenciar e o nome da variável (não necessariamente precisa criar o objeto no momento da declaração). A diferença é que o tamanho do espaço alocado para uma variável de referência é sempre fixo, porque se trata de um endereço de memória que mostra como chegar ao objeto que se refere.

Exemplo de variável de referência:

Idade minhaIdade = new Idade(22, 7, 1964);

A variável de referência serve para guardar a referência de um determinado objeto e permitir o acesso de seus métodos. Para acessar os métodos utiliza-se o nome da referência + “.” + método. Usando o mesmo exemplo anterior para expressar o acesso de um método.

minhaIdade.calcIdadeEmDias();

[Java] Definir valores literais para tipos numéricos e textuais


Esse tópico já foi abordado aqui. :D

quinta-feira, 18 de fevereiro de 2010

[Java] Diferenciar atribuições legais e ilegais de tipos de primitivas


Você deve ter percebido que na inicialização de variáveis com tipos primitivos, não é necessária a palavra new. Isto acontece porque tipos primitivos são tipos especiais de dados incorporadas a linguagem, não são objetos criados a partir de uma classe. Abaixo segue as atribuições legais para os tipos primitivos.

boolean result = true;
char capitalC = 'C';
byte b = 100;
short s = 10000;
int i = 100000;

Os tipos integrais (byte, short, int e long) podem ser expressos utilizando números decimais, octais e hexadecimais como mostrado abaixo.

int decVal = 26; // O número 26 em decimal (apenas escrever o número em decimal)
int octVal = 032; // O número 26, em octal (adicionar 0 antes do número em octal)
int hexVal = 0x1a;// O número 26, em hexadecimal (adicionar 0x antes do número em hexa)

Os tipos flutuantes (float e double) podem ser representados na forma científica utilizando E ou e, na forma float literal usando F ou f ou na forma literal double usando D ou d (esta é a padrão e omitida por convenção).

double d1 = 123.4;
double d2 = 1.234e2; // mesmo valor que d1, porém em notação científica
float f1 = 123.4f;

O tipo char pode conter qualquer caractere Unicode. Sempre use aspas simples ' ' para atribuir valores as variáveis do tipo primitivo char. A linguagem Java também permite algumas sequências especiais para o tipo char como: \b (backspace), \t (tab), \n (nova linha), \f (quebra de página), \r (retorno de carro), \" (aspas duplas), \' (aspas simples), e \\ (barra invertida).

Além de atribuir valores literais para as variáveis pode-se atribuir também valores contidos em outras variáveis.

double d1 = 123.4;
double d2 = d1; // d2 recebe o mesmo valor de d1.

Ou resultados de expressões.

float numberOrdered = 908.5F;
float casePrice = 19.99F;
float price = (casePrice * numberOrdered);

int hour = 12;
boolean isOpen = (hour > 8);

E atribuir valores de retorno de um método ou função.

int idade = i.CalculaIdade(7,4,1986);

[Java] Tipos de primitivas


A linguagem de programação Java possui, como já falado anteriormente, oito tipos primitivos de dados.

• Lógico – boolean
• Textual – char
• Integral – byte, short, int, e long
• Flutuante – double e float

Boolean

O tipo primitivo boolean tem as seguintes características: Pode possuir apenas dois valores, true e false. O uso deste tipo de dado é dado quando há a necessidades verificar a condição true/false de alguma flag. Representa um bit de informação, porém o tamanho pode variar com a JVM da plataforma. Tem como valor default false.

Char

O tipo primitivo char representa um caractere unicode de 16 bits. Possui um valor mínimo de '\u0000' (ou 0) e um máximo valor de '\uffff' (ou 65,535 inclusive). Deve estar entre aspas simples ( ' ' ). Utiliza as seguintes notações:
  • 'a' a letra a
  • '\t' o caractere tab (e outros como \b, \n...)
  • '\u????' Um caractere expecífico Unicode, "????" é substituído com os quatro dígitos hexaecimal do caractere Unicode. Por exemplo, '\u03A6' é a letra grega phi (φ).
  • Tem como valor default '\u0000'
Byte

O tipo primitivo byte, além do que já foi dito no post passado, pode ser utilizado para minimizar o uso de memória em arrays grandes, por exemplo, onde minimizar a utilização de memória realmente é importante. Tem como valor default 0.

Short

O tipo primitivo short pode ser utilizado da mesma forma que o tipo byte para minimizar a utilização de memória. Representa números variando de -32768 a +32767 (inclusive). Tem como valor default 0.

Int

O tipo primitivo int é o mais usado na programação. Este tipo de dado irá conter quantidade suficiente de números para a maioria dos programas. Porém se não for suficiente, utilize long. Tem como valor default 0.

Long

O tipo primitivo long é útil para representar números maiores que int. Tem como valor default 0L.

Float

O tipo primitivo float representa números com ponto flutuante, é o mais usado quando há a necessidade de utilizar pouca memória e números com pontos flutuantes. Não deve ser utilizado para valores de precisão. Tem como valor default 0.0f.

Double

Assim como int, double é a opção mais escolhida quando é necessário a utilização de números com pontos flutuantes. Não deve ser utilizado para valores de precisão. Tem como valor default 0.0d.

[Java] Diferenciar identificadores válidos e inválidos

Depois de explicado sobre identificadores neste post. Faremos agora uma revisão sobre identificadores com exemplos de identificadores válidos e inválidos.

Identificadores devem seguir as seguintes características:
  • Identificadores são nomes dados para as variáveis, classes ou métodos.
  • Podem começar com letras, sublinhado ( _ ) ou cifrão ( $ ).
  • Podem conter letras, sublinhado ( _ ), cifrão ( $ ) ou números.
  • Não possui tamanho máximo de caracteres.
  • São case-sensitive.
  • Não possuir espaços em branco.
Exemplos de identificadores válidos:
  • preco_total
  • flor
  • calculaJuros
  • dataNascimento
  • identifier
  • userName
  • user_name
  • _sys_var1
  • $change
Exemplos de identificadores inválidos:
  • +Fruta (Possui caractere inválido "+", não começa com caractere válido)
  • "preco total" (Possui caractere inválido " " ", não começa com caractere válido)
  • comprimento x largura (Possui espaço em branco)
  • 1lugar (Não começa com caractere válido)
  • public (Palavra reservada)
  • base*altura (Possui caractere inválido "*")

[Java] Usar comentários em um programa de origem


Comentários servem para organizar, documentar os programas e facilitar a leitura posterior. Como explicado anteriormente, existem três tipos de comentários que podem ser usados em um programa Java. Adicionalmente ao que já foi explicado, vale salientar que o comentário do tipo documentação é também chamado de Javadoc e após compilado produz um arquivo Html contendo a documentação escrita no comentário. Para que seja feito o javadoc, é necessário seguir as marcações pre-definidas que são:

Tag Descrição
@author Nome do desenvolvedor
@deprecated Marca o método como deprecated. Algumas IDEs exibirão um alerta de compilação se o método for chamado.
@exception Documenta uma exceção lançada por um método — veja também @throws.
@param Define um parâmetro do método. Requerido para cada parâmetro.
@return Documenta o valor de retorno. Essa tag não deve ser usada para construtores ou métodos definidos com o tipo de retorno void.
@see Documenta uma associação a outro método ou classe.
@since Documenta quando o método foi adicionado a a classe.
@throws Documenta uma exceção lançada por um método. É um sinônimo para a @exception introduzida no Javadoc 1.2.
@version Exibe o número da versão de uma classe ou um método.

[Java] Identificadores, Palavras-chave e Tipos


Identificadores

Identificadores são tokens de texto utilizados para nomear uma entidade. Em java, usa-se identificadores para nomear classes, objetos, métodos e variáveis. Há algumas restrições na criação de identificadores Java. elas são:
  • Identificadores Java devem iniciar com uma letra, _ ou $.
  • Não possui limite de tamanho máximo.
  • Para os caracteres seguintes use letra, _ , $ ou números.
  • Um identificador não pode ser nomeado como uma palavra-chave do Java.
E possui algumas recomendações:
  • Utilize palavras significativas.
  • Evite abreviações.
  • Por convenção, identificadores de nomes de variáveis iniciam com uma letra minúscula, enquanto de classes com letra maiúscula.
E lembre-se sempre que: Java é uma linguagem case-sensitive e portanto diferencia palavras escritas com letra maiúscula e minúscula, por exemplo, o identificador cachorro é diferente do identificador Cachorro.

Palavras-chave

A linguagem de programação Java possui algumas palavras que são reservadas e não podem ser utilizadas como indentificadores, são elas:

abstract continue for new switch
assert*** default goto* package synchronized
boolean do if private this
break double implements protected throw
byte else import public throws
case enum**** instanceof return transient
catch extends int short try
char final interface static void
class finally long strictfp** volatile
const* float native super while

*Não usado em java
** Adicionado 1.2
***Adicionado 1.4
**** Adicionado 5.0

Java também contem as palavras reservadas true e false, que são literais boolean e null, ou seja, o literal que representa uma referência a nada. Como palavras-chave, essas palavras reservadas não podem ser usadas como identificadores.

Tipos

Java possui 8 tipos primitivos são eles: boolean, char, byte, short, int, long, float e double. A tabela a seguir descreve as características de cada um dos tipos primitivos.


TipoTamanho em bitsValoresPadão
boolean
true ou false
char16'\u0000' a '\uFFFF' (0 a 65535)Conjunto de caracteres Unicode ISO
byte8-128 a +127
short16-32.768 a +32.767
int32-2.147.483.648 a +2.147.483.647
long64-9.223.372.036.854.775.808 a +9.223.372.036.854.775.807
float32

-1.40239846e-46 a +3.40282347e+38

(ponto flutuante IEEE 754)
double64-4.94065645841246544E-324 a +1.79769313486231570E+308 (ponto flutuante IEEE 754)

quarta-feira, 17 de fevereiro de 2010

[Java] Componentes de uma classe na linguagem de programação Java

Os componentes de uma classe na linguagem de programação Java são:
  • Declaração da classe.
  • Declaração e inicialização de atributos (opcional).
  • Métodos e construtores (opcional).
  • Comentários (opcional)
Como já foi mensionado anteriormente sobre a sintaxe e exemplo da declaração de classe, atributos, métodoos e métodos construtores, neste post irei apenas falar sobre os comentários.

Comentários

Comentários são linhas escritas num código fonte que não serão compiladas/interpretadas e servem apenas para orientação, organização e explicações sobre o código de um programa. Em Java, comentários podem ser escritos de três formas diferentes: comentários de uma linha, múltiplas linhas e de documentação.

Exemplo de comentário de uma linha:
public int saldo = 0; // Saldo Inicial
Exemplo de comentário de múltiplas linhas:
/* CarregamentoERoteamento (int regiao)
*
* Método da heurística para busca de uma solução factível
* para o problema de roteamento e carregamento dos
* caminhões cegonha para uma região.
*/
Exemplo de comentário de documentação:

/**
* Valida um movimento de xadrez.
*
* @param colunaDe Coluna atual da peça a ser movida.
* @param linhaDe Linha atual da peça a ser movida.
* @param colunaPara Coluna destino da peça a ser movida.
* @param linhaPara Linha destino da peça a ser movida.
* @return Verdadeiro se o movimento é válido ou falso se inválido.
* @author João
* @author Maria
*/

[Java] Definição de classe, membro, atributo, método, construtor, pacote.


Classe

Para facilitar a entendimento do conceito de classe, iremos utilizar uma analogia com a engenharia. Na engenharia, para construir qualquer coisa são utilizados os desenhos técnicos e apartir deles são construídos motores, prédios, casas entre outros. Desta mesma forma, para a computação, as classes são a descrição de um objeto. Uma classe descreve os dados que os objetos incluem e descreve os comportamentos dos objetos.

Em java, as classes suportam três características fundamentais da orientação a objetos:
  • Encapsulamento
  • Herança
  • Polimorfismo
Declarando uma classe em Java

Sintaxe básica para declaração de uma classe em Java:
<modificador>* class <nomedaclasse> {
<declaraçãoDeAtributo>*
<declaraçãoDeConstrutor>*
<declaraçãoDeMétodo>*
}
Exemplo:
public class Carro {
private double passageiros;
public void setaPassageiros(double p) {
passageiros = p;
}
}
EDITADO: Definição de Membro. Contribuição de Mário Leal. Retirado de "A linguagem de Programação Java (Sun)" Bookman - Quarta Edição Cápitulo 2 página 63.

Membro

Uma classe pode ter três espécies de membros:
  • Campos são variáveis de dados associados com uma classe e seus objetos e armazenam o estado de uma classe ou objeto.
  • Métodos contêm o código executavel de uma classe e definem o comportamento de objetos.
  • Classes aninhadas e interfaces aninhadas são declarações de classes ou interfaces que ocorrem aninhadas dentro da declaração de outra classe ou interface.
Atributo

Os Atributos em Programação Orientada a Objetos são os elementos que definem a estrutura de uma classe. Os atributos também são conhecidos como variáveis de classe, e podem ser divididos em dois tipos básicos: atributos de instância e de classe. Os valores dos atributos de instância determinam o estado de cada objeto. Um atributo de classe possui um estado que é compartilhado por todos os objetos de uma classe. Atributos de classe podem ser chamados também de atributos estáticos ou constantes.

Declarando um atributo em Java

Sintaxe básica para declaração de um atributo em Java:
<modificador>* <tipo> <nome> [ = <valorInicial> ];
Exemplo:
private int x;
private float y = 10000.0F;
public String nome = "Carina Calixto"
Método

Em orientação a objeto, um método é uma subrotina que é executada por um objeto. Os métodos determinam o comportamento dos objetos de uma classe e são análogos à funções ou procedimentos da programação estruturada. A chamada de métodos pode ou não alterar o estado de um objeto.

Declarando um método em Java

Sintaxe básica para declaração de um método em Java:
<modificador>* <tipoDoRetorno> <nome> ( <parâmetro>* ){
<corpoDoMétodo>
}
Exemplo:
public void setaPeso (int p) {
if ( p > 0 ) {
peso = p;
}
}
Construtor

Construtor é um método chamado assim que uma nova instância do objeto for criada através do operador new. Tal método geralmente é responsável pela alocação de recursos necessários ao funcionamento do objeto além da definição inicial das variáveis de estado (atributos). Sua sintaxe básica é identica a dos métodos. A assinatura de um construtor diferencia-se das assinaturas dos outros métodos por não ter nenhum tipo de retorno (nem mesmo void). Além disto, o nome do construtor deve ser o próprio nome da classe.

Exemplo:
public class Carro {
private double passageiros;
//método construtor
public Carro {
passageiros = 0;
}
//método
public void setaPassageiros(double p) {
passageiros = p;
}
}
Pacote

Como já foi falado sobre pacote, irei apenas adicionar algumas informações.

Pacotes são especialmente úteis para ocultar informações. Com este intuito, Java permite que as definições de métodos, atributos, construtores e classes sejam acompanhadas de qualificadores especiais:
  • Se um atributo, método, construtor ou uma classe for declarado public, ele poderá ser utilizado em qualquer lugar.
  • Se um atributo, método ou construtor for declarado private, ele só poderá ser utilizado (referenciado) na definição da classe onde o mesmo é definido.
  • Se um atributo, método ou construtor for declarado protected, ele só poderá ser utilizado no pacote onde o mesmo é definido ou na definição de uma subclasse da classe onde o mesmo é definido.
  • Se um atributo, método, construtor ou uma classe não for declarado com um dos qualificadores discutidos acima, ele só poderá ser utilizado no pacote onde o mesmo é definido.
Além disso, qualquer unidade de compilação de um pacote pode usar definições de outros pacotes, desde que elas sejam visíveis. Assim, se em uma unidade de compilação do pacote segundo.pacote for preciso usar o tipo (classe ou interface, juntamente com todas operaçoes e atributos visíveis) Tipo definido no pacote primeiro.pacote temos que fazer as seguinte declarações:
package segundo.pacote;
...
import primeiro.pacote.Tipo;
...

terça-feira, 16 de fevereiro de 2010

[Java] Conceitos de modelagem: abstração, encapsulamento e pacote


Neste post serão apresentados os conceitos de abstração, encapsulamento e pacote.

Abstração

Abstração é o processo ou resultado de generalização por redução do conteúdo da informação. Em programação orientada a objetos o processo de abstração possibilita esconder do usuário toda complexidade de implementação de um conceito, deixando visível apenas uma interface de serviços para ser utilizada.

Encapsulamento

Encapsulamento significa separar o programa em partes, o mais isoladas possível. A idéia é tornar o software mais flexível, fácil de modificar, mais fácil de reutilizar e de criar novas implementações. Para ficar mais simples de entender, um motorista sabe como dirigir um ônibus, porém ele não precisa saber de como funciona um ônibus por dentro para dirigí-lo.

Uma vantagem do encapsulamento é que pode-se modificar a implementação de um trecho encapsulado sem que os usuários da classe em questão sejam afetados. Outra vantagem é que o encapsulamento protege o acesso direto aos atributos de uma instância fora da classe onde estes foram declarados. Esta proteção consiste em se usar modificadores de acesso mais restritivos sobre os atributos definidos na classe.


Pacote

Em java, pacote é uma maneira de organizar as classes em "namespace". Esta funcionalidade serve para o programador organizar as classes pertencentes a uma mesma categoria ou que possuem a uma mesma funcionalidade. Fornecem também a gerência do namespace, como a proteção do acesso.

[Java] Interpretação de um programa Java com depuração dos valores das variáveis (parte 4/4)


Depois de tanto ler sobre interpretação de um programa Java com depuração dos valores das variáveis, nada melhor do que um resumo, não é?

Resumo
  • O depurador permite monitorar a execução de um aplicativo para você poder localizar e remover erros de lógica.
  • A opção de compilador -g compila uma classe para depuração.
  • O comando jdb inicia o depurador.
  • O comando run, seguido pelo nome da classe de um aplicativo, executa o aplicativo por meio do depurador.
  • O comando stop, seguido pelo nome da classe, de dois-pontos e de um número da linha, configura um ponto de interrupção no número da linha especificado.
  • O comando cont retoma a execução depois de entrar no modo de interrupção.
  • O comando print, seguido pelo nome de uma variável, examina o conteúdo da variável especificada.
  • O comando print pode ser usado para examinar o valor de uma expressão (lógica ou aritmética) durante a execução de um aplicativo.
  • O comando set modifica o valor de uma variável durante a execução de um aplicativo.
  • O comando step executa a próxima instrução no aplicativo. Se a próxima instrução a executar for uma chamada ao método, o controle será transferido para o método chamado.
  • O comando step up executa as instruções em um método e retorna o controle ao local em que o método foi chamado.
  • O comando next executa a próxima instrução no aplicativo. Se a próxima instrução a executar for uma chamada ao método, o método chamado executará na sua totalidade (sem transferir o controle e inserir o método) e o aplicativo passará para a próxima linha executável depois da chamada ao método.
  • O comando watch instrui o depurador a notificá-lo se o campo especificado for modificado.
  • O comando unwatch remove um watch de um campo.
  • O comando clear, executado por si só, lista os pontos de interrupção configurados para um aplicativo.
  • O comando clear, seguido por um nome de classe, de dois-pontos e de um número de linha, remove o ponto de interrupção especificado.

segunda-feira, 15 de fevereiro de 2010

[Java] Interpretação de um programa Java com depuração dos valores das variáveis (parte 3/4)


O comando
watch

Nesta seção, será apresentado o comando watch, que instrui o depurador a monitorar um campo. Quando esse campo está em vias de ser alterado, o depurador o notificará.
  1. Iniciando o depurador: Inicie o depurador digitando jdb.
  2. Monitorando um campo de uma classe: Configure um ponto de monitoração (watch) no campo desejado digitando watch Nomedaclasse.nomedocampo (Por exemplo watch Conta.saldo). Você pode configurar um ponto de monitoração em qualquer campo durante a execução do depurador. Sempre que o valor em um campo está em vias de mudar, o depurador entra no modo de interrupção e o notifica de que o valor mudará. Os pontos de monitoração só podem ser colocados em campos, não em variáveis locais.
  3. Executando o aplicativo: Execute o aplicativo com o comando run. O depurador agora o notificará quando o valor do campo mudar.
  4. Removendo o ponto de monitoração no campo: Suponha que em um campo você queira monitorar somente uma parte da execução de um programa. Você pode remover o ponto de monitoração do depurador digitando unwatch Nomedaclasse.nomedocampo.
Então, nesta seção você aprendeu a utilizar o comando watch para ativar o depurador a fim de notificá-lo sobre alterações no valor de um campo por todo o ciclo de vida de um aplicativo. Você também aprendeu a utilizar o comando unwatch para remover um monitor.

O comando clear

Da mesma forma que na seção anterior foi utilizado o comando unwatch para remover um monitor de um campo, o comando clear é utilizado para remover um ponto de interrupção de um aplicativo.

Freqüentemente, você precisará depurar aplicativos que contêm ações repetitivas, como umloop. Talvez você queira examinar os valores das variáveis durante várias,mas possivelmente não todas, iterações do loop. Se você configurar um ponto de interrupção no corpo de um loop, o depurador efetuará uma pausa antes de cada execução da linha que contém um ponto de interrupção. Depois de determinar que o loop está funcionando adequadamente, talvez você queira remover o ponto de interrupção e permitir que as iterações restantes prossigam normalmente.
  • Removendo um ponto de interrupção: Você pode exibir uma lista de todos os pontos de interrupção no aplicativo digitando apenas o comando clear. Suponha que você esteja satisfeito com o funcionamento do loop for do seu aplicativo, assim você quer remover o ponto de interrupção nesta linha e permitir que as demais iterações do loop prossigam normalmente. Você pode remover o ponto de interrupção na linha digitando clear Nomedaclasse:[numerodalinha], como por exemplo clear ContaTeste:22.
Você aprendeu a utilizar o comando clear para listar todos os pontos de interrupção configurados para um aplicativo e a remover um ponto de interrupção.

[Java] Interpretação de um programa Java com depuração dos valores das variáveis (parte 2/4)


Os comandos print e set

No post anterior, você aprendeu a utilizar o comando print do depurador para examinar o valor de uma variável durante a execução do programa. Neste post, aprenderá a utilizar o comando print para examinar o valor de expressões mais complexas e também a utilizar o comando set, que permite ao programador atribuir novos valores às variáveis.
  1. Inicie a depuração: No Prompt, digite jdb para iniciar o depurador Java.
  2. Avaliando expressões aritméticas e booleanas: Lembre-se, como mostrado no post anterior, de que depois de o aplicativo entrar no modo de interrupção, você pode explorar os valores das variáveis do aplicativo utilizando o comando print do depurador. O comando print também pode ser utilizado para avaliar expressões aritméticas e booleanas. Por exemplo, se você digitar print nomeDaVariavel - 2.0. Observe que o comando retornará o valor da variável menos 2.0. Entretanto, esse comando na verdade não altera o valor da variável, apenas exibe a solução da expressão. Outro exemplo porém com expressões booleanas, digite print nomeDaVarialvel == 23.0. As expressões que contêm o símbolo == são tratadas como booleanas. O valor retornado pode ser false se a variável atualmente não contém o valor comparado ou true caso contrário.
  3. Modificando valores: O depurador permite alterar os valores das variáveis durante a execução do aplicativo. Isso pode ser valioso para experimentar diferentes valores e localizar erros de lógica nos aplicativos. Você pode utilizar o comando set do depurador para alterar o valor de uma variável. Digite set nomeDaVariavel = [valordesejado]. O depurador altera o valor da variável e exibe o novo valor.
Controlando a execução com os comandos step, step up e next

Em algumas situações, será necessário executar um aplicativo linha por linha para encontrar e corrigir erros. Nesta seção, você aprenderá a utilizar o depurador para essa tarefa. Os comandos que você aprenderá aqui permitem executar um método linha por linha, executar todas as instruções de um método de uma vez ou executar apenas as instruções remanescentes de um método.
  1. Inicie a depuração: No Prompt, digite jdb para iniciar o depurador Java.
  2. Utilizando o comando step: O comando step executa a próxima instrução no aplicativo. Se a próxima instrução a executar for uma chamada ao método, o controle será transferido para o método chamado. O comando step permite que você entre em um método e estude as instruções individuais dele.
  3. Utilizando o comando step up: Depois de utilizar o comando step para inspecionar o método, iremos tentar o comando step up. Esse comando executa as instruções remanescentes no método e retorna o controle ao local em que o método foi chamado. Em métodos longos, é recomendável examinar algumas linhas-chave do código e continuar a depurar o código do chamador. O comando step up é útil para situações em que você não quer continuar a investigar todo o método linha por linha.
  4. Utilizando o comando next: Digite next. Esse comando comporta-se como o comando step, exceto quando a próxima instrução a executar contém uma chamada de método. Nesse caso, o método chamado é executado na sua totalidade e o aplicativo avança para a próxima linha executável depois da chamada ao método.
  5. Utilizando o comando exit: Utilize o comando exit para encerrar a sessão de depuração. Esse comando faz com que o aplicativo termine imediatamente em vez de executar as instruções restantes em main. Observe que ao depurar alguns tipos de aplicativos (por exemplo, aplicativos GUI), o aplicativo continua a executar mesmo depois de a sessão de depuração terminar.