154

关于类变量的向上转换和向下转换有什么区别?

例如在下面的程序中,Animal 类只包含一个方法,而 Dog 类包含两个方法,那么我们如何将 Dog 变量转换为 Animal 变量。

如果进行了强制转换,那么我们如何使用 Animal 的变量调用 Dog 的另一种方法。

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

10 回答 10

241

向上转换是转换为超类型,而向下转换是转换为子类型。向上转型总是被允许的,但向下转型涉及类型检查并且可以抛出ClassCastException.

在您的情况下,从 aDog到 an 的转换Animal是向上转换,因为 a Dogis-a Animal。通常,只要两个类之间存在 is-a 关系,您就可以向上转换。

向下转换将是这样的:

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

基本上你正在做的是告诉编译器你知道对象的运行时类型到底是什么。编译器将允许转换,但仍会插入运行时完整性检查以确保转换有意义。在这种情况下,强制转换是可能的,因为在运行时animal实际上是 aDog即使静态类型animalis Animal

但是,如果您要这样做:

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

你会得到一个ClassCastException. 原因是因为animal的运行时类型是Animal,所以当你告诉运行时执行强制转换时,它发现它animal实际上不是 a Dog,所以抛出 a ClassCastException

要调用超类的方法,您可以执行super.method()或执行向上转换。

要调用子类的方法,您必须进行向下转换。如上所示,您通常ClassCastException这样做会冒险;但是,您可以instanceof在执行强制转换之前使用运算符检查对象的运行时类型,这样可以防止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;
}

从 Java 16 开始,向下转换可以更简洁地表达,它为 引入了模式匹配instanceof

Animal animal = getAnimal(); // Maybe a Dog? Maybe a Cat? Maybe an Animal?
if (animal instanceof Dog castedDog) {
    // now castedDog is available here as in the example above
}
于 2014-05-01T19:12:42.430 回答
68

下铸和上铸如下:
在此处输入图像描述

Upcasting:当我们想将 Sub 类转换为 Super 类时,我们使用 Upcasting(或加宽)。它自动发生,无需明确执行任何操作。

Downcasting:当我们想将 Super 类转换为 Sub 类时,我们使用 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

自动装箱与铸造

于 2016-01-21T07:02:54.523 回答
34

向上转型和向下转型是 Java 的重要组成部分,它允许我们使用简单的语法构建复杂的程序,并为我们提供了很大的优势,例如多态性或对不同对象进行分组。Java 允许将子类类型的对象视为任何超类类型的对象。这称为向上转换。向上转换是自动完成的,而向下转换必须由程序员手动完成,我将尽力解释为什么会这样。

向上转换和向下转换不像将原语从一个转换到另一个,我相信当程序员开始学习转换对象时,这会导致很多混乱。

多态性:java中的所有方法默认都是虚的。这意味着在继承中使用任何方法都可以被覆盖,除非该方法声明为 final 或 static

您可以getType();根据对象(狗、宠物、警犬)类型查看下面的示例。

假设你有三只狗

  1. Dog - 这是超级类。

  2. 宠物狗 - 宠物狗扩展了狗。

  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

向下转换需要程序员手动完成

当您尝试调用在其上被引用的secretID();方法是层次结构中的超类时,它会抛出错误,因为无权访问方法。为了调用该方法,您需要手动将该 obj3 向下转换为obj3PoliceDog objectDogobj3secretId() PoliceDog

  ( (PoliceDog)obj3).secretID();

哪个打印ID

以类似的方式调用类中的dogName();方法,PetDog您需要向下转换obj2PetDog因为 obj2 被引用Dog并且无权访问dogName();方法

  ( (PetDog)obj2).dogName();

为什么会这样,向上转换是自动的,但向下转换必须是手动的?嗯,你看,向上转型永远不会失败。但是,如果您有一组不同的 Dogs 并且想要将它们全部向下转换为它们的类型,那么有可能这些 Dogs 中的一些实际上是不同的类型,即 , PetDogPoliceDog并且过程失败,通过 throwing ClassCastException

如果您已将对象引用到超类类型,这就是您需要手动向下转换对象的原因。

注意:这里通过引用意味着您在向下转换时不会更改对象的内存地址,它仍然保持不变,在这种情况下您只是将它们分组为特定类型Dog

于 2015-09-27T22:46:08.803 回答
12

我知道这个问题很久以前就问过了,但是对于这个问题的新用户。请阅读这篇文章,其中包含关于上转型、下转型和使用 instanceof运算符的完整描述

  • 无需手动向上转换,它会自行发生:

    Mammal m = (Mammal)new Cat();等于Mammal m = new Cat();

  • 但是向下转换必须始终手动完成:

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

为什么会这样,向上转换是自动的,但向下转换必须是手动的?嗯,你看,向上转型永远不会失败。但是,如果您有一组不同的动物,并且想将它们全部转换为猫,那么这些动物中的一些实际上是狗,并且通过抛出 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;
    }

欲了解更多信息,请阅读这篇文章

于 2015-11-10T05:30:50.290 回答
6

最好尝试这种方法进行向上转换,它很容易理解:

/* 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();
    }
}
于 2014-09-19T13:40:00.277 回答
6

也许这张表有帮助。调用callme()classParent或 class的方法Child。作为一个原则:

UPCAST​​ING --> 隐藏

向下投射 --> 揭示

在此处输入图像描述

在此处输入图像描述

在此处输入图像描述

于 2016-08-29T10:08:24.010 回答
5

1.- 向上转型。

进行向上转换时,您定义了某种类型的标记,该标记指向子类型的对象(类型和子类型可以称为类和子类,如果您觉得更舒服的话......)。

Animal animalCat = new Cat();

这意味着这样的标签,animalCat,将只具有 Animal 类型的功能(方法),因为我们已经将它声明为 Animal 类型,而不是 Cat 类型。

我们被允许以“自然/隐式/自动”的方式,在编译时或运行时这样做,主要是因为 Cat 继承了 Animal 的一些功能;例如,移动()。(至少,猫是一种动物,不是吗?)

2.- 垂头丧气。

但是,如果我们需要从我们的类型 Animal 标签中获取 Cat 的功能会发生什么?

由于我们已经创建了指向 Cat 对象的 animalCat 标记,我们需要一种方法来调用 Cat 对象的方法,从我们的 animalCat 标记中以某种智能漂亮的方式调用。

这样的过程就是我们所说的向下转换,我们只能在运行时进行。

一些代码的时间:

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

}
于 2018-10-06T19:02:06.660 回答
2

父母:汽车
孩子:菲戈
汽车 c1 = new Figo();

=====
向上转换:-
方法:对象 c1 将引用类的方法(Figo - 方法必须被覆盖),因为类“Figo”是用“new”指定的。
实例变量:对象 c1 将引用声明类(“汽车”)的实例变量。

当声明类是父类并且对象是由子类创建时,就会发生隐式转换,即“向上转换”。

======
向下转换:-
Figo f1 = (Figo) c1; //
方法:对象 f1 将引用类 (figo) 的方法,因为初始对象 c1 是使用类“Figo”创建的。但是一旦向下转换完成,仅存在于类“Figo”中的方法也可以由变量 f1 引用。
实例变量:对象 f1 不会引用对象 c1 的声明类的实例变量(c1 的声明类是 CAR),但通过向下转换,它将引用 Figo 类的实例变量。

======
使用:当对象是子类并且声明类是父类并且子类想要访问它自己的类而不是父类的实例变量时,可以使用“向下转换”来完成。

于 2015-08-07T06:40:46.487 回答
1

向上转型意味着将对象转换为超类型,而向下转型意味着将对象转换为子类型。

在 java 中,向上转换不是必需的,因为它是自动完成的。它通常被称为隐式转换。您可以指定它以使其他人清楚。

因此,写

Animal a = (Animal)d;

或者

Animal a = d;

导致完全相同的点,并且在这两种情况下都将执行callme()from Dog

相反,向下转换是必要的,因为您将其定义a为 Animal 的对象。目前你知道它是 a Dog,但 java 不能保证它是。实际上在运行时它可能会有所不同,java会抛出一个ClassCastException,会发生这种情况吗?当然,您的示例并非如此。如果您不强制a转换为Animal,java 甚至无法编译应用程序,因为Animal没有方法callme2()

在您的示例中,您无法访问fromcallme()的代码(因为覆盖它),除非方法如下:AnimalUseAnimlasDog

class Dog extends Animal 
{ 
    public void callme()
    {
        super.callme();
        System.out.println("In callme of Dog");
    }
    ... 
} 
于 2014-05-01T19:26:20.693 回答
0

我们可以创建对象向下转换。在这种类型也。: 调用基类方法

Animal a=new Dog();
a.callme();
((Dog)a).callme2();
于 2016-02-22T07:09:43.677 回答