0Pricing
Java Academy · Aula

Conversão para cima/baixo e instanceof

Compreenda a conversão para um tipo-pai, a conversão segura para baixo com instanceof e as armadilhas comuns que causam ClassCastException.

Conversão para cima/baixo e instanceof é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 3 aulas no total.

Conversão para cima e para baixo

Conversão para um tipo pai armazena um objeto filho em uma referência de tipo pai e é sempre segura. Conversão para um tipo filho faz o caminho inverso e exige cuidado. Usamos uma verificação de tipo para conferir o tipo real em tempo de execução.

Código: demonstração da conversão para um tipo pai

A conversão para um tipo pai é implícita e segura: um Dog pode ser tratado como um Animal. Você pode chamar os métodos declarados em Animal; a versão de Dog é executada em tempo de execução.

public class Main {
  static class Animal {
    void speak() { System.out.println("Animal sound"); }
  }
  static class Dog extends Animal {
    void speak() { System.out.println("Woof"); }
    void fetch() { System.out.println("Fetch!"); }
  }

  public static void main(String[] args) {
    // Upcasting: Dog stored in an Animal reference (safe, automatic)
    Animal a = new Dog();
    a.speak();  // calls Dog's speak() due to dynamic binding

    // a.fetch(); // Not allowed: reference is Animal, which does not declare fetch
    System.out.println("Upcasting hides Dog-only methods from the reference type.");
  }
}

Por que converter para um tipo filho?

Você faz essa conversão quando precisa de um método exclusivo do filho, como fetch(). Isso deve ser raro e bem verificado. Sempre que possível, prefira escrever o código com base no tipo pai ou em uma interface.

Código: conversão segura para um tipo filho

Faça uma verificação de tipo antes da conversão. Se a verificação falhar, não faça a conversão e escolha outro caminho; assim, você evita ClassCastException.

public class Main {
  static class Animal { void speak() { System.out.println("Animal sound"); } }
  static class Dog extends Animal { void speak() { System.out.println("Woof"); } void fetch() { System.out.println("Fetch!"); } }
  static class Cat extends Animal { void speak() { System.out.println("Meow"); } }

  public static void main(String[] args) {
    Animal a1 = new Dog();
    Animal a2 = new Cat();

    // Safe downcast using instanceof
    if (a1 instanceof Dog) {
      Dog d = (Dog) a1;
      d.fetch(); // OK
    }

    if (a2 instanceof Dog) {
      Dog d2 = (Dog) a2; // will not run
      d2.fetch();
    } else {
      System.out.println("a2 is not a Dog, skip casting.");
    }
  }
}

Armadilhas comuns

Armadilha: fazer uma conversão sem verificar pode lançar ClassCastException. Outra armadilha é usar conversões para tipos filhos em excesso, em vez de projetar com base em interfaces. Mantenha as conversões próximas do ponto em que são necessárias e prefira o polimorfismo.

Código: conversão incorreta versus conversão segura

Nunca faça uma conversão às cegas. Se não tiver certeza do tipo em tempo de execução, proteja a conversão com uma verificação de tipo e escolha uma alternativa segura caso o tipo não corresponda.

public class Main {
  static class Animal { void speak() { System.out.println("Animal"); } }
  static class Dog extends Animal { void fetch() { System.out.println("Fetch!"); } }
  static class Cat extends Animal { }

  public static void main(String[] args) {
    Animal a = new Cat();

    // Bad: direct cast (would throw at runtime)
    // Dog dBad = (Dog) a; // ClassCastException if uncommented

    // Good: check first
    if (a instanceof Dog) {
      Dog d = (Dog) a;
      d.fetch();
    } else {
      System.out.println("Not a Dog; skipping cast.");
    }
  }
}

Verificação da conversão para um tipo filho

Verificação rápida: como fazer com segurança a conversão de uma referência Animal para Dog?

Recapitulação

Recapitulação: a conversão para um tipo pai é segura e comum. A conversão para um tipo filho exige uma verificação de tipo para evitar falhas; prefira projetar com base em tipos pai ou interfaces para reduzir as conversões.

Perguntas Frequentes

A aula “Conversão para cima/baixo e instanceof” é grátis?

Sim — o texto completo de “Conversão para cima/baixo e instanceof” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 3 aulas no total.

O que vou aprender em “Conversão para cima/baixo e instanceof”?

Compreenda a conversão para um tipo-pai, a conversão segura para baixo com instanceof e as armadilhas comuns que causam ClassCastException. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 3.

Quanto tempo leva a aula “Conversão para cima/baixo e instanceof”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Classes abstratas
  2. Interfaces (introdução e comparações)
  3. Conversão para cima/baixo e instanceof
← Voltar para Java Academy