Estrutura de classe: campos, métodos, construtores

1. Campos da classe: onde armazenamos o estado do objeto

Campo — é uma variável declarada dentro da classe, mas fora de todos os métodos. Os campos garantem que cada objeto tenha seu próprio “estado”. Por exemplo, se temos a classe Person, os campos podem ser assim:

• name — nome da pessoa
• age — idade
• balance — saldo na conta (caso estejamos criando um aplicativo bancário)
• isStudent — flag indicando se a pessoa é estudante

Sintaxe de declaração de campo

A declaração de um campo é parecida com a de uma variável comum, só que não fica dentro de um método, e sim diretamente na classe:

public class Person {
    String name;
    int age;
}

Aqui declaramos dois campos: a string name e o número inteiro age. Cada campo pertencerá a um objeto específico dessa classe. Isso significa que objetos diferentes terão seus próprios valores. Por exemplo:

Person p1 = new Person();
p1.name = "Olya";
p1.age = 20;

Person p2 = new Person();
p2.name = "Igor";
p2.age = 25;

O primeiro objeto tem o nome — “Olya” e idade — 20, e o segundo — “Igor” e 25. Ambos foram criados a partir da mesma classe, mas seus campos armazenam dados diferentes.

Modificadores de acesso (public/private)

Os campos podem ser públicos (public) ou privados (private). Na vida real você não sai contando seu saldo bancário para todo mundo, certo? Da mesma forma, em programação, muitas vezes deixamos os campos private para que não possam ser acessados diretamente de outras classes. Isso faz parte do princípio de encapsulamento (mais detalhes nas próximas aulas).

Exemplo:

public class Person {
    private String name;
    private int age;
}

Por enquanto não vamos complicar, mas lembre-se: se um campo é private, não é possível acessá-lo diretamente a partir de outra classe.

2. Métodos da classe: como os objetos “agem”

Método — é uma função que descreve o comportamento do objeto. Os métodos permitem que o objeto faça algo: falar, calcular, correr, pular, exibir informações sobre si e assim por diante.

Sintaxe de declaração de método

tipo_de_retorno nomeDoMetodo(parametros) {
    // corpo do método
}

Exemplo de método que diz “Olá”:

public void sayHello() {
    System.out.println("Olá! Meu nome é " + name);
}

Aqui:

• public — modificador de acesso.
• void — o método não retorna nada (apenas faz algo).
• sayHello — nome do método.
• Dentro do método usamos o campo name para cumprimentar o usuário.

Mais um exemplo: método que retorna a idade

public int getAge() {
    return age;
}

Os métodos podem retornar valores (int, String etc.), ou podem “não retornar nada” — nesse caso usamos void.

3. Construtores: como os objetos “nascem”

Construtor — é um método especial que é chamado na criação de um novo objeto. Sua tarefa é inicializar os campos do objeto com valores iniciais, isto é, preencher os “bolsos vazios” do objeto com dados concretos. Por exemplo, definir o nome e a idade de uma pessoa já no momento da sua criação, em vez de deixá-los vazios.

• O nome do construtor sempre coincide com o nome da classe.
• O construtor não tem tipo de retorno (nem mesmo void é escrito).
• Construtores podem receber parâmetros (por exemplo, nome e idade) ou não receber parâmetro algum.

Exemplo de construtor

public class Person {
    String name;
    int age;

    // Construtor com dois parâmetros
    public Person(String name, int age) {
        this.name = name; // this.name — campo do objeto, name — parâmetro do construtor
        this.age = age;
    }
}

Você provavelmente ficou curioso sobre o que é this. Pois bem, a palavra‑chave this é uma referência ao objeto atual. Por dentro. Usamos para diferenciar o campo da classe do parâmetro com o mesmo nome. Sem this, o compilador se confundiria sobre o que exatamente queremos inicializar.

Construtor padrão

Se você não declarar nenhum construtor, o compilador Java adicionará automaticamente um construtor vazio sem parâmetros. Ele fica assim:

public Person() {
    // não faz nada, mas permite criar um objeto sem parâmetros
}

MAS! Se você declarar pelo menos um construtor seu (por exemplo, com parâmetros), o construtor padrão já não será criado automaticamente! Se precisar dele — escreva-o explicitamente.

4. Exemplo de classe completa

Vamos juntar tudo: campos, métodos, construtor.

public class Person {
    String name;
    int age;

    // Construtor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Método: dizer olá
    public void sayHello() {
        System.out.println("Olá! Meu nome é " + name + ", tenho " + age + " anos.");
    }

    // Método: aumentar a idade em 1
    public void haveBirthday() {
        age = age + 1;
        System.out.println("Oba! Agora eu tenho " + age + " anos!");
    }
}

Como usar isso no programa?

public class Main {
    public static void main(String[] args) {
        Person vasya = new Person("Vasya", 18);
        vasya.sayHello();      // Olá! Meu nome é Vasya, tenho 18 anos.
        vasya.haveBirthday();  // Oba! Agora eu tenho 19 anos!
    }
}

5. Prática: desenvolva seu aplicativo

Suponha que você esteja fazendo um aplicativo simples para gerenciar usuários. Nas aulas anteriores trabalhamos apenas com variáveis e métodos dentro de main. Agora vamos criar nossa própria classe User com campos, métodos e construtor.

public class User {
    String username;
    int score;

    // Construtor
    public User(String username, int score) {
        this.username = username;
        this.score = score;
    }

    // Método: exibir informações do usuário
    public void printInfo() {
        System.out.println("Nome de usuário: " + username + ", pontos: " + score);
    }

    // Método: aumentar os pontos
    public void addScore(int points) {
        score += points;
        System.out.println(username + " ganhou " + points + " pontos! Agora ele tem " + score + " pontos.");
    }
}

Uso:

public class Main {
    public static void main(String[] args) {
        User alice = new User("Alice", 10);
        User bob = new User("Bob", 5);

        alice.printInfo(); // Nome de usuário: Alice, pontos: 10
        bob.printInfo();   // Nome de usuário: Bob, pontos: 5

        alice.addScore(7); // Alice ganhou 7 pontos! Agora ele tem 17 pontos.
        bob.addScore(3);   // Bob ganhou 3 pontos! Agora ele tem 8 pontos.
    }
}

Observe: cada objeto tem seus próprios campos, e alterações em um objeto não afetam o outro.

6. Resumo sobre modificadores de acesso

Nos nossos exemplos, os campos estavam públicos (String name;). Na prática, muitas vezes tornamos os campos private para que não possam ser alterados acidentalmente (ou de propósito) a partir de outra classe. Isso será detalhado no tópico de encapsulamento, mas aqui vai um exemplo:

public class User {
    private String username;
    private int score;

    public User(String username, int score) {
        this.username = username;
        this.score = score;
    }

    public void printInfo() {
        System.out.println("Nome de usuário: " + username + ", pontos: " + score);
    }

    public void addScore(int points) {
        score += points;
    }
}

Agora, se alguém tentar escrever alice.score = 100500; fora da classe — o compilador vai dizer “não pode!”.

7. Erros comuns ao trabalhar com campos, métodos e construtores

Erro nº 1: Campos não inicializados.
Se você não atribuir valores aos campos, eles recebem valores padrão: números — 0, boolean — false, referências (por exemplo, String) — null. Se esquecer de inicializar um campo, pode obter um resultado inesperado ou até um NullPointerException ao tentar fazer algo com ele.

Erro nº 2: Confundir parâmetros e campos.
No construtor, iniciantes costumam escrever apenas name = name; — isso não inicializa o campo, apenas atribui o parâmetro a si mesmo. Sempre use this.name = name!

Erro nº 3: Não há construtor padrão.
Se você declarou um construtor com parâmetros, mas esqueceu de adicionar explicitamente o construtor vazio, então new Person() não vai funcionar.

Erro nº 4: Mesmos nomes para métodos e classes.
Em Java, o nome do construtor deve coincidir com o nome da classe, mas os métodos não devem. Às vezes, por engano, nomeiam um método igual à classe e o compilador reclama.

Erro nº 5: Esquecer os modificadores de acesso.
Se você tornar os campos public, eles podem ser alterados em qualquer lugar — isso é perigoso em programas grandes. É melhor se acostumar a usar private e fornecer métodos de acesso.