Sun Certified Java Programmer Capítulo 3

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

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

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.


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


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).
8.
9. Dog d;
10. d = new Dog();
11. d.go(d);
12. }
16. }
18. name = dogName;
19.
20. }
21. }


1. class Collar { }
2.
3. class Dog {
4. Collar c;
5. String name;
6.
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. }
16. }
18. name = dogName;
19.
20. }
21. }


1. class Collar { }
2.
3. class Dog {
4. Collar c;
5. String name;
6.
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. }


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.

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


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"


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


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';


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.



01. byte a1 = 27; // Casting Implícito
02. char a2 = 10; // Casting Implícito
03. char a3 = 0x892; // Casting Implícito
04. byte a4 = 128; // Erro de Compilação
07. byte a7 = a5 + a6; // Erro de Compilação
08. a7 += 7; // Casting Implícito - Válido para /= *= -= +=
09. a5 = a6 // Cópia de valores


• 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


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



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.
12. ClasseDeTeste t = new ClasseDeTeste();
13. System.out.println(t.metodo1());
14. }
15. }


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.


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;
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);
15. }
16. }


01. class Foo {
02. Bar myBar = new Bar();
03. void changeIt(Bar myBar) {
04. myBar.barNum = 99; // Altera o membro dessa instância
06. myBar = new Bar();
07. myBar.barNum = 420; // Altera outra instância
09. }
10. public static void main (String [] args) {
11. Foo f = new Foo();
13. f.changeIt(f.myBar); // Passa o próprio membro
15. }
16. }

Output1: 0
Output2: 99
Output3: 420
Output4: 99


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.

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][];


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;


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.


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


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

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"); }
09. new Main();
10. new Main(7);
11. }
12. }


01. public class Main {
02. Main(int x) { System.out.println("Costrutor com param"); }
03. Main() { System.out.println("Costrutor"); }
09. new Main();
10. new Main(7);
11. }
12. }

Static 1
Static 2
Init1
Init2
Costrutor
Init1
Init2
Costrutor com param


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 ().

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.


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


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);


• 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

01. Integer y = 567;
02. Integer x = y;
03. System.out.println(y==x);
04. y++;
05. System.out.println(x + " " + y);


02. Integer x = y;
04. y++; // AutoBoxing

true
567 568
false


02. Integer x = y;

true
567 568
false

01. Integer y = 567; // Boxing
02. Integer x = y;
04. int aux = y.intValue(); // UnBoxing
05. aux++;
06. y = new Integer(aux); // Boxing


02. Integer x = y;

true
567 568
false

01. Integer y = 567; // Boxing
02. Integer x = y;
04. int aux = y.intValue(); // UnBoxing
05. aux++;
06. y = new Integer(aux); // Boxing

Autoboxing num objeto nulo ocasiona um NullPointerException


01. System.out.println(new Integer(1000) == new Integer(1000));
02. System.out.println(new Integer(1000) != new Integer(1000));
03.
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;


03.
06.
07. Integer a1 = 1000;
08. Integer a2 = 1000;
11.

false
true
false
true


03.
06.
07. Integer a1 = 1000;
08. Integer a2 = 1000;
11.

false
true
true
false


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.


Dúvidas?


Sun Certified Java Programmer Capítulo 3

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (19)

En vedette

En vedette (6)

Similaire à Sun Certified Java Programmer Capítulo 3

Similaire à Sun Certified Java Programmer Capítulo 3 (12)

Sun Certified Java Programmer Capítulo 3