Java cert programmer

SUN Certified Java
Programmer

@regismelo

@regismelo 1

Missão

Apresentar os tópicos da certificação SUN
Certified Programmer for Java 2 Platform

@regismelo 2

Metodologias
• Exposição e discussão teóricas;
• Simulados de cada assunto;
• Simulado geral.

@regismelo 3

O que esse curso não cobre ou não é?

Não Cobre:
• Conceitos gerais de programação – Esse não é
um curso para quem nunca programou antes;
• Conceitos gerais de orientação a objeto;
• UML;
Não é:
• Um curso para aprender Java.

@regismelo 4

O quão preparado está você?

Antes de fazer esse curso, você deverá ter feito
SSJ01 – Introdução a Java e Web
SSM01 – Introdução a UML
Ter conhecimentos de inglês técnico

Ou…
Ter trabalho com Java na plataforma J2SE;
Conhecimentos básicos de O.O.;
Conhecimentos de inglês técnico
@regismelo 5

O que é a certificação SCJP?
• Certificar conhecimentos necessários para o
desenvolvimento de aplicações usando J2SE –
Java 2 Standard Edition;

• “Primeira” prova de certificação SUN Java.

@regismelo 6

Livro adotado

@regismelo 7

Referência

@regismelo 8

Outras certificações

@regismelo 9

“Se você for incapaz de pensar
diferente, o futuro sempre
chegará com surpresa”

@regismelo 10

Language Fundamentals

@regismelo 11


Objetivos
• Identificar corretamente a estrutura de um programa
Java, declaração de pacotes, import statements,
declaração de classes (incluindo inner classes),
declaração de interfaces e implements (para as interfaces
definidas na prova), declaração de métodos (incluindo o
método main), declaração de variáveis e identificadores;

@regismelo 12


Objetivos
• Conhecer todas as palavras chave de Java e seus
identificadores;
• Conhecer a faixa de todos os tipos primitivos, declarar
valores literal para Strings e todos os tipos primitivos
usando todos os formatos, bases e representações;
• Escrever código que declare, construa e inicialize arrays
de qualquer tipo usando qualquer uma das formas
permitidas;
• Conhecer como um programa se comporta quando se
usa uma variável ou array não inicializados;

@regismelo 13


Objetivos
• Conhecer a correspondência entre os argumentos
passados na linha de comando e o método main;
• Determinar a forma pela qual objeto e tipos primitivos são
passados como parâmetro e modificados;
• Entender como o processo de Garbage Collection
funciona.

@regismelo 14


Arquivos fonte
• Todos os arquivos fonte em java terminam com a
extensão “.java”;

• Um arquivo fonte deverá conter no máximo uma
declaração pública (public class...);

• Se uma declaração de classe pública estiver presente, o
nome do arquivo fonte deverá ser igual ao nome dessa
classe (obedecendo sensitive case);

• Um arquivo fonte poderá conter um número ilimitado de
declarações não públicas;
@regismelo 15


Arquivos fonte
• Existem 3 elementos “top-level” que poderão estar
presentes em um arquivo. Nenhum deles é requerido,
porém, devem obedecer uma ordem:

– Package;
– Import;
– Class.

@regismelo 16


Arquivos fonte - Package
• Formato da declaração de um package
package <nome do pacote>;
• Arquivos definidos em packages devem estar
gravados em diretórios com o mesmo nome do
pacote
package br.com.softsite.sfc
public class Teste

* O arquivo Teste.java deve estar no diretório
/br/com/softsite/sfc

@regismelo 17


Arquivos fonte - Import
• Formato da declaração de Imports
import <pacote.*>;
Import <pacote.classe>;

• O import, ao contrário do #include do C/C++, não
inclui o conteúdo das classes importadas na
classe. Portanto o import é usado apenas como
um mecanismo para sinalizar ao compilador
onde encontrar as classes – importar um pacote
não compromete performance!

@regismelo 18


Arquivos fonte - Import
• Cuidado!
– Algumas vezes você pode ter duas classes em
pacotes diferentes com o mesmo nome. Um exemplo
disso é a classe Date, que está presente em java.util e
java.sql. Se você importa os dois pacotes e tenta usar
a classe Date o compilador gera um erro.

– Importar java.util.* não é o mesmo que importar java.*.

@regismelo 19


Arquivos fonte
// Declaração do pacote
2. package br.com.softsite.sfc;
3.
4. // Imports
5. import java.awt.Button; // importa uma classe específica
6. import java.util.*; // importa um pacote
7.
8. // Definicao da classe
9. public class Test {...}

@regismelo 20


Keywords
• A linguagem Java possui 52 palavras chave/reservadas:

assert

@regismelo 21


Identifier
• Identifier são palavras utilizadas pelo programador para
nomear variáveis, métodos, classes ou rótulos (label);
• Keywords e palavras reservadas não podem ser utilizadas;
• Devem começar por uma letra, um $ ou um undescore (_).
Os caracteres subseqüentes podem ser letras, $,
undescores ou dígitos;
• Exemplos:
String fooBar; // Ok!
int BIGinterface; // Ok! Keyword + outra palavra
float $teste; // Ok!
3_node5 // Erro!
!teste // Erro!

@regismelo 22


Tipos Primitivos
• Os tipos primitivos em Java, são:

boolean
char
byte
short
int
long
float
double

@regismelo 23


Tipos Primitivos
• Tipos primitivos e seus tamanhos

* Em java, booleanos só podem receber valores true e false.
@regismelo 24


Tipos Primitivos
• Faixas dos inteiros primitivos

* Em java, não existe o modificador “unsigned”
@regismelo 25


Tipos Primitivos
• O char é um inteiro porém sem sinal. Sua faixa varia de 0 a
216-1;
• Os caracteres em Java são unicode (ocupam 16 bits);
• Se o nove mais significantes bits de um char são zero,
então o caractere corresponde a tabela ASCII;
• Exemplo:

char a = ‘a’;
char b;
char c = ‘u4567';
char d = ‘abc’; // Erro!

@regismelo 26


Tipos Primitivos
• Os tipos primitivos com suporte a ponto flutuante são:
– float
– double
• Operações com pontos flutuante podem gerar resultados
que não podem ser expressados com números (infinito, por
exemplo), para isso existem as constantes:
– Float.NaN // NaN = Not a Number
– Float.NEGATIVE_INFINITY
– Float.POSITIVE_INFINITY
– Double.NaN
– Double.NEGATIVE_INFINITY
– Double.POSITIVE_INFINITY

@regismelo 27


Literals
• Um literal é um valor especificado no fonte do programa,
ao invés de determinado em runtime;
• Boolean literals
– true
– false
• char literals
– Sempre se utiliza aspas simples para denotá-los
– Ex: ‘R’ ou ‘u4567’

@regismelo 28


Literals
• ...char literals
– Escape characters
‘n’ – Nova linha
‘r’ – Retorno
‘t’ – Tab
‘b’ – Backspace
‘f’ – form feed
‘’’ – Aspas simples
‘”’ – Aspas duplas
‘’ – Representa a

@regismelo 29


Literals
• Integral Literals
– Podem ser representados na notação decimal, octal e
hexadecimal.
– O default é decimal.
Ex:
int i = -215; // Literal inteiro
int max = 0x7fffffff; // 2147483647 em Hexadecimal
int oct = 05402202647; // Representação octal

– Por padrão os literais inteiros ocupam 32 bits (int). Para
representar um long pode-se usar L após o número.
@regismelo 30


Literals
• Floating-Point Literals
– Para ser reconhecida como ponto flutuante a literal
deverá ter um dos seguintes formatos:

• Um ponto decimal: 1.414
• A letra E, indicando notação científica 4.23E+21
• A letra F ou f indicando que é um float: 5.12f
• O sufixo D indicando que é double: 5.12d (o default)

@regismelo 31


Literals
• String Literals
– Seqüência de caracteres delimitados por “”

• String S0 = “Sagarana Tecnologia”;
• String S1 = “Sagarana Tecnologia” + 1;
• String S2 = 1 + “Sagarana Tecnologia”;
• String S3 = 1 + 1 + “Sagarana Tecnologia”;

@regismelo 32


Arrays
• Coleção de tipos primitivos, objetos ou outros
arrays
• Para criar um array você tem que seguir os
seguintes passos:
– Declarar;
– Construir;
– Inicializar.

@regismelo 33


Arrays
• Declarando:

1. int[] ints;
2. double[] dubs;
3. Dimension dims [];
4. float[][] twoDee;

@regismelo 34


Arrays
• Outro exemplo:
1. int[] ints; // Declaração
2. ints = new int[25]; // Contrução em run-time
3. int size = 1152 * 900;
4. int[] ints = new int[size];

@regismelo 35


Arrays
• Quanto um array é declarado os seus elementos
são automaticamente inicializados:

@regismelo 36


Arrays
• Declarando e inicializando:

2. float[] diameters = {1.1f, 2.2f, 3.3f, 4.4f, 5.5f};
3. char letra = new char[] { ‘a’, ‘b’ };
4. int matriz[][] = new int[3][3];
5. int [][]matriz2 = new int[3][];

• Importante: Os arrays sempre começam do
índice zero!

@regismelo 37


Class Fundamentals
• O método main() é por onde uma aplicação inicia;
• A assinatura do método é:
public static void main( String args[] )

• O argumento passado corresponde aos
argumentos da linha de comando;
% java Classe1 Sagarana Tecnologia
// args[0] = Sagarana e args[1] = Tecnologia

@regismelo 38


Variáveis e inicialização
• Java suporta dois tipos de variáveis:

– Member/instance variable
– Automatic variable

• As variáveis membro são inicializadas
automaticamente
• As variáveis “automatic” ou locais devem ser
inicializadas manualmente antes de serem
utilizadas.
@regismelo 39


Passagem de argumentos
• Quando Java passa um argumento para um
método ele está sempre passando uma cópia da
variável passada;

class foo
{
public void bar( int k ) { ++k; }
{ int i = 0; bar(i); System.out.println(i); }
}
@regismelo 40


Passagem de argumentos
• Deve-se tomar cuidado quando se passa objetos
como parâmetro – uma cópia do endereço é
passada como parâmetro!
import java.math.*; class Bar
public class foo {
{ public static void bar( Bar k ) { k.setValor(5); } private int valor;
public void setValor( int k )
{ valor = k; }
{ public String toString() {
Bar i = new Bar(); return ( valor + "" );
i.setValor(10); }
bar(i);
}
System.out.println(i);
}
}
@regismelo 41


Garbage Collection
• Processo de “limpeza” de instâncias não mais
referenciadas no programa;
• Em Java você não nunca explicitamente libera a
memória que você alocou;
...
public void goodMethod() {
Funcionario f = new Funcionario();
f.aumentarSalario();
}

@regismelo 42


Garbage Collection
• O Garbage Collector ajuda no processo de
limpeza de memória, mas você não está livre dos
“memory leaks”

... public Object pop()
public Object pop() {
{ Object o = storage[ index ];
return storage[ index--]; storage[index--] = null;
return o;
}
}

@regismelo 43


Garbage Collection
• O método finalize
protected void finalize() throws Throwable

• Chamado antes que o garbage collector libere a memória
relativa ao objeto;

• É uma má prática fazer a “limpeza da casa” nesse método;

• System.gc() – força uma chamada ao garbage collector.

@regismelo 44

Inicializadores
• Expressão de inicialização de variáveis;
– Utilizado para atribuir uma valor a variável no
momento da criação;

• Inicializadores estáticos;
– Bloco utilizado para declarações que envolvam
entidades estáticas (variáveis/métodos);

• Inicializadores de instância;
– Bloco utilizado para declarações que envolvam
entidades de instância (variáveis/métodos);

@regismelo 45

Inicialização de Variáveis
• São inicializadas na ordem que foram
criadas;
• Variáveis estáticas não podem referenciar
variáveis de instância;
Ex:
public class Inicializacao {
int diasMes = 30;
int diasAnos = diasMes * qtdeMes; //erro, variável não definida!
int qtdeMes = 12;
}

@regismelo 46

Inicialização de Variáveis
• Se um método utilizar uma variável que ainda
não foi inicializada, ocorrerá um erro de lógica;
Ex:
public class Inicializacao {
int diasMes = 30;
int diasAnos = diasMes * getDiasMes(); //erro de lógica!
int qtdeMes = 12;
public int getDiasMes() {
return qtdeMes;
}
}

@regismelo 47

Inicializadores Estáticos
• Java permite a criação de um bloco onde
pode ser colocado códigos estáticos
arbitrários;
• É executado somente uma vez, quando a
classe é carregada;
Ex:
public class StaticInitializer {
static {
//qualquer código
}
}

@regismelo 48

• Uma classe pode possuir mais de um bloco
estático;
• Eles são executados não ordem em que foram
criados;
Ex:
static int i, x;
static {
i++;
}
static {
x = i;
}
}

@regismelo 49

• Um bloco estático não pode lançar nenhuma Checked Exception;
• Todas as possíveis exceções devem ser tratadas;

Ex:
public static void initFile(String file) throws IOException { ... }
public static void initDirectory(String file) throws RuntimeException { ... }
static {
initFile(“arquivo.txt”); //erro! Checked Exception
}
static {
initDirectory(“arquivos”); //OK! Unchecked Exception
}
}

@regismelo 50

Inicializadores de Instância
• Permite a execução de códigos de
instância e estáticos arbitrários;
• Tem o mesmo propósito dos construtores;
• É executado toda vez que um objeto é
criado;
• Pode ser usado para conter um trecho de
código comum a todos os construtores;

@regismelo 51

• Assim como os blocos estáticos, podem
existir dentro da mesma classe, mais de
um bloco de instância;
• Também são executados na ordem em
foram declarados;
• Um bloco de instância não pode fazer
referência a uma variável que está
declarada depois dele;

@regismelo 52

Ex:
public class InstanceInitializer {
{
i++; //erro! Variável não declarada;
}
int i = 0;
{
for (; i < 10; i++) {
System.out.println(i);
}
}
}

@regismelo 53

• Um bloco de instância pode repassar
qualquer tipo de exceções;
• Se alguma exceção for repassada, é
obrigatório que o construtor contenha a
cláusula throws, indicando qual o tipo da
exceção;

@regismelo 54

Ex:
public class InstanceInitializer {
public void initFile(String file) throws IOException { ... }
{
initFile(“arquivo.txt”);
}
public InstanceInitializer() throws IOException { ... }
public InstanceInitializer(int i) //erro! Lança o que?
{ ... }
}

@regismelo 55

Ordem de Inicialização
• A inicialização se dá quando o operador
new é chamado;
• As variáveis de instância são inicializadas
com os seus valores padrões;
– Ex: int x; //x recebe o valor 0;
boolean val; //recebe false;
• O construtor da classe pai é executado;

@regismelo 56

• Os inicializadores de variáveis e os blocos
de instância são executados na ordem em
que foram declarados;
– Ex: int i = 20;
int x = i * 10;
• Logo após o construtor da classe;
– Ocorrendo o encadeamento de construtores,
o último será executado primeiro;

@regismelo 57

public class Order {
int i = 10; //Segundo a ser executado;
int x;
{
for (;x<10;x++) {...} //Terceiro a ser executado;
}
public Order() {
this(50);
System.out.println(x); //Quinto a ser executado;
}
public Order(int val) {
super(); //Primeiro a ser executado;
x = val; //Quarto a ser executado;
}
}

@regismelo 58


Simulado

@regismelo 59

Operators and Assignments

@regismelo 60


Objetivos
• Determinar o resultado da operação de qualquer
operador, incluindo operadores de atribuição, instanceof,
escopo e acessibilidade;

• Determinar o resultado da operação do método equals e
diferenciar do operador =;

• Entender os operadores &,/, &&, //;

@regismelo 61


@regismelo 62


Ordem de avaliação
• A expressão sempre é avaliada da
esquerda para a direita;
• O que a expressão abaixo faz?

1. int[] a = { 4, 5 };
2. int b = 1;
3. a[b] = b = 0;

@regismelo 63


Unary Operators
• Java provê 7 operadores unários

- Incremento e decremento: ++ e --
- Soma e subtração: + e -
- Operador de bits: ~
- Operador boolean: !
- Cast: ( )

@regismelo 64


Unary Operators
• Incremento e decremento ( ++ -- )
- A ordem importa!

1. int x = 0;
2. x++;
3. ++x;
4. int y = x++;
5. int k = ++x;

@regismelo 65


Unary Operators
• Incremento e decremento ( ++ -- )

@regismelo 66


Unary Operators
• Operador unário + e –

1. x = -3;
2. y = +3;
3. z = -(y + 6);

@regismelo 67


Unary Operators
Operador de bit (~)

• O operador de bit ~ inverte os bits de um tipo
primitivo;
• A manipulação de bits em java é completamente
independente de plataforma;
• ~ é frequentemente utilizado em conjunto com os
operadores shift ( <<, >> e >>>)
• ~1 ( 1 ) = -2 (111111111111111111111111111111110)
@regismelo 68


Unary Operators
Operador boolean (!)

• Esse operador inverte o valor de uma
expressão booleana;
• Só pode ser aplicada a expressões
booleanas

if (! false ) { ... }
@regismelo 69


Unary Operators
Operador cast (tipo)

• Utilizado para conversões explícitas;
• Só é possível fazer conversões para tipos
plausíveis

int i = (int)(Math.PI * diameter);

@regismelo 70


Unary Operators
Operador cast (tipo)

• Muito utilizado quando se usa containeres
como as classes Vector e ArrayList
(conversão de objetos)

1. ArrayList a = new ArrayList();
2. v.add( " blabla" );
3. Object o = v.get(0);
4. String s = (String)v.get(0);
5. Integer i = (Integer)v.get(0);
@regismelo 71


Arithmetic Operators
• Os operadores * e / realizam a multiplicação e divisão de
todos os tipos numéricos primitivos e do char;

• Divisões podem gerar um ArithmeticException;

• Em algumas situações o número gerado pela divisão ou
multiplicação não pode ser representado pelo tipo
primitivo. Nesse caso, somente os bits mais significativos
são apresentados.

@regismelo 72


public static void main( String args[] ) {
int i = 64 * 4; // Retorna 256 = 100000000
byte b = (byte) (64*4);

System.out.println( i );
System.out.println( b );
}

@regismelo 73


• Que valores são retornados pelo exemplo abaixo?

1. int a = 12345;
2. int b = 234567;
3. int c,d;
4. long e,f;
5. c = a * b / b;
6. d = a / b * b;
7. e = (long)a * b /b;
8. f = (long)a / b * b;

@regismelo 74


• O operador % retorna o resto da divisão

1. 17 % 5
2. 21 % 7
3. -5 % 2
4. 5 % -2

• Por envolver uma divisão, o módulo pode
causar uma ArithmeticException.

@regismelo 75



• Soma (+) e Subtração (-)
- Java não permite que os operadores sejam
sobrecarregados;
- Porém o operador + é sobrecarregado por natureza;
- Bastante utilizado para concatenação de Strings. Pode
envolver conversos de tipo.

String a = " BlaBla foi fundada em " + 199 + ( new
Integer(6) );

@regismelo 76


• Em uma operação usando + com dois tipos
primitivos, podemos afirmar que o resultado é :

– Um tipo numérico primitivo;
– É pelo menos um inteiro;
– É pelo menos do tamanho do maior operando;
– Teve o valor calculado realizando a promoção
dos tipos dos operandos para o resultado. Isso
pode causar overflow ou perda de precisão.

@regismelo 77


• Para uma operação usando + com qualquer
operando que não é um tipo primitivo:

– Pelo menos um operando deverá ser do tipo
String (objeto ou literal), do contrário a
operação causará erro;
– Qualquer operando não String é convertido
para String usando o metodo toString()
disponível na classe object.

@regismelo 78


Arithmetic Error Conditions
• Divisões inteira por zero (incluindo o operador %),
podem causar uma ArithmeticException;
• Operações que causam overflow simplesmene
truncam a informação gerada;
• Operações de ponto flutuante que resultam em
valores não representáveis são simbolizados com
as constantes INFINITY, MINUS_INFINITY e NaN
(not a number) das classes Float e Double.

@regismelo 79


Comparação com NaN
• Tudo que é comparado com a constante NaN resulta em
false:
1. x > Float.NaN;
2. x <= Float.NaN;
3. x == Float.NaN;
4. x < Float.NaN;
5. x >= Float.NaN.

• Existem os métodos isNaN das classes Float e Double
que podem sinalizar que o valor retornado foi um NaN.

@regismelo 80


Os operadores Shift <<, >> e >>>

• << faz um shift left de n bits;

• >> faz um shift rigth de n bits
preenchendo-os com o mesmo valor do bit
mais significativo;

• >>> faz um shift rigth preenchendo os bits
com zero
@regismelo 81



@regismelo 82



@regismelo 83



@regismelo 84



@regismelo 85


Arithmetic promotion of operands

• Todos os operandos em uma operação
binária são promovidos para pelo menos
um int;
• Isso pode causar alguns problemas
quando esse tipo de operação é efetuada
utilizando operadores do tipo byte.

@regismelo 86


Operadores de comparação

• Os operadores de comparação são <, <=, >, >=, == e !=

• Os operadores de comparação <, <=, > e >= aplicam-se
a todos os tipo numéricos incluindo o char.

• A comparação de dois valores de tipos diferentes faz com
que aconteça uma promoção automática para o maior
tipo.

@regismelo 87


O operador instanceof
• Testa a classe a qual um objeto pertence em
runtime;
• exemplo:

1. Cliente c = new Cliente();
2. Object o = c;
3. if ( o instanceof Cliente ) { ... }
4. int[] k;
5. if ( k instanceof int[] ) { ... }

@regismelo 88


Operadores de igualdade == e !=
• Testam a igualdade entre operandos;
• A igualdade está sujeita as regras para promoção
de variáveis:
float f = 10; int k = 10;
boolean b = ( f == k );

• Quando se compara objetos, se está comparando
a referência ao objeto e não o seu valor (para se
comparar se dois objetos são iguais deve-se usar
o método equals() )
@regismelo 89


Operadores de bit - &, ^ e |
• & = and, ^ = XOR e | = OR

@regismelo 90


Operadores de bit - &, ^ e /
• & = and, ^ = XOR e | = OR

@regismelo 91


Operadores de bit - &, ^ e |
• & = and, ^ = XOR e | = OR

@regismelo 92


Operadores ternário
• Operador ternário possui a seguinte
sintaxe:
a = x ? b : c;

• Uma boa prática de programação é não
exagerar no seu uso.
a = x ? b : c ? d : e ? f : g;

@regismelo 93


Assignment Operators
• =, +=, -=, *=, /=

• Castings são feitos automaticamente:
1. byte x = 2;
2. x += 3;
3. byte y = 2;
4. y = (byte)(y + 3)
• Outro exemplo:
int a,b,c,d;
a = b = c = d = 0;
@regismelo 94


Simulado

@regismelo 95

Modifiers

@regismelo 96

Modifiers

Objetivos
• Declarar corretamente inner classes, métodos, variáveis
estáticas (static) e de instância fazendo uso de todos os
modificadores permitidos.
• Definir o significado de cada modificador, tanto em uso
singular como em conjunto com outros modificadores.
• Identificar se a construção de arquivos, declarações de
pacotes, imports, classes, interfaces, inner classes,
métodos e variáveis estão corretas.

@regismelo 97

Modifiers

O que são modificadores?
• São as keywords em Java que dão informação ao
compilador a respeito da natureza do código, dos dados
ou das classes.

• Especificam características de métodos, classes e
variáveis. Um exemplo dessas características é o tipo de
acesso que lhes são permitidos.

@regismelo 98

Modifiers

Modificadores
• Em Java existem modificadores relacionados ao acesso
de métodos, classes e variáveis.

public protected private

• Outros modificadores:

final abstract
static native transient
synchronized volatile

@regismelo 99

Modifiers

Modificadores de Acesso
• Modificadores de acesso especificam quais
classes podem acessar:
– Outras classes
– Variáveis de classes
– Métodos e construtores
• Variáveis declaradas dentro de métodos
não devem conter modificadores de
acesso em suas declarações.

@regismelo 100

Modifiers

Modificadores de Acesso - Restrições
• O único modificador de acesso permitido a non-inner
class é public. Não há nada como protected ou private
top-level class.

• Variáveis de classes, classes, métodos e construtores
devem possuir especificado um modificador de acesso.

• Exemplos:
– private int i;
– Graphics offScreenGC;
– protected double getChiSquared() { ... }

@regismelo 101

Modifiers

Modificadores de Acesso - public
• O modificador public é o mais “generoso”.
Especifica que uma classe, variável ou método
pode ser usado por qualquer programa Java sem
restrições.
• Exemplo:
– Um applet é declarado como público para que possa
ser instanciado por qualquer browser.
– Uma aplicação declara o método main() como público
para ser invocado de qualquer Java runtime
environment.

@regismelo 102

Modifiers

Modificadores de Acesso - private
• Diferente do modificador public, private é o menos
“generoso”. Variáveis e métodos private só podem ser
acessados por uma instancia da classe que os declara.
• Exemplo:
1. class Complex {
2. private double real;
3. }
4.
5. class SubComplex extends Complex {
6. SubComplex(double r, double i) {
7. real = r; // Trouble!!!
8. }
9. }

@regismelo 103

Modifiers

Modificadores de Acesso - default
• default não é um modificador em Java, é somente o nível
de acesso especificado quando não é declarado nenhum
modificador de acesso.
• Esse tipo de acesso especifica que uma classe, método ou
variável pode ser acessada por classes que estão contidas
em seu mesmo pacote.
• Acessos default são mais utilizados quando se
desenvolvem classes que estão em um mesmo diretório,
ou seja, formam um pacote e o desenvolvimento de
classes nesse pacote se torna bem mais rápido, pois não
há preocupação de tratar restrições de acesso às classes
que formam o pacote.

@regismelo 104

Modifiers

Modificadores de Acesso - protected
• Esse tipo de acesso é um pouco menos restritivo do que o
acesso default. Permite que métodos e variáveis de
classes sejam acessados por outras classes do mesmo
pacote e por suas sub classes.
• Exemplo:

1. package sport; 1. package sportinggoods;
2. public class Ski { 2. class DownhillSki extends Ski{
3. protected void applyWax() 3. void tuneup(){
4. { ... } 4. applyWax();
5. } 5. ...
6. }
7. }

@regismelo 105

Modifiers

Privacidade de Métodos e Classes

• A figura abaixo mostra os acessos legais para override de
métodos:

Private Default Protected Public

• Caso a escala não seja seguida ocorrerá um erro de
compilação com a seguinte mensagem :
“Methods can’t be overriden to be more private”

@regismelo 106

Modifiers

Outros Modificadores - final
• É aplicado a classes, métodos e variáveis com a idéia de:
– Não podem ser alterados!!
• Uma classe final não deve possuir subclasses.
• Um método final não pode ser overriden.
• Uma variável não pode ter seu valor modificado após ser inicializada.

• Exemplo:
1. class Walrus{ 7. class Tester{
2. int weight; 8. final Walrus w1 = new Walrus(1500);
3. Walrus(int w){ 9. void test(){
4. Weight = w; 10. w1 = new Walrus(1400); //erro!
5. } 11. w1.weight = 1800; //certo!
6. } 12. }
13. }

@regismelo 107

Modifiers

Outros Modificadores - abstract
• Pode ser aplicado a métodos e classes.
• final x abstract
• Uma classe deve ser declarada abstrata se:
– Possui um ou mais métodos abstratos.
– Quando herda métodos abstratos e não prover implementação a
eles.
– Quando a classe declara que implementa uma interface e não
prover implementação a todos os métodos da interface.

@regismelo 108

Modifiers

Outros Modificadores - static
• Pode ser aplicado a métodos, variáveis e até a trechos de
código que estejam fora de um método.
• O valor de uma variável static é o mesmo para qualquer
instancia criada de uma classe que contenha a variável.
• Exemplo:
...
Ecstatic e1 = new Ecstatic();
class Ecstatic{ Ecstatic e2 = new Ecstatic();
static int x = 0; int y = e2.x;
Ecstatic() { x++; } y = Ecstatic.x;
} System.out.println( y );
...

@regismelo 109

Modifiers

• Métodos também podem ser static e seguem as restrições:
– Um método static só pode acessar dados static de sua classe.
– Um método static só pode fazer chamadas a métodos static de sua
classe.
– Em métodos static não há a variável implícita this. Deve-se
especificar a qual instancia da classe executa o método.
– Métodos static não podem ser overriden para serem non-static.
(somente shadowing) Exemplo:
1. class Cattle{
2. static void foo(){}
3. }
4.
5. class Sheep extends Cattle{
6. void foo(){} //erro!
7. }

@regismelo 110

Modifiers

• Static Initializers
• É legal pra uma classe possuir um bloco que execute o código static
que não está no corpo de um método da classe.
• O código é executado uma única vez quando a classe é carregada.
• Exemplo:
1. public class StaticExample{
2. static double d = 1.23;
3.
4. static{
5. System.out.println(“main : d = ” + d++);
6. }
7.
8. public static void main(String args[]){
9. System.out.println(“main : d = ” + d++);
10. }
11. }

@regismelo 111

Modifiers

Outros Modificadores - native
• Se aplica somente a métodos.
• Identifica que um método, escrito em uma
linguagem diferente de Java, está em uma
biblioteca situada fora da JVM.
• Exemplo:
class NativeExample{
native void doSomethingLocal(int i);

static{
System.loadLibrary(“MyNativeLib”);
}
}

@regismelo 112

Modifiers

Outros Modificadores - transient
• Esse modificador se aplica somente a variáveis.
• Objetos que implementam as interfaces Serializable e
Externalizable podem ser serializados e enviados para um
destino fora da JVM.
• Através do modificador transient é possível especificar que
o valor de uma variável não será escrito durante a
serialização, por motivo de segurança.
• Exemplo: class WealthyCustomer extends Customer
implements Serializable{

private float Swealth;
private transient String accessCode;
}
@regismelo 113

Modifiers

Outros Modificadores
• synchronized
– Esse modificador é utilizado para controlar acesso a
áreas críticas em programas multi-threaded e será
detalhada em aulas posteriores quando falarmos sobre
threads.
• volatile
– Se aplica somente a variáveis e proverá a atomicidade
de seus valores.
– Exemplo: em um programa muti-threaded, se duas
threads acessam a mesma variável e alteram seu valor,
a atomicidade da variável será garantida.

@regismelo 114

Modifiers

Simulado

@regismelo 115

Converting and Casting

@regismelo 116


Objetivos
• Determinar o resultado do uso de qualquer operador
incluindo operadores de associação, instanceof, castings,
escopo de classes e acessibilidade.

@regismelo 117


Explicit and Implicit Type Changes
• Você pode explicitamente alterar o tipo de uma
variável realizando uma operação de casting;

Button btn = (Button) (myVector.elementAt(5));

• Mudanças implícitas:

myVector.add( btn );

@regismelo 118


Primitives and Conversion
• Existem 3 possíveis maneiras para que a
conversão de tipos primitivos ocorra:

– Atribuições;
– Chamada de métodos;
– Promoção aritmética.

@regismelo 119


Primitives and
Conversion - Assignments
• Ocorre quando você atribui um valor a uma
variável de um tipo diferente.

1. int i;
2. double d;
3. i = 10;
4. d = i;

@regismelo 120


Primitives and Conversion -
Assignments
• Algumas conversões implícitas não são
permitidas:

1. double d;
2. short s;
3. d = 1.2345;
4. s = d; //erro!
5. s = (short)d; //certo!

@regismelo 121


Assignments
A regra geral para conversão implícita de tipos
primitivos é:

– Um boolean não pode ser convertido para nenhum outro
tipo;
– Um valor não booleano pode ser convertido para outro
valor não booleano – widening
– Um valor não booleano não pode ser convertido para um
valor não booleano caso a atribuição seja feita de um
tipo com maior precisão para um tipo de menor precisão

@regismelo 122


Assignments
“Widening Conversions”

• From a byte to a short, an int, a long, a float, or a double
• From a short to an int, a long, a float, or a double
• From a char to an int, a long, a float, or a double
• From an int to a long, a float, or a double
• From a long to a float or a double
• From a float to a double

@regismelo 123


Assignments
“Widening Conversions”

@regismelo 124


Assignments Conversion, primitive
and literal values
• Um valor literal em Java é um double ou um int
double d = 1234.56;
float f = 1234.56; // Erro!

• Essa regra funciona de maneira diferente com
literais int:
byte b = 1;
short s = 2;
char c = 3;

@regismelo 125


Primitive Conversion
Method call
• Acontece quando se passa um parâmetro de um
outro tipo para um método

1. float frads;
2. double d;
3. frads = 2.34567f;
4. d = Math.cos(frads); // Método recebe double

@regismelo 126


Method call
• Porém, o código abaixo gera um erro de
compilação:

1. double d = 12.0;
2. Object ob = myVector.elementAt(d);

• Em resumo, widening conversions são permitidas
mas narrowing conversion são proibidas.

@regismelo 127


Arithmetic Promotion
• Considerando o código:

1. short s = 9;
2. int i = 10;
3. float f = 11.1f;
4. double d = 12.2;
5. if (–s * i >= f / d)
6. System.out.println(“>>>>”);
7. else
8. System.out.println(“<<<<”);

@regismelo 128


• As regras que regem as promoções através de
operações aritméticas são distinguidas dentre os
operadores unários e binários;
• Os operadores unários realizam operações em um
simples valor. Os binários entre dois valores.

@regismelo 129


• Para os operadores unários, as regras são:
– Se o operando é um byte, short ou char, ele é convertido
para um int (a menos que o operador usado
seja ++ ou --, que não gera conversões);
– Em todos os demais casos, não existe conversão.

@regismelo 130


• Para os operadores binários, as regras são:
– Se um dos operandos é double, o outro operando é
convertido para double;
– Se não, se um dos operandos for float, o outro
operando será convertido para float;
– Se não, se um dos operandos for long, o outro será
convertido para long;
– Nos demais casos, todos os operandos são
convertidos para int.

@regismelo 131


• Exemplos:

1. byte b = 1; int i = 1;
2. b++; // Funciona!
3. b = b + 1; // Erro!
4. b = b * 1; // Erro!
5. i = i + 1; // Funciona!
6. i = i * 2.5; // Erro!

@regismelo 132


Primitives and Casting
• Casting significa dizer, explicitamente, para o
Java fazer uma conversão;

1. int i = 5;
2. double d = (double)i;

@regismelo 133


• Castings explícitos permitem fazer conversões
wide e narrow

1. short s = 259;
2. byte b = (byte)s; // Casting explícito
3. System.out.println(“b = ” + b);

@regismelo 134


Existem três regras básicas que regem o processo
de casting em tipos primitivos:

– Você pode realizar um casting de qualquer tipo não
booleano para qualquer outro tipo não booleano;
– Você não pode fazer um casting de um tipo booleano
para outro tipo qualquer;
– Você não pode um casting de um tipo qualquer para
um tipo booleano.

@regismelo 135


Object Reference Assignment
Conversion
• Conversão de objetos quando uma atribuição é
feita de um tipo para um outro tipo de objeto;
• Existem três tipos de referência a objetos:
– Classes;
– Interfaces;
– Arrays

@regismelo 136


Object Reference Assignment Conversion
• Possibilidades de conversão:
1. Oldtype x;
2. Newtype y = x;

@regismelo 137


Object Reference Casting
• As conversões de objeto são permitidas e
amplamente utilizadas em Java.
1. class Pessoa { ... }
2. class Funcionario extends Pessoa { ... }
3. {
4. Pessoa P1 = new Funcionario();
5. Funcionario F1 = new Funcionario();
6. Pessoa P1 = (Pessoa)F1;
7. Pessoa P2 = F1;
8. }
@regismelo 138


Object Reference Casting
• Possibilidades de conversão:
NewType nt; OldType ot; nt = (NewType)ot;

@regismelo 139


Simulado

@regismelo 140

Flow control and Exceptions

@regismelo 141


Objetivos
• Escrever código usando if, switch;
• Escrever código usando todas as formas de loops,
incluindo label e unlabeled break e continue;
• Conhecer o estado das variáveis durante e depois a
execução de um loop;
• Escrever código que faz uso apropriado de exceções e
blocos try, catch, finally
• Declarar métodos que sobrescrevem métodos que
disparam exceptions.

@regismelo 142


Loop Constructs – While/do While
• A forma geral de um while é:
1. while ( condicaoBooleana )
2. blocoDeCodigo;

• E de um do while é
1. do
2. blocoDeCodigo;
3. while ( condicaoBooleana)

@regismelo 143


Loop Constructs – for
• A forma geral de um for é:
1. for( statement; condition; expression )
2. blocoDeCodigo;

• Qualquer um dos elementos do for é opcional,
dessa forma a expressão:

for( ; ; ; )

Corresponderia a um loop infinito.
@regismelo 144


Loop Constructs – for
• Outra forma de utilizar o for:
1. int j, k;
2. for (j = 3, k = 6; j + k < 20; j++, k +=2) {
3. System.out.println(“j is “ + j + “ k is “ + k);
4. }
• Porém, não se pode misturar expressões com
declaração de variáveis:

1. int i = 7;
2. for (i++, int j = 0; i < 10; j++) { } // illegal!
3. for (int i = 7, long j = 0; i < 10; j++) { } // illegal!

@regismelo 145


Break and Continue
• Usando o continue:
1. for (int i = 0; i < array.length; i++) {
3. if ( algumaCoisaQualquer) {
4. continue;
5. }
6. facaAlgumaOutraCoisa();
7. }

• O continue faz com que a iteração volte para o
laço em que o continue pertence.

@regismelo 146


Break and Continue
• Continue com labels
mainLoop:
for ( ; ; )
{
for ( ; ; ) {
if ( true ) {
continue mainLoop;
}
}
}

@regismelo 147


Break and Continue
• Usando o break
1. for (int i = 0; i < array.length; i++) {
3. if ( algumaCoisaQualquer) {
4. break;
5. }
6. facaAlgumaOutraCoisa();
7. }

• O break faz com que o laço seja finalizado.

@regismelo 148


Break and Continue
• Break com labels
mainLoop:
for ( ; ; )
{
for ( ; ; ) {
if ( true ) {
break mainLoop;
}
}
}

@regismelo 149


Selection Statements
• Usando if/else

1. if (x > 5) {
2. System.out.println(“x is more than 5”);
3. }
4. else {
5. System.out.println(“x is not more than 5”);
6. }

@regismelo 150


Selection Statements
• Usando switch
1. switch (x) {
2. case 1:
3. System.out.println(“Got a 1”);
4. break;
5. case 2:
6. case 3:
7. System.out.println(“Got 2 or 3”);
8. break;
9. default:
10. System.out.println(“Not a 1, 2, or 3”);
11. break;
12. }
@regismelo 151


Exceptions
• Mecanismo para tratamento e recuperação de
erros;
• Ocorrem em situações fora do normal;
• Permitem que o fluxo normal do programa seja
programado.

@regismelo 152


Exceptions
1. int x = (int)(Math.random() * 5);
2. int y = (int)(Math.random() * 10);
3. int [] z = new int[5];
4. try {
5. System.out.println(“y/x gives “ + (y/x));
6. System.out.println(“y is “ + y + “ z[y] is “ + z[y]);
8. }
9. catch (ArithmeticException e) {
10. System.out.println(“Arithmetic problem “ + e);
11. }
12. catch (ArrayIndexOutOfBoundsException e) {
13. System.out.println(“Subscript problem “ + e);
14. }

@regismelo 153


Exceptions
• Para o exemplo do slide anterior:

@regismelo 154


Exceptions
• A cláusula finally faz com que um bloco de
código seja sempre executado;
• Muito usado para para fazer a “limpeza da casa”;
• O finally sempre é executado, com exceção das
seguintes situações:

• Um exceção aconteceu dentro do finally;
• A thread foi morta (kill);
• System.exit();
• O computador foi desligado 

@regismelo 155


1. try {
Exceptions
2. // statements
3. // some are safe, some might throw an exception
4. }
GeneralException
5. catch (SpecificException e) {
6. // do something, perhaps try to recover
7. }
SpecificException
8. catch (OtherException e) {
9. // handling for OtherException
10. }
11. catch (GeneralException e) {
12. // handling for GeneralException OtherException
13. }
14. finally {
15. // code that must be executed under
16. // successful or unsuccessful conditions.
17. }
18. // more lines of method code

@regismelo 156


Throwing Exceptions
• Dispara uma nova exceção
• Sintaxe:
– throw e;
– throw new Exception( “Erro!” );
• Para que uma nova exceção possa ser
disparada, essa exceção deve ser indicada
através da cláusula throws
– public void metodo() throws Exception
• O usuário desse método deverá tratar ou
repassar essa exceção.
@regismelo 157


Categories of Exceptions

@regismelo 158


• Checked Exceptions
– Problemas que podem afetar um programa correto –
um erro de I/O, BD fora do ar, etc.
– Precisam obrigatoriamente ser tratadas pelo
programador
• Runtime Exceptions
– Descrevem bugs em programas – acessar um
elemento inválido de um array, chamar um método
não static de um objeto null, etc.
– Não precisam ser explicitamente tratadas

@regismelo 159


• Errors
– Descrevem problemas não comuns – falta de
memória, estouro da pilha, etc.
– Não é necessário que se faça tratamento para esse
tipo de erro.

– AssertionError, AWTError, CoderMalfunctionError,
FactoryConfigurationError, LinkageError, ThreadDeath
, TransformerFactoryConfigurationError,
VirtualMachineError

@regismelo 160


Exceptions and Overriding
• Quando você estende uma classe e sobrescreve
um método, o novo método não pode declarar
nenhuma exceção nova;
• Exemplo:
public class Base
{
public void do() throws SSException { }
}
public class Base2
{
public void do() { }
}

@regismelo 161


Exceptions and Overriding

@regismelo 162


Simulado

@regismelo 163

Objects, Classes e Interfaces

@regismelo 164

Objects and Classes

Objetivos
• Conhecer os benefícios do encapsulamento;
• Conhecer os valores possíveis de retorno de qualquer
classe tomando como base o seu parent;
• Escrever código para chamar métodos e construtores
sobrescritos ou sobrecarregados;
• Declarar classes, inner classes, métodos e conhecer o
conceito de relação entre pacotes;
• Escrever código para instanciar qualquer classe concreta,
incluindo top-level classes, inner classes, static inner
classes e classes anônimas;

@regismelo 165

Objects and Classes

Objetivos
• Identificar arquivos fonte corretamente construídos,
declarações de pacote, import statements, declaração de
classes, declaração de interfaces, declaração de métodos
(incluindo o método main), de variáveis e identificadores.

@regismelo 166

Objects and Classes

Conceitos Gerais de O.O.

• Objetos; • Herança;
• Classes; • Polimorfismo;
• Interfaces; • Encapsulamento;
• Abstração; • Hierarquia;

@regismelo 167

Objects and Classes

Overloading and Overriding
• Overload – dois métodos com o
mesmo nome e parâmetros diferentes;

• Override – redefinição de um método
declarado na classe pai.

@regismelo 168

Objects and Classes

Overloading

1. public void aMethod(String s) { }
2. public void aMethod() { }
3. public void aMethod(int i, String s) { }
4. public void aMethod(String s, int i) { }
5. public int aMethod() { } // Erro!
6. public void aMethod( short s ) { }
7. Public void aMethod( int i ) { }

@regismelo 169

Objects and Classes

Overloading
• O compilador decide qual método utilizar
dependendo da ordem dos argumentos
passados;
• Dois métodos com argumentos diferentes e
mesmo nome pode ter retorno diferentes e
disparar exceções diferentes;
• Dois métodos com argumentos iguais e
mesmo nome não podem ter retorno
diferente.
@regismelo 170

Objects and Classes

Overriding
• Redefinição ou especialização de um
método;

• Sobrescrever um método significa definir
um novo método com a mesma assinatura
– nome, argumentos e retorno;

@regismelo 171

Objects and Classes

Overriding

@regismelo 172

Objects and Classes

Overriding

@regismelo 173

Objects and Classes

Overriding
• Para que um método seja sobrescrito
corretamente, as seguintes regras deverão ser
observadas:
– O nome do método, o tipo e a ordem de seus
argumentos deve ser idêntica;
– O tipo de retorno deve ser idêntico;
– A acessibilidade do método não pode ser mais restrita
que o original;
– O método não deverá disparar exceções que não
podem ser disparadas no método original.

@regismelo 174

Objects and Classes

Construtores
• Se a classe não tiver nenhum construtor, o
compilador fornece um construtor padrão, sem
argumentos.
• Um construtor pode chamar outros construtores
da seguinte forma: this(argumentos).
• O construtor da classe não é executado até que
o construtor da classe pai o seja.
• Construtores não são herdados.
• Construtores não tem valor de retorno.
(Nem void).

@regismelo 175

Objects and Classes

Construtores

@regismelo 176

Interfaces
• É um tipo de classe que não possui
implementação para os métodos;
• O corpo de uma Interface possui somente
uma lista de métodos;
• Somente protótipos;
• Por definição uma Interface é considerada
abstract, portanto, não pode ser
instanciada;

@regismelo 177

Interfaces
• A classe que implementa uma interface, é
obrigada a implementar todos os métodos
da mesma.
• Existe uma contrato entre a classe e a
interface;
• Uma classe pode implementar mais de
uma Interface;

@regismelo 178

Interfaces
public interface Pilha {
public push(Object ob);
public Object pop();
}

public class PilhaImp implements Pilha {
public push(Object ob) {
//implementação
}
public Object pop() {
//implementação
}
}

@regismelo 179

Métodos de Interface
• Todos os métodos de uma Interface
também são considerados abstract.
• Não é necessário especificar;
• Os métodos só podem ter o escopo
público ou de pacote;
• Também não podem ser declarados como
static.

@regismelo 180

Implementado um Interface
• Uma classe que implementa uma Interface deve
declarar todos os métodos da mesma como public.
Ex:
public interface Pilha {
push(Object ob);
Object pop();
}

public class PilhaImp implements Pilha {
public push(Object ob) {
//implementação
}
Object pop() { //erro!
//implementação
}
}

@regismelo 181

Interface estendendo
uma Interface
• Uma interface também possui a
possibilidade de estender de outras
Interfaces;
Ex:
public interface MicroSystem extends Radio, CDPlayer {
public void playRadio();
public void playCD();
}

@regismelo 182

Constantes em Interfaces
• Uma interface pode declarar variáveis dentro do
seu corpo;
• Todas devem ser públicas, estáticas e finais;
• Não é necessário especificar;

Ex:
public interface CalculosMatematicos {
public static final double PI = 3.14;
// ou double PI = 3.14;
}

@regismelo 183

Objects and Classes

Inner Classes
• É uma classe declarada dentro de outra
classe(isto é, entre as chaves {} ), ou
dentro de métodos.

@regismelo 184

Objects and Classes

Inner Classes Exemplo 1

@regismelo 185

Objects and Classes

Inner Classes Exemplo 2

@regismelo 186

Objects and Classes

Inner Classes
• Para um exemplo mais completo,
Adicionar ao codigo anterior...

@regismelo 187

Objects and Classes

4 Tipos de Inner Classes
• Top-level nested classes
• Non-static inner classes
• Local Classes
• Classes anônimas

@regismelo 188

Objects and Classes

Top-level nested Classes
• Declaradas como classes membro com o
modificador “static”.
• Podem ser acessadas / instanciadas sem
uma instância de uma classe externa. Podem
acessar somente membros estáticos da
classe externa. Não podem acessar variáveis
de instância ou métodos.
• Muito parecida com outra classe/interface
com nivel package. Fornecem uma extensão
ao empacotamento pelo esquema de nomes.

@regismelo 189

Objects and Classes

Top-level nested classes
• Classes podem declarar tantos membros
estáticos como não estaticos.
• Qualquer modificador de acesso pode ser
especificado.
• Interfaces são implicitamente estáticas (o
modificador estático pode ser utilizado).
Podem ter qualquer modificador de acesso.
Não existem interfaces “inner” não
estáticas(non-static inner), locais ou
anônimas.

@regismelo 190

Objects and Classes

Exemplo Top-Level Nested Class

@regismelo 191

Para referenciar...
• Para referenciar a classe (3) :
TopLevelClass.NestedTopLevelClass.NestedTopL
evelInterface

• Para referenciar a classe (4)
TopLevelClass.NestedTopLevelClass.NestedTopL
evelClass1

@regismelo 192

Objects and Classes

Classes geradas...
• Quando compilado, o exemplo anterior
gerará as seguintes 4 classes:

• TopLevelClass$NestedTopLevelClass$NestedT
opLevelClass1.class
• TopLevelClass$NestedTopLevelClass$NestedT
opLevelInterface.class
• TopLevelClass$NestedTopLevelClass.class
• TopLevelClass.class

@regismelo 193

Objects and Classes

Exemplo 2

@regismelo 194

Objects and Classes

Non-Static Inner Classes
• Declaradas como classes membro sem o identificador
static.
• Uma instância de uma inner class non-static só pode
existir com uma instância de uma classe
externa(enclosing class). Ela sempre terá de ser criada
dentro do contexto de uma instância externa.
• Podem acessar todas os membros da classe externa
(até mesmo privados). Possui um referência implícita
para a instância externa (enclosing instance).
• Não pode ter membros estáticos.
• Pode ter qualquer modificador de acesso.(public, default,
protected, private)
@regismelo 195

Objects and Classes

Definindo Non-Static Inner Class

@regismelo 196

Objects and Classes

Classes Locais
• São classes que são definidas em um
bloco. Pode ser em um corpo de um
método, um construtor, um bloco local, um
inicializador estático ou um inicializador de
instância.
• Não podem ser especificadas com o
modificador estático.

@regismelo 197

Objects and Classes

Classes Locais(Cont.)
• Não podem ter modificadores de acesso.
• Podem acessar todas as caracteristicas
da classe que a contem (porque elas são
definidas dentro do método da classe.
• Podem acessar somente variáveis finais
definidas dentro do método (incluindo
seus argumentos).

@regismelo 198

Objects and Classes

Classe Locais (cont.)
• Não podem ser especificadas com o
modificador estático, mas se elas são
declaradas dentro de um contexto estatico
ou de um inicializador estático, elas se
tornam estáticas.

@regismelo 199

Objects and Classes

Exemplo Classes Locais (1/2)

@regismelo 200

Objects and Classes

Exemplo Classes Locais (2/2)

@regismelo 201

Objects and Classes

Classes Anônimas
• Classes Anônimas são definidas onde elas são
construidas. Elas podem ser criadas onde uma
expressão de referência puder ser utilzada.
• Classe anônimas não podem ter contrutores explicitos.
Inicializadores de instância podem ser utilizados para
fazerem esse papel.
• Tipicamente utilizados quando criando objetos ”on the
fly”.
• Classes anônimas podem implementar uma interface ou
estender uma classe, mas não ambos.
• Syntaxe: new interface name() { } ou new class name()
{}

@regismelo 202

Objects and Classes

Classes Anônimas
• As mesmas regras de acesso para as
classes locais se aplicam para classe
anônimas.

@regismelo 203

Objects and Classes

Classes Anônimas

@regismelo 204

Objects and Classes

Classes Anônimas (1/2)

@regismelo 205

Objects and Classes

Classes Anônimas (2/2)

@regismelo 206

Objects and Classes

Simulado

@regismelo 207

Thread

Threads

@regismelo 208

Thread

O que é um Thread
• Thread é uma maneira de Java criar e
executar processos paralelos, sejam eles
concorrentes ou não. Dando uma
impressão que vários programas estão
executando simultaneamente.

@regismelo 209

Thread

O que entender sobre Thread?
• Quando ela executa.
• Que código é executado.
• Quais estados ela pode estar.
• Como é feita a mudança de estado.

@regismelo 210

Thread

Quando ela executa
• A Thread executa quando se chama o
método start().
• Ela não executa imediatamente.
• É feito o registro, e espera ser posta para
executar pela JVM no momento
adequado.

@regismelo 211

Thread

Que código é executado
• Todo o código contido no método run().

//Imprime os número de 0 a 9 na tela.
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println( i );
}
}

@regismelo 212

Thread
De onde vem o método run()?
• Você pode estender a classe Thread.
public class MyThread extends Thread {
public void run() {
//código a ser executado pela thread
}
}

• Ou implementar a interface Runnable.
public class MyRunnable implements Runnable {
public void run() {
//código a ser executado pela thread
}
}

@regismelo 213

Thread

Como executar uma Thread que
implementa Runnable?
Passar a instância de um objeto que
implementa Runnable para o construtor
da classe Thread.

Thread myT = new Thread( new MyRunnable );
myT.start();

@regismelo 214

Thread

Quando um Thread termina?
• No momento que termina o seu método
run().
• O seu estado muda para DEAD.
• Não pode mais ser reiniciada.
• Os métodos da Thread ainda podem ser
chamados, ela ainda é um objeto como
outro qualquer.

@regismelo 215

Thread

Estados de uma Thread
• Ready-to-Run
• Running
• Estados de espera:
Sleeping, suspended, blocked e
waiting.
• Dead

@regismelo 216

Thread
Ready-to-Run
• Quando o método start() é chamado, a
Thread não é posta imediatamente para
executar. Ela é posta como pronta, ready-
to-run. E permanece até o momento em
que é colocada para executar.

@regismelo 217

Thread
Running
• No momento em que a Thread está sendo
executada.

@regismelo 218

Thread
Sleeping
• Uma Thread é considerada no estado
sleeping, quando é chamado o método
sleep() da classe Thread. Ela permanece
até o momento que termina o tempo
determinado pelo argumento do método.

@regismelo 219

Thread
Blocked
• Quando a Thread não consegue adquirir a
posse do monitor de um objeto.

@regismelo 220

Thread
Waiting
• Uma Thread é considerada no estado
waiting, quando é feita a chamada do
método wait() para que ela aguarde por
uma determinada ação que está
impedindo o prosseguimento de sua
execução.

@regismelo 221

Thread

Seqüência dos Estados

@regismelo 222

Thread
Prioridades
• Threads tem prioridades que vão de 1 a
10.
• Se várias Threads estão esperando para
ser executada, a de maior prioridade é
colocada para executar.
• O valor 5 é a prioridade default.
setPriority(int); //seta a prioridade
getPriority(); //retorna a prioridade atual

@regismelo 223

Thread
Método yield()
• A Thread em execução move-se do estado running
para o ready-to-run, dando a vez da execução para
outra Thread.

• Método da classe Thread.
• public static void yield()

@regismelo 224

Thread
Cenários do yield()
• 1. Vai para o estado de ready-to-run, e fica esperando
execução como outra Thread qualquer.

• 2. Pode voltar imediatamente a executar, se não
houver Threads prontas.

• 3. Talvez todas as Threads que estão prontas, sejam de
menor prioridade, daí ela continua executando.

@regismelo 225

Thread
Método sleep()

• Faz com que a Thread vá para o estado de
sleeping por um determinado tempo.
• Método da classe Thread.
public static sleep(long mili)
public static sleep(long mili, int nano)
• Ambos lançam InterruptedException

@regismelo 226

Thread

Implementação de
Escalonamento
• Existem duas maneiras que fazem com
que uma Thread pare de executar sem a
explícita chamada de do método wait() ou
suspend().
1. Devido a uma operação de I/O.
2. Uma outra Thread de maior prioridade está
pronta para executar.

@regismelo 227

Thread

Escalonamento depende da
plataforma
• A forma de escalonamento das Threads
depende da plataforma. Algumas
implementam Escalonamento Preemptivo,
já outras Time sliced ou Roud-Robin.

• Obs: Nunca implemente suas Threads
dependendo do tipo de escalonamento.

@regismelo 228

Thread

Todo objeto possui um
monitor
• O que o monitor proporciona?
1. Uma trava (lock) para o objeto.
2. O uso da keyword synchronized para
criar uma região sincronizada do objeto
(região crítica).

@regismelo 229

Thread
Sincronização
• A sincronização serve para garantir que
somente um processo acesse uma
determinada posição de memória
simultaneamente.

@regismelo 230

Thread

Keyword synchonized
• Serve para criar dentro de um objeto uma região
sincronizada.
• Para uma Thread acessar um região sincronizada, antes
ela tem que conseguir o lock do objeto, ou seja o
monitor.
• Caso o lock do objeto já tenha algum dono, a Thread irá
para o estado de bloqueado (blocked).
• Caso haja mais de um método synchronized e já existe
uma Thread dona do lock do objeto, nenhuma outra
Thread conseguirá acessar nenhum outro método
synchronized do objeto, antes que o lock esteja livre.

@regismelo 231

Thread

Keyword synchonized
• Existem duas maneira de marcar um
código como sincronizado.
1. Sincronização de um método inteiro.
boolean valid = false;
public synchronized void method() {
valid = !valid;
}

@regismelo 232

Thread

Keyword synchonized
2. Ou um trecho do código.
StringBuffer message = new StringBuffer(“Java”);
public void change(String arg) {
synchronized ( message ) {
message.append( arg );
}
}

• O objeto sincronizado, não necessariamente
precisa ser o que contém o código.

@regismelo 233

Thread

Métodos wait(), notify() e
notifyAll()
public void wait()
Coloca uma Thread no estado de espera.
public void notify()
Retira uma Thread do estado de espera e coloca
denovo em ready-to-run.
public void notifyAll()
Retira todas as Thread que estão no do estado de
espera e as coloca em ready-to-run.

@regismelo 234

Thread

notifyAll()
• Todos estes métodos pertencem a classe
Object.
• Estes métodos só podem ser chamados
dentro de um código synchronized.
• Se não forem chamados dentro de um
bloco synchronized lançam
IlegalMonitorStateException

@regismelo 235

Thread

notifyAll()
• Proporcionam uma maneira para um
objeto compartilhado parar uma Thread
num determinado momento e por de volta
em execução num momento apropriado.

@regismelo 236

Thread

notifyAll()
• Uma Thread que executa o método wait(),
deixa de executar e vai para o pool,
daquele objeto, de Threads que estão
esperando para executar. Ao mesmo
tempo é deixado o lock do objeto.

@regismelo 237

Thread

notifyAll()
public synchronized String retrieveMessage() {
while (request == false) {
try {
wait();
} catch (InterruptedException e) { }
}
request = false;
return message;
}

@regismelo 238

Thread

notifyAll()
• A chamada no método notify() faz com que
ocorra uma escolha arbitrária de uma Thread,
entre as que estão bloqueadas no monitor do
objeto, para ser posta novamente em execução.

public synchronized void storeMes(String message) {
this.message = message;
request = true;
notify();
}

@regismelo 239

Thread

notifyAll()
• O método notifyAll() faz com que todas as Thread que
estão no estado bloqueado para o monitor do objeto
sejam postas no estado de pronto (ready-to-run) para
competirem pelo lock do objeto.

public synchronized void storeMes(String message) {
this.message = message;
request = true;
notifyAll();
}

@regismelo 240

Thread

Simulado

@regismelo 241

Os pacotes java.lang e
java.util

@regismelo 242

Java cert programmer

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Java cert programmer

Ähnlich wie Java cert programmer (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (6)

Java cert programmer

Hinweis der Redaktion