Est-il possible d'appeler des méthodes de sous-classes sur un objet de super-classe?

Animal est une super-classe de Chien
et le Chien a une méthode appelée écorce

public void bark()
{
    System.out.println("woof");
}

De considérer les éléments suivants:

Animal a = new Dog();
if (a instanceof Dog){
    a.bark();
}

Ce qui va arriver?

l'affectation n'est pas autorisé
l'appel à l'écorce est autorisé et "wouf" est imprimé au moment de l'exécution
l'appel à l'écorce est permis mais rien n'est imprimé
l'appel à l'écorce provoque une erreur de compilation
l'appel à l'écorce des résultats dans une erreur d'exécution

Je l'ai dit 2 que nous allons vérifier si l'objet est un chien; chien est la classe avec l'écorce de la méthode en elle, si c'est pour nous l'appelons, qui va imprimer :s

Est ma compréhension de corriger ici?

source d'informationauteur

31

Ce ne compile pas parce que l'Animal n'a pas une méthode appelée écorce. Pensez-y de cette façon, tous les chiens sont des animaux, mais pas tous les animaux sont des chiens. Tous les chiens aboient, mais pas tous les animaux de l'écorce.
27

pas - la réponse est;

4) l'appel à l'écorce provoque une erreur de compilation

l'écorce méthode n'est pas définie comme une méthode sur les type d'Animal, ce qui entraînera donc compiler le problème du temps; ceci peut être résolu par casting;
```
((Dog)a).bark();
```
11

La clé est dans la ligne suivante:
```
Animal a = new Dog();
```
Bien qu'une nouvelle instance de Dog a été créé, sa référence est par a qui est déclaré pour être de type Animal. Par conséquent, toutes les références à a rend le new Dog être traitée comme une Animal.

Donc, à moins que Animal a un bark méthode, la ligne suivante sera la cause d'une erreur de compilateur:
```
a.bark();
```
Même si a est testé pour voir si elle est une instance de Doget a instanceof Dog sera fait retour truela variable a est toujours de l'est de type Animalde sorte que le bloc à l'intérieur de la if déclaration encore des poignées de a comme un Animal.

C'est une caractéristique des statiquement typé langues où les variables sont affectées d'un type à l'avance, et vérifié à la compilation de voir que les types de match. Si ce code ont été effectuées sur un dynamiquement typés langueoù les types sont vérifiées au moment de l'exécution, quelque chose comme ce qui suit pourrait être autorisée:
```
var a = new Dog();
if (a instanceof Dog)
    a.bark();
```
a.bark() est garanti uniquement à exécuter lorsque l'instance est une Dogdonc l'appel bark le sera toujours. Cependant, Java est un statiquement typé de la langue, de sorte que ce type de code n'est pas autorisé.
5

Dans La Tête La Première, Java ils utilisent la très bonne analogie de la télécommande du TÉLÉVISEUR pour un référence et votre TÉLÉVISEUR comme le objet que les points de référence. Si votre télécommande uniquement a des boutons (méthodes) on, off, de station haut et bas, et le volume haut et bas, il n'a pas d'importance ce que cool fonctionnalités de votre TÉLÉVISEUR. Vous pouvez toujours faire quelques choses de base à partir de votre télécommande. Vous ne pouvez pas couper le son de votre TÉLÉVISEUR, par exemple, si votre télécommande n'a pas de bouton de mise en sourdine.

L'Animal de référence ne sait que sur des Animaux méthodes. Il n'a pas d'importance ce que les autres méthodes de l'objet sous-jacent a, vous ne pouvez pas y accéder à partir d'un Animal de référence.
4

C'est 4. Vous ne pouvez pas demander à un générique de l'Animal - qui est ce que votre code en dit est - à aboyer. Parce que vous pourriez tout aussi bien avoir dit
```
Animal a = new Cat();
```
et l'écorce ligne n'ont pas les moyens de savoir que vous n'avez pas.
4

Si l'idée est d'imprimer le sous-classe de la méthode de la superclasse de l'objet, cela va fonctionner:

Au lieu de Animal a = new Dog(); if (a instanceof Dog){ a.bark(); }
changement de
```
Animal a = new Dog();

if (a instanceof Dog){ 
    Dog d = (Dog) a; 
    d.bark();
}  
```
Ce qui jette de la superclasse de retour à la sous-classe et l'imprime.
bien que sa mauvaise conception, son seul moyen de savoir lequel des enfants de la classe de l'objet à son pointant vers dynamiquement.
2

Pour info, ce n'est pas une bonne conception.

N'importe quel moment vous avez le code de ce formulaire:
```
if (x instanceof SomeClass)
{
   x.SomeMethod();
}
```
vous abuser du système de type. Ce n'est pas la façon d'utiliser les classes, ce n'est pas la façon d'écrire maintenable code orienté objet. C'est fragile. C'est alambiqué. Elle est mauvaise.

Vous pouvez créer des modèles de méthodes dans une classe de base, mais ils ont pour l'appel de méthodes qui existent dans la classe de base et sont remplacées dans les sous-classes.

En java(seule langue que je connais), vous pouvez créer une méthode vide et l'appeler dans la super-classe. Ensuite, vous pouvez le remplacer dans la sous-classe pour faire ce que vous voulez. De cette façon, la super-classe des appels de ses sous-classe de la méthode.

public class Test {
    public static void main(String[] args){
        Snake S = new Snake();
        Dog d = new Dog();
    }
}


class Animal{ //Super Class
    public Animal(){
        bark(); //calls bark when a new animal is created
    }
    public void bark(){
        System.out.println("this animal can't bark");
    }
}



class Dog extends Animal{ //Subclass 1
    @Override
    public void bark(){
        System.out.println("Woof");
    }
}



class Snake extends Animal{//Subclass 2
    public void tss(){
    }
}

Ce code appelle un objet de Serpent appelle alors un objet de Chien. Il écrit ceci dans la console:

this animal can't bark
Woof

Serpent ne est pas toute l'écorce de la méthode afin que les super-classe de la méthode est appelée. Il écrit la première ligne de la console.
Chien a une écorce de la méthode de la super classe des appels à la place. Il écrit la deuxième ligne de la console.

1

"Je l'ai dit 2 que nous allons vérifier si l'objet est un chien; chien est la classe avec l'écorce de la méthode en elle, si c'est pour nous l'appelons, qui va imprimer :s"

Votre raisonnement est correct, mais ce n'est pas la façon dont il fonctionne.

Java est un statique typée langue signifie, la validité des méthodes d'un objet peut répondre à est vérifiée à moment de la compilation.

Vous pouvez penser à le vérifier:
```
if( a instanceof Dog ) 
```
Le ferait, mais en réalité il ne l'est pas. Ce que le compilateur à faire est de vérifier à l'encontre de l ' "interface" du type déclaré ( Animal dans ce cas ). L ' "interface" est composé de l'méthodes déclarées sur l'Animal de la classe.

Si le écorce() méthode n'est pas définie dans la classe super Animal le compilateur dit: "Hey, ça ne marchera pas".

C'est utile, parce que "parfois" on fait des fautes de frappe lors de l'encodage ( en tapant le barck() à la place par exemple )

Si le compilateur n'est pas le cas de nous en avertir à ce sujet, vous devez le trouver au "runtime" et pas toujours avec un message clair ( par exemple javascript dans IE dit quelque chose comme "objet inattendu" )

Encore, statique tapé langage comme java nous permettre de force à l'appel. Dans ce cas, c'est à l'aide de la "fonte" de l'opérateur ()

Comme ce
```
1. Animal a = new Dog();
2.  if (a instanceof Dog){
3.     Dog imADog = ( Dog ) a;
4.     imADog.bark();
5. }
```
Dans la ligne 3 de votre "casting" pour un Chien de type ainsi, le compilateur peut vérifier si l'écorce est un message valide.

C'est une instruction pour le compilateur en disant: "Hé, je suis le programmeur ici, je sais ce que je fais". Et le compilateur vérifie, Ok, chien, pouvez recevoir le message d'écorce (). Pourtant, si lors de l'exécution de l'animal n'est pas un chien, une exception d'exécution va augmenter.

Le casting pourrait également être abrégée comme:
```
if( a instanceof Dog ) {
   ((Dog)a).bark();  
}
```
Qui va l'exécuter.

Donc, la bonne réponse est 4: "l'appel à l'écorce provoque une erreur de compilation"

J'espère que cette aide.

Vous devez vous connecter pour publier un commentaire.