Tipos Primitivos - Java

Hoje vou falar sobre tipos primitivos em Java. Veremos uma breve introdução sobre variáveis e em seguida detalhes sobre cada tipo.

Variáveis

Variáveis são espaços na memória onde podemos guardar informações. Provavelmente todos programas que você escrever vão usar variáveis, seja para guardar um nome, o caminho de uma pasta, etc. Também, como o próprio nome diz, elas podem variar, ter seu valor modificado durante a execução do programa.
Variáveis são nada mais que depósitos de bits. Cada valor é convertido para binário e então pode ser colocado na memória. Usamos o nome da variável para acesar o valor. O nome da variável é apenas o endereço para acessar o valor atribuído a ela.
As variáveis possuem tipos diferentes, dependendo da informação a ser armazenada. Por exemplo: Podemos ter um depósito tipo short que nos dará um espaço para guardar qualquer valor que convertido em binário possua 16 bits (65535 valores possíveis).
Em Java temos os seguintes tipos primitivos:

Tipo      Bits      Bytes
___________________________
byte     8         1
short    16        2
int      32        4
long     64        8
float    32        4
double   64        8
char     16        2
boolean  -         -

Eles são chamados de tipos primitivos porque são tipos já pre definidos pela linguagem e seus nomes são palavras reservadas. Eles não são como os objetos. Objetos são um tipo de dado criado pelo usuário que possuem um estado e tem métodos. Primitivos não possuem estados nem métodos. Objetos podem mudar de tipo, mas os primitivos não. Uma vez declarado o tipo, assim ele será e somente o valor poderá mudar.

Os primitivos apenas determinam o tipo e o tamanho da informação a ser guardado. Vou fazer um breve comentário sobre os tipos primitivos disponíveis em Java:

• byte: O byte aceita até 256 valores. Eles podem estar compreendidos entre -128 <= x <= 127. Porque alguém usaria um tipo desses? Poderia usar para salvar bytes num grande vetor, como uma memória virtual.
• short: O tipo short suporta valores entre -32,768 <= x <= 32,767. Ele possui o dobro de tamanho do byte e sua aplicação poderia ser a mesma. Não se preocupe em decorar esses intervalos. Apenas o intervalo do tipo byte é bom saber mas os outros saiba apenas o número de bits de acordo com a tabela.
• int: O tipo int está compreendido entre -2,147,483,648 <= x <= 2,147,483,647. Geralmente esse tipo é usado como padrão para valores inteiros. E muitas vezes, para os valores que seu programa usará, este tipo dá e sobra!
• long: Um valor do tipo long pode estar entre 9,223,372,036,854,775,808 <= x <= 9,223,372,036,854,775,807. Como você pode ver, este tipo é usado quando precisar guardar valores realmente grandes que o int não poderia fazê-lo.
• float: O intervalo de números deste tipo é complicado de determinar, apenas saiba que ele possui 32 bits de precisão. Ele é usado para representar os números reais, não só inteiros mas também os fracionários. O formato desse tipo de número é normalmente chamado de floating point ou ponto flutuante. Eles podem representar números com uma boa precisão fornecendo uma aproximação para valores imensos. A forma como são representados pela linguaguem é um assunto muito interessante, recomendo que você procure algo sobre se ainda não conhece. Obs.: Este tipo nunca deve ser usado para valores realmente precisos, como moeda por exemplo. Para isto use a classe java.math.BigDecimal.
• double: Assim como o float, o double representa números floating point. A diferença é que ele possui 64 bits de precisão. Para valores decimais (não inteiro) esse tipo é a melhor escolha. Como mencionado anteriormente, ele também não pode ser usado para representar valores de moeda.
• char: O tipo char representa um único caractere Unicode. Unicode é um padrão para representar caracteres utilizando números inteiros de 16 bits (sem sinal). Assim ele pode armazenar o mesmo tamanho de informação que um short poderia, exceto que ele sua faixa é apenas números positivos. Pode-se digitar valores Unicode utilizano o prefixo "\u".
• boolean: Esse tipo de dado só tem duas possibilidades: false ou true. Ele representa um bit de informação, embora seu "tamanho" não é algo precisamente definido. Desta forma valores booleanos podem ser somente uma das possibilidades citadas, nunca tente usar 0 ou 1! Outras linguagens como c++ aceitam isto, mas Java não.

É importante saber a sequência: byte, short, int, long, float, double. Lembre que double é maior que float, o próprio nome diz que é o dobro de precisão.
Outro detalhe é que todos tipos numéricos possuem sinal, isto é, podem ser tanto positivos quanto negativos e que isto afeta seu intervalo.
Como disse no começo do tópico, os valores são guardados em formato binário (001011...), sendo assim precisamos de um desses bits para definir o sinal do número. Este bit será o que se encontra mais a esquerda do número. Por exemplo: Temos um byte 00010011. O primeiro zero a esquerda representa o sinal. Sobram sete bits para representar o número, ou seja, 2^7 = 128 possibilidades.
Portanto, o byte pode representar valores entre -128 <= x <= 127, ou melhor: de -128 a -1 e de 0 a 127. Também podemos dizer que há 256 valores aí, metade negativa e metade -1 positiva. Menos um porque os positivos começam pelo zero, e ele é considerado um binário positivo.
A fórmula para calcular o intervalo mínimo (negativo) é -2^(bits - 1) e o máximo (positivo) é 2^(bits - 1) - 1.
Lembrando também que em Java não existe a palavra unsigned como em c++. Isto que dizer que todos valores devem respeitar as faixas permitidas como foi mostrado anteriormente. Não tente fazer algo como byte b = 128; sem fazer nenhuma conversão.

Bom, por hoje é só e bons estudos!

Sobrescrita / Sobercarga (Overriding / Overloading) - Java

O assunto de hoje é sobre o objetivo 1.5 e 5.4 do exame SCJP. Os objetivos são basicamente determinar se um método esta corretamente sendo sobrescrito ou sobrecarregado e sobre os tipos de retorno válidos para o método.

Também fala sobre desenvolver código que declare e chame métodos sobrescritos ou sobrecarregados, e códigos que chamem construtores da superclasse sendo eles sobrescritos ou sobrecarregados.

Métodos sobrescritos

Sempre que herdamos um método da superclasse, podemos sobrescrevê-lo. Fazendo isto temos a oportunidade de determinar um comportamento específico do método para a subclasse. Então estamos dizendo "Sei que existe um método genérico herdado da superclasse para fazer isto, mas este método não me serve e quero que esta subclasse tenha o seu próprio". Tudo bem, mas não esqueça que métodos marcados como final, private ou static não são herdados e por este motivo não podem ser sobrescritos.

Para demonstrar como os métodos são sobrescritos vou usar o mesmo código que usei no tópico sobre casting:

//Superclasse
public class Animal {

void comer(){
 System.out.println("Animal comendo...");
}

}
//Subclasse
class Dog extends Animal{

void rolar(){
 System.out.println("Dog rolando...");
}
//Dog sobrescreveu o método comer
void comer(){
 System.out.println("Dog comendo...");
}
}

Dog herdou o método comer de animal mas por algum motivo teve que escrever seu próprio método comer. Então se num determinado momento quisermos chamar:

new Dog().comer();

Teremos o resultado Dog comendo.... Sem problemas.

Vamos analisar alguns casos agora. Se você herdou métodos abstratos de uma classe abstrata, então é obrigatório sobrescrevê-los (na prática você estaria implementando porque não tem nada pra sobrescrever). Mas se sua classe também for abstrata não precisa, você pode simplente "passar a vez" para a última classe concreta da árvore. Só não esqueça que em algum momento você será obrigado a sobrescrever os métodos abstract.

Uma questão interessante que também foi abordada no post sobre casting é a seguinte: Quando sobrescrevemos um método e depois fazemos o upcast, qual método será chamado? Seguindo o mesmo exemplo do código acima, se fizermos a seguinte chamada:

Animal a = new Dog();
a.comer();

Qual versão do método será executada? Sabemos que quando convertemos pra cima da árvore de herança, os métodos do subtipo são perdidos mas neste caso a versão executada será a do subtipo. Porque? O compilador só verifica o tipo da variável e não da da instância. A referência é do tipo Animal? Então só métodos de Animal poderão ser executados. Mas em tempo de execução, o objeto real que está sendo executado é Dog, então o método de Dog será chamado.

Parece confuso mas pense: Estamos criando uma referência Animal para Dog. O que o compilador vai fazer? Ele vai pensar "Vou criar um objeto tipo Dog na memória e uma variável x tipo Animal que aponte pra este objeto." A variável sendo do tipo Animal não tem conhecimento dos métodos em Dog. Acontece que quando o programa for executado a JVM vai pensar "A variável x está chamando o método em Animal, mas o objeto sobrescreveu? Então execute o método do objeto!".

Outro ponto importante é que os métodos sobrescritos não podem declarar um modificador de acesso mais restritivo do que o que foi sobrescrito. Por exemplo:

//Superclasse
public class Animal {

protected void comer(){
 System.out.println("Animal comendo...");
}

}
//Subclasse
class Dog extends Animal{

void comer(){ //Problema!!!
 System.out.println("Dog comendo...");
}
}

Declaramos o método como protected mas depois tentamos deixá-lo default. Isto não compila porque default é mais restritivo que protected. Como expliquei antes, em tempo de execução, a JVM chama a versão do método sobrescrito, e o modificador de acesso ficou mais restrito. Se ele estivesse em um pacote diferente não poderia ser chamado.

Vamos ver agora umas regras importantes:

A lista de argumentos deve se manter a mesma!. Se ela mudar o método não será mais sobrescrito e sim sobrecarregado. Lembre-se que sobrescrever não é nada mais que usar o mesmo nome do método herdado.

O modificador de acesso do novo método não pode ser mais restritivo (menos pode). Já falei sobre isto!

Métodos só podem ser sobrescritos se forem herdados. Ou seja, métodos final, private ou static não podem. E classes fora do pacote só podem sobrescrever métodos public ou protected (métodos protected são herdados).

O tipo de retorno deve ser o mesmo ou um subtipo do método original. Isto chama-se retornos covariantes ou covariant returns. Este é um assunto a parte mas apenas lembre-se que o tipo de retorno pode ser o mesmo ou um subtipo. Não tem problema em retornar um subtipo porque com certeza ele "cabe" no supertipo.

O método que sobrescreveu pode lançar qualquer exceção de tempo de execução (não verificada / unchecked), mesmo que o método original não tenha lançado.

O método que sobrescreveu não pode lançar exceções verificadas (checked) novas ou mais abrangentes que as declaras pelo método original. Este é um assunto para outro post.

Pra finalizar a parte de sobrescrita vou fazer só mais duas observações importantes: Podemos chamar a versão da superclasse do método usando a palavra chave super:

//Superclasse
public class Animal {

void comer() {
 System.out.println("Animal comendo...");
}

public static void main(String[] args) {
 Dog g = new Dog();
 g.comer();
}
}

// Subclasse
class Dog extends Animal {

void rolar() {
 System.out.println("Dog rolando...");
}

// Dog sobrescreveu o método comer
void comer() {
 super.comer(); //Chamou a versão da superclasse
 System.out.println("Dog comendo...");
}

}

E outra, mesmo não tento falado sobre exceções vou insistir em colocar uma questão aqui que poderá cobrada no exame:

//Superclasse
public class Animal {

void comer() throws Exception {
 //Lança uma exceção
}
public static void main(String[] args) {
 Animal a = new Dog(); //Referência polimórfica
 a.comer();
}
}

// Subclasse
class Dog extends Animal {

void rolar() {
 System.out.println("Dog rolando...");
}

// Dog sobrescreveu o método comer
void comer() {
 System.out.println("Dog comendo...");
}
}

Um método foi sobrescrito, mas está sendo chamado através de uma referência polimórfica (do superclasse) para apontar para o objeto do subtipo. Como vimos o compilador vai pensar que você está chamando a versão da superclasse. Mas a JVM em tempo de execução vai chamar a versão da subclasse. A versão da superclasse declarou uma exceção, mas a do subtipo não. O código não compila devido a exceção declarada. Mesmo que a versão usada em tempo de execução seja a do subtipo.

Métodos Sobrecarregados

Metodos sobrecarregados tem uma diferença básica dos métodos sobrescritos: Sua lista de argumentos DEVE ser alterada. Por este motivo, os métodos sobrecarregados permitem que se utilize o mesmo nome do método numa mesma classe ou subclasse e isto pode ser usado para dar mais opções a quem for chamar o método. Por exemplo, podemos ter um método que receba uma variável int e outro que receba double, e a pessoa que for chamar não precisará se preocupar com fazer nenhuma conversão.

Diferente dos métodos sobrescritos, os sobrecarregados podem mudar o tipo de retorno e o modificador de acesso sem restrições. Eles também podem lançar exceções verificadas novas ou mais abrangentes.

Os métodos sobrecarregados podem ser declarados na mesma classe ou na subclasse. Saber diferenciar métodos sobrecarregados dos sobrescritos é importante pra não cair em pegadinhas como:

public class Animal {

public void comer(int x, String s) {
 System.out.println("Animal comendo...");
}
}

class Dog extends Animal {

protected void comer(int x, float s) {
 System.out.println("Dog comendo...");
}
}

O código acima pode parecer violar uma das regras de sobrescrita (modificador mais restritivo) porém ele está é sobrecarregando pois houve mudança na lista de argumentos.

Uma questão importante em métodos sorbrecarregados é: Qual método será chamado? Isso vai depender exclusivamente dos argumentos passados. Por exemplo, no caso anterior se você chamar:

new Dog().comer(2, "a");

Vai retornar Animal comendo.... Mas e se usarmos argumentos de objetos ao invés de tipos primitivos?

public class Animal {

void teste(Animal a) {
 System.out.println("Animal");
}


public static void main(String[] args) {
 new Dog().teste(new Dog()); //Chamou passando um Dog
 new Dog().teste(new Animal()); //Chamou passando um Animal
}
}

class Dog extends Animal {

void teste(Dog d) {
 System.out.println("Dog");
}
}

A saída será normal, executou o método de acordo com o tipo passado:
Dog
Animal

Mas e se a referência usada fosse polimórfica:

Animal a = new Dog();
a.teste(a);

Qual versão será executada? Você poderia pensar que seria a versão de Dog, porque estamos passando uma referência ao objeto Dog. Mas não é, a saída seria Animal pois mesmo sabendo que em tempo de execução o objeto utilizado será um Dog e não um Animal, quando o método é sobrecarregado isto não é decidido em tempo de execução. Então lembre-se: Quando o método é sobrecarregado, apenas o tipo da referência importa para saber qual método será chamado.

Resumindo, o método sobrescrito a ser chamado é definido em tempo de execução e o sobrecarregado no tempo de compilação.

Então pra fechar o tópico vou dar mais uma dica: Fique atento aos métodos que parecem ser sobrescritos mas estão sendo sobrecarregados:

public class Animal {

void teste() { }

}

class Dog extends Animal {

void teste(String s) {}

}

A classe Dog tem dois métodos: A versão teste sem argumentos que herdou de Animal e a versão sobrecarregada. Um código que faz referência a Animal pode chamar somente teste sem argumentos mas uma referência a Dog pode chamar qualquer um.

Dever de casa
Dado:

class Plant{

String getName() { return "plant"; }
Plant getType() { return this; }

}

class Flower extends Plant{

 //Insira o código aqui

}

class Tulip extends Flower { }

Quais instruções, inseridas na linha comentada, irão compilar? (Marque todas corretas)

A. Flower getType() { return this; }
B. String getType() { return "this"; }
C. Plant getType() { return this; }
D. Tulip getType() { return new Tulip(); }

Conversão de Tipos ou Casting - Java

Não sei se alguem já notou mas as anotações sobre Java que estou postando aqui são apropriadas para quem vai prestar o exame SCJP (Sun Certified Java Programmer). Como também pretendo ser um programador certificado pela Sun, estou estudando e quero aproveitar para compartilhar com você meus resumos.

Hoje vou falar sobre o objetivo 5.2 do exame que é sobre Conversão de Variáveis de Referência (também conhecido por Cast ou Casting de tipos):

Dado um cenário, desenvolver código que demonstre o uso do polimorfismo. Além disso, determinar quando a conversão será necessária e saber diferenciar erros de compilação de erros de tempo de execução relacionados a conversão de referências a objetos.

Temos 2 pontos principais neste objetivo: Uso do polimorfismo e saber diferenciar erros de compilação e de tempo de execução. Veja também que no final está "referências a objetos". Isto quer dizer que esse tipo de conversão não é como conversão entre tipos primitivos (que não será abordado neste post).

Vamos começar analisando o código:

//Superclasse
public class Animal {
 
 void comer(){
  System.out.println("Animal comendo...");
 }
 
}
//Subclasse
class Dog extends Animal{
 
 void rolar(){
  System.out.println("Dog rolando...");
 }
}

Upcasting ou Conversão ampliadora

Considerando o código acima poderíamos naturalmente fazer as seguintes declarações:

Animal animal; //Declarou um tipo genérico
animal = new Dog(); //Apontou para um mais específico
//Ou simplesmente:
Animal animal = new Dog();
//Ou ainda:
Animal animal = (Animal)new Dog(); //Conversão explícita

Porque? Tipos genéricos podem apontar para tipos mais específicos. Isto chama-se upcasting ou conversão ampliadora. Esta conversão é sempre segura, pois estamos indo de um tipo mais específico para um mais genérico (de baixo pra cima na árvore de herança) e sabemos que a superclasse poderá fazer tudo que a subclasse fazia pois herdou dela. Mas fazendo isto estamos perdendo os métodos de Dog.

Nesse caso a variável de referência animal que é do tipo Animal faz referência a Dog e isto é possível porque Dog É-UM Animal (Este relacionamento É-UM significa que Dog extends Animal).

Por estes motivos o compilador permite fazer o cast sem nenhuma notação especial nem nada explícito.

Até aqui tudo bem, mas e se tentar realizar um comportamento mais específico? Por exemplo, tentar chamar um método que só existe em Dog? Não pode porque só comportamentos de Animal serão aceitos:

animal.rolar(); //Problema! Método não definido para o tipo Animal

O código não compila porque animal não tem o método rolar(). Entenda que estamos transformando um Dog num tipo mais genérico e que ele agora só poderá executar ações deste novo tipo. Ele perdeu os comportamentos específicos que tinha.

Mas um coisa interessante é que se Dog sobrescrever algum método de Animal, qual dos métodos será executado? Vamos modificar o código:

//Superclasse
public class Animal {
 
 void comer(){
  System.out.println("Animal comendo...");
 }
 
}
//Subclasse
class Dog extends Animal{
 
 void rolar(){
  System.out.println("Dog rolando...");
 }
 //Dog sobrescreveu o método comer
 void comer(){
  System.out.println("Dog comendo...");
 }
}

Suponhamos que faça a seguinte chamada:

Animal animal = new Dog();
animal.comer();

Quem vai comer? Animal ou Dog? Neste caso o método em Dog seria executado porque ele sobrescreveu. Então quando fazemos o upcasting perdemos os métodos do subtipo mas se algum for sobrescrito a versão a ser executada é a do subtipo. Muito louco isso não é?

Downcasting

Seguindo a raciocínio do upcasting, se quisermos "voltar" um tipo genérico para o mais específico (conversão redutora), devemos fazer a conversão explicitamente:

Dog dog = (Dog) animal;
dog.comer();

Veja que mudamos apenas o tipo da variável, não o tipo da referência. Então esta conversão se torna possível pois animal faz referência a Dog.

Então você se pergunta: Porque o upcasting é automático e o downcasting não? Agora chegamos num ponto interessante: No upcasting a conversão nunca falha. No downcasting, nem sempre teremos esta certeza. No exemplo citado acima, a conversão deu certo porque animal fazia referência a Dog mas e se não fizesse? Se animal fizesse referência a Animal mesmo?

Animal animal = new Animal();
Dog dog = (Dog) animal;

Como isso poderá ser feito se Animal não é um Dog? Animal nem sabe da existência de Dog. A conversão não pode ser feita porque os tipos são incompatíveis.

Só que o mais intrigante vem agora: O código compila!

Se você usa o Eclipse vá em Project > Clean..., selecione seu projeto e veja se apareceu algum erro em Problems? Não vai aparecer nada, porque pro compilador está tudo bem, ele não sabe e nem quer saber se animal faz referência a Animal ou Dog. Mas quando tentar executar:

Exception in thread "main" java.lang.ClassCastException: Animal cannot be cast to Dog
at Animal.main(Animal.java:46)

Então não tente converter um objeto para um tipo que ele não é. Mas lembre-se que o compilador não sabe se você vai tentar isto.

Para saber se dada conversão é aceita devemos usar o operador instanceof. Este operador retorna true ou false para uma comparação entre tipos:

 if (dog instanceof Animal)
 {
  System.out.println("dog é um Animal.");
 }

Na IDE Eclipse, quando começar a digitar "ins" e pressionar Ctrl + Barra de espaço ele já sugere o operador, então pressionando Enter ele já vai preencher um bloco de código igual a este:

 if (name instanceof type) {
  type new_name = (type) name;
  
 }

Aí é só você ir dando TAB e preenchendo os campos. Ele faz isso porque sabe que quase sempre que usamos o instanceof é pra saber se um objeto é de determinado tipo, e sendo positivo, já queremos que o objeto seja convertido neste tipo.

Aproveitando que já dei essa dica, tem outras duas que eu também uso muito para criar o método main e pro comando System.out.println: Para o main apenas digite main e Ctrl + Barra de espaço, para o println digite sysout Ctrl + Barra de espaço.

Só por curiosidade: Podemos converter qualquer objeto no tipo Object, como já falei no outro post, o Object é como uma classe "mãe" no Java:

Object obj = (Object)new Animal();

Mas essa conversão não tem muita utilidade pois faz com que animal perca todos seus métodos como já foi explicado. Por hoje é só!

Bons estudos e boas conversões!