1. Sun Certified Java
P R O G R A M M E R
Capítulo 3: Atribuições
José Martins da Nobrega Filho
martins.ufcg@gmail.com
2. Conteúdo do Capítulo
• Alocações - Pilha e Heap
• Tipos Primitivos e seus Literais
• Casting de valores primitivos
• Passagem de Parâmetros
• Arrays e Matrizes
• Blocos de Inicialização
• Garbage Collection
• Wrapper Classes e Boxing
• Referências
• Dúvidas
José Martins da Nobrega Filho - martins.ufcg@gmail.com
3. Alocações - Pilha e Heap
• Instâncias de variáveis locais são alocadas
na pilha.
• Os outros tipos de variáveis e os objetos
são alocados no heap.
José Martins da Nobrega Filho - martins.ufcg@gmail.com
4. Alocações - Pilha e Heap
1. class Collar { }
2.
3. class Dog {
4. Collar c;
5. String name;
6.
7. public static void main(String [] args) {
8.
9. Dog d;
10. d = new Dog();
11. d.go(d);
12. }
13. void go(Dog dog) {
14. c = new Collar();
15. dog.setName("Aiko");
16. }
17. void setName(String dogName) {
18. name = dogName;
19.
20. }
21. }
José Martins da Nobrega Filho - martins.ufcg@gmail.com
5. Alocações - Pilha e Heap
1. class Collar { }
2.
3. class Dog {
4. Collar c; // As variáveis declaradas no scopo de uma classe
5. String name; // ficam armazenadas no heap (lembrando que o
6. // valor da variavel é uma referência).
7. public static void main(String [] args) {
8.
9. Dog d;
10. d = new Dog();
11. d.go(d);
12. }
13. void go(Dog dog) {
14. c = new Collar();
15. dog.setName("Aiko");
16. }
17. void setName(String dogName) {
18. name = dogName;
19.
20. }
21. }
José Martins da Nobrega Filho - martins.ufcg@gmail.com
6. Alocações - Pilha e Heap
1. class Collar { }
2.
3. class Dog {
4. Collar c;
5. String name;
6.
7. public static void main(String [] args) {
8. // O método main() e a variável d estão
9. Dog d; // na pilha mas o objeto Dog está no
10. d = new Dog(); // heap. Nesse caso a variável d possui
11. d.go(d); // uma referência para o objeto Dog
12. }
13. void go(Dog dog) {
14. c = new Collar();
15. dog.setName("Aiko");
16. }
17. void setName(String dogName) {
18. name = dogName;
19.
20. }
21. }
José Martins da Nobrega Filho - martins.ufcg@gmail.com
7. Alocações - Pilha e Heap
1. class Collar { }
2.
3. class Dog {
4. Collar c;
5. String name;
6.
7. public static void main(String [] args) {
8.
9. Dog d;
10. d = new Dog();
11. d.go(d);
12. }
13. void go(Dog dog) { // O objeto String ("Aiko")
14. c = new Collar(); // estará no heap e durante o
15. dog.setName("Aiko"); // método set ele terá duas
16. } // variáveis que o referencia
17. void setName(String dogName) { // (name e dogName). A variável
18. name = dogName; // name estará no heap e a
19. // variável dogName estará na
20. } // pilha.
21. }
José Martins da Nobrega Filho - martins.ufcg@gmail.com
8. Tipos Primitivos e seus Literais
• Os tipos primitivos são: char, byte, short, int,
long, float, double, boolean.
• Strings e Arrays não são tipos primitivos
apesar de existir literais para o objeto
String.
• Existe as seguintes classes de literais:
Inteiro Octal, Inteiro Decimal, Inteiro
Hexadecimal, Ponto Flutante, Booleanos,
Caracteres e Strings.
José Martins da Nobrega Filho - martins.ufcg@gmail.com
9. Tipos Primitivos e seus Literais
• Números Octais possuem o prefixo '0'
tendo no máximo 22 dígitos (21 de acordo
com o livro-texto).
• Números Hexadecimais possuem o prefixo
'0x' tendo no máximo 16 dígitos.
• Os números Hexadecimais e Octais são
convertidos implicitamente em
representações decimais.
José Martins da Nobrega Filho - martins.ufcg@gmail.com
10. Tipos Primitivos e seus Literais
01. int a1 = 011111111111; // 11 dígitos - 1227133513
02. int a2 = 0111111111111; // 12 dígitos - Erro
03. long a3 = 0111111111111; // 12 dígitos - Erro
04. long a4 = 0111111111111111111111L; // 21 dígitos -
05. // "1317624576693539401"
06. long a5 = 01111111111111111111111L; // 22 dígitos -
07. // "-7905747460161236407"
08. long a6 = 011111111111111111111111L; // 23 dígitos - Erro
01. int a1 = 0x11111111; // 8 dígitos - 286331153
02. int a2 = 0x111111111; // 9 dígitos - Erro de Compilação
03. long a3 = 0x111111111; // 9 dígitos - Erro de Compilação
04. long a4 = 0x1111111111111111L; // 16 dígitos -
05. // 1229782938247303441
06. long a5 = 0x11111111111111111L;// 17 dígitos - Erro de Compilação
07. long a6 = 0xDDDDDDDDFFFFFFFFL; // 16 dígitos -
08. // "-2459565875921944577"
José Martins da Nobrega Filho - martins.ufcg@gmail.com
11. Tipos Primitivos e seus Literais
• Pontos flutuantes são normalmente
representados em 64 bits podendo ser em
32 bits caso especificado.
• Java não define uma representação inteira
para booleanos (diferente de C++).
• Os Caracteres são de 16 bits (Unicode) e
também possuem uma representação
numérica.
José Martins da Nobrega Filho - martins.ufcg@gmail.com
12. Tipos Primitivos e seus Literais
01. float a1 = 11.12F; // a1 == 11.12
02. float a2 = 11.12D; // Erro de Compilação
03. float a3 = 11.12; // Erro de Compilação
04. float a4 = 11.F; // a4 == 11.0
05. float a5 = .11F; // a5 == 0.11
01. boolean f = 0; // Erro de Compilação
02. int x = 1;
03. if (x) { } // Erro de Compilação
01. char letter1 = 'u004E'; // letter1 == 'N'
02. char letter2 = 'a';
José Martins da Nobrega Filho - martins.ufcg@gmail.com
13. Casting de valores Primitivos
• O Compilador realiza um casting implícito,
quando possível, de um literal inteiro para
unidades menores.
• Expressões envolvendo inteiros menores
que um int-size resultam sempre no tipo
int.
• A atribuição de uma variável a outra
variável é sempre realizada por cópia.
José Martins da Nobrega Filho - martins.ufcg@gmail.com
15. Casting de valores Primitivos
• Um Casting Inplícito é sempre realizado
quando um valor é atribuido a uma
variável cujo número de bits é maior.
• Um Casting de um ponto flutuante para
um inteiro é realizado por truncamento.
• Um cast para um tipo "menor" é realizado
discartando os bits de maior magnitude.
• Variáveis locais não são auto-inicializadas
sendo seu uso proibido antes da atribuição
José Martins da Nobrega Filho - martins.ufcg@gmail.com
16. Casting de valores Primitivos
01. float f = 234.56F;
02. short s = (short)f; // Truncamento do Valor
03. byte t = (byte) f; // Truncamento dos bits
04. System.out.println(s); // Output: 234
05. System.out.println(t); // Output: -22
06. char c = 70000; // Erro de Compilação
07. char d = (char) -98; // Válido
08. char e = -29; // Erro de Compilação
01. public static void main(String[] args) {
02. Date date;
03. int valor
04. if (date == null) { } // Erro de compilação
05. if (valor == 0) { } // Erro de compilação
06. }
José Martins da Nobrega Filho - martins.ufcg@gmail.com
17. Casting de valores Primitivos
01. public class ClasseDeTeste {
02. private Object valor1;
03. private int valor2;
04.
05. public ClasseDeTeste () { }
06.
07. public boolean metodo1 () {
08. return valor1.hashCode() == valor2; // Runtime Error
09. }
10.
11. public static void main(String[] args) {
12. ClasseDeTeste t = new ClasseDeTeste();
13. System.out.println(t.metodo1());
14. }
15. }
José Martins da Nobrega Filho - martins.ufcg@gmail.com
18. Passagem de Parâmetros
• A passagem de parâmetros em java é
sempre por valor.
• É comum questões que tornam o código
sombrio através de variáveis com o mesmo
nome e passagens de parâmetros.
José Martins da Nobrega Filho - martins.ufcg@gmail.com
19. Passagem de Parâmetros
01. class Foo {
02. Bar myBar = new Bar();
03. void changeIt(Bar myBar) {
04. myBar.barNum = 99;
05. System.out.println("Output2: " + myBar.barNum);
06. myBar = new Bar();
07. myBar.barNum = 420;
08. System.out.println("Output3: " + myBar.barNum);
09. }
10. public static void main (String [] args) {
11. Foo f = new Foo();
12. System.out.println("Output1: " + f.myBar.barNum);
13. f.changeIt(f.myBar);
14. System.out.println("Output4: " + f.myBar.barNum);
15. }
16. }
José Martins da Nobrega Filho - martins.ufcg@gmail.com
20. Passagem de Parâmetros
01. class Foo {
02. Bar myBar = new Bar();
03. void changeIt(Bar myBar) {
04. myBar.barNum = 99; // Altera o membro dessa instância
05. System.out.println("Output2: " + myBar.barNum);
06. myBar = new Bar();
07. myBar.barNum = 420; // Altera outra instância
08. System.out.println("Output3: " + myBar.barNum);
09. }
10. public static void main (String [] args) {
11. Foo f = new Foo();
12. System.out.println("Output1: " + f.myBar.barNum);
13. f.changeIt(f.myBar); // Passa o próprio membro
14. System.out.println("Output4: " + f.myBar.barNum);
15. }
16. }
Output1: 0
Output2: 99
Output3: 420
Output4: 99
José Martins da Nobrega Filho - martins.ufcg@gmail.com
21. Arrays e Matrizes
• A declaração de Arrays ou Matrizes contém
um par de colchetes no nome do tipo ou
no nome da variável.
• A definição do tamanho de um Array ou
Matriz só é realizada em sua instanciação.
• Os Arrays e Matrizes são objetos e portanto
ficam armazenados no Heap.
• Todos os elementos são auto-inicializados
com o valor padrão.
• Java não aceita índices negativos.
José Martins da Nobrega Filho - martins.ufcg@gmail.com
22. Arrays e Matrizes
01. int[] a1;
02. int a2 [];
03. Thread[] a3;
04. Thread a4[];
05. String[][][] a5;
06. String[] a6[];
07 int[5] a7;
01. int[] a1 = new int[5];
02. Thread[] a2 = new Thread[5];
03. int[] a3= new int[]; // Erro de Compilação
04. int[] a4 = {6,9,8}; // Usado apenas na declaração
05. Dog[] a5 = {null, new Dog("Clover"), new Dog("Aiko")};
06. int[][] a6 = {{5,2,4,7}, a4, {3,4}};
07. int[] a7;
08. a7 = new int[] {4,7,2}; // Array Anônimo
09. f.takesAnArray(new int[] {7,7,8,2,5});
10. new int[3] {3, 4, 5} //Erro de Compilação
11. int[][] a7 = new int[3][];
José Martins da Nobrega Filho - martins.ufcg@gmail.com
23. Arrays e Matrizes
01. int[][] myArray = new int[3][];
02. myArray[0] = new int[2];
03. myArray[0][0] = 6;
04. myArray[0][1] = 7;
05. myArray[1] = new int[3];
04. myArray[0][0] = 8;
04. myArray[0][1] = 9;
04. myArray[0][2] = 5;
José Martins da Nobrega Filho - martins.ufcg@gmail.com
24. Arrays e Matrizes
• Quando um Array ou Matriz é passado
como parâmetro apenas a referência é
copiada.
• Os elementos dos arrays estão sujeitos as
mesmas regras de Casting ditas
anteriormente.
• Um array de tipos primitivos não sofre
Casting inplícito quando atribuído a outro
array de tipo primitivo.
José Martins da Nobrega Filho - martins.ufcg@gmail.com
25. Arrays e Matrizes
01. private static void metodo1 (String[] valor) { }
02. private static void metodo2 (Object[] valor) { }
03. private static void metodo3 (int[] valor) { }
04.
05. public static void main(String[] args) {
06. metodo1 (new String[5]);
07. metodo1 (new Object[5]); // Erro de Compilação
08. metodo1 (new String[5][]); // Erro de Compilação
07. metodo1 ((String[]) new Object[5]); // Runtime Error
08. metodo1 ((String[]) new String[5][]); // Erro de Compilação
09.
10. metodo2 (new Object[5]);
11. metodo2 (new String[5]);
12. metodo2 (new String[5][]);
13.
14. metodo3 (new int[5]);
15. metodo3 (new byte[5]); // Erro de Compilação
16. metodo3 (new int[5][]); // Erro de Compilação
15. metodo3 ((int[]) new byte[5]); // Erro de Compilação
16. metodo3 ((int[]) new int[5][]); // Erro de Compilação
17. }
José Martins da Nobrega Filho - martins.ufcg@gmail.com
26. Blocos de Inicialização
• Os blocos de inicialização executam na
ordem em que aparecem no código.
• Os blocos de inicialização estáticos só
executam uma única vez.
• Os blocos de inicialização de instância
executam sempre que o objeto é criado e
logo após a execução do super().
• Sempre que ocorre um erro nos blocos de
inicialização a JVM lança um
ExceptionInInitializationError
José Martins da Nobrega Filho - martins.ufcg@gmail.com
27. Blocos de Inicialização
01. public class Main {
02. Main(int x) { System.out.println("Costrutor com param"); }
03. Main() { System.out.println("Costrutor"); }
04. static { System.out.println("Static 1"); }
05. { System.out.println("Init1"); }
06. { System.out.println("Init2"); }
07. static { System.out.println("Static 2"); }
08. public static void main(String [] args) {
09. new Main();
10. new Main(7);
11. }
12. }
José Martins da Nobrega Filho - martins.ufcg@gmail.com
28. Blocos de Inicialização
01. public class Main {
02. Main(int x) { System.out.println("Costrutor com param"); }
03. Main() { System.out.println("Costrutor"); }
04. static { System.out.println("Static 1"); }
05. { System.out.println("Init1"); }
06. { System.out.println("Init2"); }
07. static { System.out.println("Static 2"); }
08. public static void main(String [] args) {
09. new Main();
10. new Main(7);
11. }
12. }
Static 1
Static 2
Init1
Init2
Costrutor
Init1
Init2
Costrutor com param
José Martins da Nobrega Filho - martins.ufcg@gmail.com
29. Blocos de Inicialização
• Os blocos de inicialização executam na
ordem em que aparecem no código.
• Os blocos de inicialização estáticos só
executam uma única vez.
• Os blocos de inicialização de instância
executam sempre que o objeto é criado e
logo após a execução do super().
• Sempre que ocorre um erro nos blocos de
inicialização a JVM lança um
ExceptionInInitializationError
José Martins da Nobrega Filho - martins.ufcg@gmail.com
30. Garbage Collection
• O Garbage Collection (GC) está sob o
controle da JVM.
• Um programa em Java pode solicitar o
início do GC ao JVM que pode não atender.
• Um objeto eleito pelo GC pode ser
excluído a qualquer momento.
• Um objeto é elegível quando nenhuma
Thread viva pode acessá-lo.
• O exame para Java 6 removeu o uso do
System.gc ().
José Martins da Nobrega Filho - martins.ufcg@gmail.com
31. Wrapper Classes e Boxing
o Construtor com um parâmetro String da classe Boolean retorna
Boolean.TRUE quando o argumento é igual (case-insensitive) a 'true' e
retorna Boolean.FALSE nos outros casos.
José Martins da Nobrega Filho - martins.ufcg@gmail.com
32. Wrapper Classes e Boxing
• Cada Wrapper possui um conjunto de métodos
para realizar boxing e unboxing.
• valueOf(): cria objetos Wrappers correspondente
a uma representação textual (string).
• xxxValue(): retorna o valor encapsulado pelo
objeto Wrapper.
• parseXxx(): retorna o valor primitivo
correspondente a uma representação textual
(string).
• toString(): Converte um "valor primitivo" numa
representação textual.
José Martins da Nobrega Filho - martins.ufcg@gmail.com
33. Wrapper Classes e Boxing
José Martins da Nobrega Filho - martins.ufcg@gmail.com
34. Wrapper Classes e Boxing
01. Integer a1 = new Integer(42);
02. byte b1 = a1.byteValue();
03. short b2 = a1.shortValue();
04. double b3 = a1.doubleValue();
05.
06. Float a2 = new Float(3.14f);
07. short b4 = a2.shortValue();
08.
09. double b5 = Double.parseDouble("3.14");
10. Double b6 = Double.valueOf("3.14");
11.
12. long b7 = Long.parseLong("101010", 2);
13. Long b8 = Long.valueOf("101010", 2);
14.
15. String b9 = Double.toString(3.14);
16. String b9 = "hex = "+ Long.toString(254,16);
17.
18. String b10 = Integer.toHexString(254);
19. String b11 = Long.toOctalString(254);
20. String b12 = Long.toBinaryString(254);
José Martins da Nobrega Filho - martins.ufcg@gmail.com
35. Wrapper Classes e Boxing
• Autoboxing é a realização de Boxing e
Unboxing de forma transparete ao
programador.
• Autoboxing só existe em versões
superiores ao Java 5.
• Os operadores == e != são aplicados aos
valores dos Wrappers quando:
• O tipo é Boolean ou Byte
• É um Character entre u0000 e u007f
• É um Integer ou Short entre -128 e 127
José Martins da Nobrega Filho - martins.ufcg@gmail.com
36. Wrapper Classes e Boxing
01. Integer y = 567;
02. Integer x = y;
03. System.out.println(y==x);
04. y++;
05. System.out.println(x + " " + y);
06. System.out.println(y==x);
José Martins da Nobrega Filho - martins.ufcg@gmail.com
37. Wrapper Classes e Boxing
01. Integer y = 567;
02. Integer x = y;
03. System.out.println(y==x);
04. y++; // AutoBoxing
05. System.out.println(x + " " + y);
06. System.out.println(y==x);
true
567 568
false
José Martins da Nobrega Filho - martins.ufcg@gmail.com
38. Wrapper Classes e Boxing
01. Integer y = 567;
02. Integer x = y;
03. System.out.println(y==x);
04. y++; // AutoBoxing
05. System.out.println(x + " " + y);
06. System.out.println(y==x);
true
567 568
false
01. Integer y = 567; // Boxing
02. Integer x = y;
03. System.out.println(y==x);
04. int aux = y.intValue(); // UnBoxing
05. aux++;
06. y = new Integer(aux); // Boxing
07. System.out.println(x + " " + y);
08. System.out.println(y==x);
José Martins da Nobrega Filho - martins.ufcg@gmail.com
39. Wrapper Classes e Boxing
01. Integer y = 567;
02. Integer x = y;
03. System.out.println(y==x);
04. y++; // AutoBoxing
05. System.out.println(x + " " + y);
06. System.out.println(y==x);
true
567 568
false
01. Integer y = 567; // Boxing
02. Integer x = y;
03. System.out.println(y==x);
04. int aux = y.intValue(); // UnBoxing
05. aux++;
06. y = new Integer(aux); // Boxing
07. System.out.println(x + " " + y);
08. System.out.println(y==x);
Autoboxing num objeto nulo ocasiona um NullPointerException
José Martins da Nobrega Filho - martins.ufcg@gmail.com
40. Wrapper Classes e Boxing
01. System.out.println(new Integer(1000) == new Integer(1000));
02. System.out.println(new Integer(1000) != new Integer(1000));
03.
04. System.out.println(new Integer(10) == new Integer(10));
05. System.out.println(new Integer(10) != new Integer(10));
06.
07. Integer a1 = 1000;
08. Integer a2 = 1000;
09. System.out.println(a1 == a2);
10. System.out.println(a1 != a2);
11.
12. Integer a3 = 10;
13. Integer a4 = 10;
14. System.out.println(a3 == a4);
15. System.out.println(a3 != a4);
José Martins da Nobrega Filho - martins.ufcg@gmail.com
41. Wrapper Classes e Boxing
01. System.out.println(new Integer(1000) == new Integer(1000));
02. System.out.println(new Integer(1000) != new Integer(1000));
03.
04. System.out.println(new Integer(10) == new Integer(10));
05. System.out.println(new Integer(10) != new Integer(10));
06.
07. Integer a1 = 1000;
08. Integer a2 = 1000;
09. System.out.println(a1 == a2);
10. System.out.println(a1 != a2);
11.
12. Integer a3 = 10;
13. Integer a4 = 10;
14. System.out.println(a3 == a4);
15. System.out.println(a3 != a4);
false
true
false
true
José Martins da Nobrega Filho - martins.ufcg@gmail.com
42. Wrapper Classes e Boxing
01. System.out.println(new Integer(1000) == new Integer(1000));
02. System.out.println(new Integer(1000) != new Integer(1000));
03.
04. System.out.println(new Integer(10) == new Integer(10));
05. System.out.println(new Integer(10) != new Integer(10));
06.
07. Integer a1 = 1000;
08. Integer a2 = 1000;
09. System.out.println(a1 == a2);
10. System.out.println(a1 != a2);
11.
12. Integer a3 = 10;
13. Integer a4 = 10;
14. System.out.println(a3 == a4);
15. System.out.println(a3 != a4);
false
true
true
false
José Martins da Nobrega Filho - martins.ufcg@gmail.com
43. Referências
SIERRA, Kathy. SCJP - Sun Certified Programmer for
Java 6 Study Guide. McGraw-Hill Osborne Media; 1
edition (June 24, 2008), p 221-325.
José Martins da Nobrega Filho - martins.ufcg@gmail.com
44. Dúvidas?
José Martins da Nobrega Filho - martins.ufcg@gmail.com