Um Pouco Sobre o Java

[-Lef[T]#*~ 0]

Ola resolvi postar o basico mesmo sobre o JAVA ( A linguagem que revoluciona )

 

Características Básicas

 

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 (<condi´ão>) {

<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 {

<comandos>

} 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);

}

 

Topicos Iguais?Sorry n Tinha Visto *_*

Creditos:~attach

[Soonhadoor 0]

valew por postar