Aprendendo Java Para Certificação Volume 1

Prévia do material em texto

Desenvolvido por:
Michel Adriano Medeiros
Aprendendo Java
para Certificação
Volume 1
Campos e
Métodos01
É O PROGRAMADOR QUE CRIA E ORGANIZA OS
ELEMENTOS DE TAL FORMA QUE RESULTA EM
UM CÓDIGO ÚTIL, IDEAL, PARA OUTROS
PROGRAMADORES ENTENDEREM.
No Java há dois elementos primários:
métodos, muitas vezes chamado de
funções ou procedures em outras
linguagens, e campos, mais
conhecidos como variáveis. Juntos
estes elementos são chamados de
membros da classe. Variáveis
guardam o estado de um programa, e
métodos opera o estado. Se há uma
mudança importante, a variável irá
guardar esta mudança. Isto é tudo que
as classes fazem. 
O Java tem palavras especiais que são
as keywords(palavras chaves ou
palavras reservadas). A palavra public
é uma keyword, significa que ela pode
ser utilizada por outras classes. A
palavra class é uma keyword, significa
que você está definindo uma classe. A
palavra Animal é o nome da classe, ela
não é uma keyword. Uma classe pode
ter qualquer nome desde que não seja
um nome de uma keyword. 
Uma classe Java se
parece com isto:
 
public class Animal{
 
}
Vamos adicionar um
campo a esta classe.
 
public class Animal{
String name;
}
A palavra name é o nome da variável. A palavra String é o tipo da variável. Em um
tipo String podemos guardar textos, como este: “isto é uma string”. String é também
uma classe fornecida pelo Java. Vamos adicionar alguns métodos.
Da linha 3 à 5 foi definido um método. Um método é uma operação que pode ser
chamada. A palavra public torna este método apto para ser chamado de outras
classes. A palavra return, retorna uma resposta que neste caso é uma String, porque
name é uma String. Da linha 6 à 8 temos outro método. Este método tem a palavra
void, que significa que não haverá retorno de nenhum valor quando este método for
chamado. Para chamar este método há a necessidade de passar uma informação
que é chamada de parâmetro. Entre parênteses está o parâmetro que precisa ser
recebido, é uma String que tem o nome de newName.
 
Uma declaração total de um método é chamada de assinatura do método. Por
exemplo: public String getName().
Consegue identificar o tipo do retorno e o parâmetro deste exemplo?
public int numberVisitors(int month)
O tipo do retorno é um int, o qual é um valor numérico. O tipo do parâmetro também
é um int.
Campos e
Métodos01
Comentários02
O COMENTÁRIO SIMPLES COMEÇA COM DUAS BARRAS. VOCÊ
PODE DIGITAR QUALQUER COISA DEPOIS DAS DUAS BARRAS,
MAS APENAS EM UMA LINHA. O SEGUNDO É O COMENTÁRIO
DE MÚLTIPLAS LINHAS OU DE MÚLTIPLOS COMENTÁRIOS.
Outro elemento comum em um código
é o comentário. Os comentários não
são códigos executáveis, por isto
podem ser colocados em qualquer
lugar. Comentários podem fazer o seu
código ficar mais fácil de ser
entendido. Há três tipos de
comentários no Java. O primeiro é
chamado de comentário simples ou de
uma linha.
Este comentário começa com /* e
termina com */ Não precisa colocar *
para cada linha, mas fica mais fácil a
leitura. O terceiro é o comentário
Javadoc. 
 
Este comentário é quase igual ao
comentário de múltiplas linhas, a
diferença é que este comentário
começa com /** e pode-se colocar
algumas anotações que são
reconhecidas pelo o Javadoc como
@author.
// comente até o fim da linha
 
/* Agora sim,
* posso digitar em mais de
uma linha.
*/
/**
* Javadoc é um comentário
para documentação
* @author Blackzig
*/
Tente identificar os tipos destes
comentários:
 
No tamanduá o comentário é de
múltiplas linhas, mesmo que dentro
dele tenha comentários simples, tudo é
considerado como comentário de
múltiplas linhas. No urso é um
comentário simples. No gato e
cachorro também são comentários
simples, não importa o que venha
depois das //, tudo é considerado
como um comentário simples. No
elefante é um comentário de múltiplas
linhas, mesmo que esteja apenas em
uma linha. No do furão se fosse
colocar isto em um código iria gerar
um erro de compilação. Preste
atenção:
/*
*/ temos um comentário de múltiplas
linhas vazio, mas depois veja:
* furão *
O furão está entre duas *, e isto não é
válido como um comentário, deveria
estar assim:
/* furão */
E por fim depois do furão está assim:
/ */ falta alguma coisa não acha?
Para ficar certo deveria estar desta
maneira:
/*
*//* furão *//*
*/
Comentários02
/*
*// tamanduá
*/
// urso
// // gato
// /* cachorro */
/* elefante */
/*
*/* furão */
*/
❤  Curso Java Para
Iniciantes  
>>> http://bit.ly/java-swing  
 
� Curso de Desenvolvimento
Web Completo  
>>> http://bit.ly/2FnB5Sp
Classes Versus
Arquivos03
VOCÊ PODE COLOCAR DUAS CLASSES NO
MESMO ARQUIVO. QUANDO É FEITO ISTO, NO
MÁXIMO UMA DAS CLASSES É PERMITIDO SER
PÚBLICA. EXEMPLO:
Na maioria das vezes, cada classe
Java é definida pelo arquivo *.java.
Normalmente é pública, que significa
que qualquer código pode invocá-la.
Curiosamente, Java não requer que a
classe seja pública. Se você não sabe
ou não lembra as declarações de uma
classe visite: http://bit.ly/2FOXbOb.
Um exemplo de classe sem
declaração.
Se você tem uma classe pública o
arquivo deve ter o mesmo nome,
pegando o exemplo anterior, se você
nomear o arquivo para Animal2 o
programa não irá compilar.
 
 
public class Animal{
 
}
 
public class Animal{
 private String name;
}
class Animal2{
}
Escrevendo um
Método main()04
Um programa Java começa
executando o método main(). Um
método main() é uma ponte entre o
começo dos processos do Java, o qual
manipula a Java Virtual Machine(JVM),
e o começo do código do
programador. A JVM conversa com o
sistema operacional para alocar
memória e tempo de CPU, acessos de
arquivos e assim por diante.
O método main() nos prende neste
processo, mantendo o nosso código
rodando. Uma simples classe com um
método main() se aparece assim:
Este código não faz nada útil. Não há
outra instrução a não ser o começo (o
ponto de partida). Todo código Java
deve ter esta instrução, senão não irá
fazer compilação do programa. Para
compilar este exemplo deve-se fazer a
seguinte instrução:
 
javac Zoo.java
java Zoo
 
public class Zoo{
  public static void main(String[] args){
            }
}
😍 Deseja criar os
seus próprios
games?  
>>> http://bit.ly/gameja
Se não aparecer nenhum erro, você
conseguiu compilar e executar um
programa Java. Se apareceu algum
erro, veja se você tem o JDK instalado.
Fiz um vídeo mostrando a instalação
do JDK http://bit.ly/aula3CJ e outro
mostrando a compilação e execução
http://bit.ly/aula4CJ.
Para compilar um programa você deve
ter um arquivo .java. O nome do
arquivo deve ser o mesmo da classe. O
resultado da compilação será um
arquivo bytecode com o mesmo nome,
mas com a extensão .class. Bytecode
é a instrução para a JVM saber o que
deve ser feito. Para executar o
programa depois de compilado não se
deve colocar nenhuma extensão
depois da palavra java, como no
exemplo: java Zoo. É errado colocar
por exemplo, java Zoo.class ou java
Zoo.java.
Escrevendo um
Método main()04
� Deseja ser um
programador full-stack?  
>>> http://bit.ly/tudosei
� Quer aprender a
divulgar o seu negócio na
internet?   
>>> http://bit.ly/negocionow
Vamos revisar as regras:
·         Cada arquivo deve ter uma única
classe principal, mesmo aqueles que
tem mais de uma classe, a principal
será a pública.
·         O nome do arquivo deve ser o
mesmo da classe e deve ter extensão
.java.
Vamos dar uma olhada novamente no
método main(). A keyword public é o
que chamamos de modificador de
acesso(access modifier). Esta
declaração expõe o arquivo para que
outros o invoque, ou seja, possa ser
acessado de qualquer parte do
programa.
A keyword static permite que o método
seja invocado apenas pelo nome da
classe, por exemplo, Zoo.main(). Desta
maneira o Java não precisa criar um
objetopara chamar o método main().
Não sabe o que é um objeto? Veja o
artigo http://bit.ly/2FNRIqG. Se o
método main() não estiver presente na
classe principal do programa, você
verá uma mensagem de erro. Se o
método main não for static, um erro
também será apresentado.
Escrevendo um
Método main()04
� Curso de PHP
Developer
>>> bit.ly/phpnow
� Curso de Linux
>>> http://bit.ly/blacklinux
A keyword void representa um tipo de
retorno(return type). Um método que
não retorna nenhum tipo de dado para
o seu invocador. Nós temos no
método main() uma lista de
parâmetros que é um array do Java o
String[] args. Há outras maneiras de
escrever este array, String args[] ou
String... args; o compilador aceita
qualquer um deles. A variável args
representa os valores que a lista
contém, estes valores podem ser lidos
quando a JVM inicia. A variável não
precisa chamar args, mas por padrão
todos deixam com este nome. Os []
representa o array. Um array é uma
lista de tamanho fixa que contém
valores do mesmo tipo. A outra
representação de um array é o (...) que
é chamado de varargs.
Agora vamos fazer alguns testes.
public class Zoo{
            public static void main(String[]
args){
                       
System.out.println(args[0]);
                       
System.out.println(args[1]);
            }
}
 
args[0] acesse o primeiro elemento de
um array. Um array começa a ser
contado do zero. Execute o programa:
javac Zoo.java
java Zoo Bronx Zoo
A saída dever ser:
Bronx
Zoo
Escrevendo um
Método main()04
� CURSO PYTHON PARA
WEB COM FLASK
>>> http://bit.ly/zigpython
�Android Developer
Express
>>> http://bit.ly/androiddevexp
O programa identificou corretamente
as duas palavras passadas como
argumento. Os espaços entre elas são
utilizados para separar os argumentos.
Se precisar de espaço em uma palavra
do argumento você precisa usar
aspas.
javac Zoo.java
java Zoo “San Diego” Zoo
A saída deve ser:
San Diego
Zoo
Todos os argumentos são tratados
como objetos String, mesmo que
representem outros tipos.
javac Zoo.java
java Zoo Zoo 2
A saída deve ser:
Zoo
2
O programa espera dois argumentos e
se eu passar só um. O que acontece?
javac Zoo.java
java Zoo Zoo
Escrevendo um
Método main()04
� Aulas de Javascript
>>> http://bit.ly/blackzigjavascript
� AULAS GRÁTIS!
Android
>>> http://bit.ly/androidblack
O Java irá ler o primeiro argumento, mas quando for ler o segundo...
Gera uma exceção porque não há nada no segundo argumento.
Lembrando que para compilar um programa você deve ter instalado na máquina
o JDK, mas se for só executar um programa você precisa apenas do JRE, que é o
Java padrão que todos instalam na máquina. Para executar um programa Java
basta a máquina ter o Java instalado, não importa qual o sistema operacional
esta máquina estiver operando já que o programa roda na JVM.
Escrevendo um
Método main()04
Entendendo as
Declarações e
Importações de
Pacotes
05
A COMPILAÇÃO DO CÓDIGO GERA O SEGUINTE ERRO:
O Java tem milhares de classes que já
vem inclusas no JDK e outras que
desenvolvedores criam que podem ser
utilizadas no seu projeto. Com este
mundo de classes o java precisa de
uma maneira para organizá-las. E o
jeito é similar a guardar objetos em
uma gaveta. O Java organiza as
classes em pacotes (packages em
inglês).
 
Imagine se eu te colocasse na frente
de várias gavetas e pedisse para você
encontrar determinado objeto sem dar
nenhuma informação. Seria mais fácil
se eu te dissesse o que estou
procurando e por exemplo o número
da gaveta. Então, o Java também
precisa destas informações para saber
qual classe você deseja utilizar, para
isto ele precisa saber o pacote e a
classe.
Vamos ver o que acontece se eu
tentar compilar este código:
 
public class ImportExample{
public static void main(String[] args){
Random r = new Random();
         System.out.println(r.nextInt(10));
}
}
Entendendo as
Declarações e
Importações de
Pacotes
05
Como você pode ver houve um erro de
compilação. A mensagem cannot find
symbol nos dá a pista do que
aconteceu. Veja que tem uma seta no
Random, isto significa que foi esta
classe que o compilador não
conseguiu encontrar. Lembre-se que
você deve dizer ao Java em qual
pacote a classe está localizada, e se
você analisar o código em nenhum
lugar dissemos onde a classe Random
pode ser encontrada.
 
Se você compilar este programa e
executar a saída será um número entre
0 e 9. Agora o programa compila e
executa sem nenhum erro, porque na
primeira linha dissemos ao java onde
está localizada a classe Random. A
palavra import diz ao Java em qual
pacote encontra-se a classe que
queremos utilizar.
 
E como fazemos isto? Vamos
tentar deste jeito:
 
import java.util.Random;
public class ImportExample{
public static void main(String[] args){
Random r = new Random();
         System.out.println(r.nextInt(10));
}
}
 
Wildcards06
Vimos que para fazer as importações
de uma classe devemos dizer em que
pacote ela encontra-se. Mas se eu
quiser importar mais de uma classe,
vou ter que importar uma por uma?
Não, temos a possibilidade de
importarmos todas as classes contida
em um pacote. Vamos ao um exemplo:
 
Este é o mesmo código anteriormente
apresentado, com a diferença que
agora tem um asterisco no import,
este asterisco que é chamado de
wildcard. Fazendo o import desta
maneira não estamos apenas
importando a classe Random, mas
todas as classes que estão contidas
no pacote java.util.
 
O wildcard é uma maneira mais curta
de fazer importações de classes,
algumas pessoas podem pensar que
fazer a importação de todas as
classes de um pacote vai deixar o
sistema lento. Isto não acontece
porque o compilador sabe qual classe
o sistema vai utilizar, portanto na
compilação ele só importa as classes
que precisa.
 
 
import java.util.*;
public class ImportExample{
public static void main(String[] args){
Random r = new Random();
         System.out.println(r.nextInt(10));
}
}
Importações
Redundantes07
Por que será que algumas classes no Java não precisam ser importadas?
 
Porque há no pacote do Java chamado java.lang. Este pacote tem um comportamento
diferenciado dos outros, ele é importado automaticamente pelo Java. Você pode
importá-lo, mas não é preciso. Quantas importações você acha que é redundante no
código a seguir?
A resposta é três. A linha 1 e 2 são redundantes porque como foi dito o pacote
java.lang é importado automaticamente pelo Java. A linha 4 também é redundante
porque a classe Random já tinha sido importada com a importação explícita.
 
 
Importações
Redundantes07
 
 
public class InputImports{
public void read(Files files){
      Paths.get("name");
      }
}
Se você tentar compilar este código aparecerá que o Java não encontrou duas
classes, a Files e a Paths. As duas classes encontram-se no mesmo pacote
java.nio.file. Como você importaria estas classes?
 
Há duas maneiras, a importação wildcard e a importação explícita.
import java.nio.file.*;
 
ou
 
import java.nio.file.Files;
import java.nio.file.Paths;
 
Importações que não funcionam:
 
import java.nio.*; //o wildcard só importa classes e não pacotes.
import java.nio.*.*;//só é permitido um wildcard
import java.nio.file.Paths.*;//wildcard importa classes e não métodos.
Outro caso de redundância é importação de classes que estão no mesmo pacote. O
Java já sabe que as classes estão no mesmo pacote e por isso não há a necessidade
da importação. Vamos ver um exemplo.
 
Conflitos de Nomes08
Se você quiser usar o
java.util.Date no código a seguir,
como você faria?
 
public class Conflicts{
            Date date;
            //mais códigos
}
 
Creio que você já saiba a
resposta.
import java.util.Date;
Os pacotes são importantes para evitar o
conflito de classesque tem o mesmo
nome. Por exemplo, a classe com o nome
Date encontra-se em mais de um pacote no
Java.
 
java.util.Date;
java.sql.Date;
 
 
O problema é: e se eu quiser usar os
dois Date, como faço?
 
Posso fazer assim?
 
import java.util.*;
import java.sql.*;
public class Conflicts{
            Date date;
            //mais códigos
}
 
Isto irá gerar o seguinte erro:
 
 
 
Conflitos de Nomes08
E se eu fizer assim:
 
import java.util.Date;
import java.sql.*;
public class Conflicts{
            Date date;
            //mais códigos
}
Agora funciona, porque a importação
explícita tem prioridade sobre a importação
wildcard.
 
Mais a pergunta persiste. E se eu quiser
usar os dois Date?
 
 
Posso fazer isto?
 
import java.util.Date;
import java.sql.Date;
public class Conflicts{
            Date date;
            //mais códigos
}
 
Isto vai gerar um conflito de nomes e o Java não sabe qual você
quer utilizar.
 
 
 
Conflitos de Nomes08
Você pode importar um normalmente e utilizar só que o outro terá sempre
que ser explícito.
 
import java.util.Date; //importe comum
public class Conflicts{
            Date date; //não preciso explicita no resto do código
            java.sql.Date sqlDate;
/*importe explicito, toda vez que for utilizar o sqlDate terei que escrever
desta maneira*/
            //mais códigos
}
Soluções:
 
 
public class Conflicts{
            java.util.Date date;
            java.sql.Date sqlDate;
            //mais códigos
}
 
ou explicitar os dois sempre.
 
 
❤  Curso Java Para
Iniciantes  
>>> http://bit.ly/java-swing  
 
� Curso de Desenvolvimento
Web Completo  
>>> http://bit.ly/2FnB5Sp
 
Criando um Novo
Pacote09
Vamos analisar o seguinte código.
 
 
Local onde está o packageb E:\Java\packageb
 
package packageb;
import packagea.ClassA;
 
public class ClassB{
            public
static void main(String[] args){
                        ClassA a;
                        System.out.println("Boa");
            }
}
 
Local onde está o packagea E:\Java\packagea
 
package packagea;
public class ClassA{
}
O Java que estou utilizando é o 12, se você estiver utilizando o 8 ou um outro, você
não vai precisar estar dentro da pasta JDK como eu mostro nos meus exemplos.
 
Faço isto porque o meu JRE está configurando com o 8.
 
Note os locais onde estão localizados os arquivos. Se você tentar compilar o
programa irá gerar o seguinte erro:
 
 
 
 
Criando um Novo
Pacote09
C:\Arquivos de
Programas\java\jdk-12.0.1\bin>javac -d bin E:\Java\packageb\ClassB.java
 
 
E se eu colocar o packagea dentro do packageb, será que dá certo?
Irá gerar o mesmo erro. Se eu apagar o packagea do diretório E:\Java\pacakgeb (voltar como
estava antes) e executar o seguinte comando: 
C:\Arquivos de Programas\java\jdk-12.0.1\bin>javac -d bin E:\Java\packagea\ClassA.java
 
E:\Java\packageb\ClassB.java
Vai gerar o seguinte erro:
 
Criando um Novo
Pacote09
Para funcionar vamos executar este comando:
javac E:\Java\packagea\ClassA.java E:\Java\packageb\ClassB.java
Agora sim compila, mas será que executa?
Como você pode ver não foi encontrado a classe principal main.
 
Isto porque o comando executado está errado, execute este comando:
C:\Arquivos de Programas\java\jdk-12.0.1\bin>java -cp E:\Java packageb.ClassB
ou
E:\Java>"C:\Arquivos de Programas\java\jdk-12.0.1\bin\java" packageb.ClassB
 
Agora sim o programa será executado. A anotação -cp significa classpath, ou seja, o caminho
do arquivo.
Note que a execução do programa foi feita fora do packageb, se você for fazer a execução
dentro deste pacote irá gerar um erro. Se quiser executar a execução dentro do packageb,
você deve tirar a identificação package packageb; no arquivo ClassB.java.
❤  Curso Java Para
Iniciantes  
>>> http://bit.ly/java-swing  
 
� Curso de Desenvolvimento
Web Completo  
>>> http://bit.ly/2FnB5Sp
 
Formatação do
Código no Exame10
Algumas vezes o exame pode trazer as seguintes características de código.
Figura1 
 
Note que o código não começa na linha 1, quando isto acontece você deve supor
que os imports já foram feitos para que este código funcione. Pode notar também
que para economizar espaço a formatação do código não vai ser organizada,
muitas vezes o código vem tudo na mesma linha.
Figura 2
 
Agora veja este código que começa na linha 1, este sim deveria ter os imports
mostrado ou a questão dizer que os imports devem ser considerados incluídos.
Outra coisa que as vezes não aparece e você deve considerar que há no código é
o método main().
 
Comparando os dois códigos e se a questão fosse:
 
Os códigos da figura 1 e 2 compilam?
 
Na Figura 1 a resposta é sim, porque os imports não devem ser considerados, na
Figura 2 a resposta é não, porque os imports devem ser considerados, e em
ambas sempre considerar que o método main() existe.
 
Construtores11
Para criar uma instância de classe, basta adicionar new a frente da classe. Por
exemplo:
 
Random r = new Random();
 
Primeiro você escolhe a classe que deseja criar o objeto, no exemplo é a classe
Random, e depois de um nome para o objeto, que no caso é r. Para finalizar a
criação do objeto você adiciona o new mais o construtor da classe, que no nosso
exemplo é Random().
 
Random() parece um método, porque é seguido de parênteses. Mas na verdade
isto é chamado de construtor, é um tipo especial de método que cria um objeto.
Vamos criar um construtor:
public class Chick{
public Chick(){
  System.out.println(“dentro do construtor”);
}
}
Há dois pontos que devemos ver no construtor: o nome do construtor é igual
ao nome da classe e não há retorno de tipo, ou seja, o construtor não retorna
nada. Pode aparecer algo assim no exame:
 
public void Chick(){} //não é um construtor
 
Quando você ver um método que tem o nome iniciado com letra maiúscula e
tem um tipo de retorno, preste atenção. Isto não é um construtor porque há um
retorno (void), void também é considerado um tipo de retorno. É um método
comum que não serve para criar um objeto (new Chick).
 
O propósito de um construtor é inicializar campos, contundo você pode colocar
o código que quiser dentro dele. Outra maneira de inicializar campos é fazer
diretamente na linha onde são declarados. Vamos ver um exemplo:
 
Construtores11
public class Chicken {
 
 Int numEggs = 0; //inicializado na linha
 String name;
 
 Public Chicken(){
  name = “Duke”; //inicializado no construtor
}
}
Para a maioria das classes você não vai precisar colocar nenhum código no
construtor e nem declarar, porque o compilador fará isto para você.
😍 Deseja criar os
seus próprios
games?  
>>> http://bit.ly/gameja
😍 Viciados em
Java  
https://cursojavanow.com.br/
Lendo e Escrevendo
Campos do
Objeto12
É possível ler e escrever variáveis de instância diretamente dentro de um
chamador. No exemplo, um cisne bota ovos:
public class Cisne {
 
int numeroDeOvos; //instanciando a variável
 
public static void main(String[] args){
Cisne mae = new Cisne();
  mae.numeroDeOvos = 1; //escrevendo valor para variável
System.out.println(mae.numeroDeOvos); //ler variável
}
}
Quando se diz ler uma variável, você vai escutar o termo get. O get foi executado
diretamente pela a variável out. Escrever um valor para uma variável é conhecido
como set. No exemplo a variável numeroDeOvos recebe o valor 1.
Você pode ler e escrever campos diretamente na linha de declaração:
 
public class Name {
            String first = “Theodore”;
            String last = “Mouse”;
            String full = first + last;
}
Nas linhas das variáveis first e last utiliza a escrita e na linha da variável full utiliza
a escrita e leitura. A variável full primeiro lê as variáveis first e last e depois
escreve nela.
� Desejaser um
programador full-stack?  
>>> http://bit.ly/tudosei
Blocos
Inicializadores de
Instância13
Quando vimos os métodos, vimos que há chaves ({}). O código entre as chaves é
chamado de bloco de código.
 
Algumas vezes os blocos de código estão dentro do método. Eles são executados
quando o método é chamado. Outra vezes, os blocos de códigos estão fora do
método. Estes são chamados de blocos inicializadores de instância. 
 
Quantos blocos você vê no exemplo? Quantas instâncias inicializadoras você vê
no exemplo?
 
public static void main(String[] args){
            {System.out.println(“Penas”);}
}
            {System.out.println(“Nevada”);}
 
Há três blocos de código e uma instância inicializadora. A contagem de blocos é
fácil: apenas conte os números de pares das chaves. Se não houver pares de
abertura ({) e fechamento de chaves (}), o código não irá compilar. Não importa se
as chaves estão dentro do método main(), mesmo assim serão contados.
 
Para contar as instâncias inicializadoras, os blocos que estão dentro de métodos
não devem ser contados. No exemplo só há um par de chaves fora do método.
Então só há uma instância inicializadora no exemplo.
� Quer aprender a
divulgar o seu negócio na
internet?   
>>> http://bit.ly/negocionow
 
Ordem da
Inicialização14
Quando escrevemos códigos que inicializam campos em múltiplo lugares, temos
que saber a ordem de inicialização. Vamos ver algumas regras:
 
O construtor executa depois de todos os campos e blocos inicializadores de
instância serem executados. Exemplo:
public class Chick {
 
 private String name = “Fluffy”;
 {System.out.println(“valor atribuído ao campo”);}
 
public Chick() {
      name = “Tiny”;
           System.out.println(“construtor executado”);
}
 
public static void main(String[] args) {
            Chick chick = new Chick();
            System.out.println(chick.name)
}
}
Executando este exemplo a saída é:
 
valor atribuído ao campo
construtor executado
Tiny
 
Ordem da
Inicialização14
Vamos analisar a execução. A execução começa no método main() porque é por
onde todo código Java começa. 
 
Começamos chamando o construtor Chick. O Java cria um objeto. Primeiro
inicializa a variável name com o valor de “Fluffy”. A seguir executa o bloco
inicializadora de instância “valor atribuído ao campo”.
 
Depois de todos os campos e blocos inicializadores de instância serem
executados, o Java retorna para o construtor. Dentro do construtor a variável
name tem o seu valor mudado para “Tiny” e é executado uma saída de mensagem.
 
Agora que o construtor foi executado, a execução retorna para o método main
para continuar a execução do código, que no caso é a saída de mensagem com o
valor da variável name.
 
A ordem de campos e blocos de código é importante. Você não pode modificar o
valor de uma variável antes de inicializá-la.
 
{System.out.println(name);} //não compila
 
private String name = “Fluffy”;
 
Pode ser que apareça questões sobre inicialização na prova. Vamos ver mais um
exemplo. Qual será a saída deste código?
� Curso de PHP
Developer
>>> bit.ly/phpnow
 
Ordem da
Inicialização14
public class Egg {
 
 public Egg() {
   number = 5;
 }
 
public static void main(String[] args) {
Egg egg = new Egg();
System.out.println(egg.number);
}
 
private int number = 3;
{number = 4;}
}
A saída será 5. Campos e blocos são executados primeiro e na ordem, a variável
number recebe o valor 3 de depois 4. A seguir o construtor é executado e a variável
number recebe o valor 5.