explicite de la coulée de super-classe de la sous-classe

À l'aide d'un cast vous êtes essentiellement de dire au compilateur "faites-moi confiance. Je suis un professionnel, je sais ce que je fais et je sais que même si tu ne peux pas le garantir, je vous dis que cette animal variable va certainement être un chien."

Puisque l'animal n'est pas un chien (c'est un animal, vous pourriez faire Animal animal = new Dog(); et c'est un chien) la VM déclenche une exception à l'exécution parce que vous avez violé la confiance (vous avez dit au compilateur que tout serait ok et il n'est pas!)

Le compilateur est un peu plus intelligent que de simplement accepter aveuglément tout, si vous essayez et de la fonte d'objets dans les différentes hiérarchies d'héritage (fonte d'un Chien à une Chaîne de caractères par exemple), alors le compilateur va le jeter de retour à vous, car il sait que ne pourrait jamais travailler.

Parce que vous êtes essentiellement juste arrêter le compilateur de se plaindre à chaque fois que vous lancez, il est important de vérifier que vous n'aurez pas de provoquer un ClassCastException en utilisant instanceof dans une instruction if (ou quelque chose à cet effet.)

Afin d'éviter ce genre de ClassCastException, si vous avez:

class A
class B extends A

Vous pouvez définir un constructeur de B, qui prend un objet de A. de Cette façon, nous pouvons faire de la "fonte" par exemple:

public B(A a) {
    super(a.arg1, a.arg2); //arg1 and arg2 must be, at least, protected in class A
    //If B class has more attributes, then you would initilize them here
}

Le code génère une erreur de compilation car votre type d'instance est un Animal:

Animal animal=new Animal();

De passer n'est pas autorisé en Java pour plusieurs raisons.
Voir ici pour plus de détails.

De développer la réponse de @Caumons:

Imaginer un père de classe a de nombreux enfants et il est nécessaire d'ajouter une commune
champ dans la classe. Si vous envisagez de le mentionné approche, vous devez
aller à chaque classe des enfants un par un et refactoriser leurs constructeurs pour le nouveau champ.
donc cette solution n'est pas une solution prometteuse dans ce scénario

Maintenant, jetez un oeil à cette solution.

Un père peut recevoir un objet à partir de chacun des enfants. Voici un père
catégorie:

public class Father {

    protected String fatherField;

    public Father(Father a){
        fatherField = a.fatherField;
    }

    //Second constructor
    public Father(String fatherField){
        this.fatherField = fatherField;
    }

    //.... Other constructors + Getters and Setters for the Fields
}

Voici notre enfant de la classe qui devrait mettre en œuvre l'un de ses père
constructeur, dans ce cas susmentionnés constructeur :

public class Child extends Father {

    protected String childField;

    public Child(Father father, String childField ) {
        super(father);
        this.childField = childField;
    }

    //.... Other constructors + Getters and Setters for the Fields

    @Override
    public String toString() {
        return String.format("Father Field is: %s\nChild Field is: %s", fatherField, childField);
    }
}

Maintenant nous tester l'application:

public class Test {
    public static void main(String[] args) {
        Father fatherObj = new Father("Father String");
        Child child = new Child(fatherObj, "Child String");
        System.out.println(child);
    }
}

Et voici le résultat :

Père de Champ est: le Père de la Chaîne

Enfant Champ: Enfants de Chaîne

Maintenant, vous pouvez facilement ajouter de nouveaux champs à père de classe sans être inquiet de vos enfants des codes à briser;