В чем разница между up-casting и down-casting относительно переменной класса

Down-casting и up-casting было следующим образом:

Upcasting: когда мы хотим привести подкласс к супер классу, мы используем Upcasting (или расширение). Это происходит автоматически, не нужно ничего делать явно.

Downcasting: когда мы хотим привести супер класс к подклассу, мы используем Downcasting (или сужение), а Downcasting непосредственно невозможно в Java, явно мы должны это сделать.

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 и downcasting являются важной частью Java, которая позволяет нам создавать сложные программы с использованием простого синтаксиса и дает нам большие преимущества, такие как полиморфизм или группирование различных объектов. Java разрешает объект типа подкласса рассматриваться как объект любого типа суперкласса. Это называется upcasting. Upcasting выполняется автоматически, в то время как downcasting должен выполняться вручную программистом, и я собираюсь дать все возможное, чтобы объяснить почему это так.

Upcasting и downcasting не похожи на кастинг примитивов от одного к другому, и я считаю, что это вызывает много путаницы, когда программист начинает изучать объекты кастинга.

полиморфизм: все методы в Java являются виртуальными по умолчанию. Это означает, что любой метод может быть переопределен при использовании в наследовании, если этот метод не объявлен как final или static.

вы можете увидеть пример ниже как!--6--> работы согласно типу предмета (собаки,любимчика,собаки полиции).

Предположим, у вас есть три собаки

1. Собака - это супер класс.
2. Pet Dog-собака расширяет собаку.

3. полицейская собака-полицейская собака расширяет собаку.

   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";
    }
   }
   

полиморфизм : все методы в Java являются виртуальными по умолчанию. Это означает, что любой метод может быть переопределен при использовании в наследовании, если этот метод объявляется как final или static.(Объяснение относится к концепции виртуальных таблиц)

виртуальная таблица / таблица отправки: таблица отправки объекта будет содержать адреса динамически связанных методов объекта. Вызовы метода выполняются путем извлечения адреса метода из таблицы отправки объекта. Таблица отправки одинакова для всех объектов, принадлежащих к одному классу, и поэтому обычно используется совместно их.

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

печать Normal Dog

  obj2.getType();

печать Pet Dog

 obj3.getType();

печать Police Dog

Downcasting нужно сделать программистом вручную

при попытке вызвать secretID(); метод on obj3 что это PoliceDog object но ссылаться на Dog который является супер-классом в иерархии, он выдает ошибку, так как obj3 нет доступа к secretId() метод.In чтобы вызвать этот метод, вам нужно вручную понизить obj3 до PoliceDog

  ( (PoliceDog)obj3).secretID();

, который печатает ID

аналогичным образом вызвать dogName();метод PetDog класс нужно опустить obj2 до PetDog поскольку obj2 ссылается на Dog и не имеют доступа к dogName(); метод

  ( (PetDog)obj2).dogName();

почему это так, что upcasting является автоматическим, но downcasting должен быть ручным? Ну, вы видите, upcasting может никогда не подведет. Но если у вас есть группа разных собак и вы хотите опустить их всех до их типов, то есть шанс, что некоторые из этих собак на самом деле разных типов, т. е. PetDog, PoliceDog, и процесс терпит неудачу, бросая ClassCastException.

это причина, по которой вам нужно опустить объекты вручную если вы ссылались на свои объекты на тип супер класса.

Примечание: здесь ссылка означает вы не меняете адрес памяти ваших объектов, когда вы опускаете его, он все еще остается тем же, вы просто группируете их к определенному типу в этом случае Dog

Я знаю, что этот вопрос задан довольно давно, но для новых пользователей этого вопроса. Пожалуйста, прочитайте эту статью, где содержится полное описание по upcasting, downcasting и использованию instanceof оператор

• нет необходимости поднимать вручную, это происходит само по себе:

  Mammal m = (Mammal)new Cat(); равна Mammal m = new Cat();

• но downcasting необходимо всегда делать вручную:

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

Почему это так, что upcasting является автоматическим, но downcasting должен быть ручным? Видите ли, апкастинг никогда не подводит. Но если у вас есть группа разных животных и вы хотите унизить их всех до кошки, то есть шанс, что некоторые из этих животных на самом деле собаки, и процесс терпит неудачу, бросая ClassCastException. Именно здесь следует ввести полезную функцию под названием "instanceof", который проверяет, является ли объект экземпляр некоторого класса.

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

для получения дополнительной информации, пожалуйста, прочитайте в этой статье

лучше попробуйте этот метод для upcasting, это легко понять:

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

может быть, эта таблица помогает. Вызываю callme() метод класса Parent или класс Child. В принципе:

UPCASTING -- > скрытие

DOWNCASTING -- > выявление

Родитель: Автомобиль
Ребенок: Figo
Автомобиль c1 = новый Figo ();

=====
Upcasting:-
Метод: объект c1 будет ссылаться на методы класса (Figo-метод должен быть переопределен), потому что класс "Figo" указан с "new".
Переменная экземпляра: объект c1 будет ссылаться на переменную экземпляра класса объявления ("автомобиль").

когда класс объявления является родительским, а объект создается дочерним, происходит неявное приведение, которое является "Upcasting".

======
Приведения типов:-
Figo f1 = (Figo) c1; //
Метод: объект f1 будет ссылаться на метод класса (figo), поскольку исходный объект c1 создается с классом "Figo". но после завершения литья вниз методы, которые присутствуют только в классе "Figo", также могут быть отнесены к переменной f1.
Переменная экземпляра: объект f1 не будет ссылаться на переменную экземпляра класса объявления объекта c1 (класс объявления для c1-автомобиль), но с приведением вниз он будет ссылаться на экземпляр переменные класса Figo.

======
Использование: когда объект имеет дочерний класс и класс объявления является родительским, а дочерний класс хочет получить доступ к переменной экземпляра собственного класса, а не родительского класса, то это можно сделать с помощью "Downcasting".

upcasting означает приведение объекта к супертипу, в то время как downcasting означает приведение к подтипу.

в java, upcasting не является необходимым, как это делается автоматически. И это обычно называют неявным кастингом. Вы можете указать его, чтобы он был понятен другим.

таким образом, пишет

Animal a = (Animal)d;

или

Animal a = d;

приводит к точно такой же точке и в обоих случаях будет выполнено callme() от Dog.

Downcasting вместо этого необходимо, потому что вы определили a как объект животного. В настоящее время вы знаете, что это Dog, но java не имеет никаких гарантий. На самом деле во время выполнения это может быть по-другому, и java бросит ClassCastException, это произошло. Конечно,это не относится к вашему образцу. Если бы вы не бросили a to Animal, java не смог даже скомпилировать приложение, потому что Animal не имеет метода callme2().

в вашей пример вы не можете достичь кода callme() of Animal С UseAnimlas (поскольку Dog перезаписать его), если метод не будет следующим:

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

мы можем создать объект для Downcasting. В этом типе тоже. вызов методов базового класса

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