×
Ir ao conteúdo
  • Cadastre-se

Java Superclass, subclass (retorna true para todas as subclasses)


lsnkesp
Ir à solução Resolvido por AdrianoSiqueira,

Posts recomendados

Gente, hoje fazendo uma atividade de Java, tive que fazer a vinculação entre o professor e o aluno, como ambos são autenticáveis, ambos estão na mesma lista.

A minha dúvida é quanto ao método que eu estou utilizando, na minha mente estava sendo correto verificar se o array que estou usando naquela posição digitada no momento de vinculação, era um objeto de professor, no entanto, se eu cadastro diretor e coordenador (que também são autenticáveis e também estão nessa lista) e eu digito o ID desses que acabei de cadastrar, retorna true da mesma forma, mesmo não sendo um professor, alguém sabe me explicar porque isso ocorre? estou apanhando de uma coisa que pode parecer muito simples, mas é complicado p mim.

Eu consegui resolver com a seguinte instrução:

public String setAlunoProfessor(int i) {
        if(arrayAutenticaveis[i] instanceof Funcionario) {
            Funcionario f = (Funcionario) arrayAutenticaveis[i];
            if(f.getClass().equals(Professor.class)) {
                return "É um professor";
            } else {
                return "NÃO É UMA INSTÂNCIA DE PROFESSOR";
            }
        } else {
            return "Não é um funcionário";
        }
      
    }

Lembrando que isso é apenas um teste que eu estava fazendo, mas ainda assim não entendi muito bem porque retorna true em todos esses casos. (Aliás, coordenador e diretor são extends de Professor, caso seja necessário saber).

O meu caso é semelhante a este: https://www.ti-enxame.com/pt/java/como-verificar-se-uma-subclasse-e-uma-instancia-de-uma-classe-em-tempo-de-execucao/968109548/

Link para o comentário
Compartilhar em outros sites

  • Solução

Nunca tinha pensado nisso, mas fazendo alguns testes vi algo interessante, mas que pensando bem é o esperado. Analise o código:

public class Main {

    public static void main(String[] args) {
        Autenticavel[] vetor = new Autenticavel[]{
                new Funcionario(),
                new Professor(),
                new Diretor()
        };


        System.out.println(">> Checando instância posição 0");
        checarInstancia(vetor, 0);
        System.out.println("--------------------");

        System.out.println(">> Checando instância posição 1");
        checarInstancia(vetor, 1);
        System.out.println("--------------------");

        System.out.println(">> Checando instância posição 2");
        checarInstancia(vetor, 2);
        System.out.println("--------------------");

        System.out.println("\n");

        System.out.println(">> Checando classe posição 0");
        checarClasse(vetor, 0);
        System.out.println("--------------------");

        System.out.println(">> Checando classe posição 1");
        checarClasse(vetor, 1);
        System.out.println("--------------------");

        System.out.println(">> Checando classe posição 2");
        checarClasse(vetor, 2);
        System.out.println("--------------------");
    }


    private static void checarClasse(Autenticavel[] vetor, int indice) {
        Autenticavel autenticavel = vetor[indice];

        if (autenticavel.getClass().equals(Funcionario.class)) {
            System.out.println("Classe funcionário");
        }

        if (autenticavel.getClass().equals(Professor.class)) {
            System.out.println("Classe professor");
        }

        if (autenticavel.getClass().equals(Diretor.class)) {
            System.out.println("Classe diretor");
        }
    }

    private static void checarInstancia(Autenticavel[] vetor, int indice) {
        Autenticavel autenticavel = vetor[indice];

        if (autenticavel instanceof Funcionario) {
            System.out.println("É funcionário");
        }

        if (autenticavel instanceof Professor) {
            System.out.println("É professor");
        }

        if (autenticavel instanceof Diretor) {
            System.out.println("É diretor");
        }
    }


    // ----- Declaracao das classes -----


    static class Autenticavel {
    }

    static class Funcionario extends Autenticavel {
    }

    static class Professor extends Funcionario {
    }

    static class Diretor extends Funcionario {
    }
}

 

A saída:

>> Checando instância posição 0
É funcionário
--------------------
>> Checando instância posição 1
É funcionário
É professor
--------------------
>> Checando instância posição 2
É funcionário
É diretor
--------------------


>> Checando classe posição 0
Classe funcionário
--------------------
>> Checando classe posição 1
Classe professor
--------------------
>> Checando classe posição 2
Classe diretor
--------------------

 

Sobre o quesito INSTÂNCIA, obtive um resultado inesperado, mas que depois eu entendi que realmente está correto. Como podemos ver, eu não encadeei os ifs no método checarInstancia justamente para que todos eles fossem testados de forma independente. O resultado foi o seguinte, os objetos mais específicos passaram em mais de um teste. Eu não esperava isso, mas parando para pensar é assim que deve ser. Por exemplo o diretor, ele é um funcionário mesmo sendo um diretor, e por ser um funcionário ele é autenticável. Resultado interessante.

 

Sobre o quesito CLASSE, obtive o resultado que eu estava esperando obter no quesito acima. Como podemos ver na saída da execução, cada objeto passou em apenas um if, sendo esse o correspondente à classe que gerou o objeto.

 

Analisando os resultados, posso concluir o seguinte:

  • Se queremos analisar um objeto considerando toda sua linha de herança, nós usamos o instanceof, mas devemos ter o cuidado de testar as condições mais específicas primeiro, pois como vimos um objeto específico passa em teste de tipo mais genérico.
  • Por outro lado, se queremos analisar um objeto de forma pontual, desconsiderando a herança, devemos comparar as classes. Nesse caso - ao que parece - a ordem do teste não fará diferença, pois apenas um teste será verdadeiro.
  • Curtir 1
Link para o comentário
Compartilhar em outros sites

@AdrianoSiqueira Eu também nunca havia pensado dessa forma, fazendo o teste para ver se estava tudo correto, resolvi vincular diretor e aluno (diretor é uma extensão de professor), apenas para verificar se estava vinculando somente professor e aluno, o inesperado aconteceu: retornou true mesmo fazendo a verificação se era um instanceof de professor. Foi aí que ficou confuso, está bem mais claro agora com sua explicação, obrigada!!!!

Link para o comentário
Compartilhar em outros sites

Achei um pouco estranho você declarar Diretor estendendo Professor. No meu entendimento são coisas completamente diferentes, com funções e propósitos diferentes.

 

Pelo que eu aprendi, você estende uma classe quando precisa mudar seu comportamento, ou para estender suas funcionalidades (tipo, adicionar algo a mais sem ter que reinventar a roda).

  • Curtir 1
Link para o comentário
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisa ser um usuário para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...

Ebook grátis: Aprenda a ler resistores e capacitores!

EBOOK GRÁTIS!

CLIQUE AQUI E BAIXE AGORA MESMO!