Java - Variables de référence

Question

« Il est important de comprendre que est le type de variable de référence - pas le type d'objet qu'il se réfère à -. Qui détermine ce que les membres peuvent accéder »

Que voulez-vous dire exactement par cette déclaration? Est-ce restreint au concept d'héritage? Comment JVM le gère-t-il?

Answer 1

Cela signifie que supposons que vous avez:

Object x = "hello"; 

Le type de la variable est Object, mais le type de l'objet auquel il fait référence est String. c'est le type de variable qui détermine ce que vous pouvez faire si - vous ne pouvez pas appeler

// Invalid 
String y = x.toUpperCase(); 

Le compilateur sait seulement que vous appelez une méthode sur Object, qui ne comprend pas toUpperCase. De même, les méthodes surchargées ne sont résolus contre ceux que vous connaissez sur:

public class Superclass 
{ 
    public void foo(Object x) {} 
} 

public class Subclass extends Superclass 
{ 
    public void foo(String y) {} 
} 
... 
Subclass x = new Subclass(); 
Superclass y = x; 

x.foo("hello"); // Calls Subclass.foo(String) 
y.foo("hello"); // Calls Superclass.foo(Object) 

Answer 2

public class Base 
{ 
    public object BaseMethod() 
    { 
     return new String("From Base"); 
    } 

} 

public class Child extends Base 
{ 
    public object BaseMethod 
    { 
     return new String("From Child.BaseMethod (overridden)"); 
    } 

    public object ChildMethod 
    { 
     return new String("From Child.ChildMethod"); 
    } 
} 

public class Test 
{ 
    public static void main(String[] args) 
    { 
     Base base = new ChildMethod(); 
     System.out.println(base.BaseMethod()); //prints "From Child.BaseMethod (overridden)" 

     System.out.println(base.ChildMethod()); //Will not compile as ChildMethod as reference is of type Base, and ChildMethod is not specified. 

     Child child = (Child) base; //But I can cast it. 
     System.out.println(child.ChildMethod()); // This will work. 
    } 
} 

Answer 3

En Java une référence de base type de classe peut se référer à un objet de classe child. Mais en utilisant une telle référence nous pouvons seulement accéder aux membres de la classe base qui ont été hérités à la classe child et non aux membres que la classe child aurait pu ajouter.

Answer 4

Si vous avez une classe Foo avec un champ public foo et une classe Bar extends Foo avec un champ public bar ...

• Foo myRef = new Bar(); vous permettra seulement d'accéder myRef.foo même si l'objet est vraiment un Bar.
• Bar myRef = new Bar(); permet l'accès à la fois myRef.foo et myRef.bar. Parce que la référence est déclarée Bar.

Answer 5

Par exemple:

Bike b = new Bike(); 
Bike b2 = new MountainBke(); 
b.speedUp(); 
b2.speedUp(); 
b2.shiftGearUp(); 

Dans l'exemple ci-dessus, supposons qu'un vélo ne possède pas la méthode shiftUp. La ligne b2.shiftGearUp() ne compilerait pas parce que la machine virtuelle Java sait seulement que b2 est un Bike, pas un MountainBike.

Vous pouvez le faire fonctionner par coulée à un type de vélo de montagne:

((MountainBike)b2).shiftGearUp(); // This compiles and runs propperly 

Answer 6

« Il est important de comprendre que ce est le type de variable de référence - pas le type d'objet il renvoie à - qui détermine les membres auxquels peut accéder."

Ce que cela signifie est que le compilateur vérifie la classe de la variable de référence pour la présence de méthodes et d'autres membres, par exemple, dire que vous avez une sous-classe Dog qui étend Animal baseclass,

Animal obj=new Dog(); 
obj.makeSound(); 

ici le compilateur vérifie si la méthode makeSound() est déclarée dans la classe animale ou non pour compiler.