[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 =)