Tipos de dados

Variáveis e usando primitivos

Valores numéricos podem ser expressados em base binária, octal, decimal e hexadecimal. Operações matemáticas da classe Math também podem utilizar qualquer base.

Valores long e float devem ser expressados com uma letra L e F, respectivamente, ao final do número. Sem essa letra pode ocorrer do valor ser interpretado como os tipos padrão para números inteiros ou de ponto flutuante (int e double).

Valores de ponto flutuante podem ser expressos de maneira normal ou com notação exponencial. (e.g. float e = 1.99E2F;.)

Um valor para o tipo char deve ser envolto por aspas simples (').

Atribuir uma variável x à outra y, resulta na cópia do valor de x para y. Assim, se x só pode ser atribuído se já estiver inicializado.

Um valor maior que o tamanho máximo do tipo da variável não pode ser atribuído. O compilador lançará um erro.

Java é case-sensitive. Isso quer dizer que false e False não são a mesma coisa.

Operadores Java

Os operadores && || executam a avaliação de maneira curto-circuito(short-circuit evaluation). Isso quer dizer que ela para de avaliar a expressão assim que puder.

Já os operadores & | ^ funcionam com avaliação completa(full evaluation), ou seja, eles sempre validam todos membros da expressão.

O operador ternário x ? "true" : "false" deve ser utilizado para atribuições condicionais.


true && evaluated
false && not evaluated
true || not evaluated
false || evaluated
//
true & evaluated
false & evaluated
true | evaluated
true ^ evaluated
//
int x = 5;
int y = x == 5 ? "igual a 5" : "diferente de 5";

Cast

O tipo de um valor pode ser alterado utilizando o cast. Essa operação é feita com (<NOVO TIPO>)<VARIÁVEL OU EXPRESSÃO>. Quando um valor é atribuído a uma variável cujo tipo seja maior que o seu, ocorre um cast implícito para o tipo da variável, chamado de promoção. Porém, o contrário não acontece. Não é possível atribuir um valor maior que a capacidade do tipo de uma variável, sem um cast explícito.

Uma expressão aritmética com valores de múltiplos tipos irá resultar em um dado do maior tipo da expressão.

Em uma divisão com dois valores inteiros, o resultado permanecerá inteiro.

É possível realizar operações aritméticas em valores do tipo char.


byte a = 125, b = 5;
int c = a + b; // Okay
byte d = a + b; // Erro de compilação
byte e = (byte) a + b; // Funciona, mas gera overflow -> e = -124
double f = 69;
a + c + f; // Resulta em um double
char g = 'g';
char h = ++g;

Controle de texto com `String` e `StringBuilder`

Com `String`

Em Java, um conjunto de texto é representado pela classe String. Isso mesmo, em Java um conjunto de caracteres é representado por uma instância de classe — não que seja impossível declarar um texto como um vetor de caracteres, mas na maioria esmagadora dos casos a classe String será muito mais útil.

Como qualquer outra classe, uma instância nova de String pode ser criada com new. Porém, ela é a única classe em que o compilador aceita — e recomenda — uma inicialização com uma string literal, com a sintaxe String x = "valor". Esse inicialização permite à JVM uma otimização de uso de memória: cada string literal é armazenada apenas uma única vez; não importa quantas variáveis utilizem-na (processo chamado interning). Utilizar a abordagem de inicialização com a palavra new desabilita o interning.

Após sua inicialização, uma instância de String não pode ser alterada — são imutáveis. Assim, operações mutáveis, como trim, concat, toLowerCase, etc. sempre retornam uma nova instância com o valor alterado. Vale deixar claro que uma variável String não é por si só imutável, apenas a instância a que ela está atribuída é. Para que a variável seja imutável existe outra palavra reservada (final).

Por mais que a String seja uma classe, ela possuí características de sequencia de caracteres, dentre elas está sua indexação. O primeiro caractere (da esquerda para direita) possuí o index 0. Também tentar acessar a posição -1 resultará em uma exceção.

Com `StringBuilder`

Para exercer trabalhos mais complexos em textos, foi criada a classe StringBuilder. Objetos dessa classe são mutáveis e possuem métodos de conveniência para fazer essas alterações. Diferente de String, instâncias dessa classe precisam ser feitas com new.

A capacidade inicial de um objeto StringBuilder é de 16 caracteres, expandindo automaticamente conforme necessidade. Também é possível definir um conteúdo prévio ou tamanho inicial através do construtor. Por questão de performance é ideal já definir a capacidade esperada no momento de inicialização, evitando a expansão automática.

Existe ainda uma alternativa thread-safe ao StringBuilder que é a classe StringBuffer. Como garantir que a classe seja thread-safe é custoso para questões de performance, essa classe só é recomendada em caso de código concorrente.

Inferência de tipo em variáveis locais

Através do identificador var podemos omitir uma definição estática de tipo. Esse tipo de omissão só é possível em contextos onde o compilador consegue inferir qual é o tipo da variável.

Só podem ser utilizadas com inicialização. Isso não impede de serem modificadas posteriormente, porém apenas aceitará valores do tipo inferido na inicialização.

Não pode ser utilizada em parâmetros, já que o compilador não saberia qual tipo o valor se refere. Porém, em funções lambda podem ser utilizadas devido a essas serem apenas a implementação de uma interface funcional (essa interface tem os tipos estaticamente definidos).

O tipo é definido no momento de atribuição. Isso quer dizer que se um objeto da classe Car, que implementa Vehicle, for atribuído a uma variável identificada com var, apenas instâncias de Car poderão ser utilizadas.

Facilita a utilização de classes anônimas.


var v = new Car();
v = new Bike(); // mesmo que bike implemente Vehicle, isso causará 
								// um erro de compilação

// se ao invés de var fosse utilizado Object, não seria possível 
// acessar name ou total, pois eles não existem na classe Object
var productInfo = new Object() {
	String name = "Apple";
	int total = 30;
};