Oracle Certified Associate - Java Programmer I - aula 3

Java Certiﬁed Associate
Jose Berardo
www.especializa.com.br/curso/oca-javaassociate

Agenda
Macrotemas do curso:

1. Introdução às certiﬁcações Java
2. Iniciando com Java
3. Tipos de dados e seus detalhes
4. Expressões e construções
5. Usando arrays e coleções
6. Construções de laço
7. Classes, construtores e métodos
8. Herança e polimorﬁrsmo
9. Manipulação de exceções
10. Aplicações Java

Exercício 1:
What will happen when you compile and run the following code?
public class ScopeClass{
private int i = 35;
public static void main(String argv[]){
int i = 45;
ScopeClass s = new ScopeClass();
s.someMethod();
}
public static void someMethod(){
System.out.println(i);
}
}

A. 35 will be printed out
B. 45 will be printed out
C. A compile time error will be generated
D. An exception will be thrown

Exercício 2:
Which of the following lines will compile without warning or error?
A. char d="d";
B. ﬂoat f=3.1415;
C. int i=34;
D. byte b=257;
E. boolean isPresent=true;

Exercício 3:
Given the following declaration:
public class SomeClass{
public int i;
public static void main(String argv[]){
SomeClass sc = new SomeClass();
// Comment line
}
}

Which of the following statements are correct if they replace the comment
line?
A. System.out.println(i);
B. System.out.println(sc.i);
C. System.out.println(SomeClass.i);
D. System.out.println((new SomeClass()).i);

Exercício 4:
Given the following declaration:
StringBuilder sb = new StringBuilder();

Which of the following are valid uses of the sb variable?
A. sb.append(34.5);
B. sb.deleteCharAt(34.5);
C. sb.toInteger(3);
D. sb.toString();

Exercício 5:
Which of the following will return the position of the ﬁrst letter a where the
string s contains "banana"?

A. lastIndexOf(2,s);
B. s.indexOf('a');
C. s.charAt(2);
D. indexOf(s,'v');

Exercício 6:
Given the following code, which expression displays the word "Equal"?

String s1="Java";
String s2="java";
if(expression) {
System.out.println("Equal");
} else {
System.out.println("Not equal");
}

A. s1==s2
B. s1.matchCase(s2)
C. s1.equalsIgnoreCase(s2)
D. s1.equals(s2)

Agenda
3. Tipos de dados de seus detalhes

3.1. Como Java manipula dados
3.2. Variáveis
3.3. Tipos primitivos
3.4. Objetos, wrappers e autoboxing
3.5. Literais, constantes e enums
3.6. Unicode, Character e CharSequence
3.7. Strings
3.8. StringBuffer e StringBuilder

Como Java manipula dados
Memória Heap:
Região de memória onde a VM carrega os objetos e aloca dinamicamente
espaços para seus estados
O Heap Manager controla como isso é feito
Quando um objeto não é mais acessível, o Garbage Collector poderá
apagá-lo
Antes de detonar o objeto, a VM chama seu método ﬁnalize()
Memória Stack:
Local onde parâmetros e variáveis locais a métodos são armazenados
Quando o método sai da pilha de chamadas, esses valores são apagados

Como Java manipula dados
Toda variável instância de uma classe é dita variável de tipo referência:
Cliente c; // c é uma variável do tipo Cliente
c = new Cliente(); // c referencia um novo objeto Cliente
Cliente d = c; // d possui a mesma referência de c
d.nome = "Duke"; // O nome de d foi alterado (String é classe)
System.out.println(c.nome); // "Duke". Alteração afeta c

Variáveis
Variáveis podem ser:
Instance variables: Atributos de objeto dinamicamente alocados
Static variables: Atributos de classe estaticamente alocados (static)
Local variables / Automatic variables: Variáveis locais a métodos
Identiﬁcadores:
Só admitem letras, números, underscores (_) e cifrões ($)
Não podem ser iniciados por números
Por convenção, variáveis são identiﬁcadas por termos com iniciais
maiúsculas a partir da segunda palavra

Variáveis locais
Três passos na utilização de variáveis locais (declarada dentro de um
método):

Declaração
int a;

Inicialização
a = 5;

Utilização
System.out.println(a);

Variáveis locais
Chaves demarcam blocos de código
Declarações dentro de bloco não são visíveis fora do bloco
{
int a;
}
a = 10; // ilegal, a não existe fora do bloco

Declarações fora do bloco são visíveis internamente
int a, b;
{
a = 10;
int b = 20; // ilegal, b não pode ser redeclarado
}

Tipos primitivos
Há 4 tipos primitivos inteiros com sinal:
byte
8 bits – 1byte
Representa de -128 a 127
short
16 bits – 2 bytes
Representa de -32.768 a 32.767
int
32 bits – 4 bytes
Representa de -2.147.483.648 a 2.147.483.647
long
64 bits – 8 bytes
Representa aproximadamente de -9 a 9 quintilhões

Tipos primitivos - inteiros
Todo literal inteiro é um int
int i = 10;
Literais em atribuições simples (=) são convertidos para o tipo
correspondente
byte b = 10;
byte b = 128; // ilegal, não cabe em um byte
short s = 10;
int i = 10;
long l = 10;
Um literal é um long se sucedido de l ou L
long a = 10L;
int a = 10L; // ilegal

Primitivos - pontos flutuantes
Há 2 tipos primitivos de ponto flutuante
float
32 bits – 4bytes
Representa +- 3.40282347E+38F
double
64 bits – 8 bytes
Representa +- 1.7976931348623157E+308D

Literais ponto flutuante são sempre double
float precisa de F ou f, double aceita d ou D
double d = 3.14D;
double d = 3.14;
float f = 3.14F;
float f = 3.14; // ilegal 3.14 é double

Tipos primitivos - char
Há um tipo primitivo inteiro sem sinal
char
16 bits – 2 bytes
Representa de 0 a 65535
Representa os caracteres Unicode

Aceita números, caracteres entre aspas simples ou notações Unicode
char c = 65;
System.out.println(c); // imprime A
char c = 'A';
char c = 'u0041'; // Hexadecimal, corresponde a ‘A’
int i = 'A'; // corresponde a 65

Tipos primitivos - boolean
Tipo lógico verdadeiro ou falso
Só admite os literais true ou false
Representação interna depende da implementação da VM, mas é
irrelevante para o programador

Não pode ser convertido para nenhum outro tipo
boolean bool1 = true;
boolean bool2 = 0; // ilegal, 0 é int

Admitem resultados de operações lógicas
boolean metaCumprida = (vendas >= meta);

Tipos primitivos - promoções
Variáveis de tipos maiores podem receber tipos menores
byte b = 10;
int i = b;

Resultado de operações são do tipo do maior operando ou pelo menos int
byte b = 10;
long l = 10;
int i = 10;
l = l + i;
i = l + i; // ilegal, l é um long
b = b + b; // ilegal, operações são pelo menos int

Tipos primitivos - casting
Todos os tipos possuem casts correspondentes
int i = b;
byte b = (byte) i;

Resultado de operações podem ser moldadas para um tipo menor
byte b = 10;
long l = 10;
int i = 10;
i = (int) l + i; // l foi convertida para int
b = (byte) (b + b);
// parênteses necessários para afetar o resultado da operação

Tipos primitivos - casting
Podem provocar resultados estranhos por perda de precisão
byte b;
short s = 200;
b = (byte) s;

System.out.println(s); // 200
System.out.println(b); // -56

Tipos primitivos

8 bits 16 bits 32 bits 64 bits

Inteiro sem
char
sinal
Inteiro com
byte short int long
sinal
Ponto
ﬂoat double
ﬂutuante

Promoções automáticas
Castings explícitos

Tipos primitivos - denorex
“Parece mais não é...”
BigDecimal
Objetos para manipulação de números grandes
Utilizam pontos decimais, mas é melhor trabalhar com construtores que
recebem strings
São imutáveis
Mais difíceis de trabalhar
String
Parece primitivo, você cria objetos sem dar new, mas são objetos
Wrappers
Objetos imutáveis que encapsulam primitivos

Wrappers
São usados em coleções ou outros lugares onde só objetos são permitidos
Classes wrappers e seus respectivos tipos empacotados:
Boolean - boolean
Byte - byte
Character - char *
Short - short
Integer - int *
Long - long
Float - ﬂoat
Double - double
Sabe lá por que cargas d’água eles não se chamam Char e Int como sugerem
os demais

Wrappers
Embora haja relação em os tipos primitivos, não há relação entre as classes
Exceto Boolean e Character, todas as classes herdam de Number

Métodos estáticos utilitários
A classe mãe Number declara diversos métodos estáticos e abstratos:
parseByte(String) parseShort(String)
parseInt(String) parseLong(String)
parseFloat(String) parseDouble(String)
Cada classe wrapper redeﬁne (override) seu método especíﬁco
Possuem construtores que recebem valores de tipos respectivos
Possem métodos convenientes como Intege.intValue()
Retornam o valor primitivo empacotado

Autoboxing e unboxing
Autoboxing é o processo de criação automática do objeto que empacota o
tipo primitivo:
Character c = 'A'; // A é tipo primitivo char. Isso equivale a:
Character c = new Character('A');

Unboxing é o processo reverso. Revela o primitivo por dentro do objeto
Character c = new Character('A');
char meuChar = c; // Isso equivale:
char meuChar = c.charValue();

Não admitem erro de tipo (Não há relação hierárquica entre essas classes):
Integer i = 10; // Correto
Integer i = 10L // Errado

Wrappers - dicas
Objetos poder ser nulos, mas tipos primitivos não
Integer iObj = null;
int i = iObj; // NullPointerException
int i = iObj.intValue();

Comparações Dois primitivos Dois objetos Ambos

Tratados como dois
a == b Simples comparação Compara referências
primitivos, unboxing

Compara igualdade do Não compila se a for
a.equals(b) Não compila valor primitivo primitivo, do contrário
empacotado compara valores

Literais, constantes e enums
Literais são valores absolutos (imutáveis) usados todo o tempo
boleanos: true / false
números: 10, 049, 0x35, 23.5F, 3.14D, 35.05E10
caracteres: 65, ‘a’, ‘u0043’,
strings: “eita”

Literais devem ser compatíveis com o tipo
int i = 10L; // Errado
long l = 10;
long l = 999999999999; // Errado, use o L porque o número extrapola um int

Constantes são identificadores de valores que não podem variar
São “variáveis” que só admitem uma única atribuição

São declaradas usando a palavra reservada final
final double PI = 3.14;

Por convenção, identificadores de constantes são expressos totalmente em letras
maiúsculas
final String CONSTANTE = "Minha constante";

Palavras são normalmente separadas pelo caractere underscore
final String MINHA_CONSTANTE = "É minha e eu não empresto!";

O compilador não permite uma segunda atribuição a uma constante:
public class Constantes {
final String CONSTANTE_ERRADA1; // ERRO: Não inicializada
final String CONSTANTE_ERRADA2 = "Até agora tá tudo certo";
final String CONSTANTE_ERRADA3;

final String CONSTANTE_CERTA1; // Inicializada só no construtor
O compilador
acusa o erro no
final String CONSTANTE_CERTA2 = "Tudo certo aqui";
construtor
public Constantes() {
CONSTANTE_CERTA1 = "Não há nada de errado aqui";
final double PI = 3.14; // até aqui tudo certo com PI
PI = 3.15; // errado porque PI já recebeu valor
}

public void metodo() {
CONSTANTE_ERRADA2 = "A constante não pode receber novo valor";
CONSTANTE_ERRADA3 = "Constante de classe não pode " +
"receber valor em métodos";
}
}

Enumerations são objetos de classes que herdam de java.lang.Enum
Determinam quais os objetos podem existir a partir de uma classe
As classes são construídas com a palavra reservada enum no lugar de class
public enum Direcoes {NORTE, SUL, LESTE, OESTE}
minhaBussola.setDirecao(Direcoes.NORTE);

Classes enum, possuem o construtor SEMPRE private e herdam os métodos:
valueOf(String) - Retorna um enum a partir de uma string passada
values() - Retorna um array com os objetos enum

Objetos Enum métodos como:
ordinal() - Retorna o índice numérico da ordem de declaração do enum
No exemplo acima NORTE é 0, SUL é 1 e assim por diante
name() - Retorna o nome da constante como uma string

Enums implementam o padrão de projeto Type Safe Enum
public class TamanhoTSE {
public static final TamanhoTSE GRANDE = new TamanhoTSE(3);
public static final TamanhoTSE MEDIO = new TamanhoTSE(2);
public static final TamanhoTSE PEQUENO = new TamanhoTSE(1);
private int num;
private TamanhoTSE(int num) {
this.num = num;
}
public int getNum() { return this.num; }
}

enum TamanhoEnum {
GRANDE(1), MEDIO(2), PEQUENO(3);
O construtor é private int num;
private por padrão
TamanhoEnum(int num) {
this.num = num;
}
public int getNum() { return this.num; }
}

Unicode
Tabela de codiﬁcação baseada na antiga tabela ASCII, de 7 bits
Seus 128 primeiros caracteres são os mesmos da ASCII

É representada em Java pelo tipo char, capaz de catalogar 65.536 caracteres
No entanto, sua versão atual (6.2) ultrapassa os 110 mil caracteres
O char representa os mais comuns deles

Exemplo de uso do tipo primitivo char
char c = 65;
System.out.println(c); // Sai A

Desde o Java 5, é possível utilizar o tipo int em alguns métodos de classes que
lidam com caracteres como Strings

Character
Classe wrapper que empacota valores primitivos char
Abrange o padrão Unicode versão 4.0
Declara alguns métodos interessantes:
isDigit() - true se o caractere for um número
isLetter() - true se o caractere for uma letra
isLetterOrDigit() - true se for um dos dois
isLowerCase() - true se o caractere for letra em minúsculo
isSpace() - true se for um espaço
isUpperCase() - true se estiver em caixa alta
toLowerCase() - retorna o equivalente em caixa baixa
toUpperCase() - retorna o equivalente maiúsculo

CharSequence
A API traz mais de uma classe que coleciona caracteres
java.lang.CharSequence é uma interface que determina o comportamento
básico de coleções de caracteres
String, StringBuffer e StringBuilder são as três principais implementações da
interface CharSequence. Por isso deﬁnem os seguintes métodos:
length() - Tamanho da sequência de caracteres
charAt(int) - Caractere na posição fornecida
subSequence(int start, int end) - CharSequence contendo o trecho entre start
(incluído - intervalo fechado) e end (excluso - intervalo aberto)

Strings
Strings são coleções de caracteres imutáveis
Nenhum método de java.lang.String modiﬁca o teor do char[] value que cada
String carrega
Ou seja, os métodos de String retornam novas strings em vez de manipular a
original:
String s = "um exemplo";
System.out.println(s.toUpperCase()); // retorna a versão em maiúsculo
System.out.println(s); // nada foi alterado na String original

Strings
Strings são normalmente criadas utilizando as aspas
String s = "exemplo"; aqui, dois
objetos String
Podem também utilizar o operador new foram criados
String s = new String("exemplo"); 0 é 'a'
2 é 'c’
String s = new String(new char[] {'a', 'b', 'c'}); Só entram 0 e 1 na
String ﬁnal
String s = new String(new char[] {'a', 'b', 'c'}, 0, 2);
Existem outros construtores ainda menos usuais
Novas strings criadas diretamente entre as aspas são armazenadas em uma área
de memória chamada Pool de Strings
Sempre que o sistema precisar da mesma String ele vai recuperar do pool
Essa reutilização transparente do objeto reduzem overhead, mas só podem
ser feitas quando eles são imutáveis
Strings criadas a partir do new nunca usam o pool

Igualdades entre Strings
O operador == checa se as variáveis apontam para o mesmo objeto, ele pode
provar quando a VM utiliza o pool e quando cria um objeto em uma área nova

String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
String s4 = new String(new char[] {'a', 'b', 'c'});
String s5 = new String(new char[] {'a', 'b', 'c'});
String s6 = new String(s1);

System.out.println(s1 == s2); // true - uso do pool
System.out.println(s1 == s3); // false - uma do pool outra não
System.out.println(s1 == s4); // false - idem
System.out.println(s1 == s5); // false - idem
System.out.println(s1 == s6); // false - idem, mesmo que uma seja argumento
// do construtor da outra
System.out.println(s4 == s5); // false - construídas da mesma forma,
// mas fora do pool

Igualdades entre Strings
Utilize o método equals() para checar a igualdade do teor interno das Strings
Utilize equalsIgnoreCase() para checar a mesma igualdade desprezando
diferenças de maiúsculos e minúsculos

String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
String s7 = s1.toUpperCase();
String s8 = "aBc";

System.out.println(s1.equals(s2)); // true, já eram o mesmo objeto
System.out.println(s1.equals(s3)); // true, dois objetos de mesmo teor
System.out.println(s1.equals(s7)); // false, caracteres diferentes
System.out.println(s1.equalsIgnoreCase(s2)); // true óbvio
System.out.println(s1.equalsIgnoreCase(s7)); // true
System.out.println(s1.equalsIgnoreCase(s8)); // true

Operações com Strings
O operador + concatena Strings, o método concat() também:
String a = "existem 10 tipos de pessoas ";
String b = "as que sabem e as que não sabem binários";
System.out.println(a + b);
System.out.println(a.concat(b));

Se a variável a estivesse nula, o método concat() daria uma exceção de Runtime
NullPointerException, mas o operador concateria b com a string null
String a = null;
String b = "teste";
System.out.println(a + b); // nullteste
System.out.println(a.concat(b)); // NullPointerException

Mais comparações com strings
startsWith(String) - true se a String iniciar com a String passada
endsWith(String) - true se a String terminar com a String passada
compareTo(String) - Método comumente chamado pelas árvores para
classiﬁcar a ordem das strings
retorna -1 se a string principal deve vir primeiro na ordem Unicode
retorna 1 se a string principal deve vir depois na ordem Unicode
retorna 0 se as strings são iguais (mais uma forma de checar igualdade)

compareToIgnoreCase(String) - mesmo que o anterior mas sem fazer
distinção entre maiúsculos e minúsculos

length() - recupera o tamanho da string
charAt(int) - retorna o caractere da posição informada
substring(int start) - retorna a string a partir de start até o ﬁnal
substring(int start, int end) - retorna a string de start até end
Levanta IndexOutOfBoundsException se end for maior que a string ou
menor do que start e ainda se start for negativo
indexOf(String) - posição da primeira ocorrência da string na principal
indexOf(int) - posição da primeira ocorrência do caractere referente ao
número informado na string principal
Até o Java 5, o valor aqui era um char. A troca pra int se deve à
possibilidade de buscar caracteres posteriores ao padrão Unicode 4.0
indexOf(String, int pos) - só começa a procurar a partir de pos

lastIndexOf(String) - possui as mesmas sobrecargas de indexOf(), mas
procura a última ocorrência em vez da primeira
replace(char antigo, char novo) - Troca todas as ocorrências de antigo por
novo
replace(CharSequence antigo, CharSequence novo) - Troca todas as
ocorrências de antigo que é uma String ou outro CharSequence por novo
Os métodos replaceAll() e replaceFirst() têm a funcionalidades
semelhantes, mas carregam o engenho de expressões regulares, assunto
da prova OCP - Java Programmer II
toLowerCase() - String original toda em letras minúsculas
toUpperCase() - String original toda em letras maiúsculas

Conversões números x Strings
Classes wrappers possuem métodos estáticos que recuperam um valor
numérico a partir de uma String
int num1 = Integer.parseInt("123");
double num2 = Double.parseDouble("3.14");

A classe String possui método estático valueOf() que recupera strings a partir
de números
String s1 = String.valueOf(123);
String s2 = String.valueOf(3.14);

Operações entre números e strings geram novas strings concatenadas
String resultado = 10 + "10"; // resultado "1010"

StringBuffer
StringBuffers são CharSequences mutáveis, ou seja, possuem métodos capazes
de alterar a sequência de char que carregam internamente
StringBuffer sbuf1 = new StringBuffer();
StringBuffer sbuf2 = new StringBuffer("abc");
StringBuffer sbuf3 = new StringBuffer(sbuf2);
StringBuffer sbuf4 = new StringBuffer(10); // tamanho original interna

sbuf1.reverse(); // de trás pra frente, mas essa variável estava vazia
sbuf2.append("def"); // insere def no final
sbuf3.insert(1, "def"); // insere def na posição 1
sbuf4.delete(0, 1); // apaga o range de caracteres informado aqui

System.out.println(sbuf1); // vazia
System.out.println(sbuf2); // abcdef
System.out.println(sbuf3); // adefbc
System.out.println(sbuf4); // vazia
System.out.println(sbuf4.length()); // 0

StringBuilder
Classe inserida na API do Java 5
Implementa a mesma funcionalidade da StringBuffer, mas não declara seus
métodos como synchronized (thread-safe)
Threads não são assunto desta prova, mas é importante saber a diferença
entre essas classes
StringBuilder, apesar de eventualmente permitir falhas de isolamento em
ambientes concorrentes, é mais eﬁciente devido à melhor gestão de memória e
tempo de realização das operações

Objetivos cobertos
Understanding how Java handles data
Investigating the relationships between identifiers, the Java class, and memory
Defining the scope of the variables
Initializing identifiers
Building expressions using operators and operands
Working with strings
Understanding the difference between objects and primitive data types

Oracle Certified Associate - Java Programmer I - aula 3

Recomendados

Recomendados

Mais conteúdo relacionado

Mais de Jose Berardo

Mais de Jose Berardo (12)

Oracle Certified Associate - Java Programmer I - aula 3