Como Somar Dois Números em Java

Somar dois números é a primeira aritmética que a maioria das pessoas escreve em Java, mas a forma "correta" depende de onde os números vêm e quão grandes podem ser. Este capítulo aborda as abordagens idiomáticas: matemática com int literal, análise de valores de texto, adição de ponto flutuante e adição segura sem overflow silencioso.

Somando dois valores int

O caso mais simples é somar duas variáveis int com o operador +, um dos operadores aritméticos do Java. O resultado é um int.

int a = 7;
int b = 5;
int sum = a + b;
System.out.println(sum); // 12

Este é o caso do dia a dia e o que você mais irá escrever. A única coisa a observar é o intervalo de int: ele armazena valores de -2.147.483.648 a 2.147.483.647. Somar além desse limite faz o valor dar a volta silenciosamente em vez de lançar uma exceção — abordado abaixo.

Somando números analisados a partir de texto

Quando os números chegam como strings — de entrada no console, de um arquivo ou de uma requisição HTTP — você deve convertê-los antes de somar. Use Integer.parseInt para números inteiros ou Double.parseDouble para decimais.

String first = "42";
String second = "58";
int sum = Integer.parseInt(first) + Integer.parseInt(second);
System.out.println(sum); // 100

Um erro comum de iniciantes é usar + diretamente nas strings: "42" + "58" produz "4258" porque + concatena strings em vez de somá-las. Converta primeiro, depois some. Se o texto não for um número válido, parseInt lança NumberFormatException, então valide ou envolva a chamada em um try/catch quando a entrada não for confiável.

Somando decimais e tratando overflow

Para valores decimais, some operandos double (ou float). Esteja ciente de que o ponto flutuante binário não pode representar todos os decimais com exatidão, então 0.1 + 0.2 resulta em 0.30000000000000004, não 0.3. Para valores monetários, use BigDecimal.

Para números inteiros que podem exceder o intervalo de int, amplie um operando para long, ou use Math.addExact para transformar o overflow em uma exceção em vez de uma resposta errada. Escolher o tipo numérico correto desde o início é a defesa mais limpa — veja tipos de dados Java para o intervalo de cada tipo.

int big = Integer.MAX_VALUE;
System.out.println(big + 1);               // -2147483648 (wrapped!)
System.out.println((long) big + 1);        // 2147483648 (correct)
System.out.println(Math.addExact(big, 1)); // throws ArithmeticException

Somando dois números digitados pelo usuário

Em um programa real, os operandos frequentemente vêm do teclado. Um Scanner lê cada linha e a converte para um número em uma única etapa com nextInt (ou nextDouble para decimais), então você não precisa chamar parseInt manualmente.

import java.util.Scanner;

public class AddInput {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter first number: ");
        int a = scanner.nextInt();
        System.out.print("Enter second number: ");
        int b = scanner.nextInt();
        System.out.println("Sum: " + (a + b));
    }
}

Se o usuário digitar algo que não seja um inteiro, nextInt lança InputMismatchException. Proteja-se com hasNextInt() ou um try/catch quando a entrada não for confiável.

Um exemplo prático

O que observar na execução:

• int sum: 12 mostra o operador + simples somando dois valores int diretamente — o caso do dia a dia.
• parsed sum: 100 confirma que Integer.parseInt converte "42" e "58" em números antes de somar, em vez de concatená-los em "4258".
• double sum: 0.30000000000000004 é o erro de representação de ponto flutuante de 0.1 + 0.2 — prova de que double não é exato para decimais, então use BigDecimal quando a precisão for importante.
• int overflow: -2147483648 mostra Integer.MAX_VALUE + 1 dando a volta silenciosamente para o int mais negativo, enquanto long safe: 2147483648 dá a resposta correta ao ampliar um operando para long.
• addExact: overflow detected confirma que Math.addExact lança ArithmeticException no mesmo overflow em vez de retornar um valor incorreto.

Prática