terça-feira, 31 de agosto de 2010

Resumo SCJP - Parte VI


Aqui iniciamos mais um capitulo, o 4.

OPERADORES

A precedencia de valores sermpe será avaliada a expressão da direita.

int x = 8;
x += 2 + 5;

COMPARAÇÃO -> os operadores de comparação sempre resultam em um valor booelano (true ou false)

- não se pode comparar tipos diferentes;
- podemos fazer o seguinte.
      double d = 3.0;
      int a = 3;
      System.out.println(d == a);//true

-    Nunca confundir =(atribuição) com == (comparação)
-    Para valores boolean vc pode usar a atribuição dentro do if
      boolean b;
      if(b = true) System.out.println("");


ENUMS

Para enums podemos utilizar tanto o == quanto o equals() para comparação das variaveis.

enum color{
      RED, GREEN
}

class Estudo{
     
      public static void main(String[] args) {
            color c = color.GREEN;
            color d = color.RED;
      System.out.println(c == d);
      }
}


INSTANCEOF

Este operador é usado apenas para variveis de objeto, para verificar se um objeto é específico de outro.

class LuzDaVida{}

class Estudo extends LuzDaVida{
     
      public static void main(String[] args) {
     
            LuzDaVida ldv = new Estudo(); // passa no teste E-UM
            Estudo estudo = new Estudo();
            m2(ldv);
           
      }
     
      public static void m2(LuzDaVida ldv){
            if(ldv instanceof Estudo){
                  System.out.println("Ops");
            }
      }
     
}

CONCATENAÇÃO DE STRINGS

O operador de + pode somar inteiros e concatenar strings, vai depender do valor a sua esquerda.
     
      public static void main(String[] args) {
            String a = "aa";
            int b = 10;
            int c = 20;
            System.out.println(a + b + c); //aa1020
           
      }

ACRÉSCIMO E DECRÉSCIMO

Aumenta ou diminui um valor da variavel.
(i++) => so aumenta depois da exibição do valor
(++i) => incrementa antes de ser usada.


VARIAVEL FINAL
Variavel que é marcada como final, não pode ser alterada, logo, operadores de incremento ou decremento, gera erro de compilação.

OPERERADORES LÓGICOS DE ABREVIAÇÃO
Serve para avaliar instruções com mais de uma expressão.

&& -> verifica as duas expressões sendo verdadeira
|| -> verifica  um dos dois operandos, se o primeiro é verdadeiro o segundo é ‘esquecido’, rsrs


OPERADORES SEM ABREVIAÇÃO
Estes operadores avaliam os dois lados da expressão.

& -> mesmo se a primeira expressão for falsa, ele verifica a outra.
| -> mesmo se a primeira expressão for verdadeira, ele verifica a outra.
^ -> avalia somente valores booleanos, avalia ambos operando.
! -> inverte o resultado da expressão (true<->false)

Aqui chegamos ao final de mais um capitulo.
Espero que o resumão ajude.

segunda-feira, 30 de agosto de 2010

Resumo SCJP - Parte V


CONVERSÃO DE TIPOS PRIMITIVOS:
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{
      public static void 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{
      public static void main(String[] args) {
            int [5] array; //invalido
            int [] array1 = new int[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 = new int[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{
      public void velocidade() {
      }
}

class fusca{
      void cor(){
           
      }
}
class Estudo{
      public static void 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() {
                  public void 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{
      public static void 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);
      Float f2 = 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.
  
class Estudo{
      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 ");    }
     
      public static void main(String[] args) {
            byte a = 5;
            short s = 4;
            long l = 3;
            float f = 5.0f;
           
            go(a); //int
            go(s); // int
            go(l); // long
            go(f); // double
      }
}


BOXING == e EQUALS:
Com objetos wrapper devemos tomar muito cuidade ao usar o == e o equals.

== > funciona bem até o 127
Equals > verifica se os valores dos objetos wrapper são iguais.

class Estudo{
      public static void main(String[] args) {
            Integer x = 10;
            Integer y = 10;
            Integer m = new Integer(10);
           
            System.out.println(x == y); //true
            System.out.println(x == m); // false
            System.out.println(x.equals(m)); // true
      }
}
Quando camparamos com o equals, verificamos no objeto, devemos tomar cuidado com isso.

SOBRECARGA COM BOXING E VARARGS:
 - A ampliação tem mais prioridade que boxing e varargs.
 - Mas o boxing tem mais prioridade do que os varargs.


AMPLIAÇÃO DE VARIAVEIS DE REFERENCIA


class golf implements veiculo{
      public void velocidade() {
      }
}

class fusca extends golf{
      public void corre(golf g){}
}

class Estudo{
      public static void main(String[] args) {
            fusca fuc = new fusca();
            golf g = new golf();
            fuc.corre(g); //aqui ocorre ampliação
      }
}

·         NÃO É POSSIVEL AMPLIAR E DEPOIS FAZER BOXING
·         O COMPILADOR PODE FAZER BOXING SEGUIDA DA OPERAÇÃO DE AMPLIAÇÃO
class Estudo{

      static void go(Long x){System.out.println("ampliação");}
     
      public static void main(String[] args) {
            byte b = 5;
            go(b); // erro de compilação
      }
}
·         JÁ COM VARARGS É POSSIVEL REALIZAR A COMBINAÇÃO DE COM AMPLIAÇÃO OU COM BOXING.
class Estudo{
     
      static void go1(long ... x){System.out.println("long");}
      static void go2(Integer ... x){System.out.println("Integer");}
       
  public static void main(String[] args) {
        int i = 5;
        go1(i);//long
        go2(i);//integer
  }
}


COLETOR DE LIXO

Solução automatica em java para o gerenciamento de memória.
Ele tebalha com objetos que estão na memoria heap.

MÉTODO FINALIZE()
- não se pode contar para sua execução.
- objetos chamam o finalize apenas 1 vez;
- o foco principal é que informa ao codigo que seja executado até sua exclusão do heap;
- qualquer excessão lançada por esse metodo é ignorada pela coletor de lixo.

Chegamos ao final de mais um capítulo, o terceiro.
Espero mais uma vez que meus resumos possam ajudar.