A conversão permite a conversão de um tipo primitivo de um para outro de forma explícita ou implícita.
Vou esclarecer melhor:
Explícito é quando nós programadores escrevemos claramente.
Int To Long
Implícito, não precisamos informar nada para o compilador.
Long To Int
Em java temos a opção de inicialiazar uma variável ou não.
Uma variável local, deve possuir um valor antes de ser utilizada. Já variável de Instancia podem ser usadas com os valores que recebem “automaticamente” referente ao seu tipo.
Rereferencias de Objetos Locais: quando temos 2 objetos apontando para um, quando ocorre uma modificação em qualquer um deles, os outros também são alterados.
class Estudo{
publicstaticvoid main(String[] args) {
Integer num = new Integer(10);
Integer ref = num;
System.out.println(num);
}
}
Objetos STRING:
Em objetos do tipo String, quando se tem duas instancias apontando para uma referencia, a JVM não altera todos os “apontamentos”.
ARRAY
São objetos que armazenam diversas variáveis do mesmo tipo. Pode ser primitivo ou de objeto.
class Estudo{
publicstaticvoid main(String[] args) {
int [5] array; //invalido
int [] array1 = newint[5]; // valido
}
}
Array de objetos seguem a mesma sintaxe.
Int[] array = new Int[]; // invalido, onde está definido o tamanho?
Ainda podemos ter ARRAYS MULTIDIMENSIONAIS, que são arrays dentro de arrays.
int [][] array = newint[3][]; //valido
Arrays de objetos só armazenam as referências deles.
NULLPOINTEREXCEPTION => quando tentamos acessar algo onde sua referencia está nula.
Durante alguns exercícios que venho fazendo, tenho observado uma pegadinha bastante comum, que é a de verificar o tamanho de arrays.
Para verificar o tamanho deles utilizamos o LENGTH.
Uma array pode ser inicializado na sua construção;
int [] array = {6,7,8,9};
Um recurso interessante é que quando um array é de uma classe (Animal, por exemplo) podemos inserir nele um objeto do tipo Cachorro (tem que passar no teste É-UM).
ARRAY INTERFACE:
Quando um array é do tipo de uma interface, podemos adicionar elementos de outras classes, desde que estas implementam a interface, caso contrário um erro de compilação é exibido.
interface veiculo{
void velocidade();
}
class golf implements veiculo{
publicvoid velocidade() {
}
}
class fusca{
void cor(){
}
}
class Estudo{
publicstaticvoid main(String[] args) {
veiculo [] array = new veiculo[2];
array[0] = new golf();
array[1] = new fusca(); //erro de compilacao. Fusca nao implementa
array[2] = new veiculo() {
publicvoid velocidade() {}
}; //aqui adicionamos a interface, mas tivemos que implementar o metodo.
}
}
BLOCOS DE INICIALIZAÇÃO
É executado quando a classe é criada pela primeira vez, ou uma nova instancia é criada.
- Não possui nomes
- Não possui argumentos
- Não retorna nada
Existe uma ordem para ser executado:
1 – static
2 – bloco de instancia da classe
3 – instancia depois do construtor
class fusca{
{System.out.println("2 - Instancia - segundo a executar");}
fusca(){
System.out.println("3 - Bloco - terceiro a executar");
}
static{
System.out.println("1 - STATIC - primeiro a executar");
}
}
class Estudo{
publicstaticvoid main(String[] args) {
new fusca();
}
}
Blocos de inicialização podem lançar exceções....
CLASS WRAPPER.
Fornece a coversão de tipos primitivos para objetos String (vice-versa)
O nome do tipo primitivo é sempre representado em letra minuscula, execeto para int e char.
Uma class WRAPPER, possui 2 construtores.
1 – primitivo (boolean, byte, double)
2 – String
Float fl = new Float(3.14f);
Floatf2 = new Float("3.14f");
xxxValue()-> server para converter um valor de um objeto em um tipo primitivo.
Float fl = new Float(3.14f);
Integer inteiro = fl.intValue();
valueOf() -> Conversão de string para WRAPPER.
parseXXX() -> Conversão de string para primitivo
toString() -> representação signigicativa de um objeto.
Obs.: CLASSES WRAPPER, SÃO MARCADAS COMO FINAL, AU-TO-MA-TI-CA-MEN-TE
AUTOBOXING
Torna-se mais conveniente o uso das classes WRAPPER.
Quando usar ‘==’ e ‘!=’?
Quando tipos primitivos de uma classe wrapper forem: Boolean, Byte, Character, Short e Integer.
Segue um pequeno exemplo da JVM ampliando um método menor para um maior. Uma sobrecarga nada elegante.