Seja bem-vindo a série de postagens sobre a certificação Java. Como funciona, o que fazer para comprar, marcar o dia da prova e o principal, o que estudar.
Para ver o índice da série e as datas das publicações, acesse este link
Parte 2 – Java básico
Neste post, vamos iniciar os estudos pelo básico da linguagem focando no que é exigido na prova.Objetivos do exame
- Estrutura de uma classe Java
- Criando um programa executável
- Importando outros pacotes
- Escopo de variáveis
- Conhecendo a plataforma
- Declarando e inicializando variáveis
- Variáveis primitivas e referência de objeto
- Ciclo de vida de um objeto
Estrutura de uma classe Java
Classes Java são a definição e o comportamento do que será representado posteriormente por uma instancia desta classe (objeto). Os elementos primários de uma classe Java são os campos (variáveis) e os métodos. Juntos, estes elementos são chamados de membros da classe. Uma classe Java simples é definida assim:
public class Person {
}
Como em outras linguagens, o Java possui as suas palavras chave. Na classe acima podemos observar duas palavras chave. A palavra-chave public indica que a classe pode ser utilizada em outras classes. A palavra-chave class indica a definição da classe e Person o nome da classe.
public class Person {
String name;
}
No exemplo acima, estamos definindo uma variável chamada name. Para dar acesso a esta variável, podemos criar os métodos getters and setters.
public class Person {
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
String name;
}
Neste outro exemplo, nossa classe está mais completa, disponibilizando métodos de acesso a nossa variável name. Nossos métodos possuem parâmetros e retorno.
Criando um programa executável
Todo programa Java se inicia no método main(). O método main é um método especial interpretado pela JVM quando se invoca o comando java + nome da classe. A JVM irá procurar um método main na classe e caso não encontre, ela emitirá um erro.
class Person {
public static void main(String[] args) {
System.out.println("Hello Person!!");
}
}
Nossa classe Person com o método main definido. Agora já podemos compilar e executar a nossa classe Person:
$ javac Person.java$ java Person
O código acima deverá compilar e em seguida executar a classe Person. Caso não tenha conseguido compilar, verifique se esta tudo ok com a instalação do JDK.
A saída da execução da classe Person deve ser “Hello Person!!” conforme foi especificada pela instrução println. Note que no comando java não preciso informar a extensão do arquivo.
Perceba que o método main() possui um parâmetro com um array de Strings (String[] args). Este parâmetro serve para que possamos passar argumentos para o nosso programa. A variável args é um padrão, porem podemos utilizar qualquer nome válido.
Perceba que o método main() possui um parâmetro com um array de Strings (String[] args). Este parâmetro serve para que possamos passar argumentos para o nosso programa. A variável args é um padrão, porem podemos utilizar qualquer nome válido.
public static void main(String[] args) {
System.out.println("Hello " + args[0]);
}
Nosso método main modificado para exibir o parâmetro zero no console. Lembre-se de que arrays iniciam em zero.
$ javac Person.java$ java Person student
A execução acima irá imprimir “Hello student” no console. O que acontece não passar nenhum parâmetro ou mais de um parâmetro? Caso não passe nenhum parâmetro, irá ocorrer uma exceção em tempo de execução (java.lang.ArrayIndexOutOfBoundsException), pois o programa espera alguma informação na posição zero do array. Caso passe mais de um parâmetro, será impresso o parâmetro zero apenas.
Classes e arquivos
Normalmente uma classe Java é salva em um arquivo *.java e é definida como public. Não é obrigatório que a classe seja pública. Você ainda pode ter várias classes dentro de um mesmo arquivo java, porém apenas uma delas pode ser public. Se uma classe é definida como public, obrigatoriamente, o nome do arquivo deve ser o mesmo da classe. Ex:
class Person {
}
O arquivo não precisa ser obrigatoriamente Person.java, pois não esta declarada como public.
public class Person1 {
}
O arquivo acima deve se chamar Person1.java, caso contrário, o compilador irá emitir a seguinte mensagem: “class Person1 is public, should be declared in a file named Person1.java”
Importando pacotes
Pacotes em Java são uma forma de organizar as classes em diretórios. Como o Java possui milhares de classes, então estas ficam divididos em pacotes. E para que possamos utilizar classes de pacotes diferentes em nossas classes, precisamos dizer ao Java que queremos importar a classe do pacote em que ela se encontra. Também podemos ter várias classes com o mesmo nome, então uma forma de identificar a classe é pelo nome completo composto pelo nome do pacote mais o nome da classe.
public class Person {
public static void main(String[] args) {
List address = new ArrayList();
}
}
O exemplo acima não compila, pois como as classes List e ArrayList não estão no mesmo diretório da classe Person, o Java não consegue encontrá-las. Estas duas classes pertencem a API do Java e estão no pacote java.util. Ao tentar compilar a classe acima, deverá receber um erro do tipo: error: cannot find symbol. Para resolver o problema, indique ao Java que deseja importar as classes List e ArrayList do pacote java.util
import java.util.ArrayList;
import java.util.List;
public class Person {
public static void main(String[] args) {
List address = new ArrayList();
}
}
Agora nossa classe deve compilar sem problemas. A principal estrutura das classes Java do JDK inicial com java ou javax e uma boa forma de se conhecer a API é consultando a sua documentação:
https://docs.oracle.com/javase/8/docs/api/
Também é possível a utilização de "curingas" nas instruções de import. Ex:
import java.util.*;
A instrução acima está importando as classes ArrayList e Array do pacote java.util e todas as demais classes deste pacote. As duas abordagens serão cobradas no exame.
Importações redundantes
O Java importa automaticamente para nós o pacote java.lang, porém podemos ainda importar em nossa classe que a mesma irá compilar sem problemas. No código abaixo, podemos ver alguns imports redundantes:
import java.util.*;
import java.util.List;
import java.util.ArrayList;
import java.lang.*;
import java.lang.System;
public class Person {
public static void main(String[] args) {
List address = new ArrayList();
System.out.println(address.size());
}
}
A linha 1 não é necessária, pois estamos importando as classes necessárias logo abaixo nas linhas 2 e 3. As linhas 4 e 5 não são necessárias porque o Java importa automaticamente.
Importações inválidas
Podemos importar apenas as classes de um pacote utilizando o curinga. Não serão considerados os pacotes filhos. Ex: temos o pacote zip dentro de java.util onde importamos as classes List e ArrayList. Ao utilizar o import import java.util.*; não estaremos importando as classes do pacote java.util.zip.
import java.util.*;
public class Person {
public static void main(String[] args) {
ZipFile zipFile = new ZipFile("rt.jar");
}
}
O código acima não compila, pois a classe ZipFile esta no pacote java.util.zip e não no pacote java.util conforme estamos importando todas as classes. Para este código compilar, devemos colocar o pacote correto onde se encontra a classe ZipFile ou importar a classe explicitamente.
import java.util.zip.*; import java.util.zip.ZipFile;As duas formas acima são válidas, porém o import da linha 1 é desnecessário.
Precedência de imports e conflitos
Imagine que queremos utilizar a classe Date do Java. Ela esta presente nos pacotes java.util e java.sqlimport java.util.*;
import java.sql.*;
public class Person {
public static void main(String[] args) {
Date date = new Date();
}
}
Ao tentar compilar o código acima, teremos um erro "reference to Date is ambiguous. both class java.sql.Date in java.sql and class java.util.Date in java.util match" Pois o Java não sabe qual classe Date utilizar. Podemos resolver o problema desta forma:
import java.util.*;
import java.sql.*;
import java.util.Date;
public class Person {
public static void main(String[] args) {
Date date = new Date();
}
}
Os dois primeiros imports são desnecessário, porém eles podem estar em uma pergunta da prova. O código agora compila e o nosso programa estará utilizando a classe Date do pacote java.util. Como ele foi importado explicitamente, o java ignora as duas importações anteriores.
Agora, se fizermos o import da classe Date do pacote java.sql, teremos o mesmo problema de antes quando o Java não saberá qual das classe Date ele deverá considerar.
import java.util.Date;
import java.sql.Date;
public class Person {
public static void main(String[] args) {
Date date = new Date();
}
}
O código acima não compila. Qual Date devo utilizar? "error: a type with the same simple name is already defined by the single-type-import of Date"
Para o exame, não é necessário decorar os pacotes das classes da API Java, mas é bom você conhecer as principais. E como eu faria para utilizar as duas classes Date no meu código? Existem duas formas:
1 - Deixar apenas um import de Date e na sua variável, utilizar o nome completo da classe
2 - Em ambos os casos, utilizar o nome completo da classe
import java.util.Date;
public class Person {
public static void main(String[] args) {
Date date = new Date();
java.sql.Date sqlDate = new java.sql.Date(1L);
} }Forma 1.
public class Person {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
java.sql.Date sqlDate = new java.sql.Date(1L);
}
}
Forma 2.Criando seus próprios pacotes
Na vida real, temos que separar nossas classes em vários pacotes para melhor organização. Então vamos criar dois pacotes para acomodar nossas classes. Vamos supor que o nosso projeto esta no diretório "/tmp/project1" Crie dois diretórios "domain" e "service"
/tmp/project1├── domain
└── service
Dentro do diretório domain, crie a classe Person.java e dentro do diretório service, crie a classe PersonService.java
package domain;
public class Person{
}
package service;
import domain.Person;
public class PersonService {
public static void main(String[] args) {
Person p = new Person();
System.out.println("Person created!");
}
}
Para compilar as duas classes:$ javac domain/Person.java service/PersonService.java
Executando a classe PersonService:
$java service.PersonService
Person created!
Criando Objetos
Objetos são instâncias de classes, então você vai precisar saber como se comporta um objeto na sua inicialização.
Construtores
Para criar uma instancia de uma classe, utilizamos a palavra new antes do nome da classe:
Person p = new Person();
Primeiro declaramos o tipo da variável, seguida pelo nome da variável. Após o sinal de igual, estamos associando uma nova instancia de Person na variável p.
Perceba que utilizamos Person() com parenteses. Isso indica que utilizamos um método. Neste caso um método especial chamado construtor. Porém na nossa classe Person, não definimos nenhum método ou construtor. Neste caso, o Java cria um construtor padrão para nós. Este construtor (método) deve ser publico e sem um tipo de retorno. O nome do método deve ser o mesmo nome da classe:
public class Person{
public Person() {
System.out.println("create a new Person");
}
}
Agora se compilarmos as nossas classes e rodarmos a classe PersonService, teremos a seguinte saída:
$ java service.PersonService
create a new Person
Person created!
Preste atenção no exame, pois podem querer te confundir com algum método que não é um construtor:
public void Person() {
System.out.println("this is not a constructor");
}
O método acima não tem problema algum, porém ele não é um construtor. O objetivo dos construtores é inicializar variáveis, porem pode-se fazer outras coisas dentro dele.
Lendo e escrevendo em variáveis
Seus objetos tem atributos e comportamentos. Os atributos são as variáveis e os comportamentos os métodos. Podemos inicializar as variáveis na própria declaração ou através do construtor.
public class Person{
String name = "Person";
int age;
public Person() {
age = 33;
}
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.name);
System.out.println(p.age);
}
}
No exemplo acima, estamos criando uma nova instancia de Person. Ao passar pelo construtor, é setada a variável age com o valor 33. A variável name já foi setada em sua criação e está disponível com o valor já setado dentro do construtor. A saída do código acima é:
Person33
Após atribuídas as nossas variáveis pelo construtor e na criação da variável, ainda podemos alterar os valores após a criação da instancia.
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.name);
System.out.println(p.age);
p.age = 22;
p.name = "Student";
System.out.println(p.name);
System.out.println(p.age);
}
Veja que após criar o objeto e imprimir os valores, alteramos os valores e em seguida imprimimos novamente. Agora a saída deverá ser:
Person33
Student
22
É bem comum termos perguntas deste tipo no exame. Outra questão não muito comum no dia a dia, mas que aparece no exame, são os blocos de inicialização:
public class Person{
String name = "Person";
int age;
public Person() {
age = 33;
name = "Director";
}
{
name = "Student";
}
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.name);
System.out.println(p.age);
}
}
E agora, o que acontece se compilarmos e executarmos este código? Uma das perguntas na prova é se ele compila. Sim, este código compila e a saída é:
Director33
Como as variáveis são inicializadas antes do construtor, então podemos supor que a variável name foi inicializada com "Person", após foi encontrado um bloco de inicialização que alterou para "Student" e finalmente passou pelo construtor que alterou para "Director".
Outro detalhe pouco comum é que os blocos de inicialização são executados em ordem de declaração. Faça os testes colocando blocos de inicialização em diferentes locais da classe.
Outro ponto pouco comum é termos um bloco dentro de um método:
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.name);
System.out.println(p.age);
{
p.name = "CEO";
}
System.out.println(p.name);
}
O bloco acima compila sem problemas e altera a variável name para "CEO". Muita atenção em um detalhe:public class Person {
{
name = "Person";
}
String name;
int age;
public Person() {
age = 33;
}
public static void main(String[] args) {
Person p = new Person();
System.out.println(p.name);
System.out.println(p.age);
}
}
O código acima compila, por mais que o bloco de inicialização esteja acima da declaração da variável. Porem não se pode utilizar a variável.
{
name = "Person";
System.out.println(name);
}
O código acima não compila, pois a variável name ainda não foi declarada. Caso use o mesmo bloco abaixo da declaração da variável, o código irá compilar normalmente:
String name;
{
name = "Person";
System.out.println(name);
}
Referencia de Objetos e tipos primitivos
Tipos primitivos
No Java, temos dois tipos de dados, sendo que oito deles são primitivos. O exame exige que você saiba quem são eles, o tamanho e o que pode ser gravado neles. Estude bem esta parte através do tutorial disponibilizado pela Oracle no link abaixo:
https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
Para o exame, não é preciso memorizar o tamanho que pode ser atribuído em cada tipo numérico primitivo, porém você deve saber que um int não pode ser atribuído em um short ou em um byte. A atribuição de um número é chamada de literal. Na declaração abaixo estamos utilizando o literal 123 para atribuir a uma variável do tipo int.
int a = 123;Apenas de um byte suportar até o número 127, não é possível fazer a atribuição abaixo:
int a = 123; byte b = a; //erro de compilação
A atribuição somente é possível se realizarmos uma conversão, indicando ao Java que se deve converter a variável "a" em byte antes de atribuir a variável "b":
byte b = (byte) a;
Esta conversão é chamada de "Cast" e será vista em mais detalhes em breve. Para associar valores literais ao tipo long, devemos informar no literal qual tipo ele se refere, mas somente no caso do literal (que é um int) não tiver o tamanho suficiente.
O valor máximo de int é 2147483647 (231-1). O Java possui constantes com estes valores. Para saber o valor máximo, utilize Integer.MAX_VALUE
long b = 2147483647; //OK long c = 2147483648; //Erro de compilação
A variável c ultrapassou o valor máximo de int, então é preciso informar que é um literal do tipo long. Para fazer o código compilar, basta completar o literal com a letra (L)
long c = 2147483648L; //OKPose-se utilizar o (L) minúsculo, porem ficará quase impossível de diferenciar do número 1.
long c = 2147483648l; //OK long d = 21474836481; //Erro
A partir da versão 7, foi adicionado uma funcionalidade aos literais Java. Agora é possível utilizar o (_) underscore para separar números. O único objetivo desta função é melhorar a leitura.
Podemos adicionar o underscore em qualquer lugar, exceto no início de um literal, o final de um literal, antes de um ponto decimal, ou logo após um ponto decimal. Abaixo a documentação oficial a respeito dos Underscores em literais.
Referência de Objetos
Quando criamos objetos em Java, as referências (variáveis) não apontam diretamente para o Objeto em memória, mas sim para o endereço de memória onde este objeto foi alocado. Por este motivo é que podemos criar um objeto e apontar outras variáveis para este mesmo endereço de memória.
Date d1 = new Date(); Date d2 = d1;
Ambas variáveis de referencia acima apontam para o mesmo endereço de memória.
Tipos primitivos não possuem métodos e também não podem ser definidos como "null".
Declaração de variáveis
Podemos declarar e inicializar múltiplas variáveis em uma linha.String name, lastName; int age = 30, addressNum = 70;Não podemos declarar em uma mesma linha, tipos diferentes.
String name, int age; //erro de compilaçãoMesmo sendo de tipos iguais, não se pode repetir os tipos na mesma linha, pois o Java não permite.
String name, String age; //erro de compilaçãoVocê ainda poderá encontrar no exame, algo do tipo:
String name; int age; //validoA declaração acima é valida pois não esta usando virgula (,) mas sim ponto e virgula (;)
Identificadores
Identificadores podem ser aplicados em variáveis, métodos, classes e campos. Existem três regras básicas para definir identificadores válidos.
- O nome deve começar com uma letra ou o símbolo $ ou _
- Caracteres subsequentes podem ser números
- Não podem ser utilizadas palavras reservadas do Java.
https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
Por mais que seguimos as convenções do Java quanto a nomes de métodos, classes e variáveis, no exame podem aparecer códigos que não o seguem.
Inicialização padrão das variáveis
Algumas variáveis tem deu valor padrão inicializado automaticamente, porém existem algumas regras que devemos saber.
Variáveis locais
Uma variável local é aquela definida dentro de um método, e deve ser inicializada explicitamente antes de ser utilizada. Caso contrário o código não irá compilar.
void invalidInit(){
int a;
System.out.println(a); //não compila
}
Variáveis que estão fora dos métodos são consideradas variáveis de instancia ou de classe. Variáveis de instancia não precisam ser inicializadas explicitamente. Elas irão receber um valor default quando o a classe for instanciada. Você precisa saber quais são estes valores default, conforme a tabela abaixo:
| Tipo | Valor padrão |
| boolean | False |
| byte , short , int , long | 0 |
| float , double | 0.0 |
| char | '\u0000' (NUL) |
| Object | null |
Escopo de variável
Variáveis locais são aquelas que existem dentro de um método ou escopo. Parâmetros de métodos também são consideradas variáveis locais.public int calcAge(LocalDate birthDate) {
LocalDate currentDate = LocalDate.now();
int age = Period.between(birthDate,
currentDate).getYears();
return age;
}
No exemplo acima temos 3 variáveis locais (birthDate, currentDate e age). A variável local ainda pode existir dentro de um escopo menor. Ex:
if (age == 0){
int months = Period.between(birthDate,
currentDate).getMonths();
}
A variável months só existe dentro do if declarado acima. Caso tente utilizar ela fora deste escopo, teremos um erro de compilação.
Pratique bastante escrevendo códigos que tenham variáveis locais dentro de métodos, ifs, for e while.
Garbage Collection
Um item que não nos preocupamos muito, porém é cobrado na prova, é quando um objeto estará elegível para ser coletado pelo GC (Garbage Collector). O GC é um processo automático que liberada a memória de objetos que não possuem mais referência. Ou seja, ninguém mais aponta para aquele endereço de memória. Embora ele seja automático e você não sabe quando ele será executado, pode-se invocar o método System.gc().
A chamada deste método não garante que será executado o GC naquele momento. É apenas um pedido para a JVM, que também pode ser ignorado. O que você deve saber para a prova é quando um objeto estará elegível para ser processado pelo GC, o que pode ocorrer em duas situações:
- O objeto não tem mais nenhuma referência apontando para ele.
- Todas as referências ao objeto ficaram fora do escopo.
Esta é uma boa oportunidade para se usar a caneta e "papel" disponibilizados para a prova. Saiba diferenciar uma referência de um objeto. Abaixo uma parte da documentação que você pode se aprofundar:
https://docs.oracle.com/javase/tutorial/java/javaOO/objectcreation.htmlfinalize()
A classe Object possui o método finalize(). Portanto todas as classes herdam este método. O método será invocado pelo GC quando o objeto estiver elegível para ser excluído da memória. Este método poderá ser chamado uma vez ou nunca ser chamado.
Benefícios do Java
Uma questão teórica presente na prova é referente aos benefícios de se utilizar o Java. Você deve estar preparado para responder perguntas como:
Java é uma linguagem orientada a objetos? Possui encapsulamento? É independente de plataforma? É robusta, simples e segura?
Bons estudos e até a próxima!
Comentários
Postar um comentário