Lanzar objetos en Java

Estoy confundido acerca de lo que significa lanzar objetos en Java.

Digamos que tienes …

Superclass variable = new Subclass object(); (Superclass variable).method(); 

¿Que está sucediendo aquí? ¿El tipo de variable cambia, o es el objeto dentro de la variable el que cambia? Muy confundido.

Echa un vistazo a esta muestra:

 public class A { //statements } public class B extends A { public void foo() { } } A a=new B(); //To execute **foo()** method. ((B)a).foo(); 

Supongamos que tiene una superclase Fruit y la subclase Banana y tiene un método addBananaToBasket ()

El método no aceptará uvas, por ejemplo, por lo que debe asegurarse de agregar una banana a la cesta.

Asi que:

Fruit myFruit = new Banana();
((Banana)myFruit).addBananaToBasket(); ⇐ Esto se llama casting

El ejemplo al que te refieres se llama Upcasting en java.

Crea un objeto de subclase con una variable de clase superior que lo señala.

La variable no cambia, sigue siendo la variable de la superclase pero apunta al objeto de la subclase.

Por ejemplo, digamos que tiene dos clases Máquina y Cámara; La cámara es una subclase de la máquina

 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 ejecuta los enunciados anteriores, creará una instancia de la clase Camera con una referencia de la clase Machine apuntando hacia ella. Por lo tanto, ahora la salida será ” Camera Started “. La variable sigue siendo una referencia de la clase Machine. Si intentas machine1.snap(); el código no comstackrá

El punto clave aquí es que todas las cámaras son máquinas, ya que la cámara es una subclase de la máquina, pero todas las máquinas no son cámaras. Entonces puede crear un objeto de subclase y apuntarlo a una refrencia de superclase, pero no puede pedirle a la referencia de superclase que realice todas las funciones de un objeto de subclase (en nuestro ejemplo, machine1.snap() no comstackrá). La referencia de la superclase solo tiene acceso a las funciones conocidas de la superclase (en nuestro ejemplo machine1.start() ). No puede pedir una referencia de máquina para tomar un complemento. 🙂

Superclass variable = new subclass object();
Esto solo crea un objeto de tipo subclase, pero lo asigna a la clase superclase. Todos los datos de las subclases se crean, etc., pero la variable no puede acceder a las datos / funciones de las subclases. En otras palabras, no puede llamar a ningún método ni acceder a datos específicos de la subclase, solo puede acceder a las cosas de las superclases.

Sin embargo, puede convertir Superclassvariable en la Subclase y usar sus métodos / datos.

A veces le gustaría recibir como argumento una referencia de los padres y dentro de usted probablemente quiera hacer algo específico de un niño.

 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. } ... 

En el método de arriba puedes pasar Tiburón o Perro, pero ¿qué pasa si tienes algo como esto?

 void doSomethingSharky(Shark shark){ //Here you cannot receive an Animal reference } 

Ese método solo se puede llamar al pasar referencias de tiburón. Por lo tanto, si tienes un Animal (y es profundamente un Tiburón) puedes llamarlo así:

 Animal animal... doSomethingSharky((Shark) animal) 

En pocas palabras, puede usar las referencias principales y, por lo general, es mejor cuando no se preocupa por la implementación del elemento principal y usa el molde para usar el elemento secundario como un objeto específico, será exactamente el mismo objeto, pero su referencia lo sabe Si no lo haces, tu referencia apuntará al mismo objeto pero no puede estar seguro de qué tipo de Animal sería, por lo tanto, solo te permitirá llamar a métodos conocidos.

Digamos que tiene Clase A como superclase y Clase B subclase de 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 } } 

En este ejemplo, su variable de superclase indica al objeto de la subclase que implemente el método de la superclase. Este es el caso del lanzamiento de tipo de objeto Java. Aquí la función de método () es originalmente el método de la superclase, pero la variable de superclase no puede acceder a los otros métodos del objeto de subclase que no están presentes en la superclase.

Por ejemplo, tiene la superclase Animal y la subclase Cat. Diga que su subclase tiene speak (); método.

 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(); } } 

en algunos casos no podemos proporcionar la garantía para el tipo de elementos u objetos presentes dentro de nuestra colección o sabios, en el momento de la recuperación obligatoria debemos realizar el tipo de conversión, de lo contrario obtendremos un error de tiempo de comstackción.

Las matrices siempre son seguras, es decir que podemos proporcionar la garantía para el tipo de elementos presentes dentro de la matriz. para lograr seguridad tipo tenemos que usar encasillamiento.

Casting es necesario para decirle que está llamando a un niño y no a un método de padres. Entonces es siempre hacia abajo. Sin embargo, si el método ya está definido en la clase padre y reemplazado en la clase secundaria, no se realiza ningún lanzamiento. Aquí un ejemplo:

 class Parent{ void method(){ System.out.print("this is the parent"); } } class Child extends Parent{ @override void method(){ System.out.print("this is the child"); } } ... Parent o = new Child(); o.method(); ((Child)o).method(); 

Las dos llamadas al método se imprimirán: “este es el niño”.