Capítulo 3 - Atribuições

3. Atribuições 04:23 João Sávio C. Longo

Pilha e Heap

As variáveis locais residem na pilha;

Os objetos e suas variáveis de instâncias residem no heap;

04:23 João Sávio C. Longo

Literais

Os literais integer podem ser decimais, octais ou hexadecimais;

Os literais para longs terminam com L ou l;

Os literias float terminam com F ou f;

Os literais double terminam com um dígito, com D ou d;

Os literais booleanos são true e false;

Os literais char são os únicos dentro de aspas simples;

Literais char

Pode-se digitar o valor Unicode do caractere, usando a notação Unicode que acrescenta o prefixo u ao valor. Exemplo:

char letraN = ‘u004E’ //a letra ‘n’

Os caracteres são inteiros de 16 bits sem sinal (65535 ou menos);

Literais char

Exemplos válidos:

char a = 0x892; //literal hexadecimal

char b = 982; //literal inteiro

char c = (char) 70000; //a conversão é necessária -> possível perda de precisão

char d = (char) -98; //absurdo, mas válido;

char e = ‘”’; //aspas duplas

char f = ‘ ’; //nova linha

Escopo

Tempo de vida de uma variável;

As variáveis static vivem o mesmo tempo que suas classes;

As variáveis de instância vivem o mesmo tempo que seus objetos;

As variáveis locais vivem pelo mesmo tempo que os seus métodos na pilha. Entretanto, se o método chamar outro métodos, elas ficam temporariamente indisponíveis;

As variáveis de bloco (por exemplo, em um for ou if) vivem até a conclusão do bloco;

Atribuições Básicas

O resultado de uma expressão que envolva qualquer item do tamanho de um int ou menor, será sempre um tipo int;

Válido para char, short e byte;

Exemplo:

byte b = 3;

b = b + 7; //erro de compilação!

b= (byte) (b + 7); //correto

Os números de ponto flutuante são implicitamente doubles (64 bits);

Diminuir um tipo primitivo causa o corte dos bits de ordem mais alta (pode ocasionar mudança de sinal);

Atribuições compostas (por exemplo +=) realizam uma conversão automática;

No exemplo anterior, é válido b += 7;

As variáveis de referência podem referir-se a subclasses do tipo declarado, mas não a superclasses;

Ao criar-se um novo objeto, por exemplo, Button b = new Button();, três coisas acontecem:

Cria-se uma variável de referência chamada b, do tipo Button;

Cria-se um novo objeto Button;

Atribui-se o objeto Button à variável de referência b;

Valores Padrão

Variáveis locais não são inicializadas automaticamente. Se você tentar utilizar uma antes de inicializá-la, receberá um erro do compilador;

04:23 João Sávio C. Longo Tipo de Variável (instância) Valor Padrão Variável de referência de objeto null byte, short, int, long 0 float, double 0.0 boolean false char ‘ u0000’

Arrays

Podem conter tipos primitivos ou objetos, mas o array propriamente dito sempre será um objeto;

Quando você declarar um array, os colchetes poderão ficar à esquerda ou à direita do nome;

Não é válido incluir o tamanho do array na declaração;

Você precisa incluir o tamanho do array quando o construit (usando new), a menos que esteja criando um array anônimo;

Arrays

Quando um array de objetos for instanciado, os objetos do array não serão instanciados automaticamente, mas todas as referências receberão o valor padrão null;

Quando um array de primitivos for instanciado, todos os elementos receberão seu valor padrão;

Os arrays são indexados começando pelo 0;

Você receberá um NullPointerException se tentar usar o elemento de um array de objetos e esse elemento não referenciar um objeto real;

ArrayIndexOutOfBoundsException ocorre se você usar um valor de índice inválido;

Arrays

Um array de tipos primitivos aceitará qualquer valor que possa ser promovido implicitamente ao tipo declarado para o array. Por exemplo, uma variável byte, short ou char pode ser inserida em um array int;

Um array de objetos pode conter qualquer objeto que passe no teste “É-UM” aplicado ao tipo declarado para o array. Por exemplo, se Dog estender Animal, então um objeto Dog pode ser inserido em um array Animal;

Arrays

Se você atribuir um array a uma referência de array já declarada, o array terá que estar na mesma dimensão da referência ao qual foi atribuído;

Você pode atribuir um array de um tipo a uma referência de array já declarada de um de seus supertipos. Por exemplo, um array Dog pode ser atribuído a um array declarado como do tipo Animal;

Arrays

Arrays multidimensionais são arrays compostos por outros arrays;

Exemplo:

int [][] scores = new int[3][]; //isso é válido

scores[0] = new int[4];

Arrays

Declarando, construindo e inicializando em uma linha:

int[] a = {6,7,8};

int[][] scores = {{5, 2, 4, 7}, {9, 2}, {3, 4}};

scores[0] -> um array de quatro ints;

scores[1] -> um array de dois ints;

scores[0][1] -> o valor int igual a 2

Arrays

Construindo e inicializando um array anônimo:

int[] a;

a = new int[] {4, 7, 2};

O tamanho não deve ser especificado;

Observações

Dog[] d = null;

System.out.println(d[0]); //NullPointerException

Dog[] d = null;

d = new Dog[5];

System.out.println(d[0]); //o resultado será null

String title = null;

String s = title; //ok

String t = s.toLowerCase(); //NullPointerException

Passagem de Parâmetros

Sempre por valor;

No caso de variáveis de referência a objetos, o método chamado pode modificar o estado do objeto a que a variável se refere, mas não pode fazer com que ela se refira a um objeto diferente ou a null;

Exemplo 1:

class Dog {

static int idade = 7;

public static void main(String[] args) {

System.out.println(idade); //a saída é 7

mudaIdade(idade);

}

static void mudaIdade(int a) {

idade = a + 3;

}

}

Exemplo 2:

class Dog {

static int idade = 7;

mudaIdade(idade);

}

static void mudaIdade(int idade) { //sombreamento

idade = idade + 3;

}

}

Exemplo 3:

class Teste {

static int[] a;

a = new int[5];

System.out.println(a[0]); //a saída é 0

mudaA(a);

System.out.println(a[0]); //a saída é 4

}

static void mudaA(int[] b) { //sombreamento

b[0] = 4;

System.out.println(b[0]); //a saída é 4

}

}

Exemplo 4:

class Dog {

String nome;

}

public class Teste {

Dog b = new Dog();

mudaNome(b);

System.out.println(b.nome); //a saída é Dog1

}

static void mudaNome(Dog a) {

a.nome = "Dog1"; //muda o nome do objeto passado

a = new Dog(); //cria-se outro objeto

a.nome = "Dog2"; //muda o nome do novo objeto

}

}

Blocos de Inicialização

Os blocos de inicialização static rodam uma vez, quando a classe é carregada pela 1ª vez;

Os blocos de inicialização de instâncias rodam sempre que uma nova instância é criada. Eles rodam depois de todos os super-construtores e antes de ser executado o código do construtor;

Se existirem vários blocos de inicialização, eles seguem as regras acima e rodam na ordem em que aparecem no arquivo-fonte;

Usando Wrappers

As classes wrapper estão correlacionadas aos tipos primitivos;

Encapsulam tipos primitivos para que possam ser manipulados como objetos;

Fornecem métodos utilitários para tipos primitivos (geralmente conversões);

O nome do tipo wrapper é simplesmente o nome em maiúsculas do primitivo, exceto para char, que passa a ser Character, e int, que passa a ser Integer;

Usando Wrappers

Os objetos wrapper são inalteráveis. Uma vez que receberem um valor, ele não poderá ser alterado;

Os construtores wrapper podem usar uma String ou um tipo primitivo, exceto para Character, que só pode usar um tipo char;

Métodos mais importantes

xxxValue() -> wrapper -> primitivo ; não usa argumentos;

parseXxx() -> String -> primitivo ; usa uma String, é static, lança a exceção NumberFormatException;

valueOf() -> String -> wrapper ; usa uma String, retorna um objeto encapsulado, é static, lança a exceção NumberFormatException;

toString() -> wrapper/objeto -> String ;

toXxxString() -> wrapper -> String bin/octal/hex;

Exemplos:

Integer i = new Integer(42);

short s = i.shortValue();

double d = i.doubleValue();

double d2 = Double.parseDouble(“3.14”);

Double d3 = Double.valueOf(“3.14”);

Double d4 = new Double(“3.14”);

String s1 = d4.toString();

5. String d = Integer.toHexString(254); //converte 254 para hexa

Boxing

Permite converter tipos primitivos em wrappers ou vice-versa automaticamente;

A partir de Java 5 é possível:

Integer y = new Integer(567);

y++;

System.out.println(y); //a resposta é 568

Um segundo objeto wrapper foi criado;

Boxing, == e equals()

equals() -> Para todas as classes wrapper, dois objetos são iguais se forem do mesmo tipo e tiverem o mesmo valor;

== -> wrappers com os mesmos valores baixos (-128 a 127) serão ==, mas valores maiores não serão ==;

Sobrecarga Avançada

A ampliação de primitivos usa o menor argumento que seja mais amplo que o parâmetro;

Usados individualmente, o boxing e os var-args são compatíveis com a sobrecarga;

Não é possível ampliar de um tipo wrapper para outro (É-UM falha);

Não é possível ampliar e depois fazer boxing (um int não pode se tornar um Long);

Você pode fazer boxing e depois ampliar (um int pode se tornar um Object, através de um Integer);

Você pode combinar var-args com a ampliação ou com o boxing;

A ordem de preferência é:

Ampliação;

Boxing;

Var-args;

Exemplo 1:

class Teste {

static void go(int x) {System.out.println(“int “);}

static void go(long x) {System.out.println(“long “);}

static void go(double x) {System.out.println(“double“);}

byte b = 5; short s = 5; long l = 5; float f = 5.0f;

go(b); //a saída é int

go(s); //a saída é int

go(l); //a saída é long

go(f); //a saída é double

}

}

Exemplo 2:

class Teste {

static void go(Integer x) {System.out.println(“Integer “);}

static void go(long x) {System.out.println(“long “);}

int i = 5;

go(i); //a saída é long

}

}

Exemplo 3:

class Teste {

static void go(int x, int y) {System.out.println(“int, int“);}

static void go(byte... x) {System.out.println(“byte... “);}

byte b = 5;

go(b, b); //a saída é int, int

}

}

Exemplo 4:

class Teste {

static void go(Byte x, Byte y) {System.out.println(“Byte, Byte“);}

static void go(byte... x) {System.out.println(“byte... “);}

byte b = 5;

go(b, b); //a saída é Byte, Byte

}

}

Exemplo 5:

class Animal { static void eat() {} }

class Dog extends Animal {

Dog d = new Dog();

d.go(d); //sem problemas, porque Dog É-UM animal

}

void go(Animal a) {}

}

Exemplo 6:

class Dog {

Dog d = new Dog();

d.test(new Integer(5)); //não se pode ampliar de um tipo

//wrapper para outro

}

void test(Long x) {}

}

Exemplo 7:

class Teste {

static void go(Long x) {System.out.println(“Long“);}

byte b = 5;

go(b); //não se pode ampliar e depois fazer boxing

}

}

Exemplo 8:

class Teste {

static void go(Object o) {

Byte b2 = (Byte) o;

System.out.println(b2)

}

byte b = 5;

go(b); //este byte pode ser transformado em um Object?

}

}

Resposta -> Sim, pois:

O byte b foi encapsulado com boxing em um Byte;

A referência Byte foi ampliada para se tornar Object (Byte É-UM Object);

O método go() recebeu uma referência Object que, na verdade, aponta para um objeto Byte;

O método go() converteu a referência Object de volta para uma referência Byte (nunca houve um objeto do tipo Object, apenas um objeto do tipo Byte com referência Object);

Coleta de Lixo

A JVM decide quando executá-lo;

Pode-se solicitar a JVM a execução, mas não haverá garantia, em nenhuma circunstância, de que ela o fará;

É garantido que o coletor de lixo rodará antes que um OutOfMemoryError seja lançado;

System.gc() solicita a coleta de lixo;

Tornando os objetos explicitamente qualificados para a coleta

Anulando uma referência:

Car c = new Car();

//ainda não está qualificado

c = null;

//agora o objeto está qualificado

Reatribuindo uma variável de referência

Car c1 = new Car();

Car c2 = new Car();

c1 = c2; //perde-se a referência ao primeiro objeto

//Car e o torna qualificado para a coleta

Isolando uma referência

public class Car {

private Car car;

public static void main(String[] args){

Car c1 = new Car(); Car c2 = new Car(); Car c3 = new Car();

c1.car = c2;

c2.car = c3;

c3.car = c1;

c1 = null; c2 = null; c3 = null;

//c1, c2 e c3 estão qualificados para a coleta

}

}

Fazendo a limpeza antes da coleta de lixo - método finalize()

Este método é chamado pelo Garbage Collector antes de remover determinada instância do objeto da JVM;

Você pode sobrescrever este método em sua classe e implementar dentro dele rotinas para serem executadas antes da finalização, como por exemplo liberar recursos que estejam presos, etc;

Como não é possível contar com o coletor de lixo para excluir o objeto, nenhum código que você insira no método finalize() sobrescrito de sua classe terá a execução garantida;

Fazendo a limpeza antes da coleta de lixo - método finalize()

finalize() será chamado apenas uma vez (no máximo) pelo coletor de lixo;

finalize() pode resultar em salvar um objeto da exclusão - você poderia escrever um código que retornasse uma referência do objeto em questão para outro objeto, desqualificando o objeto da coleta;