Este documento apresenta os tópicos da certificação SUN Certified Programmer for Java 2 Platform. Ele discute as metodologias de ensino, os pré-requisitos necessários, o livro adotado e outras certificações relacionadas. O documento também fornece uma introdução aos fundamentos da linguagem Java, incluindo estrutura de programas, tipos primitivos, arrays e coleta de lixo.

1. SUN Certified Java
Programmer
@regismelo
@regismelo 1

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

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

4. 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

5. 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

6. 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

7. Livro adotado
@regismelo 7

8. Referência
@regismelo 8

9. Outras certificações
@regismelo 9

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

11. Language Fundamentals
@regismelo 11

12. Language Fundamentals
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

13. Language Fundamentals
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

14. Language Fundamentals
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

15. Language Fundamentals
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

16. Language Fundamentals
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

17. Language Fundamentals
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

18. Language Fundamentals
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

19. Language Fundamentals
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

20. Language Fundamentals
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

21. Language Fundamentals
Keywords
• A linguagem Java possui 52 palavras chave/reservadas:
assert
@regismelo 21

22. Language Fundamentals
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

23. Language Fundamentals
Tipos Primitivos
• Os tipos primitivos em Java, são:
boolean
char
byte
short
int
long
float
double
@regismelo 23

24. Language Fundamentals
Tipos Primitivos
• Tipos primitivos e seus tamanhos
* Em java, booleanos só podem receber valores true e false.
@regismelo 24

25. Language Fundamentals
Tipos Primitivos
• Faixas dos inteiros primitivos
* Em java, não existe o modificador “unsigned”
@regismelo 25

26. Language Fundamentals
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

27. Language Fundamentals
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

28. Language Fundamentals
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

29. Language Fundamentals
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

30. Language Fundamentals
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

31. Language Fundamentals
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

32. Language Fundamentals
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

33. Language Fundamentals
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

34. Language Fundamentals
Arrays
• Declarando:
1. int[] ints;
2. double[] dubs;
3. Dimension dims [];
4. float[][] twoDee;
@regismelo 34

35. Language Fundamentals
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

36. Language Fundamentals
Arrays
• Quanto um array é declarado os seus elementos
são automaticamente inicializados:
@regismelo 36

37. Language Fundamentals
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

38. Language Fundamentals
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

39. Language Fundamentals
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

40. Language Fundamentals
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; }
public static void main( String args[] )
{ int i = 0; bar(i); System.out.println(i); }
}
@regismelo 40

41. Language Fundamentals
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 )
public static void main( String args[] )
{ valor = k; }
{ public String toString() {
Bar i = new Bar(); return ( valor + "" );
i.setValor(10); }
bar(i);
}
System.out.println(i);
}
}
@regismelo 41

42. Language Fundamentals
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

43. Language Fundamentals
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

44. Language Fundamentals
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

45. 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

46. 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

47. 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

48. 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

49. Inicializadores Estáticos
• Uma classe pode possuir mais de um bloco
estático;
• Eles são executados não ordem em que foram
criados;
Ex:
public class StaticInitializer {
static int i, x;
static {
i++;
}
static {
x = i;
}
}
@regismelo 49

50. Inicializadores Estáticos
• Um bloco estático não pode lançar nenhuma Checked Exception;
• Todas as possíveis exceções devem ser tratadas;
Ex:
public class StaticInitializer {
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

51. 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

52. Inicializadores de Instância
• 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

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

54. Inicializadores de Instância
• 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

55. Inicializadores de Instância
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

56. 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

57. Ordem de Inicialização
• 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

58. Ordem de Inicialização
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

59. Language Fundamentals
Simulado
@regismelo 59

60. Operators and Assignments
@regismelo 60

61. Operators and Assignments
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

62. Operators and Assignments
@regismelo 62

63. Operators and Assignments
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

64. Operators and Assignments
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

65. Operators and Assignments
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

66. Operators and Assignments
Unary Operators
• Incremento e decremento ( ++ -- )
@regismelo 66

67. Operators and Assignments
Unary Operators
• Operador unário + e –
1. x = -3;
2. y = +3;
3. z = -(y + 6);
@regismelo 67

68. Operators and Assignments
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

69. Operators and Assignments
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

70. Operators and Assignments
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

71. Operators and Assignments
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

72. Operators and Assignments
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

73. Operators and Assignments
Arithmetic Operators
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

74. Operators and Assignments
Arithmetic Operators
• 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

75. Operators and Assignments
Arithmetic Operators
• 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

76. Operators and Assignments
Arithmetic Operators
• 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

77. Operators and Assignments
Arithmetic Operators
• 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

78. Operators and Assignments
Arithmetic Operators
• 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

79. Operators and Assignments
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

80. Operators and Assignments
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

81. Operators and Assignments
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

82. Operators and Assignments
Os operadores Shift <<, >> e >>>
@regismelo 82

83. Operators and Assignments
Os operadores Shift <<, >> e >>>
@regismelo 83

84. Operators and Assignments
Os operadores Shift <<, >> e >>>
@regismelo 84

85. Operators and Assignments
Os operadores Shift <<, >> e >>>
@regismelo 85

86. Operators and Assignments
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

87. Operators and Assignments
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

88. Operators and Assignments
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

89. Operators and Assignments
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

90. Operators and Assignments
Operadores de bit - &, ^ e |
• & = and, ^ = XOR e | = OR
@regismelo 90

91. Operators and Assignments
Operadores de bit - &, ^ e /
• & = and, ^ = XOR e | = OR
@regismelo 91

92. Operators and Assignments
Operadores de bit - &, ^ e |
• & = and, ^ = XOR e | = OR
@regismelo 92

93. Operators and Assignments
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

94. Operators and Assignments
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

95. Operators and Assignments
Simulado
@regismelo 95

96. Modifiers
@regismelo 96

97. 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

98. 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

99. 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

100. 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

101. 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

102. 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

103. 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

104. 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

105. 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

106. 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

107. 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

108. 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

109. 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

110. Modifiers
Outros Modificadores - static
• 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

111. Modifiers
Outros Modificadores - static
• 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

112. 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

113. 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

114. 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

115. Modifiers
Simulado
@regismelo 115

116. Converting and Casting
@regismelo 116

117. Converting and Casting
Objetivos
• Determinar o resultado do uso de qualquer operador
incluindo operadores de associação, instanceof, castings,
escopo de classes e acessibilidade.
@regismelo 117

118. Converting and Casting
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

119. Converting and Casting
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

120. Converting and Casting
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

121. Converting and Casting
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

122. Converting and Casting
Primitives and Conversion -
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

123. Converting and Casting
Primitives and Conversion -
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

124. Converting and Casting
Primitives and Conversion -
Assignments
“Widening Conversions”
@regismelo 124

125. Converting and Casting
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

126. Converting and Casting
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

127. Converting and Casting
Primitive Conversion
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

128. Converting and Casting
Primitive Conversion
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

129. Converting and Casting
Primitive Conversion
Arithmetic Promotion
• 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

130. Converting and Casting
Primitive Conversion
Arithmetic Promotion
• 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

131. Converting and Casting
Primitive Conversion
Arithmetic Promotion
• 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

132. Converting and Casting
Primitive Conversion
Arithmetic Promotion
• 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

133. Converting and Casting
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

134. Converting and Casting
Primitives and Casting
• 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

135. Converting and Casting
Primitives and Casting
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

136. Converting and Casting
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

137. Converting and Casting
Object Reference Assignment Conversion
• Possibilidades de conversão:
1. Oldtype x;
2. Newtype y = x;
@regismelo 137

138. Converting and Casting
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

139. Converting and Casting
Object Reference Casting
• Possibilidades de conversão:
NewType nt; OldType ot; nt = (NewType)ot;
@regismelo 139

140. Converting and Casting
Simulado
@regismelo 140

141. Flow control and Exceptions
@regismelo 141

142. Flow control and Exceptions
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

143. Flow control and Exceptions
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

144. Flow control and Exceptions
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

145. Flow control and Exceptions
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

146. Flow control and Exceptions
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

147. Flow control and Exceptions
Break and Continue
• Continue com labels
mainLoop:
for ( ; ; )
{
for ( ; ; ) {
if ( true ) {
continue mainLoop;
}
}
}
@regismelo 147

148. Flow control and Exceptions
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

149. Flow control and Exceptions
Break and Continue
• Break com labels
mainLoop:
for ( ; ; )
{
for ( ; ; ) {
if ( true ) {
break mainLoop;
}
}
}
@regismelo 149

150. Flow control and Exceptions
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

151. Flow control and Exceptions
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

152. Flow control and Exceptions
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

153. Flow control and Exceptions
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

154. Flow control and Exceptions
Exceptions
• Para o exemplo do slide anterior:
@regismelo 154

155. Flow control and Exceptions
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

156. Flow control and Exceptions
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

157. Flow control and Exceptions
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

158. Flow control and Exceptions
Categories of Exceptions
@regismelo 158

159. Flow control and Exceptions
Categories of Exceptions
• 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

160. Flow control and Exceptions
Categories of Exceptions
• 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

161. Flow control and Exceptions
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

162. Flow control and Exceptions
Exceptions and Overriding
@regismelo 162

163. Flow control and Exceptions
Simulado
@regismelo 163

164. Objects, Classes e Interfaces
@regismelo 164

165. 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

166. 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

167. Objects and Classes
Conceitos Gerais de O.O.
• Objetos; • Herança;
• Classes; • Polimorfismo;
• Interfaces; • Encapsulamento;
• Abstração; • Hierarquia;
@regismelo 167

168. 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

169. 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

170. 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

171. 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

172. Objects and Classes
Overriding
@regismelo 172

173. Objects and Classes
Overriding
@regismelo 173

174. 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

175. 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

176. Objects and Classes
Construtores
@regismelo 176

177. 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

178. 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

179. 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

180. 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

181. 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

182. 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

183. 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

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

185. Objects and Classes
Inner Classes Exemplo 1
@regismelo 185

186. Objects and Classes
Inner Classes Exemplo 2
@regismelo 186

187. Objects and Classes
Inner Classes
• Para um exemplo mais completo,
Adicionar ao codigo anterior...
@regismelo 187

188. Objects and Classes
4 Tipos de Inner Classes
• Top-level nested classes
• Non-static inner classes
• Local Classes
• Classes anônimas
@regismelo 188

189. 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

190. 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

191. Objects and Classes
Exemplo Top-Level Nested Class
@regismelo 191

192. Para referenciar...
• Para referenciar a classe (3) :
TopLevelClass.NestedTopLevelClass.NestedTopL
evelInterface
• Para referenciar a classe (4)
TopLevelClass.NestedTopLevelClass.NestedTopL
evelClass1
@regismelo 192

193. 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

194. Objects and Classes
Exemplo 2
@regismelo 194

195. 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

196. Objects and Classes
Definindo Non-Static Inner Class
@regismelo 196

197. 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

198. 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

199. 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

200. Objects and Classes
Exemplo Classes Locais (1/2)
@regismelo 200

201. Objects and Classes
Exemplo Classes Locais (2/2)
@regismelo 201

202. 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

203. Objects and Classes
Classes Anônimas
• As mesmas regras de acesso para as
classes locais se aplicam para classe
anônimas.
@regismelo 203

204. Objects and Classes
Classes Anônimas
@regismelo 204

205. Objects and Classes
Classes Anônimas (1/2)
@regismelo 205

206. Objects and Classes
Classes Anônimas (2/2)
@regismelo 206

207. Objects and Classes
Simulado
@regismelo 207

208. Thread
Threads
@regismelo 208

209. 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

210. 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

211. 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

212. 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

213. 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

214. 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

215. 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

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

217. 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

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

219. 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

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

221. 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

222. Thread
Seqüência dos Estados
@regismelo 222

223. 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

224. 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

225. 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

226. 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

227. 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

228. 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

229. 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

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

231. 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

232. 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

233. 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

234. 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

235. Thread
Métodos wait(), notify() e
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

236. Thread
Métodos wait(), notify() e
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

237. Thread
Métodos wait(), notify() e
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

238. Thread
Métodos wait(), notify() e
notifyAll()
public synchronized String retrieveMessage() {
while (request == false) {
try {
wait();
} catch (InterruptedException e) { }
}
request = false;
return message;
}
@regismelo 238

239. Thread
Métodos wait(), notify() e
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

240. Thread
Métodos wait(), notify() e
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

241. Thread
Simulado
@regismelo 241

242. Os pacotes java.lang e
java.util
@regismelo 242

243. Os pacotes java.lang e java.util
Objetivos
• Determinar o resultado da aplicação do método boolean
equals(Object ) para objetos de qualquer combinação de
classes java.lang.String, java.lang.Boolean ,
java.lang.Object.
• Escrever código usando os seguintes métodos de
java.lang.Math class: abs, ceil, floor, max, min, random,
round, sin, cos, tan,sqrt.
• Descrever o significado da imutabilidade de objetos
String.
• Fazer apropriada seleção de classes e interfaces de
coleções conforme especificados requerimentos.
@regismelo 243

244. Os pacotes java.lang e java.util
A classe Object
• Object é a classe mais genérica da hierarquia
de classes, todas as outras classes herdam
diretamente ou indiretamente dela.
• Se uma classe não contém a palavra extends na
sua declaração, o compilador construirá uma
classe que herda de Object.
• Todos os métodos desta classe são herdados
por suas sub classes.
@regismelo 244

245. Os pacotes java.lang e java.util
A classe Object
• Três métodos (wait, notify , notifyAll), que
oferecem suporte a threads, são vistos com
detalhes nos slides sobre threads.
• Dois outros métodos, equals() e toString(), não
oferecem muita funcionalidade por eles
próprios. A intenção é que o programador os
reescreva para lhes prover uma funcionalidade
mais específica para a classe.
@regismelo 245

246. Os pacotes java.lang e java.util
A classe Object
• Assinatura do método equals()
public boolean equals(Object object).
• Comparação com o operador == .
– if (date1 == date2) , compara se date1 e date2
referenciam ao mesmo objeto.
– If (date1.equals(date2)) , compara se date1 e date2
representam o mesmo momento no tempo.
• A versão de equals() fornecida por Object não é
muito útil, ela apenas faz uma comparação ==.
@regismelo 246

247. Os pacotes java.lang e java.util
A classe Object
• O propósito do método toString() é
fornecer uma representação do objeto
como String.
• É muito utilizado para debug.
• Assim como equals(), o método toString()
fornecido por Object, não é muito útil, ele
fornece o nome da classe do objeto
seguido por um hashcode.
@regismelo 247

248. A classe Object
• Outros métodos compõe a classe Object.
• public int hashCode();
– Retorna um código hash que identifica uma
instância.
• protected Object clone();
– Retorna uma cópia do objeto.
@regismelo 248

249. A classe Object
• protected void finalize()
– Método chamado quando o objeto vai ser
coletado pelo Garbage Collection;
• public final Class getClass()
– Método que retorna a classe do objeto;
@regismelo 249

250. Os pacotes java.lang e java.util
A classe Math
• A classe Math fornece uma coleção de métodos
e duas contantes para suporte a computação
matemática.
• A classe Math é final e não pode ser estendida.
• O construtor é private e não é possível criar uma
instância.
• Os métodos e constantes são static e podem
ser acessados sem construir um object Math.
@regismelo 250

251. Os pacotes java.lang e java.util
A classe Math
• As duas constantes da classe Math são :
Math.PI e Math.E, e são declaradas como
public , static, final e double.
• Os métodos da classe Math.
– int abs(int i) valor absoluto de i
– long abs(long l) valor absoluto de l
– float abs(float f) valor absoluto de f
– double abs(double d) valor absoluto de d
– double ceil(double d) o menor inteiro que não é
menor que d.
@regismelo 251

252. Os pacotes java.lang e java.util
A classe Math
– double floor(double d) o maior inteiro que não é
maior do que d .
– int max(int i1, int i2) maior entre i1 e i2
– long max(long l1, long l2) maior entre l1 e l2
– float max(float f1, float f2) maior entre f1 f2
– double max(double d1, double d2) maior entre d1 e
d2
– int min(int i1, int i2) menor entre i1 e i2
– long min(long l1, long l2) menor entre l1 e l2
– float min(float f1, float f2) menor entre f1 e f2
– double min(double d1, double d2) menor entre d1 e
d2
@regismelo 252

253. Os pacotes java.lang e java.util
As classes Wrapper
• Cada tipo primitivo boolean Boolean
tem uma byte Byte
correspondente
classe wrapper. char Character
• Uma classe wrapper short Short
é simplesmente uma int Integer
classe que encapsula
long Long
um simples e
imutável valor. float Float
double Double
@regismelo 253

254. Os pacotes java.lang e java.util
As classes Wrapper
• Todas as Wrapper classes podem ser
construídas passando o valor encapsulado pelo
construtor.
• Existem outros construtores para as classes
Wrapper (exceto a classe Character).
– Pode-se passar para o construtor, o valor a ser
encapsulado como uma String.
– Muitos desses construtores podem lançar uma
NumberFormatException, exceto a classe Boolean
que encapsula o valor true se a String é (ignore case)
“true”, encapsula o valor false caso contrário.
@regismelo 254

255. Os pacotes java.lang e java.util
As classes Wrapper
• Para extrair o valor de uma classe Wrapper que
encapsula determinado tipo type, usa-se o
método typeValue. Exemplo : intValue,
charValue, booleanValue, etc.
• Classes Wrapper fornecem métodos utilitários,
incluindo o métodos estáticos valueOf, que
convertem uma String para o tipo primitivo
assoaciado.
• As classes Wrapper são imutáveis, os valores
encapsulados não podem ser modificados.
@regismelo 255

256. Os pacotes java.lang e java.util
A classe String
• A classe string contém uma string imutável.
Uma vez que uma instância é criada, a string
que esta contém não pode ser alterada.
• Existem várias formas de construtor, criar uma
instância através de um array de bytes ou chars,
um subconjunto de um array de bytes ou chars,
outra string ou um string buffer.
@regismelo 256

257. Os pacotes java.lang e java.util
A classe String
• Podemos criar uma string sem utilizar o
construtor, através de uma literal.
String s = “chocolate”;
• Quando uma string literal é compilada, o
compilador adiciona ela a um pool de strings. Se
a mesma literal for utilizada novamente a
instância do pool será utilizada.
@regismelo 257

258. Os pacotes java.lang e java.util
A classe String
• Strings literais e comparação com ==.
String s1 = “chocolate”;
String s2 = new String(s1);
String s3 = “chocolate”;
s1 == s2 // não são a mesma instância.
s1 == s3 // são a mesma instância.
@regismelo 258

259. Os pacotes java.lang e java.util
A classe String
• Existem muitos métodos convenientes na classe String,
alguns desses realizarão uma transformação na String.
Por exemplo, toUpperCase() que transforma todos os
caracteres da String para maiúsculo. A string original
não é alterada (é imutável), uma nova instância é
retornada.
• Lista de métodos da classe String:
– char charAt(int index):
• Retorna um caracter indexado de uma string, onde o índice do
caracter inicial é 0.
@regismelo 259

260. Os pacotes java.lang e java.util
A classe String
– String concat(String addThis):
• Retorna uma nova string consistindo da string atual seguida
por addThis.
– int compareTo(String otherString):
• Faz uma comparação entra as duas strings. Se as duas
forem iguais 0 é retornado, -1 se a string for menor que o
argumento e 1 se ela for maior.
– boolean endsWith(String suffix):
• Verifica se a string corrente termina com suffix;
– boolean equals(Object ob):
• Verifica se duas strings são iguais em relação ao conteúdo.
@regismelo 260

261. A classe String
– boolean equalsIgnoreCase(String s):
• Este é igual ao equals(), porém a comparação não é case-
sensitive.
– int indexOf(int ch) ou int indexOf(String ch):
• retorna o indice da primeira ocorrência de argumento dentro
da atual string.
– int lastIndexOf(int ch) ou int lastIndexOf(String ch):
• Retorna o indice da última ocorrência do argumento dentro da
atual string.
@regismelo 261

262. Os pacotes java.lang e java.util
A classe String
– int length():
• Retorna o número de caracteres da atual string.
– String replace(char oldChar, char newChar):
• Retorna uma nova string, gerada pela substituição de todas
as ocorrências de oldChar por newChar.
– boolean startsWith(String prefix):
• Verifica se a string atual inicia com um determinado prefixo.
– String substring(int startIndex) ou String
substring(int start, int len):
• Retorna uma substring de uma determinada string.
@regismelo 262

263. Os pacotes java.lang e java.util
A classe String
– String toLowerCase():
• Converte todos os caracteres para minúsculo.
– String toString():
• Retorna a atual instância.
– String toUpperCase():
• Converte todos os caracteres para maiúsculo.
– String trim():
• Remove os espaços em branco do início e do fim da string.
@regismelo 263

264. Os pacotes java.lang e java.util
A classe StringBuffer
• Uma instância da classe StringBuffer representa
uma string que pode ser dinâmicamente
modificada.
• Construtores:
– StringBuffer(): constrói um string buffer vazio.
– StringBuffer(int capacity): contrói um string buffer
vazio com a capacidade inicial specificada.
– StringBuffer(String initialString): constrói um string
buffer com uma string inicial.
@regismelo 264

265. Os pacotes java.lang e java.util
A classe StringBuffer
• Um string buffer tem uma capacidade inicial de
16 caracteres.
• Caso uma string seja passado no construtor, o
tamanho final será de 16 mais o tamanho da
string.
• O string buffer pode crescer se necessário.
• A lista a seguir apresenta alguns métodos que
modificam o conteúdo de um string buffer.
Todos os métodos retornam a instância atual.
@regismelo 265

266. Os pacotes java.lang e java.util
A classe StringBuffer
– StringBuffer append(String str):
• Concatena a atual string com str. Alternativas
formas suportam a concatenação de tipos
primitivos e arrays de caracteres.
– StringBuffer append(Object obj):
• Chama toString no obj e concatena o resultado ao
atual string buffer.
– StringBuffer insert(int offset, String str):
• Insere o argumento no atual string buffer na
posição do offset.
@regismelo 266

267. A classe StringBuffer
– StringBuffer reverse():
• Inverte os caracters do atual string buffer.
– StringBuffer setCharAt(int offset, char newChar):
• Substitui o caractere da posição offset por
newChar.
– StringBuffer setLength(int newLength):
• Seta o tamanho do string buffer para newLength.
Se newLength é menor que o atual tamanho, a
string é trunacada. Se newlength é maior que o
atual tamanho, o string buffer é preenchida com
caracteres null.
@regismelo 267

268. Os pacotes java.lang e java.util
A classe StringBuffer
• Ambas as classes ,String e StringBuffer contém
métodos para comparação.
• Podemos comparar string com string, string
buffer com string buffer , porém a comparação
de string com string buffer sempre retornará
false, mesmo que os dois representem as
mesma sequência de caracteres.
@regismelo 268

269. Os pacotes java.lang e java.util
A classe StringBuffer
• Operador + de String x append de StringBuffer:
– A classe StringBuffer realiza as operações de
concatenação com uma performance muito maior do
que a concatenação com String.
– Para realizar a concatenação de duas strings com o
operador + , é criado um string buffer representando
a primeira string, concatenado a ele a outra string
através do método append() e retornado toString() do
string buffer criado.
@regismelo 269

270. Os pacotes java.lang e java.util
A API Collections
• A API Collections é frequentemente
referenciada como um framework. Isto é, as
classes foram designadas com uma comum
abstração de container de dados em mente,
garantindo uma uniforme semântica sempre que
possível.
• A classe factory java.util.Collections fornece
suporte suplementar para os vários tipos de
coleções com vários métodos auxiliares
estáticos. Alguns desses métodos oferecem
busca, imutabilidade e sincronização para as
coleções, entre outras coisas.
@regismelo 270

271. Os pacotes java.lang e java.util
A API Collections
• A API Collections fornece uma variedade
de interfaces e algumas classes
concretas.
• A Interface mais geral (de hierarquia mais
alta) é a interface Collection, que
especifica métodos para adicionar e
remover itens, determinar se itens
pertencem as coleções e verificar o
número de itens na coleção.
@regismelo 271

272. Os pacotes java.lang e java.util
A API Collections
@regismelo 272

273. Os pacotes java.lang e java.util
A API Collections
• Existem quatro comportamentos que
determinam os principais tipos de coleções:
– Uma coleção (collection) não tem uma especial
ordem e não rejeita itens duplicados.
– Uma lista (List) é ordenada e não rejeita itens
duplicados.
– Um conjunto (Set) não é ordenado e rejeita itens
duplicados.
– Um map suporta busca por um campo chave, valor
que deve ser único.
@regismelo 273

274. Os pacotes java.lang e java.util
Métodos Interface Collection
• Operações Básicas
int size();
boolean isEmpty();
boolean constains(Object element);
boolean add(Object element); (*)
boolean remove(Object element); (*)
(*) opcional
@regismelo 274

275. Os pacotes java.lang e java.util
Métodos Interface Collection
• Operações em Coleções
– boolean containsAll(Collection c);
– boolean addAll(Collection c); (*)
– boolean removeAll(Collection c); (*)
– boolean retainAll(Collection c); (*)
– Void clear(); (*)
(*) opcional
@regismelo 275

276. Os pacotes java.lang e java.util
Métodos Interface Collection
• Outros métodos
– Object[] toArray();
Preenche um array com os elementos da
coleção.
– Object[] toArray(Object a[]);
Permite especificar que tipo de array os
elementos da coleção serão armazenados.
@regismelo 276

277. Os pacotes java.lang e java.util
Métodos Interface Collection
• Iterator
– Interface Iterator {
public boolean hasNext();
public Object next();
public void remove(); //opcional
}
Permite o acesso seqüencial aos elementos de
uma coleção.
@regismelo 277

278. Os pacotes java.lang e java.util
Métodos Interface List
• Acesso aos elementos pelo índice.
Object get(int index);
Object set(int index, Object val); //opcional
void add(Object element);
void add(int index, Object element); //opcional
Object remove(int index); //opcional
boolean addAll(int index, Collection c); //opcional
@regismelo 278

279. Classe Collections
• Fornece métodos estáticos que
implementam algoritmos para operações
em coleções (a maioria em listas).
static int binarySearch(List list, Object key);
static void fill(List list, Object o);
static shuffle(List list);
static void sort(List list);
@regismelo 279

280. Coleções Sincronizadas
• Classe Collections
• Collection synchronizedCollection(Collection c)
• List synchronizedList(List l)
• Map synchronizedMap(Map m)
• Set synchronizedSet(Set s)
• SortedMap synchronizedSortedMap(SortedMap m)
• SortedSet synchronizedSortedSet(SortedSet s)
@regismelo 280

281. Os pacotes java.lang e java.util
Métodos Interface Map
• Um Map define um mapeamento de chave
para valor.
Object put(Object key, Object value); //opcional
Object get(Object key);
Object remove(Object key); //opcional
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
@regismelo 281

282. Os pacotes java.lang e java.util
Métodos Interface Map
• Operações em mais de um elemento.
– public void putAll(Map t); //opcional
– public void clear(); //opcional
• Operações em Coleções
– Set keySet();
– Collection values();
– Set entrySet();
@regismelo 282

283. Os pacotes java.lang e java.util
A API Collections
• Uma linked list permite elementos serem adicionados,
ou removidos de uma coleção em qualquer posição do
container, e permite o tamanho da coleção crescer
arbitrariamente. Cada item da lista é um objeto que
guarda uma referência para o próximo elemento.
• Uma tree, igualmente como uma list, oferece fácil
inserção e deleção de elementos e crescimento
arbitrário. Diferente de list, uma tree insiste em ordenar
os elementos. De fato o tipo Tree corresponde a uma
árvore ordenada, o mecanismo de comparação pode ser
especificado ou criado artificialmente em muitos casos.
@regismelo 283

284. Os pacotes java.lang e java.util
A API Collections
• Um hashtable requer que cada elemento
tenha um identificador único associado a
ele, o qual provê uma busca eficiente.
Hashes geram um hash code que
adiciona um overhead adcional , assim
um hashtable pode não ser o tipo
apropriado para uma coleção de poucos
elementos.
@regismelo 284

285. Os pacotes java.lang e java.util
A API Collections
• Existe uma variedade implementações
fornecidas pela API Collections que
implementam , Collection, Set , List , Map
usando vários tipos de armazenamento.
– HashMap- Hashtable. Ambas usam os
esquemas de armazenamento em hash. As
duas principais diferenças entre as duas
classes é que Hashtable não armazena itens
nulls e é sincronizada para ser utilizada com
várias threads.
@regismelo 285

286. Os pacotes java.lang e java.util
A API Collections
– HashSet é um set , assim não permite
elementos duplicados e utiliza hashing para
armazenamento.
– LinkedList é uma implementação de uma
linkedlist.
– TreeMap provê a implementação de uma
árvore ordenada. Os elementos devem ser
ordenáveis e devem implementar a interface
Comparable ou uma classe Comparator deve
ser fornecida para realizar as comparações.
@regismelo 286

287. Os pacotes java.lang e java.util
A API Collections
• TreeSet é uma classe que provê um ordenado
conjunto (set), usando uma árvore como forma
de armazenamento.
• Vector é uma classe implementa uma lista
utilizando um array interno como forma de
armazenamento. Esse array é dinamicamente
realocado conforme o número de itens cresce. A
coleção Vector é sincronizada suportando várias
threads.
• Nenhuma coleção é melhor do que outra,
apenas algumas são mais apropriadas para
uma determinada situação.
@regismelo 287

288. Os pacotes java.lang e java.util
Tipos de Classificação
• Interface Comparator.
public int compare(Object o1, Object o2);
• Retorna um numero negativo se o 1º objeto é
menor, positivo se for maior e zero se for igual.
• Ordem customizada. Se não especificada, utiliza
a ordem natural dos elementos(Interface
Comparable).
@regismelo 288

289. Os pacotes java.lang e java.util
Tipos de Classifcação
• Interface Comparable
• Permite especificar a ordem natural dos
elementos. String, Date, File utilizam ela.
• public int compareTo(Object o)
– Retorna um numero negativo se o objeto
corrente é menor do que o especificado,
maior que zero se for maior e zero se for
igual.
@regismelo 289

290. Simulado
@regismelo 290

291. Assertions
@regismelo 291

292. Assertions
Objetivos
• Saber quando, como e em quais situações
usar assertions.
• Como compilar código-fonte, controlar a
execução do programa, adicionar e
remover assertions.
@regismelo 292

293. Assertions
Por que usar Assertions?
• Como programadores, devemos fazer mais do
que checagem de erro.
• Código de tratamento de erro inclui uma
quantidade substancial de esforço de
programação.
• Não é possível eliminar todos os erros, mas
podemos planejar à frente do inesperado.
• Assertion pode ser usado para capturar
condições que não esperávamos acontecer.
@regismelo 293

294. Assertions
Por que usar Assertions?
• Assertions vs. outro código de erro;
• Design-by-Contract
– Pré-condições;
– Pós-condições;
– Invariantes;
@regismelo 294

295. Assertions
Sintaxe
• assert expressao1;
Exemplo:
assert foo != null;
Equivalente a
if ( ! (foo != null) ) {
throw new AssertionError();
}
@regismelo 295

296. Assertions
Sintaxe
• assert expressao1 : expressao2;
Exemplo:
assert foo != null : “Assertion”;
Equivalente a
if ( ! (foo != null) ) {
throw new AssertionError(“Assertion”);
}
@regismelo 296

297. Assertions
Compilando com Assertions
• java –source 1.3
– usa a sintaxe antiga.
• java –source 1.4
– usa a sintaxe nova, com assertion.
@regismelo 297

298. Assertions
Controlando Assertions
• Linha de comando
Símbolo Exemplo______________
-ea java –ea
-da java –da
-ea:<classname> java –ea:AssertClass
-da:<classname> java –da:AssertClass
-ea:<packagename> java –ea:Package0
-da:<packagename> java –da:Package0
@regismelo 298

299. Assertions
Controlando Assertions
• Linha de comando
Símbolo Exemplo______________
-esa java –esa
-dsa java –das
esa = enable system Assretion
@regismelo 299

300. Assertions
Controlando Assertions
• Programaticamente.
• Habilita ou desabilita o uso de assertions para uma
classe.
– public void setClassAssertionStatus(
String className, boolean enabled);
- Habilita ou desabilita o uso de assertions para um
pacote.
– public void setPackageAssertionStatus(
String packageName, boolean enabled);
@regismelo 300

301. Assertions
Controlando Assertions
• Programaticamente.
• Habilita o uso de assertions como default.
– public void setDefaultAssertionStatus(
boolean enabled);
• Desabilita o uso de todas as assertions.
– public void clearAssertionStatus();
@regismelo 301

302. Assertions
Quando usar Assertions
• Reforçar suposições sobre aspectos de
estruturas de dados.
• Reforçar constraints em argumentos de
métodos private.
• Checar condições que nunca deveriam ocorrer.
• Checar condições que nunca deveriam ocorrer,
mesmo que você esteja certo disso.
@regismelo 302

303. Assertions
Quando usar Assertions
• Checar condições relacionadas ao início de
qualquer método.
• Checar coisas no meio de loops grandes.
• Qualquer assertion é melhor do que nada.
@regismelo 303

304. Assertions
Quando não usar Assertions
• Reforçar o uso na linha de comando.
• Reforçar constraints em argumentos de
métodos públicos.
• Reforçar uso público de padrões ou protocolos.
• Reforçar uma propriedade de qualquer
informação de um usuário.
@regismelo 304

305. Assertions
Quando não usar Assertions
• Como se fosse o seguinte:
– If (something) error();
• Como um controle condicional externo.
• Checar a corretude de seu compilador, sistema
operacional ou hardware.
@regismelo 305

306. Assertions
Exemplos(regras de uso)
Regra: não usar assertions para reforçar o uso da
linha de comando.
public class Application {
public static void main(String[] args) {
//BAD!!
assert args.length == 3;
}
}
@regismelo 306

307. Assertions
Exemplos(regras de uso)
Regra: usar assertions para reforçar o uso de
constraints de argumentos para métodos
private.
public class aClass {
private void method(Object required, Object optional) {
assert (required != null) : “method():required = null”;
}
}
@regismelo 307

308. Assertions
Exemplos(regras de uso)
Regra: não usar assertions para reforçar
constraints de argumentos para métodos public.
public class aClass {
public void disconnect(Source required, Object optional)
{
//BAD!!
assert (required != null) : “method():required = null”;
}
}
@regismelo 308

309. Assertions
Exemplos(regras de uso)
Regra: não usar assertions para reforçar uso
público de padrões ou protocolos.
public class Connection {
private boolean isOpen = false;
public void close() {
//BAD!!
assert isOpen : “Cannot close a connection!”;
}
}
@regismelo 309

310. Assertions
Exemplos(regras de uso)
Regra: não usar assertions para reforçar uma
propriedade de uma informação de usuário.
public void processZipCode(String zipCode) {
if (zipCode.length() == 5) { //ok }
else {
//BAD!!
assert false:”Only 5- and 9- digit supported!”;
}
}
@regismelo 310

311. Assertions
Exemplos(regras de uso)
Regra: usar assertions para reforçar suposições
internas sobre aspectos de estruturas de dados.
private void showDate(int array[]) {
assert (array.length == 3);
}
@regismelo 311

312. Assertions
Exemplos(regras de uso)
Regra: usar assertions para checar condições no
fim de qualquer método.
public void open() {
//...
isOpen = true;
//...
assert isOpen;
}
@regismelo 312

313. Assertions
Exemplos(regras de uso)
Regra: usar assertions para checar condições
que nunca aconteceriam.
public void method() {
int a = getValue(); //returns 0
if (a == 0) { //deal with 0 }
else { assert false : “Impossible!!!” }
}
@regismelo 313

314. Assertions
Exemplos(regras de uso)
Regra: usar assertions para checar condições que
nunca aconteceriam, mesmo que você tenha
certeza.
public void method() {
int a = getValue(); //returns 0
assert a < 0 || a > 0 : “Impossible!!!”
}
@regismelo 314

315. Assertions
Exemplos(regras de uso)
Regra: usar assertions para checar condições
relacionadas ao início de qualquer método.
public void processZipCode(String zipCode) {
assert zipCodeMapIsValid();
//.....
}
@regismelo 315

316. Assertions
Exemplos(regras de uso)
Regra: usar assertions para checar coisas no meio
de um loop grande.
public void method() {
while (true) {
Socket socket = serverSocket.accept(); //long pause
assert socketListIsValid();
}
}
@regismelo 316

317. Assertions
Exemplos(regras de uso)
Regra: não usar assertions como algo do tipo: “if
(something) error();”
public class Server {
private int port;
public void listen() {
//BAD!!
assert port >= 1024 : “No permission to listen!”;
}
}
@regismelo 317

318. Assertions
Exemplos(regras de uso)
Regra: não usar assertions como uma condição de
controle externa.
public class App {
static private boolean turnLoggingOn() { return true; }
static public void main(String[] args) {
//BAD!!
assert turnLoggingOn();
}
}
@regismelo 318

319. Assertions
Exemplos(regras de uso)
Regra: não usar assertions para checar a
corretude de seu compilador, sistema
operacional ou hadware, a não ser que você
esteja depurando.
public void method() {
int a = 10;
//REDUNDANT!!
assert a == 10;
}
@regismelo 319

320. Assertions
Simulado
@regismelo 320

321. Assertions
Simuladão
@regismelo 321