Características Básicas do Java

Este capítulo apresenta as características básicas da linguagem, como identificadores, palavras chave, valores literais, tipos de dados e operadores.
3.1 Palavras chave e valores literais

Java possui 49 palavras chave, todas elas são escritas em minúsculas:

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

Possui três identificadores que são valores literais:

null, false, true

Cada uma dessas palavras serão vistas mais adiante no tutorial.
3.2 Tipos primitivos

Existem somente oito tipos primitivos em Java, todo o resto é objeto. Estes tipos ficaram na linguagem pela sua velocidade de intera´ão, e por isso não foram transformados em Objetos. Como não são objetos a sua declara´ão já cria a variável em memória não necessitando de construtores.

Nesta se´ão os tipos Array e String não são tratados, pois não são considerados tipos primitivos. Ambos são classes e serão tratadas no capítulo sobre classes.
3.2.1 Numéricos inteiros

Todos esses tipos possuem uma representa´ão interna em complemento de dois. O valor default para esses atributos é 0 e cada vez que se usar uma constante numérica no código fonte ela será um int a não ser que se coloque a constante? L? no final do número.

* byte - Tamanho de 8 bits com sinal. Valores de - 128 a + 127.
* short - Tamanho de 16 bits com sinal. Valores de - 32.768 a + 32.767.
* int - Tamanho de 32 bits com sinal. Valores de - 2.147.483.648 a + 2.147.483.647.
* long - Tamanho de 64 bits com sinal. Valores de - 9.223.372.036.854.775.808 a + 9.223.372.036.854.775.807.

Exemplo:

100L = > long
100 = > int
0L = > long
0 = > int

Não existe os tipos unsigned, long int ou short int em Java.
3.2.2 Ponto flutuante

Os pontos flutuantes seguem a representa´ão IEEE 754, sendo que 0.0 é o valor default. No código fonte, tudo o número com decimais será um float a não ser que o caractere ? d ? ou ? D ? estejam no final do número.

* float - Tamanho de 32 bits com sinal. Valores de - 1.40239846E-45 a + 3.40282347E + 38 (com nove dígitos significativos de precisão).
* double - Tamanho de 64 bits com sinal. Valores de - 4.94065645841246544E-324 a + 1.79769313486231570E + 308 (com 18 dígitos significativos de precisão).

Exemplo:

100.0 = > float
100.00d = > double
0 = > float
0f = > float
0d = > double

3.2.3 Caractere

O caractere guarda o valor traduzido de um código ASCII. Seu valor default é o código zero, \ 0;



char - Caractere Unicode com tamanho 16 bits sem sinal. Valores possíveis 0 a 65535

O char também pode ser representado por um numero inteiro de 16 bits sem sinal, ou seja, pode-se atribuir Ã* uma variável char o valor 100 ou o valor 65535, pois se está operando com os valores da tabela Unicode que representam caracteres de qualquer idioma.
3.2.4 Booleano

Tipos boleanos identificam verdadeiro ou falso e podem ser utilizados diretamente em expressões de retorno para testes como if, switch, while e for., porém não podem ser comparados com variáveis ou constantes numéricas como em C.

boolean - Valor indicando true ou false. Tamanho de 8 bit.

3.2.5 Valores padrão

Abaixo segue uma lista com os valores padrões de todos os tipos primitivos, sendo que não é necessário inicializar as variáveis com esses valores, a máquina virtual cuidará desse trabalho.



* byte = 0;
* short = 0;
* int = 0;
* long = 0;
* float = 0.0;
* double = 0.0;
* boolean = false;
* char = ` \ u0000 ';
* Object = null;

Um objeto, como veremos mais adiante, é inicializado com valor null, pois ele necessita que a instância seja criada explicitamente, o que não ocorre em tipos primitivos.
3.3 Identificadores

Os identificadores em Java iniciam com uma letra, um sublinhado ? _ ? ou um sinal de dólar " $ " e podem possuir números após o primeiro caractere da palavra. Pela premissa de ser case-sensitive existe uma diferencia´ão entre letras maiúsculas e minúsculas. Identificadores válidos são: identificador, meu_Carro, MeuCarro2, _atributo, $bola _2seg

Identificadores usados para determinar nomes de variáveis, atributos de classe ou de instância, parâmetros e métodos.
3.4 O operador de atribui´ão

O sinal de atribui´ão em Java é o " = " igual ao " = " do C e ao ": = " do Delphi. Vale deixar gravado que a compara´ão é feita com " = = " como no C. Uma atribui´ão é feita com a seguinte sintaxe:

= ;

Veja o exemplo:

public class Atribui´ão {
public static void main (String [] args) {
int x = 1;
int y = 5;
}
}

No exemplo é atribuído as variáveis inteiras x e y os valores 1 e 5 respectivamente.
3.5 Literais

O valor literal é um valor escrito no código fonte e identificado como de um tipo primitivo.

int x = 1; // literal inteiro
char u = 'a'; // literal char
boolean b = true; // literal boolean
double d = 002.11d; // literal double

Há três maneiras de representar literais numéricos inteiros em Java:

- octal (base 8). Representado com um 0 na frente de cada valor numérico. Exemplo:

int x = 01;
int x = 0931;
int x = 021;

- hexadecimal (base 16). Representado com um 0x na frente de cada valor numérico. Exemplo:

int quinze = 0xF; // 15 (decimal)
int vinte_e_nove = 0x1D; // 29 (decimal)
int vinte_e_nove = 0x1D; // 29 (decimal)
int valor = 0xBAFAFA; // 12253946 (decimal)
int valor = 0XBaFaFa; / / 12253946 (decimal)

- decimal (base 10). Representado normalmente como o primeiro exemplo.

Caracteres também possuem representa´ão especial. Todo o caractere se encontra entre aspas simples, porém pode-se atribuir um valor inteiro ao caractere sem precisar de uma conversão explícita. Alguns exemplos são:

char a = 'A'; // letra A
char b = '&'; // caractere &
char c = '\u004D'; // letra M (Unicode)
char d = '\n'; // Pula de linha
char e = '\t'; // Tab
char f = '\r'; // Retorno de carro
char g = '\b'; // Backspace
char h = '\f'; // FormFeed
char i = '\\'; // Barra
char j = '\''; // Apostrofo
char k = '\"'; // Aspas duplas
char l = 65; // char recebe o valor de um int
char m = (char) -1; // fora do intervalo, conversão explícita
char n = (char) 100000; // fora do intervalo, conversão explícita

3.6 Conversões entre tipos primitivos

Existem duas maneiras de fazer conversões de tipos:

1. Conversão implícita, quando o tamanho de uma variável é maior que o tamanho da variável ou o valor que está sendo atribuído. Exemplo:

int y = 10;
long x = y;

O tamanho de int é menor que o de long, portanto é perfeitamente aceitável.

2. Conversão explícita, quando o tamanho de uma variável é menor que o tamanho da variável ou o valor que está sendo atribuído. Exemplo:

long y = 10L;
int x = (int) y;

O tamanho de long é maior que o de int, portanto necessita indicar uma conversão. Esta indicativa é feita pelo tipo da variável, que irá receber o valor, entre parênteses: (int). Se esta informa´ão não for colocada, ocorreria um erro de compila´ão indicando tipos incompatíveis. Outra forma é usar as constantes de identifica´ão de tipos para fazer uma conversão explícita, como em: long y = 10L;
3.7 Operadores aritméticos

Operadores aritméticos são aqueles que efetuam opera´ões aritméticas em um ou mais tipos primitivos. A seguir são apresentados os operadores aritméticos unários, que atuam sobre um único identificador.

Op Nome Uso Descri´ão
++ Incremento var++ / ++var Retorna e adiciona / adiciona e retorna.
-- Decremento var-- / --var Retorna e subtrai / subtrai e retorna.
- Negativo -var Inverte o sinal da variável
+ Positivo +var Não tem efeito.

Abaixo estão os operadores aritméticos que atuam sobre duas variáveis.

Op Nome Uso Descri´ão
+ Adi´ão x + y Soma x com y.
- Subtra´ão x - y Subtrai y de x.
* Multiplica´ão x * y Multiplica x por y.
/ Divisão x / y Divide x por y.
% Resto x % y Resto da divisão de x por y.

3.8 Operadores relacionais e lógicos

Os operadores relacionais e lógicos são utilizados em testes e condi´ões de entrada em um fluxo do programa. Abaixo estão todos eles relacionados.

Op Nome Uso Descri´ão
> Maior que x > y x maior que y.
>= Maior ou igual a x >= y x maior ou igual a y.
< Menor que x < y x menor que y
<= Menor ou igual a x <= y x menor ou igual a y.
== Igual a x == y x igual a y.
!= Diferente de x != y x diferente de y.
! NÃO lógico (NOT) !y contrário de y.
&& E lógico (AND) x && y x e y.
|| OU lógico (OR) x ||y x ou y.
instanceof Verif Instância x instanceof X x é instância da classe X

3.9 Operadores bitwise

Os operadores bitwise são aqueles que alteram o valor das variáveis em opera´ões lógicas diretamente no processador, tornando-as muito mais performáticas. Estas opera´ões são geralmente chamadas de ? tratamento por bits ? pois são opera´ões que comparam e modificam a variável bit por bit.

Op Nome Uso Descri´ão
~ Inversão ~x Inversão dos bits de x.
& E lógico x & y AND bit a bit entre x e y.
| OU lógico x | y OR bit a bit entre x e y.
^ OU excl. lógico x ^ y XOR bit a bit entre x e y.
<< Desloc. a esq. x << y Desloc. a dir os bits de x, y vezes.
>> Desloc. a dir. x >> y Desloca a direita os bits de x, y vezes.
>>> Desloc. a dir. x >>> y Preenche zero a esquerda de x, y vezes.

3.10 O operador de atribui´ão composto

Já foi apresentado o operador de atribui´ão " = ". Porém este operador pode funcionar em conjunto com outros operadores reduzindo o tempo de processamento de determinadas chamadas. O operador de atribui´ão composto junta um operador aritmético ou de bitwise com o operador de atribui´ão. É sempre utilizado na sintaxe var = var como no exemplo abaixo:

public class OperadorAtribuicaoComposto {
public static void main (String [] args) {
int x = 1;
x + = 5;
}
}

Neste exemplo a variável inteira x é inicializada com 1 e na linha seguinte é realizado uma opera´ão composta: A soma e atribui´ão. Esta instru´ão é semelhante a esta: x = x + 5;. O resultado em x será 6. Outros exemplos são:

public class OperadorAtribuicaoComposto {
public static void main (String [] args) {
int x = 1; // Atribui 1 a x
x += 5; // Equivalente a x = x + 5; x é igual a 6
x *= 2; // Equivalente a x = x * 2; x é igual a 12
x /= 2; // Equivalente a x = x / 2; X é igual a 6
x -= 3; // Equivalente a x = x - 3; x é igual a 3
x %= 5; // Equivalente a x = x % 5; x é igual a 3
x |= 4; // Equivalente a x = x | 4; x é igual a 7
x ^= 1; / / Equivalente a x = x ^ 1; x é igual a 6
x &= 255; / / Equivalente a x = x & 255; x é igual a 6
x <<= 2; / / Equivalente a x = x << 2; x é igual a 24
x >>= 4; // Equivalente a x = x > > 3; x é igual a 1
x >>>= 7; / / Equivalente a x = x > > > 7; x é igual a 0
}
}

3.11 Precedência de operadores

Tabela de precedência de operadores em ordem decrescente, ou seja, o que está mais acima, ocorre antes.
Precedência
+ + - - + - ! (cast)
* / %
+ -
<< >> >>>
<>< = > = instanceof
= =! =
&
^
|
&&
| |
?:
= * = / = % = + = - = << = >> = >>> = & = | =
4 Comandos de decisão, repeti´ão e desvio

Este capítulo apresentará o extremamente necessário para a constru´ão de qualquer sistema em Java. Declara´ão de variáveis, comandos de decisão, repeti´ão e desvio de fluxo no programa. 4.1 Declara´ão e Inicializa´ão de Variáveis
A declara´ão de variáveis em Java pode ser feita em qualquer local do código fonte desde que esteja dentro de uma classe. Quando a declara´ão da variável é feita globalmente, ou seja, na estrutura da classe, é dita que a variável é um atributo, caso contrário ela continua sendo chamada de variável. O escopo ou a vida de uma variável em Java dura de acordo com o bloco onde ela foi declarada. A variável é criada no primeiro acesso a ela e destruída após o interpretador sair do bloco de execu´ão ao qual ela pertence.

Em Java a declara´ão de variáveis é feita pelo tipo e depois um identificador. A declara´ão muitas vezes é acompanhada pela inicializa´ão a qual acrescenta o sinal de atribui´ão e um valor literal ou variável.

A declara´ão de uma variável é feita no formato:

Tipo identificador [= valor_inicial];

Observando o exemplo 4.1 pode-se identificar várias maneiras de declarar inicializar tipos primitivos e objetos. Na linha 3 existe uma declara´ão simples, ela está criando uma variável byte e o valor de bt será 0. Na linha 4 há a declara´ão de três variáveis do tipo short: sht1, sht2 e sht3. Todas as três serão inicializadas com zero. Na linha 5 existe a declara´ão de um inteiro i e a sua inicializa´ão atribuindo o valor 9 para a variável. Na linha 6 há duas variáveis sendo criadas: f1 e f2, ambas receberão o mesmo valor 98.76. Na última linha existe a declara´ão de uma variável de tipo complexa String. String é a classe que armazena uma cadeia de caracteres sem tamanho definido em Java. No exemplo, ela está sendo inicializada com a cadeia " TESTE ". Exemplo:

public class DeclarandoVariáveis {
int atributo = 9; // Declarando uma variável global => Atributo.

public void main(String[] args) {
byte bt; // Declara´ão simples
short sht1, sht2, sht3; // Declara´ão múltipla
int i = 9; // Declara´ão e inicializa´ão
float f1, f2 = 98.76 // Declara´ão e inicializa´ão múltipla
String str = "TESTE" // Declara´ão e cria´ão de um objeto String
}
}

4.2 Instru´ões de Desvio

Linguagens de alto nível implementam várias estruturas de controle do fluxo do programa para facilitar o desenvolvimento de programas e promover um melhor estilo de programa´ão. Os comandos de sele´ão e repeti´ão são mais empíricos do que os comandos tradicionais em linguagem de máquina.

Java possui duas instru´ões de desvio condicionais mais uma palavra reservada que não deve ser usada. Todas elas existem em várias outras linguagens e plataformas.
4.2.1 Comando: if

O comando if executa um trecho de código apenas uma vez, dependendo de sua condi´ão. A sintaxe segue a sintaxe abaixo.

if ( <condi´ão> ) {
<comandos>
} else {
<comandos>
}


A condi´ão é uma expressão da linguagem java e pode ser qualquer conjunto de opera´ões que retornem um valor booleano. Ex: (i > = 0) ou (a = = 5 & & b! = 5 | | c = = a) O " comandos 1 " e " comandos 2 " são um conjunto de um ou mais comandos da linguagem Java. No caso de ser apenas um comando o uso de {} não é necessário.

Se a condi´ão for verdadeira o interpretador executará o " comandos 1 " caso contrário o bloco " comandos 2 " será executado. Exemplo:

public class ExemploIf {
public static void main(String[] args) {
int i = 8;
// If que dirá se o valor do i é igual a 1 ou igual a dois.
if (i \% 2)
System.out.println("Oito é divisível por dois");
else
System.out.println("Oito não é divisível por dois");

// Verifica se o nome é Vitor.
String nome = "Vitor";
if (nome.equals("Vitor")) {
System.out.println("Nome é Vitor");
} else {
System.out.println("Nome não é Vitor");
}
}
}

No primeiro if do exemplo é testado se o valor de i é divisível por 2, ou seja, se valor de i é par. Se for divisível, é impresso o texto Oito é divisível por dois, caso contrário é impresso o texto Oito não é divisível por dois na linha de comando.

No segundo exemplo é feito um teste para saber se a variável String nome é igual a Vitor. Em compara´ão de objetos sempre usa-se o método equals. Se o valor de nome for Vitor é impresso Nome é Vitor, caso contrário é impresso Nome não é Vitor.
4.2.2 Comando: switch

O comando switch é o mesmo do C e é semelhante ao case do Delphi. Permite selecionar o bloco de código a ser executado baseado no teste lógico de uma expressão. O switch é a forma evoluída para o if, podendo tratar mais de dois blocos de execu´ão.

Sintaxe:

switch ( <expressão> ) {
case <valor1>:<comandos 1>
[break;]
case <valor2>:<comandos 2>
[break;]
case <valor3>:<comandos 3>
[break;]
case <valor4>:<comandos 4>
[break;]
...
default: <comandos default>
}

O comando switch executa a expressão e compara o valor encontrado com os valores: , , , etc. Quando encontra a igualdade ele executa o bloco de comandos daquele valor. A execu´ão continuará até o final do switch ou até que ele encontre um break;. Exemplos:

public class ExemploSwitch {
public static void main(String[] args) {
int i = 2;
// Switch que irá imprimir na tela o valor 2
switch (i) {
case 1 : System.out.println("Valor de i é 1");
break;
case 2 : System.out.println("Valor de i é 2");
break;
case 3 : System.out.println("Valor de i é 3");
break;
default: System.out.println("Default");
}

// Switch que irá imprimir na tela o valor "Vitor"
String nome = "Vitor";
switch (nome.hashcode()) {
case "Vitor".hashCode() : System.out.println("Valor de nome é Vitor");
break;
case "Paulo".hashCode() : System.out.println("Valor de nome é Paulo");
break;
default: System.out.println("Default");
}
}
}

Não é necessário utilizar as chaves ({}) para delimitar um bloco de comandos, pois o interpretador executará todos eles até encontrar um break ou o switch finalizar.

A única limita´ão do switch é que a deve retornar um valor numérico inteiro, qualquer um de seus quatro tipos primitivos. O switch não funciona com String, float, char e boolean por exemplo. E é por este motivo que no segundo switch do exemplo é utilizado o método hashcode (), que retorna um código inteiro único para cada String diferente.
4.2.3 Comando: goto

Há um consenso entre os desenvolvedores de software de que instru´ões goto devem ser usadas somente para criar estruturas de controle, de sele´ão ou repeti´ão, caso elas não existam na linguagem trabalhada. E é exatamente por isso que, embora a palavra goto seja uma palavra reservada do Java, ela não pode ser utilizada, o compilador Java acusará erro se encontrá-la no código.

Os especialistas afirmam que o goto polui o código fonte e se não for utilizado adequadamente pode se tornar um problema maior do que o próprio software.
4.3 La´os

La´os controlam uma repeti´ão de execu´ão de acordo com uma condi´ão imposta. Em Java, assim como tantas outras linguagens, existem três tipos de la´o: for, while e do.. while.
4.3.1 Comando: for

O comando for cria um la´o de repeti´ão no fluxo do programa baseado em três parâmetros:

* expressão inicial: Onde é executado apenas uma vez, na entrada do la´o.
* condi´ão: É executado a cada itera´ão do la´o e determina quando o programa deve sair do mesmo. Caso a condi´ão seja verdadeira, repete-se os do la´o uma vez, caso seja falsa, o programa pula para a próxima instru´ão seguinte ao la´o.
* incremento: É uma opera´ão normal, executada a cada itera´ão. Geralmente é usada para incrementar contadores ou configurar variáveis.

Sintaxe:

for (<expressão inicial>; <condi´ão>; <incremento>) {
<comandos>
}

Exemplos:

public class ExemploFor {
public static void main(String[] args) {
for (int i=0; i<10; i++) {
System.out.println("Contador é " + i);
}

for (; {
System.out.println("La´o infinito.");
}
}
}

O primeiro for do exemplo acima irá apresentar 10 mensagens indicando o contador de 0 até 9. Quando o valor do inteiro i ser igual a 10 o interpretador java alternará o fluxo para o início do outro for.

No segundo for do exemplo o código entra num la´o infinito, ou seja o programa não termina, sequer sairá do la´o, já que não existe condi´ão para que tal evento ocorra.
4.3.2 Comando: while

O comando while é utilizada quando não se quer que o corpo do la´o seja necessariamente executado. A expressão de compara´ão é avaliada antes que o la´o seja executado, enquanto ela for verdadeira os são repetidos.

Sintaxe:

while (<comandos>
}

Exemplos:

public class ExemploWhile {
public static void main(String[] args) {
int i=0;
while(i++<10) {
System.out.println("Contador é " + i);
}

while(true) {
System.out.println("La´o infinito.");
}
}
}

Assim como nos exemplos com o comando for, o primeiro exemplo imprime contadores de 0 até 9 e o segundo é um la´o infinito, pois o resultado da condi´ão sempre será verdadeiro.
4.3.3 Comando: do.. while

O comando do.. while é utilizada quando se quer que o corpo do la´o seja executado pelo menos uma vez. A expressão de compara´ão é avaliada depois que o la´o foi executado, enquanto ela for verdadeira os são repetidos.

Sintaxe:

do {
} while (<condi´ão>);

Exemplos:

public class ExemploDoWhile {
public static void main(String[] args) {
int i=0;
do {
System.out.println("Contador é " + i);
} while(++i<10)

do {
System.out.println("La´o infinito.");
} while(true);
}
}

Assim como nos exemplos anteriores, o primeiro exemplo do comando do.. while imprime contadores de 0 até 9 e o segundo é um la´o infinito, pois o resultado da condi´ão sempre será verdadeiro. Embora a diferen´a entre os dois comandos while sejam mínimas, cada uma é utilizada em uma determinada ocasião.
4.4 Comandos: break e continue

É a declara´ão de desvio usada para sair de um la´o antes do normal. O tipo determina para onde é transferido o controle. O break é transfere o controle para o final de uma constru´ão de la´o (for, do, while ou switch). O la´o vai encerrar independentemente de seu valor de compara´ão e a declara´ão após o la´o será executada. Exemplo:

int i = 0;
while (true) {
System.out.println(i);
if ( i++ >= 10 )
break;
}

Este exemplo imprime os valores da variável i de 0 até 9.

A declara´ão continue faz com que a execu´ão do programa volte imediatamente para o início do la´o, porém para a próxima intera´ão. O continue faz o interpretador pular para a próxima itera´ão e obriga-o a testar a condi´ão. Exemplo:

for (int i = -10; i<10; i++) {
if ( i == 0 )
continue;
System.out.println(i);
}

No exemplo, é impresso os valores de - 10 até 9 pulando o número zero.


FLP :king: