¿Cuál es la diferencia entre up-casting y down-casting con respecto a la variable de clase?

¿Cuál es la diferencia entre ascender y descender con respecto a la variable de clase?

Por ejemplo, en la siguiente clase de programa, Animal contiene solo un método, pero la clase Dog contiene dos métodos, y luego cómo convertimos la variable Dog en la Variable Animal.

Si se realiza el casting, ¿cómo podemos llamar al otro método de Dog con la variable de Animal?

class Animal 
{ 
    public void callme()
    {
        System.out.println("In callme of Animal");
    }
}


class Dog extends Animal 
{ 
    public void callme()
    {
        System.out.println("In callme of Dog");
    }

    public void callme2()
    {
        System.out.println("In callme2 of Dog");
    }
}

public class UseAnimlas 
{
    public static void main (String [] args) 
    {
        Dog d = new Dog();      
        Animal a = (Animal)d;
        d.callme();
        a.callme();
        ((Dog) a).callme2();
    }
}

Upcasting es la conversión a un supertipo, mientras que downcasting es la conversión a un subtipo. El upcasting siempre está permitido, pero downcasting implica una verificación de tipo y puede arrojar un ClassCastException.

En su caso, un elenco de a Doga an Animales un upcast, porque a Doges-a Animal. En general, puede ascender siempre que haya una relación is-a entre dos clases.

Downcasting sería algo como esto:

Animal animal = new Dog();
Dog castedDog = (Dog) animal;

Básicamente lo que hace es decirle al compilador que usted sabe lo que el tipo de ejecución del objeto realmente es. El compilador permitirá la conversión, pero aún insertará una verificación de cordura en tiempo de ejecución para asegurarse de que la conversión tenga sentido. En este caso, la conversión es posible porque en tiempo de ejecución animales en realidad un Dogaunque el tipo estático de animales Animal.

Sin embargo, si tuviera que hacer esto:

Animal animal = new Animal();
Dog notADog = (Dog) animal;

Obtendría un ClassCastException. La razón es porque animalel tipo de tiempo de ejecución es Animal, por lo que cuando le dice al tiempo de ejecución que realice el lanzamiento, ve que en animalrealidad no es un Dogy arroja un ClassCastException.

Para llamar al método de una superclase, puede hacerlo super.method()o realizando el upcast.

Para llamar al método de una subclase tienes que hacer un abatimiento. Como se muestra arriba, normalmente se arriesga a ClassCastExceptionhacer esto; sin embargo, puede usar el instanceofoperador para verificar el tipo de tiempo de ejecución del objeto antes de realizar el lanzamiento, lo que le permite prevenir ClassCastExceptions:

Animal animal = getAnimal(); // Maybe a Dog? Maybe a Cat? Maybe an Animal?
if (animal instanceof Dog) {
    // Guaranteed to succeed, barring classloader shenanigans
    Dog castedDog = (Dog) animal;
}

La conversión hacia abajo y hacia arriba fue la siguiente:

Upcasting : cuando queremos lanzar una subclase a Super class, usamos Upcasting (o ensanchamiento). Sucede automáticamente, no es necesario hacer nada explícitamente.

Downcasting : cuando queremos convertir una superclase en subclase, usamos Downcasting (o estrechamiento), y Downcasting no es directamente posible en Java, explícitamente tenemos que hacerlo.

Dog d = new Dog();
Animal a = (Animal) d; //Explicitly you have done upcasting. Actually no need, we can directly type cast like Animal a = d; compiler now treat Dog as Animal but still it is Dog even after upcasting
d.callme();
a.callme(); // It calls Dog's method even though we use Animal reference.
((Dog) a).callme2(); // Downcasting: Compiler does know Animal it is, In order to use Dog methods, we have to do typecast explicitly.
// Internally if it is not a Dog object it throws ClassCastException

Upcasting y downcasting son parte importante de Java, lo que nos permite construir programas complicados utilizando una sintaxis simple, y nos brinda grandes ventajas, como el polimorfismo o la agrupación de diferentes objetos. Java permite que un objeto de un tipo de subclase sea tratado como un objeto de cualquier tipo de superclase. Esto se llama upcasting. El upcasting se realiza automáticamente, mientras que el downcasting debe ser realizado manualmente por el programador , y voy a dar mi mejor esfuerzo para explicar por qué es así.

Upcasting y downcasting NO son como pasar primitivas de una a otra, y creo que eso es lo que causa mucha confusión, cuando el programador comienza a aprender a lanzar objetos.

Polimorfismo: todos los métodos en Java son virtuales de forma predeterminada. Eso significa que cualquier método puede anularse cuando se usa en herencia, a menos que ese método se declare como final o estático .

Puede ver el siguiente ejemplo de cómo getType();funciona según el tipo de objeto (perro, mascota, perro policía).

Suponga que tiene tres perros

1. Perro: esta es la superclase.

2. Perro mascota - Perro mascota extiende Perro.

3. Perro policía - Perro policía extiende perro mascota.

   public class Dog{ 
      public String getType () {
         System.out.println("NormalDog");
         return "NormalDog";
      }
    }
   
   /**
    * Pet Dog has an extra method dogName()
    */   
   public class PetDog extends Dog{ 
      public String getType () {
         System.out.println("PetDog");
         return "PetDog";
      }
      public String dogName () {
         System.out.println("I don't have Name !!");
         return "NO Name";
      }
    }
   
   /**
    * Police Dog has an extra method secretId()
    */
   public class PoliceDog extends PetDog{
   
    public String secretId() {
       System.out.println("ID");
       return "ID";
    }
   
    public String getType () {
        System.out.println("I am a Police Dog");
        return "Police Dog";
    }
   }
   

Polimorfismo: todos los métodos en Java son virtuales de forma predeterminada. Eso significa que cualquier método puede anularse cuando se usa en herencia, a menos que ese método se declare como final o estático (la explicación pertenece al concepto de tablas virtuales).

Tabla virtual / Tabla de despacho: la tabla de despacho de un objeto contendrá las direcciones de los métodos enlazados dinámicamente del objeto. Las llamadas a métodos se realizan obteniendo la dirección del método de la tabla de despacho del objeto. La tabla de distribución es la misma para todos los objetos que pertenecen a la misma clase y, por lo tanto, normalmente se comparte entre ellos.

public static void main (String[] args) {
      /**
       * Creating the different objects with super class Reference
       */
     Dog obj1 = new Dog();
`         /**
           *  Object of Pet Dog is created with Dog Reference since                
           *  Upcasting is done automatically for us we don't have to worry about it 
           *  
           */
     Dog obj2 = new PetDog();
`         /**
           *  Object of Police Dog is created with Dog Reference since                
           *  Upcasting is done automatically for us we don't have to worry       
           *  about it here even though we are extending PoliceDog with PetDog 
           *  since PetDog is extending Dog Java automatically upcast for us 
           */
      Dog obj3 = new PoliceDog();
}



 obj1.getType();

Huellas dactilares Normal Dog

  obj2.getType();

Huellas dactilares Pet Dog

 obj3.getType();

Huellas dactilares Police Dog

El programador debe realizar el downcasting manualmente

Cuando intenta invocar el secretID();método en el obj3que se hace PoliceDog objectreferencia a Dogcuál es una superclase en la jerarquía, arroja un error ya obj3que no tiene acceso al secretId()método. Para invocar ese método, necesita Downcast ese obj3 manualmente para PoliceDog

  ( (PoliceDog)obj3).secretID();

que imprime ID

De forma similar para invocar el dogName();método en PetDogla clase que necesita abatido obj2a PetDogdesde obj2 está referenciada a Dogy no tienen acceso a dogName();método

  ( (PetDog)obj2).dogName();

¿Por qué es así que el upcasting es automático, pero el downcast debe ser manual? Bueno, ya ves, el upcasting nunca puede fallar. Pero si usted tiene un grupo de perros diferentes y desea abatido a todos ellos a una de sus tipos, entonces existe la posibilidad de que algunos de estos perros son en realidad de diferentes tipos, es decir, PetDog, PoliceDog, y el proceso falla, lanzando ClassCastException.

Esta es la razón por la que necesita abatir sus objetos manualmente si ha hecho referencia a sus objetos al tipo de superclase.

Nota: Aquí, al hacer referencia, significa que no está cambiando la dirección de memoria de sus objetos cuando los rebaja, sigue siendo el mismo, solo los está agrupando en un tipo particular en este caso Dog

Sé que esta pregunta se hizo hace bastante tiempo, pero para los nuevos usuarios de esta pregunta. Lea este artículo donde contiene una descripción completa sobre el upcasting, downcasting y el uso del operador de instancia

• No es necesario realizar una conversión ascendente manualmente, ocurre por sí solo:

  Mammal m = (Mammal)new Cat(); igual a Mammal m = new Cat();

• Pero el abatimiento siempre debe hacerse manualmente:

  Cat c1 = new Cat();      
  Animal a = c1;      //automatic upcasting to Animal
  Cat c2 = (Cat) a;    //manual downcasting back to a Cat
  

¿Por qué es así que el upcasting es automático, pero el downcast debe ser manual? Bueno, ya ves, el upcasting nunca puede fallar. Pero si tiene un grupo de animales diferentes y quiere rebajarlos a todos a un gato, entonces existe la posibilidad de que algunos de estos animales sean en realidad Perros y el proceso falle al lanzar ClassCastException. Aquí es donde debería introducir una característica útil llamada "instancia de" , que prueba si un objeto es una instancia de alguna clase.

 Cat c1 = new Cat();         
    Animal a = c1;       //upcasting to Animal
    if(a instanceof Cat){ // testing if the Animal is a Cat
        System.out.println("It's a Cat! Now i can safely downcast it to a Cat, without a fear of failure.");        
        Cat c2 = (Cat)a;
    }

Para obtener más información, lea este artículo.

Mejor prueba este método para upcasting, es fácil de entender:

/* upcasting problem */
class Animal
{ 
    public void callme()
    {
        System.out.println("In callme of Animal");
    }
}

class Dog extends Animal 
{ 
    public void callme()
    {
        System.out.println("In callme of Dog");
    }

    public void callme2()
    {
        System.out.println("In callme2 of Dog");
    }
}

public class Useanimlas 
{
    public static void main (String [] args) 
    {
        Animal animal = new Animal ();
        Dog dog = new Dog();
        Animal ref;
        ref = animal;
        ref.callme();
        ref = dog;
        ref.callme();
    }
}

Quizás esta mesa ayude. Llamando al callme()método de clase Parento clase Child. Como principio:

UPCASTING -> Ocultar

DOWNCASTING -> Revelador

1.- Upcasting.

Al hacer un upcasting, define una etiqueta de algún tipo, que apunta a un objeto de un subtipo (el tipo y el subtipo pueden llamarse clase y subclase, si se siente más cómodo ...).

Animal animalCat = new Cat();

Lo que significa que dicha etiqueta, animalCat, tendrá la funcionalidad (los métodos) de tipo Animal solamente, porque la hemos declarado como tipo Animal, no como tipo Cat.

Se nos permite hacer eso de una manera "natural / implícita / automática", en tiempo de compilación o en tiempo de ejecución, principalmente porque Cat hereda parte de su funcionalidad de Animal; por ejemplo, move (). (Al menos, el gato es un animal, ¿no?)

2.- Downcasting.

Pero, ¿qué pasaría si necesitamos obtener la funcionalidad de Cat, de nuestro tipo Animal tag ?.

Como hemos creado la etiqueta animalCat apuntando a un objeto Cat, necesitamos una forma de llamar a los métodos del objeto Cat, desde nuestra etiqueta animalCat de una manera bastante inteligente.

Tal procedimiento es lo que llamamos Downcasting, y solo podemos hacerlo en tiempo de ejecución.

Es hora de un código:

public class Animal {
    public String move() {
        return "Going to somewhere";
    }
}

public class Cat extends Animal{
    public String makeNoise() {
        return "Meow!";
    }   
}

public class Test {

    public static void main(String[] args) {
        
    //1.- Upcasting 
    //  __Type_____tag________object
        Animal animalCat = new Cat();
    //Some animal movement
        System.out.println(animalCat.move());
        //prints "Going to somewhere"
        
    //2.- Downcasting   
    //Now you wanna make some Animal noise.
        //First of all: type Animal hasn't any makeNoise() functionality.
        //But Cat can do it!. I wanna be an Animal Cat now!!
        
        //___________________Downcast__tag_____ Cat's method
        String animalNoise = ( (Cat) animalCat ).makeNoise();
        
        System.out.println(animalNoise);
        //Prints "Meow!", as cats usually done.
        
    //3.- An Animal may be a Cat, but a Dog or a Rhinoceros too.
        //All of them have their own noises and own functionalities.
        //Uncomment below and read the error in the console:
        
    //  __Type_____tag________object
        //Cat catAnimal = new Animal();
        
    }

}

Padre: Coche
Hijo: Figo
Coche c1 = nuevo Figo ();

=====
Upcasting: -
Método: El objeto c1 se referirá a los métodos de clase (Figo - El método debe ser anulado) porque la clase "Figo" se especifica con "nuevo".
Variable de instancia: el objeto c1 se referirá a la variable de instancia de la clase de declaración ("Coche").

Cuando la clase de declaración es padre y el objeto se crea del hijo, se produce la conversión implícita, que es "Upcasting".

======
Downcasting: -
Figo f1 = (Figo) c1; //
Método: El objeto f1 se referirá al Método de clase (figo) ya que el objeto inicial c1 se crea con la clase "Figo". pero una vez que se realiza el down casting, los métodos que solo están presentes en la clase "Figo" también pueden ser referidos por la variable f1.
Variable de instancia: el objeto f1 no se referirá a la variable de instancia de la clase de declaración del objeto c1 (la clase de declaración para c1 es CAR), pero con la conversión descendente se referirá a las variables de instancia de la clase Figo.

======
Uso: cuando el objeto es de clase secundaria y la clase de declaración es padre y la clase secundaria quiere acceder a la variable de instancia de su propia clase y no de la clase principal, entonces se puede hacer con "Downcasting".

upcasting significa lanzar el objeto a un supertipo, mientras que downcasting significa lanzar a un subtipo.

En Java, la conversión ascendente no es necesaria ya que se realiza automáticamente. Y generalmente se lo conoce como casting implícito. Puede especificarlo para dejarlo claro a los demás.

Por lo tanto, escribiendo

Animal a = (Animal)d;

o

Animal a = d;

conduce exactamente al mismo punto y en ambos casos se ejecutará el callme()from Dog.

En cambio, el abatimiento es necesario porque lo definiste acomo objeto de Animal. Actualmente sabes que es un Dog, pero Java no tiene garantías de que lo sea. En realidad, en tiempo de ejecución podría ser diferente y java lanzará un ClassCastException, si eso sucediera. Por supuesto, no es el caso de su ejemplo de muestra. Si no echaría aa Animal, java ni siquiera podía compilar la aplicación, ya que Animalno tiene método callme2().

En su ejemplo no puede comunicarse con el código de callme()de Animalde UseAnimlas(porque Dogsobreescribirla) a menos que el método sería de la siguiente manera:

class Dog extends Animal 
{ 
    public void callme()
    {
        super.callme();
        System.out.println("In callme of Dog");
    }
    ... 
} 

Podemos crear un objeto para Downcasting. En este tipo también. : llamando a los métodos de la clase base

Animal a=new Dog();
a.callme();
((Dog)a).callme2();