Variáveis e tipos básicos

public class Acervo {

    public static void main(String[] args) {
        // Cada variável tem um tipo escolhido pelo tipo de dado que guarda.
        String titulo = "O Cortiço";
        int anoPublicacao = 1890;
        int paginas = 312;
        double multaDiaria = 1.5;
        char estante = 'C';
        boolean disponivel = true;

        System.out.println("Título: " + titulo);
        System.out.println("Ano: " + anoPublicacao);
        System.out.println("Páginas: " + paginas);
        System.out.println("Multa por dia: " + multaDiaria);
        System.out.println("Estante: " + estante);
        System.out.println("Disponível: " + disponivel);
    }
}

Passo a passo

1. String titulo = "O Cortiço"; guarda o texto entre aspas duplas; String é o tipo para qualquer sequência de caracteres.
2. anoPublicacao e paginas são int, porque são números inteiros pequenos, bem abaixo do limite de 2,1 bilhões.
3. multaDiaria é double, já que o valor tem casa decimal; em Java o separador decimal no código é sempre o ponto.
4. estante é char com aspas simples, porque guarda uma única letra.
5. disponivel é boolean e só aceita true ou false, sem aspas.
6. Cada println junta o rótulo à variável com +; o Java converte o número, o caractere e o booleano em texto automaticamente.

Por que funciona

Cada variável foi declarada com o tipo que combina com o dado que ela guarda, e o compilador confere essa combinação: um texto num int ou um número decimal num int não compilaria. Na hora de imprimir, a concatenação com uma String transforma qualquer tipo em texto, por isso o double aparece como 1.5 e o boolean como true.

Erros comuns

• Decimal em variável int: int multaDiaria = 1.5; não compila ("possible lossy conversion from double to int"). Use double.
• Aspas duplas no char: char estante = "C"; não compila ("incompatible types: String cannot be converted to char"). Use aspas simples: 'C'.
• Booleano entre aspas: boolean disponivel = "true"; também não compila, porque "true" é uma String. Escreva true sem aspas.
• Vírgula decimal: double multaDiaria = 1,5; gera erro de sintaxe. No código, o decimal usa ponto.

Outra forma de resolver

Com var, o compilador deduz os mesmos tipos a partir dos valores:

var paginas = 312;       // int
var multaDiaria = 1.5;   // double
var estante = 'C';       // char

var encurta declarações em que o tipo fica óbvio pelo valor; o enunciado pede o tipo explícito justamente para treinar a escolha de cada um.

Saída esperada

Título: O Cortiço
Ano: 1890
Páginas: 312
Multa por dia: 1.5
Estante: C
Disponível: true

public class Moedas {

    public static void main(String[] args) {
        int moedas = 125;
        int jogadores = 4;

        // int / int: divisão inteira, a parte decimal é descartada.
        int porJogador = moedas / jogadores;
        // % devolve o que sobrou da divisão.
        int sobra = moedas % jogadores;
        // O casting converte moedas para double antes de dividir.
        double divisaoExata = (double) moedas / jogadores;

        System.out.println("Moedas no baú: " + moedas);
        System.out.println("Cada jogador recebe: " + porJogador);
        System.out.println("Sobram no baú: " + sobra);
        System.out.println("Divisão exata: " + divisaoExata);
    }
}

Passo a passo

1. moedas e jogadores são int, porque não existe meia moeda nem meio jogador.
2. moedas / jogadores divide dois inteiros, então o Java faz divisão inteira: 125 / 4 dá 31 e a parte decimal é descartada, sem arredondar.
3. moedas % jogadores devolve o resto dessa divisão: 125 - 4 * 31 é 1.
4. (double) moedas converte 125 em 125.0 antes da divisão; com um dos lados double, a conta inteira é feita em double e dá 31.25.
5. As quatro linhas concatenam o rótulo ao valor; o double aparece com o ponto decimal.

Por que funciona

Em Java o tipo dos operandos decide o tipo da operação. Dois int produzem um int, e é por isso que / e % andam juntos: um dá o quociente, o outro o que sobrou, e 31 * 4 + 1 volta a 125. O casting tem precedência maior que a divisão, então (double) moedas / jogadores converte primeiro e divide depois.

Erros comuns

• Casting no lugar errado: (double) (moedas / jogadores) imprime 31.0. A divisão inteira já aconteceu dentro dos parênteses; converta só moedas.
• Guardar o resultado num double sem casting: double divisaoExata = moedas / jogadores; também dá 31.0, porque a conta é feita em int antes da atribuição.
• Esperar arredondamento: a divisão inteira sempre corta os decimais (7 / 2 é 3). Para arredondar, use Math.round sobre o valor double.

Outra forma de resolver

Multiplicar por 1.0 também força a conta em double:

double divisaoExata = moedas * 1.0 / jogadores;

Funciona, mas o casting (double) deixa a intenção mais clara para quem lê; o truque do 1.0 aparece em código antigo.

Saída esperada

Moedas no baú: 125
Cada jogador recebe: 31
Sobram no baú: 1
Divisão exata: 31.25

public class Faturamento {

    public static void main(String[] args) {
        int porFilial = 950_000_075;   // centavos de cada filial
        int filiais = 3;

        // int * int é calculado em int e estoura o limite em silêncio.
        int totalInt = porFilial * filiais;
        // Com um dos lados em long, a conta inteira é feita em long.
        long total = (long) porFilial * filiais;

        // Centavos viram reais com divisão inteira e resto.
        long reais = total / 100;
        long centavos = total % 100;

        System.out.println("Faturamento por filial: " + porFilial + " centavos");
        System.out.println("Total em int: " + totalInt);
        System.out.println("Total em long: " + total);
        System.out.printf("Em reais: R$ %d,%02d%n", reais, centavos);
        System.out.println("Cabe em int? " + (total <= Integer.MAX_VALUE));
    }
}

Passo a passo

1. int porFilial = 950_000_075; cabe num int, cujo limite é 2.147.483.647; os _ só separam os dígitos para facilitar a leitura.
2. porFilial * filiais multiplica dois int, então o resultado também é int. O valor real, 2.850.000.225, passa do limite e dá a volta: sobra -1444967071, sem erro nem aviso.
3. (long) porFilial * filiais converte o primeiro operando antes da multiplicação, e a conta toda passa a ser feita em long, que vai até cerca de 9,2 quintilhões.
4. total / 100 é divisão inteira entre long e int, então devolve só a parte em reais: 28500002.
5. total % 100 devolve os centavos que sobraram: 25.
6. printf("Em reais: R$ %d,%02d%n", reais, centavos) imprime os reais e, com %02d, os centavos sempre com dois dígitos (5 viraria 05).
7. (total <= Integer.MAX_VALUE) compara o long com o limite do int e produz um boolean; os parênteses fazem a comparação antes da concatenação.

Por que funciona

O tipo de uma operação aritmética é decidido pelos operandos, não pela variável que recebe o resultado. Por isso o casting precisa estar dentro da expressão, num dos operandos: assim a multiplicação acontece em 64 bits e o valor cabe. A representação em centavos com long evita a imprecisão do double com dinheiro, e / e % separam reais e centavos sem nenhuma conta com vírgula.

O int estourado mostra por que escolher o tipo importa: o Java não lança exceção no overflow de inteiros, ele simplesmente continua a partir do menor valor negativo.

Erros comuns

• Casting no resultado: long total = porFilial * filiais; imprime -1444967071, porque a multiplicação estourou em int antes de virar long. Converta um dos operandos: (long) porFilial * filiais.
• Casting depois da conta: (long) (porFilial * filiais) tem o mesmo problema; os parênteses fazem a multiplicação em int primeiro.
• Centavos sem zero à esquerda: %d no lugar de %02d imprimiria R$ 10,5 para 1.005 centavos, quando o certo é R$ 10,05.
• Literal grande sem L: long total = 2850000225; não compila ("integer number too large"). Escreva 2_850_000_225L.

Outra forma de resolver

Math.multiplyExact faz a conta em int e lança ArithmeticException se estourar, em vez de devolver um valor errado:

try {
    int total = Math.multiplyExact(porFilial, filiais);
} catch (ArithmeticException e) {
    System.out.println("Estourou o int: use long");
}

É a escolha certa quando o valor deveria caber no int e um estouro indica um problema que precisa aparecer na hora.

Saída esperada

Faturamento por filial: 950000075 centavos
Total em int: -1444967071
Total em long: 2850000225
Em reais: R$ 28500002,25
Cabe em int? false