</>Codding
Java Completo0/20 lições

Módulo 2 • Orientação a objetos

Classes e objetos

Ferramentas e leitura
Leitura100%
Aula guiada50–75 min5 etapas práticas

Nesta aula, você vai compreender Classes e objetos com explicação progressiva, exemplo resolvido, checagens e prática. Nada de apenas copiar: cada etapa prepara a próxima.

Antes de começar: Leia a aula anterior do módulo se algum termo parecer novo. Você pode testar o exemplo antes de continuar.

Ao terminar, você vai conseguir

  • Explicar Classes e objetos com suas próprias palavras
  • Reconhecer as partes importantes em um exemplo real
  • Identificar e corrigir os erros mais frequentes
  • Aplicar o conteúdo em uma atividade prática
1

Entrada

Reconheça os dados e condições disponíveis.

2

Processamento

Use Classes e objetos para transformar a entrada.

3

Saída

Confira o resultado e os casos que podem falhar.

0/6 atividades
1

Entenda o problema

O que é Classes e objetos

Classe é o molde; objeto é a instância. POO junta dados e comportamento no mesmo lugar para que o resto do programa não precise conhecer os detalhes internos.

Cheque seu entendimento

Polimorfismo permite:

1 de 5

O que você aprendeu

  • Classe é o molde; objeto é a instância. POO junta dados e comportamento no mesmo lugar para que o resto do programa não precise conhecer os detalhes internos.
  • saldoFinal é escrito uma vez e funciona para qualquer conta futura: quem adiciona uma nova classe só implementa taxa().
  • Evite: Campos públicos que permitem estados inválidos.
  • Evite: Herança profunda usada como reaproveitamento de código.

Videoaulas sobre este tema

Se você aprende melhor assistindo, abrimos uma seleção de aulas em vídeo em português sobre exatamente este assunto.

Aula em vídeo sobre este temaVídeos em português explicando "Classes e objetos" passo a passo.Vendo alguém programar issoExemplos práticos, com o código sendo escrito na tela.Playlist completa de Java CompletoCurso em vídeo do começo ao fim, para acompanhar junto com o módulo "Orientação a objetos".

Quiz rápido

0/2 • 0 certas

1. Polimorfismo permite:

2. Encapsulamento serve para:

Laboratório

1/4

1. Faça funcionar

Laboratório de Classes e objetos: execute o exemplo, identifique entrada, processamento e saída e altere pelo menos um valor para observar como o resultado muda.

Abrir no playground
  • Checkpoints da prática (1/4)
  • Escreva sua versão a partir do modeloO texto do editor ainda é igual ao modelo inicial. Altere pelo menos uma linha para que a prática conte como sua.
  • Nenhuma lacuna deixada em branco
  • Execute seu códigoClique em “Verificar resposta” para rodar seu código e comparar a saída com o esperado.
  • Resultado ainda não confereEsperado: o programa rodar sem erro. Se aparecer uma mensagem de erro, leia a última linha: ela indica a linha e o tipo do problema.

Escreva sua solução e clique em Verificar.

Tire sua dúvida

Cada resposta é conferida contra o material desta lição antes de aparecer. Sem IA por trás e sem inventar nada.

Classes e objetos

Java Completo • Módulo 2: Orientação a objetos • Codding — material para estudo offline

Aluno: ______________________________ Data: ____ / ____ / ______

Nesta aula, você vai compreender Classes e objetos com explicação progressiva, exemplo resolvido, checagens e prática. Nada de apenas copiar: cada etapa prepara a próxima.

Objetivos da aula

  • Explicar Classes e objetos com suas próprias palavras
  • Reconhecer as partes importantes em um exemplo real
  • Identificar e corrigir os erros mais frequentes
  • Aplicar o conteúdo em uma atividade prática

Pré-requisito: Leia a aula anterior do módulo se algum termo parecer novo. Você pode testar o exemplo antes de continuar. • Duração: 50–75 min

Explicação passo a passo

1. O que é Classes e objetos

Classe é o molde; objeto é a instância. POO junta dados e comportamento no mesmo lugar para que o resto do programa não precise conhecer os detalhes internos.

Checkpoint: Polimorfismo permite: — Resposta: Chamar o mesmo método em tipos diferentes sem saber qual implementação roda

2. Como pensar antes de fazer

Encapsulamento: exponha métodos, esconda campos. Se qualquer parte do sistema pode alterar o saldo direto, nenhuma regra de negócio sobrevive.

Dica: Não decore a forma. Tente explicar com suas palavras qual problema “Classes e objetos” resolve.

3. Exemplo completo, do início ao resultado

Herança expressa 'é um tipo de' e deve ser rara; composição ('tem um') costuma ser mais flexível. Herdar só para reaproveitar código gera hierarquias impossíveis de mudar.

public class Main {
    static abstract class Conta {
        protected double saldo;                    // escondido do mundo
        void depositar(double v) { if (v > 0) saldo += v; }
        abstract double taxa();
        double saldoFinal() { return saldo - taxa(); }
    }
    static class Corrente extends Conta { double taxa() { return 10; } }
    static class Poupanca extends Conta { double taxa() { return 0; } }

    public static void main(String[] args) {
        Conta[] contas = { new Corrente(), new Poupanca() };
        for (Conta c : contas) { c.depositar(100); System.out.println(c.saldoFinal()); }
    }
}
TrechoO que faz
public class Main {Cria uma estrutura reutilizável para organizar comportamento.
static abstract class Conta {Cria uma estrutura reutilizável para organizar comportamento.
protected double saldo; // escondido do mundoContribui para a transformação principal mostrada neste exemplo.
void depositar(double v) { if (v > 0) saldo += v; }Decide qual caminho será executado de acordo com uma condição.
abstract double taxa();Contribui para a transformação principal mostrada neste exemplo.
double saldoFinal() { return saldo - taxa(); }Cria ou atualiza um valor que será usado pelo restante do exemplo.
}Contribui para a transformação principal mostrada neste exemplo.
static class Corrente extends Conta { double taxa() { return 10; } }Cria uma estrutura reutilizável para organizar comportamento.

Dica: saldoFinal é escrito uma vez e funciona para qualquer conta futura: quem adiciona uma nova classe só implementa taxa().

Checkpoint: Encapsulamento serve para: — Resposta: Proteger o estado interno, expondo só operações válidas

4. Do detalhe para o todo

Polimorfismo é a parte que compensa: várias classes implementam o mesmo método e o chamador não precisa saber qual é qual. É a base de interfaces e de código extensível sem if gigante.

5. Erros comuns e como corrigi-los

1. Campos públicos que permitem estados inválidos. 2. Herança profunda usada como reaproveitamento de código. 3. Classe que faz tudo (God class) em vez de responsabilidades separadas.

Dica: Quando algo der errado, compare uma diferença por vez com o exemplo. Evite mudar várias partes ao mesmo tempo.

Prática guiada

1. 1. Faça funcionar

Laboratório de Classes e objetos: execute o exemplo, identifique entrada, processamento e saída e altere pelo menos um valor para observar como o resultado muda.

public class Main {
    static abstract class Conta {
        protected double saldo;                    // escondido do mundo
        void depositar(double v) { if (v > 0) saldo += v; }
        abstract double taxa();
        double saldoFinal() { return saldo - taxa(); }
    }
    static class Corrente extends Conta { double taxa() { return 10; } }
    static class Poupanca extends Conta { double taxa() { return 0; } }

    public static void main(String[] args) {
        Conta[] contas = { new Corrente(), new Poupanca() };
        for (Conta c : contas) { c.depositar(100); System.out.println(c.saldoFinal()); }
    }
}

Dica: Volte ao exemplo resolvido e compare a estrutura. Campos públicos que permitem estados inválidos.

2. 2. Preveja antes de testar

Sem executar, explique qual resultado o exemplo de Classes e objetos deve produzir e qual parte é responsável por ele.

Minha previsão:

A parte responsável pelo resultado:

Como vou conferir:

Dica: Use o modelo mental da aula: entrada, transformação e evidência observável.

3. 3. Encontre e corrija o erro

Use o exemplo de Classes e objetos, identifique um risco citado na aula e registre ou implemente a correção.

public class Main {
    static abstract class Conta {
        protected double saldo;                    // escondido do mundo
        void depositar(double v) { if (v > 0) saldo += v; }
        abstract double taxa();
        double saldoFinal() { return saldo - taxa(); }
    }
    static class Corrente extends Conta { double taxa() { return 10; } }
    static class Poupanca extends Conta { double taxa() { return 0; } }

    public static void main(String[] args) {
        Conta[] contas = { new Corrente(), new Poupanca() };
        for (Conta c : contas) { c.depositar(100); System.out.println(c.saldoFinal()); }
    }
}

Dica: Campos públicos que permitem estados inválidos.

4. 4. Aplique em um caso novo

Crie uma variação própria usando Classes e objetos. Mude os dados ou o cenário e demonstre que o resultado continua correto.

public class Main {
    static abstract class Conta {
        protected double saldo;                    // escondido do mundo
        void depositar(double v) { if (v > 0) saldo += v; }
        abstract double taxa();
        double saldoFinal() { return saldo - taxa(); }
    }
    static class Corrente extends Conta { double taxa() { return 10; } }
    static class Poupanca extends Conta { double taxa() { return 0; } }

    public static void main(String[] args) {
        Conta[] contas = { new Corrente(), new Poupanca() };
        for (Conta c : contas) { c.depositar(100); System.out.println(c.saldoFinal()); }
    }
}

Dica: Mantenha a estrutura que já funcionou e altere uma decisão por vez.

Revisão

  • Classe é o molde; objeto é a instância. POO junta dados e comportamento no mesmo lugar para que o resto do programa não precise conhecer os detalhes internos.
  • saldoFinal é escrito uma vez e funciona para qualquer conta futura: quem adiciona uma nova classe só implementa taxa().
  • Evite: Campos públicos que permitem estados inválidos.
  • Evite: Herança profunda usada como reaproveitamento de código.

Exemplo comentado

public class Main {
    static abstract class Conta {
        protected double saldo;                    // escondido do mundo
        void depositar(double v) { if (v > 0) saldo += v; }
        abstract double taxa();
        double saldoFinal() { return saldo - taxa(); }
    }
    static class Corrente extends Conta { double taxa() { return 10; } }
    static class Poupanca extends Conta { double taxa() { return 0; } }

    public static void main(String[] args) {
        Conta[] contas = { new Corrente(), new Poupanca() };
        for (Conta c : contas) { c.depositar(100); System.out.println(c.saldoFinal()); }
    }
}

saldoFinal é escrito uma vez e funciona para qualquer conta futura: quem adiciona uma nova classe só implementa taxa().

Erros comuns

  • Campos públicos que permitem estados inválidos.
  • Herança profunda usada como reaproveitamento de código.
  • Classe que faz tudo (God class) em vez de responsabilidades separadas.

Quiz e gabarito completo

  1. 1. Polimorfismo permite:

    • a) Ter vários construtores
    • b) Chamar o mesmo método em tipos diferentes sem saber qual implementação roda
    • c) Criar objetos mais rápido
    • d) Herdar de várias classes

    Gabarito: b) Chamar o mesmo método em tipos diferentes sem saber qual implementação roda — O chamador depende do contrato, não da classe concreta.

  2. 2. Encapsulamento serve para:

    • a) Deixar o código menor
    • b) Proteger o estado interno, expondo só operações válidas
    • c) Acelerar a execução
    • d) Permitir herança

    Gabarito: b) Proteger o estado interno, expondo só operações válidas — Regras de negócio ficam garantidas em um único lugar.

Codding • Java Completo • Classes e objetos • Prova final e certificado em codding.lovable.app/cursos/java/prova