Esta página precisa de um navegador recente (com suporte a SharedArrayBuffer). Por favor, atualize Chrome, Edge, Firefox ou Safari para a versão mais recente.
Este site compila Java usando as regras da linguagem Java ⟨⟩8. Esses exemplos independentes colocam seu método de entrada, ⟨⟩main, dentro de uma classe. Classes auxiliares e respostas apenas com métodos não precisam de suas próprias ⟨⟩main. ⟨⟩System.out.println(...) imprime uma linha; ⟨⟩System.out.print(...) imprime sem nova linha.
public class Main {
public static void main(String[] args) {
System.out.println("Hello, world!");
System.out.println("I am learning Java.");
}
}
Java é compilado: o compilador verifica todo o programa, depois ele é executado.
Declarações, atribuições, chamadas de método e statements ⟨⟩return terminam com ponto e vírgula ⟨⟩;. Um bloco ⟨⟩if, ⟨⟩for ou ⟨⟩while usa chaves; não adicione ponto e vírgula apenas porque sua chave de fechamento aparece.
Este exemplo independente de Java ⟨⟩8 define main dentro de uma classe
1.2
Variáveis & tipos primitivos
Uma variável deve declarar seu tipo. Tipos primitivos comuns: ⟨⟩int (número inteiro), ⟨⟩double (decimal), ⟨⟩boolean (true/false), ⟨⟩char (uma letra).
public class Main {
public static void main(String[] args) {
int age = 17;
double price = 9.99;
boolean passed = true;
System.out.println(age + " " + price + " " + passed);
}
}
1.3
Comentários e estilo
Um comentário é ⟨⟩// (uma linha) ou ⟨⟩/* ... */ (um bloco). Recue o código dentro das chaves ⟨⟩{ }. Nomes de classes começam com letra maiúscula; variáveis e métodos usam camelCase (minúscula na primeira).
public class Main {
public static void main(String[] args) {
// greet the user
String firstName = "Mei";
System.out.println("Hi, " + firstName);
}
}
Erros comuns
Toda statement termina com ponto e vírgula ; ;.
main deve ser exatamente public static void main(String[] args).
A aritmética Java 算术 usa + - * / e % (resto). Com dois ints, / é divisão inteira 整数除法 — ela descarta o decimal. +=, -= e ++ são atalhos.
public class Main {
public static void main(String[] args) {
int a = 7, b = 2;
System.out.println(a / b); // 3 (integer division)
System.out.println(a % b); // 1
double x = 7.0 / 2; // 3.5 (one side is double)
System.out.println(x);
}
}
int/int trunca; use um double para obter um quociente real
2.2
Usando objetos: String, Math, wrappers
Alguns valores são objetos 对象 com métodos. String tem .length(), .substring(), .toUpperCase(). Math tem Math.max, Math.sqrt, Math.pow. Classes wrapper 包装类 (Integer, Double) encapsulam um primitivo — por exemplo, Integer.parseInt("42").
public class Main {
public static void main(String[] args) {
String s = "Hello";
System.out.println(s.length()); // 5
System.out.println(s.toUpperCase()); // HELLO
System.out.println(Math.max(3, 9)); // 9
System.out.println(Integer.parseInt("42") + 1); // 43
}
}
Math.random() retorna um número aleatório 随机 double de 0.0 até (mas não incluindo) 1.0. Escalonar e converter para obter números inteiros — esta é a expressão idiomática do AP:
public class Main {
public static void main(String[] args) {
// a random whole number from 1 to 6 (a dice roll)
int roll = (int) (Math.random() * 6) + 1;
System.out.println(roll >= 1 && roll <= 6); // true
}
}
Integer.MAX_VALUE (2147483647) e Integer.MIN_VALUE são os limites de int; passar deles faz o valor voltar ao início (estouro).
Uma variável de objeto que aponta para nenhum objeto contém null; chamar um método nela lança um NullPointerException.
2.3
Conversão de tipo & casting
Uma conversão de tipo 强制转换 muda o tipo de um valor. (int) descarta o decimal; (double) evita a divisão inteira quando você precisa de um resultado exato.
public class Main {
public static void main(String[] args) {
double pi = 3.99;
System.out.println((int) pi); // 3
int total = 7, n = 2;
System.out.println((double) total / n); // 3.5
}
}
Erros comuns
Divisão inteira: 5 / 2 é 2, não 2.5. Converta primeiro: (double) 5 / 2.
Compare Strings (e outros objetos) com .equals(), não ==.
== em dois objetos testa se eles são o MESMO objeto, não se parecem iguais.
if executa um bloco quando uma condição 条件 é verdadeira; else if e else adicionam mais casos. A condição vai em ( ), o bloco em { }.
public class Main {
public static void main(String[] args) {
int score = 72;
if (score >= 80) {
System.out.println("A");
} else if (score >= 60) {
System.out.println("B");
} else {
System.out.println("fail");
}
}
}
*if escolhe o ramo verdadeiro; else o ramo falso
3.2
Operadores lógicos & comparações
Compare com ==, !=, <, >, <=, >= — uma comparação 比较 resulta em um valor booleano boolean. Combine com && (e), || (ou), ! (não) — os operadores lógicos 逻辑运算符. Para Strings, use .equals(...), não==.
public class Main {
public static void main(String[] args) {
int age = 16;
boolean member = true;
System.out.println(age >= 18 && member); // false
String a = "hi";
System.out.println(a.equals("hi")); // true
}
}
3.3
interruptor
switch escolhe entre muitos valores fixos. Cada case termina com break; default é o caso padrão (fallback).
public class Main {
public static void main(String[] args) {
int day = 3;
switch (day) {
case 1: System.out.println("Mon"); break;
case 3: System.out.println("Wed"); break;
default: System.out.println("other");
}
}
}
Erros comuns
Uma condição deve ser um valor booleano boolean; if (x = 5) não compila (use ==).
Cada caso switch precisa de um break break;, caso contrário o controle cairá no próximo caso.
&& e || são operadores lógicos; & e | são bitwise.
Um loop while repete enquanto uma condição for verdadeira. Altere algo dentro, ou ele rodará para sempre.
public class Main {
public static void main(String[] args) {
int n = 1;
while (n <= 3) {
System.out.println(n);
n++;
}
}
}
while verifica a condição antes de cada passagem do corpo
4.2
loops for
Um loop for agrupa o início, a condição e o passo em uma única linha. Ideal quando você conhece a contagem.
public class Main {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
System.out.print(i + " ");
}
System.out.println(); // 0 1 2 3 4
}
}
4.3
Acumulação
O padrão acumulador 累加器: inicie uma variável antes do loop, depois atualize-a a cada iteração.
public class Main {
public static void main(String[] args) {
int total = 0;
for (int i = 1; i <= 5; i++) {
total += i;
}
System.out.println(total); // 15
}
}
4.4
Laços aninhados
Um loop dentro de outro é um loop aninhado 嵌套循环. O loop interno roda completamente em cada iteração do externo.
public class Main {
public static void main(String[] args) {
for (int r = 0; r < 3; r++) {
for (int c = 0; c < 3; c++) {
System.out.print("*");
}
System.out.println();
}
}
}
Erros comuns
for (int i = 0; i < n; i++) executa n vezes (de 0 até n - 1); usar <= executa uma vez a mais.
Não coloque ponto e vírgula logo após for (...) ou while (...) — isso cria um loop vazio.
Declare o contador no cabeçalho do for para que seu escopo termine com o loop.
Uma String String 字符串 é texto. Métodos úteis: .length(), .charAt(i), .substring(a, b), .indexOf(x), .toUpperCase(), .equals(...). Strings são imutáveis 不可变 — cada método retorna uma nova String.
public class Main {
public static void main(String[] args) {
String s = "Python";
System.out.println(s.length()); // 6
System.out.println(s.charAt(0)); // P
System.out.println(s.substring(0, 3)); // Pyt
System.out.println(s.toUpperCase()); // PYTHON
}
}
Os métodos que você usará todos os dias:
Método
Significado
Exemplo → resultado
.length()
quantos caracteres
"Hi".length() → 2
.charAt(i)
um caractere
"Hi".charAt(0) → H
.substring(a, b)
parte, para antes de b
"Python".substring(0, 3) → Pyt
.substring(a)
de a até o final
"Python".substring(3) → hon
.indexOf(x)
primeira posição, -1 se ausente
"banana".indexOf("na") → 2
.equals(s)
mesmo texto?
"hi".equals("hi") → true
.compareTo(s)
ordem: negativo / 0 / positivo
"apple".compareTo("banana") → negativo
compareTo coloca Strings em ordem dicionária — o exame AP usa isso para perguntas de ordenação:
public class Main {
public static void main(String[] args) {
String a = "apple", b = "banana";
System.out.println(a.compareTo(b) < 0); // true (apple comes first)
System.out.println(a.compareTo("apple")); // 0 (equal)
}
}
Métodos principais de String: length, charAt, substring, equals
5.2
Construindo e percorrendo strings
Junte strings com + (concatenação 拼接). Acesse cada caractere com um loop e .charAt(i).
public class Main {
public static void main(String[] args) {
String word = "banana";
int count = 0;
for (int i = 0; i < word.length(); i++) {
if (word.charAt(i) == 'a') count++;
}
System.out.println(count); // 3
}
}
Ao construir uma String longa em um loop, StringBuilder é muito mais rápido: append as peças, depois chame .toString() uma vez.
public class Main {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
for (int i = 1; i <= 5; i++) {
sb.append(i).append(" ");
}
System.out.println(sb.toString().trim()); // 1 2 3 4 5
}
}
Erros comuns
Strings são imutáveis: s.toUpperCase() retorna uma nova String, então armazene o resultado.
Leia um caractere com s.charAt(i); o comprimento é s.length() (um método, com ()).
Construir uma String com += em um loop grande é lento; use um StringBuilder.
Um array 数组 guarda um número fixo de valores de um único tipo. Indexe de 0 e obtenha o tamanho com .length.
public class Main {
public static void main(String[] args) {
int[] scores = {88, 71, 95};
System.out.println(scores[0]); // 88
System.out.println(scores.length); // 3
scores[1] = 100;
System.out.println(scores[1]); // 100
}
}
Um primitivo guarda seu valor; uma variável de array guarda uma referência ao objeto array
6.2
Algoritmos de arrays
Percorra o array com um loop para encontrar um máximo, um total, uma contagem ou para pesquisar 查找. Um loop for-each (for (int x : a)) lê cada valor por vez.
public class Main {
public static void main(String[] args) {
int[] a = {3, 9, 2, 7};
int max = a[0], total = 0;
for (int x : a) {
if (x > max) max = x;
total += x;
}
System.out.println(max + " " + total); // 9 21
}
}
6.3
Arrays 2-D
Um array 2-D 二维数组 é uma grade 网格 de linhas e colunas: grid[row][col].
public class Main {
public static void main(String[] args) {
int[][] grid = {{1, 2, 3}, {4, 5, 6}};
System.out.println(grid[1][2]); // 6
for (int[] row : grid) {
for (int v : row) System.out.print(v + " ");
}
System.out.println(); // 1 2 3 4 5 6
}
}
Erros comuns
O tamanho de um array é a.length (sem colchetes, sem ()), e é fixo na criação.
Índices válidos são de 0 a a.length - 1; a[a.length] lança ArrayIndexOutOfBoundsException.
Um novo int[5] é preenchido com zeros, não deixado vazio.
Um ArrayList ArrayList é uma lista de tamanho variável 可变大小 — ela cresce e encolhe conforme você adiciona ou remove itens. Ela armazena objetos, então use um tipo wrapper 包装类 como Integer (não int). A parte <Integer> é um tipo genérico 泛型. Métodos principais: .add(x), .get(i), .set(i, x), .size(), .remove(i).
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> nums = new ArrayList<Integer>();
nums.add(10);
nums.add(20);
nums.add(30);
System.out.println(nums.size()); // 3
System.out.println(nums.get(1)); // 20
nums.set(0, 99);
System.out.println(nums); // [99, 20, 30]
}
}
ArrayList: add, get, size em uma lista redimensionável
7.2
Algoritmos de ArrayList e o bug do remove
.remove(i) desloca 移动 cada elemento subsequente uma posição para a esquerda. Se você remover enquanto conta ipara cima, pula o próximo elemento. Correção: faça o loop para trás, ou não incremente i após um remove.
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> nums = new ArrayList<Integer>();
for (int n : new int[]{4, 7, 4, 9, 4}) nums.add(n);
// Remove every 4 — loop backwards so removals don't skip items.
for (int i = nums.size() - 1; i >= 0; i--) {
if (nums.get(i) == 4) nums.remove(i);
}
System.out.println(nums); // [7, 9]
}
}
Erros comuns
ArrayList usa .size(), .get(i) e .add(...) — não o [] que você usa em arrays.
Remover itens enquanto itera para frente por índice pula o próximo item (o bug do remove). Itere para trás, ou use um iterator.
Armazene objetos, não primitivos: use ArrayList<Integer>, e Java auto-boxes int valores.
Uma classe é um modelo para objetos. Seus campos armazenam dados, seu construtor configura um novo objeto e seus métodos são as ações. this.name significa "o name deste objeto". Crie um objeto com new.
public class Main {
public static void main(String[] args) {
Dog d = new Dog("Rex", 3);
System.out.println(d.describe()); // Rex is 3 years old
d.haveBirthday();
System.out.println(d.describe()); // Rex is 4 years old
}
}
class Dog {
private String name;
private int age;
public Dog(String name, int age) { // constructor
this.name = name;
this.age = age;
}
public String describe() {
return name + " is " + age + " years old";
}
public void haveBirthday() {
age++;
}
}
Um membro static pertence à classe em si, não a nenhum objeto específico. Chame um método estático pelo nome da classe — como Math.max — e um campo estático é compartilhado por todos os objetos:
public class Main {
public static void main(String[] args) {
System.out.println(Counter.made()); // 0
new Counter();
new Counter();
System.out.println(Counter.made()); // 2
}
}
class Counter {
private static int count = 0; // shared by ALL Counter objects
public Counter() { count++; }
public static int made() { // called on the class: Counter.made()
return count;
}
}
O encapsulamento controla o acesso ao estado do objeto. Marque os campos private para bloquear o acesso direto de classes não relacionadas; um acessor (getter) lê o estado e um mutador o altera. Um setter é um tipo de mutador. private não valida valores: construtores e métodos mutadores precisam de suas próprias verificações ou pré-condições declaradas. Este exemplo assume um start não negativo e adições que cabem em int; seu método de depósito rejeita valores não positivos.
public class Main {
public static void main(String[] args) {
Account a = new Account(100);
a.deposit(50);
a.deposit(-999); // rejected by the guard
System.out.println(a.getBalance()); // 150
}
}
class Account {
private int balance; // hidden from outside
public Account(int start) {
balance = start;
}
public void deposit(int amount) {
if (amount > 0) balance += amount; // this guard checks the deposit amount
}
public int getBalance() { // accessor (getter)
return balance;
}
}
Erros comuns
Um construtor tem o nome da classe e nenhum tipo de retorno (nem sequer void).
Use this.field para distinguir um campo de um parâmetro com o mesmo nome.
Torne os campos private e acesse-os através de métodos getter/setter (encapsulamento).
Herança 继承 permite que uma subclasse 子类 reutilize uma superclasse 父类. Escreva class Cat extends Animal e Cat obtém os campos e métodos de Animal gratuitamente. Chame o construtor pai com super(...).
public class Main {
public static void main(String[] args) {
Cat c = new Cat("Milo");
c.eat(); // Milo is eating (inherited from Animal)
c.speak(); // Meow (Cat's own method)
}
}
class Animal {
protected String name;
public Animal(String name) { this.name = name; }
public void eat() { System.out.println(name + " is eating"); }
}
class Cat extends Animal {
public Cat(String name) { super(name); } // call Animal's constructor
public void speak() { System.out.println("Meow"); }
}
Gato e Cão estendem Animal: eles herdam seus membros e adicionam os próprios
9.2
Polimorfismo e toString
Uma subclasse pode sobrescrever 重写 um método para substituir a versão do pai. Polimorfismo 多态 significa que uma variável Shape pode conter qualquer subtipo, e Java escolhe o toString correto em tempo de execução. System.out.println(obj) chama obj.toString() automaticamente.
public class Main {
public static void main(String[] args) {
Shape[] shapes = { new Circle(2), new Square(3) };
for (Shape s : shapes) {
System.out.println(s); // each calls its own toString
}
}
}
class Shape {
public String toString() { return "a shape"; }
}
class Circle extends Shape {
private int r;
public Circle(int r) { this.r = r; }
public String toString() { return "Circle r=" + r; } // override
}
class Square extends Shape {
private int side;
public Square(int side) { this.side = side; }
public String toString() { return "Square side=" + side; } // override
}
Erros comuns
Um método sobrescrito deve corresponder exatamente à assinatura; adicione @Override para que o compilador capture erros.
super(...) deve ser a primeira linha de um construtor de subclasse.
Um objeto de subclasse É-UM objeto de superclasse, mas não o contrário.
Recursão 递归 é um método que se chama a si mesmo. Toda recursão precisa de um caso base 基准情形 (quando parar) e uma chamada recursiva 递归调用 que se aproxime dele. Sem um caso base, nunca para e falha com stack overflow.
A pilha de chamadas para factorial(3): cada chamada espera, depois retorna em ordem inversa
public class Main {
public static void main(String[] args) {
System.out.println(factorial(5)); // 120
}
public static int factorial(int n) {
if (n <= 1) return 1; // base case
return n * factorial(n - 1); // recursive call: n * (n-1)!
}
}
Rastreie: factorial(5) espera por factorial(4), que espera por factorial(3)… até factorial(1) retornar 1. Depois as respostas multiplicam de volta para cima: 1 → 2 → 6 → 24 → 120.
Recursão também funciona em Strings — remova um caractere por chamada:
public class Main {
public static void main(String[] args) {
System.out.println(reverse("PYTHON")); // NOHTYP
}
static String reverse(String s) {
if (s.length() <= 1) return s; // base case
return reverse(s.substring(1)) + s.charAt(0);
}
}
Merge sort 归并排序 é a ordenação recursiva no exame AP: divida o array pela metade, ordene cada metade recursivamente, depois combine 合并 as duas metades ordenadas. Ele roda em O(n log n) — muito mais rápido que as ordenações O(n²) em arrays grandes.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] a = {5, 2, 9, 1, 7, 3};
mergeSort(a, 0, a.length - 1);
System.out.println(Arrays.toString(a)); // [1, 2, 3, 5, 7, 9]
}
static void mergeSort(int[] a, int lo, int hi) {
if (lo >= hi) return; // base case: one element
int mid = (lo + hi) / 2;
mergeSort(a, lo, mid); // sort the left half
mergeSort(a, mid + 1, hi); // sort the right half
merge(a, lo, mid, hi); // merge the two halves
}
static void merge(int[] a, int lo, int mid, int hi) {
int[] tmp = new int[hi - lo + 1];
int i = lo, j = mid + 1, k = 0;
while (i <= mid && j <= hi) {
if (a[i] <= a[j]) tmp[k++] = a[i++];
else tmp[k++] = a[j++];
}
while (i <= mid) tmp[k++] = a[i++];
while (j <= hi) tmp[k++] = a[j++];
for (k = 0; k < tmp.length; k++) a[lo + k] = tmp[k];
}
}
Erros comuns
A recursão precisa de um caso base, ou lança StackOverflowError.
Cada chamada recursiva deve se mover PARA PERTO do caso base.
Rastreie um pequeno exemplo manualmente para verificar se a recursão retorna o valor correto.
No merge sort, o passo de combinação faz o trabalho real; a recursão apenas divide o array.
Busca linear 线性查找 verifica cada elemento — funciona em qualquer array. Busca binária 二分查找 é muito mais rápida, mas precisa de um array ordenado 已排序: olha para o meio, depois descarta metade a cada passo. Ambas retornam o índice, ou -1 se não encontrado.
public class Main {
public static void main(String[] args) {
int[] a = {2, 5, 8, 12, 16, 23}; // sorted, so binary search works
System.out.println(linear(a, 12)); // 3
System.out.println(binary(a, 12)); // 3
System.out.println(binary(a, 9)); // -1 (not found)
}
static int linear(int[] a, int target) {
for (int i = 0; i < a.length; i++)
if (a[i] == target) return i;
return -1;
}
static int binary(int[] a, int target) {
int lo = 0, hi = a.length - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (a[mid] == target) return mid;
else if (a[mid] < target) lo = mid + 1;
else hi = mid - 1;
}
return -1;
}
}
A busca binária reduz a faixa pela metade a cada passo, então um array ordenado é buscado em O(log n)
11.2
Ordenação por seleção e inserção
Ordenação por seleção 选择排序 encontra repetidamente o menor valor restante e o troca para a frente. Ordenação por inserção 插入排序 pega cada valor e o desliza para trás no lugar entre os valores já ordenados.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] a = {5, 2, 9, 1, 7};
for (int i = 0; i < a.length - 1; i++) {
int min = i;
for (int j = i + 1; j < a.length; j++)
if (a[j] < a[min]) min = j;
int t = a[min]; a[min] = a[i]; a[i] = t; // swap into place
}
System.out.println(Arrays.toString(a)); // [1, 2, 5, 7, 9]
}
}
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] a = {5, 2, 9, 1, 7};
for (int i = 1; i < a.length; i++) {
int key = a[i], j = i - 1;
while (j >= 0 && a[j] > key) { // shift bigger values right
a[j + 1] = a[j];
j--;
}
a[j + 1] = key; // drop key into the gap
}
System.out.println(Arrays.toString(a)); // [1, 2, 5, 7, 9]
}
}
Como as velocidades se comparam:
Algoritmo
Tempo
busca linear
O(n)
busca binária
O(log n), apenas arrays ordenados
seleção / inserção
O(n²)
merge sort (tópico 10)
O(n log n)
Erros comuns
A busca binária só funciona em um array ordenado.
A busca linear é O(n); a busca binária é O(log n), mas precisa da ordenação primeiro.
Seleção e inserção são O(n²) — claro para aprender, lento em grandes volumes de dados.
Um Scanner lê texto linha por linha. Para um arquivo real, escreva new Scanner(new File("scores.txt")); aqui envolvi um String para que o exemplo rode em qualquer lugar. Use .split(" ") para dividir 拆分 uma linha em partes e Integer.parseInt(...) para parsear 解析 um número do texto.
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// Real file: Scanner in = new Scanner(new File("scores.txt"));
String data = "Alice 80\nBob 95\nCara 72";
Scanner in = new Scanner(data);
int total = 0, count = 0;
while (in.hasNextLine()) {
String line = in.nextLine();
String[] parts = line.split(" "); // break the line on the space
total += Integer.parseInt(parts[1]);
count++;
}
System.out.println("average = " + (total / count)); // average = 82
}
}
Scanner lê linhas enquanto hasNextLine for true
12.2
Tipos de questões do FRQ do AP
O exame AP CS A tem quatro questões de resposta aberta 自由作答, cada uma com formato fixo:
Q1 — Métodos e controle: escreva métodos segundo uma especificação dada; loops, if, String/Math.
Q2 — Design de classe: escreva uma classe completa (campos, construtor, métodos) a partir de uma descrição.
Q3 — Array / ArrayList: processe um array 1-D ou ArrayList (busca, contagem,=cria uma nova lista).
Q4 — Array 2-D: percorra uma grade por linha e coluna.
A habilidade é sempre a mesma: leia a especificação, escreva o método exatamente como descrito, retorne o tipo correto.
public class Main {
public static void main(String[] args) {
// Q1 style: implement a method to a spec, then it is tested.
System.out.println(countEven(new int[]{4, 7, 10, 3, 6})); // 3
}
/** Returns how many values in arr are even. */
public static int countEven(int[] arr) {
int count = 0;
for (int x : arr)
if (x % 2 == 0) count++;
return count;
}
}
Erros comuns
nextInt() deixa a quebra de linha para trás, então um nextLine() subsequente lê uma linha vazia — leia-a primeiro para removê-la.
Verifique hasNext() antes de ler, para evitar sair do fim do arquivo.
Na FRQ, leia o cabeçalho do método com atenção: corresponda o tipo de retorno e os parâmetros exatamente.