Fundamentos da Linguagem Java
Autor: Kayo Bruno | Publicado: 2012-03-11T13:33:00-07:00

Palavras-ChaveNa linguagem Java, 49 são as palavras chaves e você deverá memorizá-las. Não tente fazer como fazíamos no ensino fundamental para decorar a tabuada (como era difício a do 9, lembra?), essa assimilação será com o tempo, mesmo assim, dê uma olha na lista a seguir, e observe que TODAS as palavras chaves são definidas em letras minúsculas:byte - short - int - long - char - booleandouble - float - public - private - protectedstatic - abstract - final - strictfp - transientsynchronized - native - void - class - interfaceimplements - extends - if - else - dodefault - switch - case - break - continueassert - const - goto - throws - thrownew - catch - try - finally - returnthis - package - import - instaceofwhile - for - volatile - superNão tente decorar todas elas, tente entender o que elas fazem, isso será possível com o desenvolver dos capítulos.LEMBRE-SE: null, false, true (Não são palavras chaves, são valores literais!)Tipos primitivos:byte&nbsp;- Inteiro de 8 bits com sinalshort&nbsp;- Inteiro de 16 bits com sinalint&nbsp;- Inteiro de 32 bits com sinallong&nbsp;- Inteiro de 64 bits com sinalchar&nbsp;- Caracter Unicode (16 bits sem sinal)float&nbsp;- Ponto flutuante de 32 bits com sinaldouble&nbsp;- Ponto flutuante de 64 bits com sinalboolean&nbsp;- Valor indicando true ou falseModificadores de acesso:private&nbsp;- Define que um método ou variavel seja acessada somente pela própria classe&nbsp;protected&nbsp;- Faz com que uma subclasse acesse um membro da superclasse, mesmo estando em pacotes diferentespublic&nbsp;- Faz com que um identificador possa ser acessado de qualquer outra classe.Modificadores de classe, métodos e variável:abstract&nbsp;- Define uma classe abstrata&nbsp;class&nbsp;- Define a implementação de uma classeextends&nbsp;- Define qual a hierarquia de classes, quem é a superclassefinal&nbsp;- Faz com que um identificador não possa ser alteradoimplements&nbsp;- Faz com que uma classe implemente todos os métodos de uma interfaceinterface&nbsp;- Define uma interfacenative&nbsp;- Define que o método será escrito em linguagem nativa como C, C++new&nbsp;- Instancia um novo objeto na pilhastatic&nbsp;- Defina um identificado de classe e não de instânciastrictfp&nbsp;- Define que o método esta segundo o padrao IEE754synchronized&nbsp;- Define que um método só poderá ser acessado por uma única thread por veztransient&nbsp;- Faz com que uma variável não seja serializadavolatile&nbsp;- Indica que uma variável pode não ficar sincronizada ao ser usada por threadsControle de Fluxo:break&nbsp;- Faz com que o fluxo seja desviado para o fim do blococontinue&nbsp;- Muda o curso do fluxo para a proxima iteracao do loopif&nbsp;- Testa o valor lógico de uma condiçãoelse&nbsp;- Indica qual o bloco que deverá ser executado caso o teste feito pelo if seja falsodefault&nbsp;- Bloco que será executado caso nenhuma condição case satisfaça o swicthswitch&nbsp;- Iniciar uma sequencia de testes para uma variavel a ser testada pelo casecase&nbsp;- Testa o valor de uma variavel indicada pelo switchfor&nbsp;- Usado para executar um bloco quantas vezes forem necessárias para satisfazer sua condiçãodo&nbsp;- Executa um bloco quantas vezes a condição se fizer verdadeira. A condição é testada depois do blocowhile&nbsp;- Executa um bloco quantas vezes a condição se fizer verdadeira. A condição é testada antes do blocoreturn&nbsp;- Finaliza a execução de um método, podendo opcionalmente retornar um valorinstanceof&nbsp;- Testa se um objeto é instancia de uma classe qualquerTratamento de erros:catch&nbsp;- Define o bloco de decisão que executará se por acaso ocorrer no bloco try uma exceção pré-definidafinally&nbsp;- Bloco que sempre será executado, mesmo que uma exceção seja lançadathrow&nbsp;- Lança uma exceçãothrows&nbsp;- Indica que um método pode lançar algum tipo de exceçãotry&nbsp;- Iniciar um bloco com auditoriaassert&nbsp;- Usado no projeto, testa uma expressão para verificar alternativas para o programador.Controle de pacotes:import&nbsp;- Importa uma ou todas as classes de um pacotepackage&nbsp;- Define que a(s) classes farão parte de um pacote;&nbsp;Variáveis/Herança:super&nbsp;- Refere-se a superclasse imediatathis&nbsp;- Refere-se a instância do objeto&nbsp;Retorno:void&nbsp;- Define que um método não retorna nadaReservadas mas não utilizadas:const&nbsp;- Não use para definir uma variável, use finalgoto&nbsp;- Não serve para nadaTipo primitivos:Você precisará saber "tudo" sobre os tipos primitivos, suas faixas de valores, valores padrões, conversões implicitas e explícitas, e muito mais. Por isso, prepare-se o seu pesadelo começou! Mas não se preocupe, com um pouco de fé e perseverança, tudo se resolve!&nbsp;A Java é composta por 8 (oito) tipos primitivos, e como você já deve ter percebido, todos começam com letras minúsculas (pois também são palavras chaves), portanto se você for tiver que responder uma pergunta onde aparece perguntando por exemplo se String é um tipo primitivo, não hesite em responder que NÃO!Outro conceito importante sobres os tipos primitivos em Java é que todos os tipos numéricos tem sinal. Mas o que isso significa? - deve ter vindo à sua mente! Significa que podem ser negativos ( - ) ou positivos ( + ), ou seja, o tipo int pode ter o numero -1 como tambem o numero +1. Observe a tabela de valores abaixo:
tipo &nbsp; &nbsp;bits &nbsp; fórmula &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;faixa&nbsp;&nbsp;
byte&nbsp; &nbsp; &nbsp;8&nbsp; &nbsp;-2^7&nbsp;&nbsp;à&nbsp;2^7-1&nbsp; &nbsp;-128&nbsp;a +127&nbsp;&nbsp;
short&nbsp; &nbsp;16&nbsp; &nbsp;-2^15&nbsp;à&nbsp;2^15-1&nbsp; -32768&nbsp;a&nbsp;+32767&nbsp;&nbsp;
int&nbsp; &nbsp; &nbsp;32&nbsp; &nbsp;-2^31&nbsp;à&nbsp;2^31-1&nbsp; -2147483648&nbsp;a&nbsp;+2147483647&nbsp;&nbsp;
long&nbsp; &nbsp;&nbsp;64&nbsp; &nbsp;-2^63&nbsp;à&nbsp;2^63-1&nbsp; -9223372036854775808&nbsp;a +9223372036854775807&nbsp;&nbsp;
Dica sem ônus: Lembre-se da palavrinha bsil (já está no aurélio), que indica os tipos b-byte, s-short, i-int, l-long ! Pois "1 byte é representado por 8 bits", isso até Hitler morreu sabendo!Entendendo essa fórmula maluca...Você deve estar se perguntando, porque deve elevar a 7 (sete) no caso do byte e não a 8 (oito), certo ? 1 Bit é usado para guardar o sinal. E porque só subtrai -1 da faixa positiva ? Porque o zero é incluído no intervalo também.&nbsp;Se ainda ficou confuso, vamos fazer um teste. Um regra nós sabemos: o tipo byte em Java é representado por oito bits. Se 1 bit é usado para guardar o sinal (+) ou (-), então sobrou 7 bits para representar um número. Se convertermos o número +125 em bits teremos 1111101 e ficaria representado da seguinte forma: 01111101 (observe que o zero inicial indica que é um numero positivo, estranho mas se o primeiro digito fosse um 1, seria um numero negativo). Agora se convertermos o numero +128 em bits, teremos 10000000, como esse numero é composto por oito bits não é possível adicionar o bit do sinal portanto o numero 128 positivo não está no intervalo do tipo byte, e está na faixa negativa pois o bit mais significativo a esquerda é 1 que indica sinal negativo. Quais os bits representam o numero 127 ?Tipos primitivos (não acabou):Os demais tipos primitivos são: char, float, double, boolean !char&nbsp;- É representado por caracter Unicode de 16 bits (sem sinal). Tambem pode ser representado por um numero inteiro de 16 bits sem sinal, ou seja, pode-se atribuir à uma variavel char o valor 100 ou 14555 ou 65535, mas não 65536 ! Pois essa é a faixa de valores da tabela Unicode para representação de caracteres de qualquer idioma. Mas a unica coisa que você precisa saber é a faixa de valores do tipo char. 2 ^ 16 - 1 = 65535 (valores possíveis).&nbsp;float&nbsp;- É um tipo numérico ponto flutuante de 32 bits (COM SINAL) !! Apesar de ter um tamanho definido por 32 bits, não é necessário saber a faixa de valores.&nbsp;double&nbsp;- É um tipo numérico ponto flutuante de 64 bits (COM SINAL) ! Apesar de ter um tamanho definido por 64 bits, não é necessário saber a faixa de valores.&nbsp;boolean&nbsp;- Um valor que indicado pelos valores literais: true ou false.Conversões implicitas/explícitas:Você pode sempre que precisar, fazer conversões entre os tipos numéricos, mas uma regra não pode ser quebrada: nunca você poderá convertar um tipo de maior valor (bits) em um número de menos valor.&nbsp; 
Por exemplo:&nbsp;
1.&nbsp;public&nbsp;class&nbsp;Conversao&nbsp;{&nbsp;&nbsp;
2.&nbsp;public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{&nbsp;&nbsp;
3.&nbsp;int&nbsp;x&nbsp;=&nbsp;10;&nbsp;&nbsp;
4.&nbsp;long&nbsp;y&nbsp;=&nbsp;20;&nbsp;&nbsp;
5.&nbsp;y&nbsp;=&nbsp;x;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;perfeitamente&nbsp;possível&nbsp;&nbsp;
6.&nbsp;x&nbsp;=&nbsp;y;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;não&nbsp;é&nbsp;possível&nbsp;&nbsp;
7.&nbsp;x&nbsp;=&nbsp;(int)y;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;quero&nbsp;correr&nbsp;o&nbsp;risco&nbsp;e&nbsp;deixa&nbsp;eu&nbsp;queto&nbsp;!&nbsp;&nbsp;
8.&nbsp;}&nbsp;&nbsp;
9.&nbsp;}&nbsp;&nbsp;
Na linha 5 houve um conversão implicita perfeitamente possível pois o tipo da variavel y é long, ou seja, maior que o tipo da variavel x.Na linha 6 houve um tentativa de conversão, mas o compilador não permitira essa operação, pois o tipo long é maior que int.Na linha 7,uma conversão explícita foi realizada e o compilador gentilmente atendeu a solicitação do programador.Literais Inteiros:Um valor literal em Java é um valor escrito no código fonte e identificado como um tipo primitivo como por exemplo:&nbsp;int&nbsp;x&nbsp;=&nbsp;10;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;literal&nbsp;inteiro&nbsp;&nbsp;
char&nbsp;u&nbsp;=&nbsp;'k';&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;literal&nbsp;char&nbsp;&nbsp;
boolean&nbsp;b&nbsp;=&nbsp;false;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;literal&nbsp;boolean&nbsp;&nbsp;
double&nbsp;d&nbsp;=&nbsp;9832.11;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;literal&nbsp;double&nbsp;&nbsp;
Há três maneiras de representar valores inteiros em Java: octal (base 8), decimal (base 10) e hexadecimal (base 16) ! Será bom você estudar um pouco sobre esses sistemas de numeração, pode-se que os sacanas dos caras que fazem a prova, possa testar você em alguma questão! Mas observe o código abaixo e veja como se representam valores literais em octal e hexadecimal (pois decimal você viu acima):&nbsp;public&nbsp;class&nbsp;Octal&nbsp;{&nbsp;&nbsp;
public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{&nbsp;&nbsp;
int&nbsp;seis&nbsp;=&nbsp;06;&nbsp;&nbsp;//&nbsp;idem&nbsp;ao&nbsp;decimal&nbsp;6&nbsp;&nbsp;
int&nbsp;sete&nbsp;=&nbsp;07;&nbsp;&nbsp;//&nbsp;idem&nbsp;ao&nbsp;decimal&nbsp;7&nbsp;&nbsp;
int&nbsp;oito&nbsp;=&nbsp;010;&nbsp;//&nbsp;idem&nbsp;ao&nbsp;decimal&nbsp;8&nbsp;&nbsp;
int&nbsp;nove&nbsp;=&nbsp;011;&nbsp;//&nbsp;idem&nbsp;ao&nbsp;decimal&nbsp;9&nbsp;&nbsp;
}&nbsp;&nbsp;
}&nbsp;&nbsp;
Ou seja, se você ver o numero 0 antes de um número, saiba que está representando um número octal.public&nbsp;class&nbsp;Hexadecimal&nbsp;{&nbsp;&nbsp;
public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{&nbsp;&nbsp;
int&nbsp;quinze&nbsp;=&nbsp;0xF;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;15&nbsp;(decimal)&nbsp;&nbsp;
int&nbsp;vinte_e_nove&nbsp;=&nbsp;0x1D;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;29&nbsp;(decimal)&nbsp;&nbsp;
int&nbsp;vinte_e_nove&nbsp;=&nbsp;0x1D;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;29&nbsp;(decimal)&nbsp;&nbsp;
int&nbsp;valor&nbsp;=&nbsp;0xBAFAFA;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;12253946&nbsp;(decimal)&nbsp;&nbsp;
int&nbsp;valor&nbsp;=&nbsp;0XBaFaFa;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;12253946&nbsp;(decimal)&nbsp;&nbsp;
}&nbsp;&nbsp;
}&nbsp;&nbsp;
Deve vir precedido do sufixo (0x) ! É um dos poucos casos na linguagem em que não importa se as letras forem maiúsculas ou minúsculas. Todos os tipos inteiros literais (tanto octal quanto hexa) são por padrão definidos como int, portanto se ver no exame um questão que atribui a uma variavel menor que int (em bits) isso dará erro de compilação. Veja o código a seguir:1.&nbsp;public&nbsp;class&nbsp;ConversaoHexa&nbsp;{&nbsp;&nbsp;
2.&nbsp;public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{&nbsp;&nbsp;
3.&nbsp;int&nbsp;&nbsp;a&nbsp;=&nbsp;0xbafa;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;ok,&nbsp;sem&nbsp;conversão&nbsp;&nbsp;
4.&nbsp;long&nbsp;b&nbsp;=&nbsp;0xfff;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;ok,&nbsp;conversão&nbsp;implicita&nbsp;&nbsp;
5.&nbsp;long&nbsp;c&nbsp;=&nbsp;0xfffL;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;ok,&nbsp;conversão&nbsp;explícita&nbsp;&nbsp;
6.&nbsp;byte&nbsp;d&nbsp;=&nbsp;0xf;&nbsp;&nbsp;&nbsp;//&nbsp;ok,&nbsp;conversão&nbsp;implícita&nbsp;&nbsp;
7.&nbsp;byte&nbsp;e&nbsp;=&nbsp;0xff;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;erro!&nbsp;-&nbsp;255&nbsp;não&nbsp;é&nbsp;comportado&nbsp;&nbsp;
8.&nbsp;byte&nbsp;f&nbsp;=&nbsp;(int)0xff;&nbsp;&nbsp;&nbsp;//&nbsp;erro!&nbsp;-&nbsp;255&nbsp;não&nbsp;é&nbsp;comportado&nbsp;&nbsp;
9.&nbsp;}&nbsp;&nbsp;
10.}&nbsp;&nbsp;
Na linha 6 o compilador sabe que F em hexa equivale a 15, o que pode ser perfeitamente suportado no tipo byte, então ele realiza a conversão.Na linha 7 o compilador sabe que FF em hexa equivale a +255 o que não pode ser suportado, por isso, erro!Na linha 8 o compilador só não chinga o programador por conflito de drivers entre seu sistema operacional com sua placa de som, ou seja, mas intimamente ele fala: CARA OLHA O QUE VOCÊ ESTÁ QUERENDO ME FORÇAR A FAZER !!! (%#%$!#%)Literais de ponto flutuante:Um valor literal de ponto flutuante por padrão em Java é definido com&nbsp;double&nbsp;de 64 bits, portanto de você quiser atribuir um valor literal&nbsp;float&nbsp;você deverá adicionar o sufixo&nbsp;f&nbsp;no final do valor como o exemplo:1.public&nbsp;class&nbsp;Teste&nbsp;{&nbsp;&nbsp;
2.public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{&nbsp;&nbsp;
3.double&nbsp;a&nbsp;=&nbsp;9223372036854775807.0;&nbsp;//&nbsp;ok&nbsp;tipo&nbsp;double&nbsp;&nbsp;
4.float&nbsp;b&nbsp;=&nbsp;2147483647;&nbsp;//&nbsp;ok&nbsp;tipo&nbsp;int&nbsp;para&nbsp;float&nbsp;conv&nbsp;implicita&nbsp;&nbsp;
5.float&nbsp;c&nbsp;=&nbsp;2147483647.0;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;erro!&nbsp;double&nbsp;-&gt;&nbsp;float&nbsp;&nbsp;
6.float&nbsp;d&nbsp;=&nbsp;(float)2147483647.0;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;ok&nbsp;-&nbsp;conversão&nbsp;&nbsp;
7.float&nbsp;e&nbsp;=&nbsp;2147483647.0f;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;ok&nbsp;&nbsp;
8.}&nbsp;&nbsp;
9.}&nbsp;&nbsp;
Na linha 4, funciona pois 2147483647 é um literal int e não double! Não tem decimal !Na linha 5, o compilador reclamará pois 2147483647.0 é um tipo double (o padrão dos literais de ponto flutuante) não pode ser atribuído a uma variável float.Na linha 6 é feito uma conversão explícita.Na linha 7 é atribuído um valor float por causa do sufixo fLiterais booleanos:Os valores literais booleanos são compreendidos entre true ou false e só !&nbsp;public&nbsp;class&nbsp;LitBoo&nbsp;{&nbsp;&nbsp;
public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{&nbsp;&nbsp;
boolean&nbsp;a&nbsp;=&nbsp;true;&nbsp;&nbsp;&nbsp;//&nbsp;ok&nbsp;&nbsp;
boolean&nbsp;b&nbsp;=&nbsp;false;&nbsp;&nbsp;&nbsp;//&nbsp;ok&nbsp;&nbsp;
boolean&nbsp;c&nbsp;=&nbsp;1;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;erro&nbsp;de&nbsp;compilacao&nbsp;&nbsp;
}&nbsp;&nbsp;
}&nbsp;&nbsp;
Cuidado que em Java diferentemente de C e outras linguagens não se pode atribuir o valor 0 ou 1 para literais booleanos.Literais Caracteres:Os valores literais caracteres são compreendidos com um único caracter entre apóstrofo - se você não sabe o que é apóstrofo, é o mesmo que aspas simples&nbsp;'public&nbsp;class&nbsp;Carac&nbsp;{&nbsp;&nbsp;
public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{&nbsp;&nbsp;
char&nbsp;a&nbsp;=&nbsp;'a';&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;ok&nbsp;&nbsp;
char&nbsp;b&nbsp;=&nbsp;'@';&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;ok&nbsp;&nbsp;
char&nbsp;c&nbsp;=&nbsp;'\u004E';&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;refere-se&nbsp;a&nbsp;letra&nbsp;N&nbsp;&nbsp;
}&nbsp;&nbsp;
}&nbsp;&nbsp;
Como foi falado, o tipo char nada mais é do que um tipo inteiro sem sinal de 16 bits, portanto você poderá atribuir 2 ^ 16 - 1 = 65535. Veja no código abaixo:&nbsp;public&nbsp;class&nbsp;A&nbsp;{&nbsp;&nbsp;
public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{&nbsp;&nbsp;
char&nbsp;a&nbsp;=&nbsp;65;&nbsp;&nbsp;
char&nbsp;b&nbsp;=&nbsp;(char)-65;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;fora&nbsp;do&nbsp;intervalo,&nbsp;precisa&nbsp;de&nbsp;conversão&nbsp;&nbsp;
char&nbsp;c&nbsp;=&nbsp;(char)70000;&nbsp;//&nbsp;fora&nbsp;do&nbsp;intervalo,&nbsp;precisa&nbsp;de&nbsp;conversão&nbsp;&nbsp;
}&nbsp;&nbsp;
}&nbsp;&nbsp;
O tipo char pode aceitar valores fora de sua faixa, desde haja uma conversão explícita.ARRAY&nbsp;Um array em Java é um objeto criado na pilha (mémoria), usado para armazenar e trabalhar com elementos semelhantes por seu tipo.Para que se possa utilizar um array você deverá:&nbsp;Declarar - Especificar um nome e o tipo do array.Construir - Informar o tamanho do array, ou seja, numero de elementos.Inicializar - Atribuir valores aos elementos do array.&nbsp;Declarando um arrayint[] a; // RecomendadoThread b[];String []c;Observe que ainda não se sabe quantos elementos esses array armazenará, ou seja, não sabe qual será o custo para a memória desse array. Nunca coloque a quantidade de elementos do array no passo de declaração, a não ser que você faça tudo em uma única linha (isso será mostrado posteriormente). Se você ver uma questão onde aparece algo como no trecho a seguir, marque sempre erro de compilação.int[3] a; // só pode mencionar a quantidade de elementos, na construção :shock:&nbsp;Construindo um arrayint[] a = new int[3]; // Recomendado :o&nbsp;Thread b[] = new Thread[1];String []c = new String[19];Usa-se a palavra&nbsp;new&nbsp;conjugada com o tipo do array. Nunca se esqueça, em Java a contagem dos elementos SEMPRE COMEÇARÁ EM 0 (ZERO), portando uma referência ao elemento a[3] (no array a acima) causará um erro, pois só existem os elementos 0, 1, 2 -&gt; com um total de 3 elementos. Esse passo reserva espaço na memória para os elementos do objeto array, pois somente na construção que a JVM saberá quantos elementos serão composto o array, com isso cria-se um objeto na pilha com espaço necessário para armazenar os elementos do objeto. No passo de construção, todos os elementos são inicializados com seus valores padrão. Veja a tabela a seguir:TIPO VALOR PADRÃO&nbsp;byte 0&nbsp;short 0&nbsp;int 0&nbsp;long 0&nbsp;float 0.0&nbsp;double 0.0&nbsp;boolean false&nbsp;char '\u0000'&nbsp;Object nullInicializando um arrayAtribuir valores aos elementos de um objeto array. Quando um array é contruído, seus elementos são automaticamente inicializados com seus valores padrão.&nbsp;int[] x; // declaradox = new int[2]; // construindox[0] = 10; // inicializandox[1] = 20; // inicializandoObserve o seguinte código:1.public&nbsp;class&nbsp;ArrayInicia&nbsp;{&nbsp;&nbsp;
2.public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{&nbsp;&nbsp;
3.float[]&nbsp;f;&nbsp;&nbsp;
4.f&nbsp;=&nbsp;new&nbsp;float[1];&nbsp;&nbsp;
5.System.out.println("valor&nbsp;antes&nbsp;"+f[0]&nbsp;);&nbsp;&nbsp;
6.f[0]&nbsp;=&nbsp;9.0;&nbsp;&nbsp;
7.System.out.println("valor&nbsp;depois&nbsp;"+f[0]&nbsp;);&nbsp;&nbsp;
8.}&nbsp;&nbsp;
9.}&nbsp;&nbsp;
O que será impresso na linha 5 e 7 ??? ( Feche os olhos e responda !!, Não vale olhar...) Se você respondeu 0.0 e 9.0, parabéns por você ser uma pessoa de opnião! Mas infelizmente você errou !!! Lembra-se que todo valor literal ponto flutuante em Java é por padrão double, portanto esse código não compila. Se alterarmos esse código e adicionar o sufixo f na linha 6 =&gt; f[0] = 9.0f;, o resultado seria 0.0 e 9.0, por isso: PRESTE MAIS ATENÇÃO !!! :x&nbsp;Os três passos para a utilização de um array: declaração, construção e inicialização podem ser realizados em uma única linha de código. EUREKA !!! :!:&nbsp;boolean[] c = { false, true, false };int[] a = {0,1,1,1};char[] b = {'a','b','c'};Observe que a palavra chave new não foi utilizada, visto que está implícito o tipo no início, o número de elementos entre as chaves { }. Caso você se depare com uma questão (como o código abaixo) que especifica o número de elementos juntamente com a inicialização na mesma linha, não hesite em marcar a resposta: Erro de compilação !!!&nbsp;int[3] a = {1, 2, 1}; // erro de compilação :x&nbsp;Array MultidimensionalUm array multidimensional é um array com mais de uma dimensão (isso é ridículo de dizer!), ou seja, é uma coleção de objetos array dentro de um objeto array. Portanto um array definido como: int[][] i = new int[3][]; nada mais é do que um objeto array i que contém três objeto array (ainda não construído) dentro. (Complicado?)&nbsp;int[][] i = new int[2][];O que isso significa ? O que são os elementos de i ?? Significa que foi criado um objeto na pilha chamado a, e seus elementos ainda não foram contruídos. Para utilizar seus elementos, você deverá construí-los como mostra o código a seguir:i[0] = new int[2]; // construído o elemento 0 do array ii[1] = new int[3]; // construído o elemento 1 do array iQuantos objetos foram criados na pilha ?1 referenciado por a2 referenciados por a[0] e a[1]Total de objetos criados: 3 (três)Agora observe o seguinte código:public&nbsp;class&nbsp;TestArray&nbsp;{&nbsp;&nbsp;
public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{&nbsp;&nbsp;
String&nbsp;s&nbsp;=&nbsp;new&nbsp;String("Kuesley");&nbsp;&nbsp;
String[]&nbsp;nomes&nbsp;=&nbsp;{&nbsp;s,&nbsp;null,&nbsp;new&nbsp;String("Kuesley")&nbsp;};&nbsp;&nbsp;
}&nbsp;&nbsp;
}&nbsp;&nbsp;
Quantos objetos foram criados na pilha ?? :shock:&nbsp;1 obj String referencido por s1 obj array de String referenciado por nomes1 obj String referenciado por nomes[2]Observe que o elemento 0 é apenas uma referência para s portanto não é criado um novo objeto. O elemento 1 não tem um objeto referenciado, já o elemento 2 é um objeto String.Array AnônimoComo o próprio nome já diz, é um objeto array criado sem a definição de um nome. Imagine que você precise passar um objeto array como parâmetro para um método, e você não queira criar um array, basta passar anonimamente. Veja como no código abaixo:&nbsp;public&nbsp;class&nbsp;A&nbsp;{&nbsp;&nbsp;
public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{&nbsp;&nbsp;
A&nbsp;obj_a&nbsp;=&nbsp;new&nbsp;A();&nbsp;&nbsp;
int&nbsp;soma&nbsp;=&nbsp;obj_a.somarArray(&nbsp;new&nbsp;int[]&nbsp;{&nbsp;0,1,2,3&nbsp;}&nbsp;);&nbsp;&nbsp;
System.out.println("Soma&nbsp;do&nbsp;array&nbsp;é:&nbsp;"+soma);&nbsp;&nbsp;
}&nbsp;&nbsp;
public&nbsp;int&nbsp;somarArray(&nbsp;int[]&nbsp;a&nbsp;)&nbsp;{&nbsp;&nbsp;
int&nbsp;rc&nbsp;=&nbsp;0;&nbsp;&nbsp;
for&nbsp;(&nbsp;int&nbsp;i=0;&nbsp;i&nbsp;&lt;&nbsp;a.length;&nbsp;i++)&nbsp;{&nbsp;&nbsp;
rc&nbsp;+=&nbsp;a[i];&nbsp;&nbsp;
}&nbsp;&nbsp;
return&nbsp;rc;&nbsp;&nbsp;
}&nbsp;&nbsp;
}&nbsp;&nbsp;
Observe que não foi criado um objeto array com um identificador específico e passado como parâmetro, foi criado no momento em que se passará o argumento.Outro exemplo:int[][] numeros = new int[3][];numeros[0] = new int[10];numeros[1] = numeros[0];numeros[2] = new int[] { 0,1,2,3 };LEMBRE-SE: NUNCA ESPECIFIQUE O TAMANHO ENTRE OS COLCHETES, ISSO SERÁ DEDUZIDO DOS ELEMENTOS ENTRE O PAR DE CHAVES !!!&nbsp;Array - ObservaçõesAlgumas regras devem ser consideradas no uso de array que referenciam objetos!&nbsp;Dado as classes:class&nbsp;Car&nbsp;implements&nbsp;CarMove&nbsp;{&nbsp;}&nbsp;&nbsp;
class&nbsp;Mazda&nbsp;extends&nbsp;Car&nbsp;{&nbsp;}&nbsp;&nbsp;
class&nbsp;Fusca&nbsp;extends&nbsp;Car&nbsp;{&nbsp;}&nbsp;&nbsp;
class&nbsp;VMax&nbsp;{&nbsp;}&nbsp;&nbsp;
interface&nbsp;CarMove&nbsp;{&nbsp;}&nbsp;&nbsp;
&nbsp;&nbsp;
1.&nbsp;public&nbsp;class&nbsp;Test&nbsp;{&nbsp;&nbsp;
2.&nbsp;public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{&nbsp;&nbsp;
3.&nbsp;Car[]&nbsp;cars&nbsp;=&nbsp;new&nbsp;Car[3];&nbsp;&nbsp;
4.&nbsp;Fusca&nbsp;f&nbsp;=&nbsp;new&nbsp;Fusca();&nbsp;&nbsp;//&nbsp;instanciando&nbsp;um&nbsp;obj&nbsp;do&nbsp;tipo&nbsp;Fusca&nbsp;&nbsp;
5.&nbsp;cars[0]&nbsp;=&nbsp;f;&nbsp;&nbsp;
6.&nbsp;}&nbsp;&nbsp;
7.&nbsp;}&nbsp;&nbsp;
Observe que na linha 5, um objeto Fusca foi armazenado em um array do tipo Car. Por que isto é possivel ?Existe um pergunta que você sempre deverá fazer, para saber se uma classe X pode ser armazenada em um array do tipo Y.X é membro de YEm nosso contexto: Fusca é membro de Car ?Em outras palavras, Fusca é uma subclasse de Car ?Se a resposta for positiva, essa atribuição é perfeitamente possível !Agora observe o seguinte código (baseando-se nas mesmas classes Car, Fusca ):1.&nbsp;public&nbsp;class&nbsp;Test&nbsp;{&nbsp;&nbsp;
2.&nbsp;public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{&nbsp;&nbsp;
3.&nbsp;Fusca[]&nbsp;fuscas&nbsp;=&nbsp;new&nbsp;Fusca[3];&nbsp;&nbsp;
4.&nbsp;Car&nbsp;c&nbsp;=&nbsp;new&nbsp;Car();&nbsp;&nbsp;
5.&nbsp;fuscas[0]&nbsp;=&nbsp;c;&nbsp;&nbsp;
6.&nbsp;}&nbsp;&nbsp;
7.&nbsp;}&nbsp;&nbsp;
Isso é possível ?? Se tem dúvida, faça você mesmo e faça o teste e sem preguiça !!!Aproveite e teste o seguinte:1.&nbsp;public&nbsp;class&nbsp;Test&nbsp;{&nbsp;&nbsp;
2.&nbsp;public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{&nbsp;&nbsp;
3.&nbsp;Car[]&nbsp;c&nbsp;=&nbsp;new&nbsp;Fusca[1];&nbsp;&nbsp;
4.&nbsp;Fusca[]&nbsp;f&nbsp;=&nbsp;new&nbsp;Car[1];&nbsp;&nbsp;
5.&nbsp;}&nbsp;&nbsp;
6.&nbsp;}&nbsp;&nbsp;
O que acontecerá com o código acima ?Mudando um pouco de assunto!Um objeto array de uma interface, pode receber referencias de instâncias de classes que implementem essa interface.public&nbsp;class&nbsp;Test&nbsp;{&nbsp;&nbsp;
public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args)&nbsp;{&nbsp;&nbsp;
CarMove[]&nbsp;cm&nbsp;=&nbsp;new&nbsp;CarMove[4];&nbsp;&nbsp;
cm[0]&nbsp;=&nbsp;new&nbsp;Car();&nbsp;&nbsp;&nbsp;&nbsp;//&nbsp;ok!&nbsp;Car&nbsp;implementa&nbsp;CarMov&nbsp;&nbsp;
cm[1]&nbsp;=&nbsp;new&nbsp;Fusca();&nbsp;&nbsp;//&nbsp;ok!&nbsp;Fusca&nbsp;implementa&nbsp;CarMov&nbsp;&nbsp;
cm[2]&nbsp;=&nbsp;new&nbsp;Mazda();&nbsp;&nbsp;//&nbsp;ok!&nbsp;Mazda&nbsp;implementa&nbsp;CarMov&nbsp;&nbsp;
cm[3]&nbsp;=&nbsp;new&nbsp;VMax();&nbsp;//&nbsp;erro&nbsp;de&nbsp;compilação&nbsp;&nbsp;
}&nbsp;&nbsp;
}&nbsp;&nbsp;
LEMBRE-SE: Vmax é membro de CarMove ???Cuidado com detalhes de atribuições tais como:int[] n = new int[10];int[] m = new int[] {8,2,1,2,0};n = m; // ok! mesmo tipoint[][] n = new int[3][];int[] m = new int[] {1,2,3};n = m; // erro! objetos diferentesA JVM não elimina o objeto n da pilha e subtitui pelo valor de m!Observe também que o array n tem 2 dimensões, enquanto que m tem apenas uma!Porém o seguinte código seria perfeitamente possível:n[0] = m; // ok!