Lancer des objets dans Java
Je ne comprends pas ce que signifie lancer des objets en Java.
Dis que tu as ...
Superclass variable = new Subclass object();
(Superclass variable).method();
Que se passe-t-il ici? Le type de variable change-t-il ou s'agit-il de l'objet de la variable qui change? Très confus.
Regardez cet exemple:
public class A {
//statements
}
public class B extends A {
public void foo() { }
}
A a=new B();
//To execute **foo()** method.
((B)a).foo();
Disons que vous avez une superclasse Fruit et la sous-classe Banana et que vous avez une méthode addBananaToBasket ()
La méthode n'acceptera pas raisins par exemple, vous voulez donc vous assurer que vous ajoutez une banane au panier.
Alors:
Fruit myFruit = new Banana();((Banana)myFruit).addBananaToBasket(); Ceci s'appelle le casting
L'exemple auquel vous faites référence s'appelle Upcasting en Java.
Il crée un objet de sous-classe avec une variable de classe supérieure pointant vers lui.
La variable ne change pas, c'est toujours la variable de la super classe mais elle pointe vers l'objet de la sous-classe.
Par exemple, disons que vous avez deux classes Machine et Caméra; Caméra est une sous-classe de la machine
class Machine{
public void start(){
System.out.println("Machine Started");
}
}
class Camera extends Machine{
public void start(){
System.out.println("Camera Started");
}
public void snap(){
System.out.println("Photo taken");
}
}
Machine machine1 = new Camera();
machine1.start();
Si vous exécutez les instructions ci-dessus, une instance de la classe Camera sera créée avec une référence de la classe Machine pointant vers elle.Alors, la sortie sera "Camera Started" La variable est toujours une référence de la Machine classe. Si vous essayez machine1.snap();, le code ne sera pas compilé
À retenir ici, toutes les caméras sont des machines, car cette dernière est une sous-classe de la machine, mais toutes les machines ne sont pas des caméras. Vous pouvez donc créer un objet de sous-classe et le diriger vers une référence de classe, mais vous ne pouvez pas demander à la référence de classe de faire toutes les fonctions d'un objet de sous-classe (dans notre exemple, machine1.snap() ne sera pas compilé). La référence de la superclasse n'a accès qu'aux fonctions connues de la superclasse (dans notre exemple machine1.start()). Vous ne pouvez pas demander à une référence machine de prendre un cliché. :)
Superclass variable = new subclass object();
Ceci crée simplement un objet de type sous-classe, mais l’assigne à la superclasse de type. Toutes les données des sous-classes sont créées, etc., mais la variable ne peut pas accéder aux données/fonctions des sous-classes. En d'autres termes, vous ne pouvez appeler aucune méthode ou accéder à des données spécifiques à la sous-classe, vous ne pouvez accéder qu'au matériel des super-classes.
Cependant, vous pouvez convertir Superclassvariable dans la sous-classe et utiliser ses méthodes/données.
Disons que vous avez la classe A comme superclasse et la classe B de la classe A.
public class A {
public void printFromA(){
System.out.println("Inside A");
}
}
public class B extends A {
public void printFromB(){
System.out.println("Inside B");
}
}
public class MainClass {
public static void main(String []args){
A a = new B();
a.printFromA(); //this can be called without typecasting
((B)a).printFromB(); //the method printFromB needs to be typecast
}
}
Parfois, vous aimerez recevoir comme argument une référence Parent et à l'intérieur, vous voudrez probablement faire quelque chose de spécifique à un enfant.
abstract class Animal{
public abstract void move();
}
class Shark extends Animal{
public void move(){
swim();
}
public void swim(){}
public void bite(){}
}
class Dog extends Animal{
public void move(){
run();
}
public void run(){}
public void bark(){}
}
...
void somethingSpecific(Animal animal){
// Here you don't know and may don't care which animal enters
animal.move(); // You can call parent methods but you can't call bark or bite.
if(animal instanceof Shark){
Shark shark = (Shark)animal;
shark.bite(); // Now you can call bite!
}
//doSomethingSharky(animal); // You cannot call this method.
}
...
Dans la méthode ci-dessus, vous pouvez passer Shark ou Dog, mais si vous avez quelque chose comme ceci:
void doSomethingSharky(Shark shark){
//Here you cannot receive an Animal reference
}
Cette méthode ne peut être appelée qu'en passant des références de requin. Ainsi, si vous avez un animal (et profondément un requin), vous pouvez l'appeler ainsi:
Animal animal...
doSomethingSharky((Shark) animal)
En bout de ligne, vous pouvez utiliser les références parent et il est généralement préférable de ne pas vous soucier de l'implémentation du parent et d'utiliser le transtypage pour utiliser l'enfant en tant qu'objet spécifique. Ce sera exactement le même objet, mais votre référence le sait. Si vous ne le lancez pas, votre référence pointera sur le même objet mais ne peut pas dire avec certitude de quel type d’animal il serait, par conséquent, vous permettra uniquement d’appeler des méthodes connues.
Dans cet exemple, votre variable superclasse demande à l'objet de sous-classe d'implémenter la méthode de la superclasse. C'est le cas de la conversion du type d'objet Java. Ici, la fonction method () est à l'origine la méthode de la superclasse, mais la variable superclass ne peut pas accéder aux autres méthodes de l'objet sous-classe qui ne sont pas présentes. dans la superclasse.
Par exemple, vous avez la superclasse Animal et la sous-classe Cat. Indiquez que votre sous-classe a speak (); méthode.
class Animal{
public void walk(){
}
}
class Cat extends Animal{
@Override
public void walk(){
}
public void speak(){
}
public void main(String args[]){
Animal a=new Cat();
//a.speak(); Compile Error
// If you use speak method for "a" reference variable you should downcast. Like this:
((Cat)a).speak();
}
}
dans certains cas, nous ne pouvons pas garantir le type d’éléments ou d’objets présents dans notre collection ou de manière judicieuse. Au moment de la récupération, nous devrions effectuer une transtypage de caractères, sans quoi nous aurions une erreur de compilation.
Les tableaux sont toujours protégés contre le type, c’est-à-dire que nous pouvons fournir la garantie du type des éléments présents dans le tableau. pour atteindre la sécurité de type, nous devons utiliser la conversion de type.