[OCPJP6] 021 – Atribuições

Cast de tipos primitivos

No post anterior vimos um exemplo de cast com tipo primitivo, vamos complementar o assunto. Veja algumas regras abaixo:

  • Toda soma de número inteiros resulta em int (como vimos no post anterior)
  • Todo número inteiro é implicitamente int. Tome cuidado com o tamanho, talvez seja necessário converter para um tipo maior – por exemplo long
  • Todo número flutuante é implicitamente um double
  • Não precisa de cast quando ocorre ampliação
  • É necessário cast quando houver perda de precisão

Exemplos

Cast para um tipo menor que float (float > int)

float f1 = 128.987f;
int i1 = (int) f1; // PERDA DE PRECISAO
// s1 = 128

Cast para um tipo menor que float (float > short)

float f1 = 128.987f;
short s1 = (short) f1; // PERDA DE PRECISAO
// s1 = 128

Cast para um tipo menor que float (float > byte)

float f1 = 128.987f;
byte b1 = (byte) f1;
// E agora? 128?

Um ponto de atenção no exemplo acima, byte vai de -128 até 127! Qual seria o resultado?

-128 será a resposta, porque a JVM irá remover os primeiros (esquerda) 24 bits, dando o resultado -128.

// Compare os resultados
Integer.toBinaryString((byte)128);
Integer.toBinaryString(-128);

Cast para um tipo maior que float (float > double)

float f1 = 128.545f;
// 32 bits cabe dentro de 64 (cast implicito)
double d1 = f1;
// d1 = 128.98699...
}

Adicional (pegadinhas de cast)

byte b1 = 128; // NÃO COMPILA, certo?

byte b2 = 3;
b2 += 7; // COMPILA :O

byte b3 = 3;
b3 = b3 + 7; // NÃO COMPILA (ahhhh)
b3 = (byte) (b3 + 7); // AGORA COMPILA

No exemplo acima b2 += inclui o cast implicito =D

Comentem, estendam o assunto… Compartilhem =)

Anúncios

[OCPJP6] 020 – Atribuições

Tipos primitivos

Veja a tabela abaixo:

Tipo Tamanho
byte 8 bit
short 16 bit
int 32 bit
long 64 bit
float 32 bit
double 64 bit
boolean
char 16 bit

 Todas expressões com tipos primitivos menor que int (char, byte, short) resultam em int.

Vamos entender melhor em exemplos:

byte

byte a = 1;
byte b = 2;
byte c = a + b; // NAO COMPILA!

short

short a = 1;
short b = 1;
short c = a + b + 1; // NAO COMPILA!
Por que o código acima não compila?

Como destacado anteriormente “toda expressão” (soma, subtração…) com tipos menores que int resultam em int, ou seja, no exemplo de com byte (a + b)  o resultado será um int e consequentemente no exemplo de short a mesma coisa.

E como fazer funcionar?

Transformando c em um int 🙂

byte a = 1;
byte b = 2;
int c = a + b; // =D
Mas e se mesmo assim eu quiser que c seja um byte ou short?

Cast resolve 🙂

byte a = 1;
byte b = 2;
byte c = (byte) (a + b); // =D

Comentem, estendam o assunto… Compartilhem =)

[OCPJP6] 019 – Atribuições

literais

Literal é uma sequência de caracteres (dígitos, letras, e outros caracteres) que representa um valor constante que referência uma variável. Neste capítulo vamos ver como os literais se comportam com os tipos primitivos.

literais do tipo inteiro

Os literais de tipo inteiro (dígitos) podem ser divididos em 3 categorias: decimal (base 10), octal (base 8) e hexadecimal (base 16).

Decimal

Um inteiro do tipo decimal não tem muitos segredos, é a representação “tradicional”.

int length = 123;

Octal

Um inteiro do tipo octal usa somente dígitos de 0 a 7 e com até 21 dígitos não incluindo o zero inicial. Veja no exemplo abaixo que quando acaba o dígito 7 iniciamos novamente com 01.

package certificacao;
public class ExemploOctal {
    private static int um = 01;
    private static int dois = 02;
    private static int tres = 03;
    private static int quatro = 04;
    private static int cinco = 05;
    private static int seis = 06;
    private static int sete = 07;
    private static int oito = 010;
    private static int nove = 011;
    private static int dez = 012;

    public static void main(String[] args) {
        System.out.println(um); System.out.println(dois);
        System.out.println(tres); System.out.println(quatro);
        System.out.println(cinco); System.out.println(seis);
        System.out.println(sete); System.out.println(oito);
        System.out.println(nove); System.out.println(dez);
    }
}

Hexadecimal

Os números hexadecimais são construídos com o uso de 16 símbolos distintos:

0 1 2 3 4 5 6 7 8 9 a b c d e f

Veja alguns exemplos válidos:

int x = 0X0001;
int y = 0x7fffffff;
int z = 0xCafe; // =D

literais do tipo flutuante

São definidos com números e símbolos. É importante notar que double tem 64 bits e float tem 32 bits, mais precisamente, quando quiser dizer que um literal flutuante é um float é necessário indicar com f ou F. Vejam alguns exemplos abaixo:

// por padrao um numero com casas decimais e' double
// o double tambem pode indicar d ou D
double d1 = 123456789.987654321;

float f1 = 123.4567890; // nao compila (necessario declarar f/F)
float f2 = 123.4567890f; // agora sim

literais do tipo boolean

Só podem ser true ou false. Simples assim.

literais do tipo caractere

São representados por um único caractere entre aspas simples, ou pelo valor unicode do caractere. Importante notar que os caracteres são inteiros de 16 bits sem sinal. (0 a 65535). Veja os exemplos abaixo:

char a = 0x892;
char b = 982;
char c = (char) 70000; // com cast funciona na compilacao
char d = (char) -98; // so' com cast mesmo

Comentem, estendam o assunto… Compartilhem =)