java(向上向下转型)

在Java编程中经常碰到类型转换,对象类型转换主要包括向上转型和向下转型。

5.13.1 向上转型

我们在现实中常常这样说:这个人会唱歌。在这里,我们并不关心这个人是黑人还是白人,是成人还是小孩,也就是说我们更倾向于使用抽象概念“人”。再例如,麻雀是鸟类的一种(鸟类的子类),而鸟类则是动物中的一种(动物的子类)。我们现实中也经常这样说:麻雀是鸟。这两种说法实际上就是所谓的向上转型,通俗地说就是子类转型成父类。这也符合Java提倡的面向抽象编程思想。来看下面的代码:

package a.b;

public class A {

public void a1() {

System.out.println("Superclass");

}

}

A的子类B:

package a.b;

public class B extends A {

public void a1() {

System.out.println("Childrenclass");
//覆盖父类方法

}

public void b1(){} //B类定义了自己的新方法

}

C类:

package a.b;

public class C {

public static void main(String[] args) {

A a = new B(); //向上转型

a.a1();

}

}

如果运行C,输出的是Superclass
还是Childrenclass?不是你原来预期的Superclass,而是Childrenclass。这是因为a实际上指向的是一个子类对象。当然,你不用担心,Java虚拟机会自动准确地识别出究竟该调用哪个具体的方法。不过,由于向上转型,a对象会遗失和父类不同的方法,例如b1()。有人可能会提出疑问:这不是多此一举吗?我们完全可以这样写:

B a = new B();

a.a1();

确实如此!但这样就丧失了面向抽象的编程特色,降低了可扩展性。其实,不仅仅如此,向上转型还可以减轻编程工作量。来看下面的显示器类Monitor:

package a.b;

public class Monitor{

public void displayText() {}

public void displayGraphics() {}

}

液晶显示器类LCDMonitor是Monitor的子类:

package a.b;

public class LCDMonitor extends Monitor {

public void displayText() {

System.out.println("LCD display
text");

}

public void displayGraphics() {

System.out.println("LCD display
graphics");

}

}

阴极射线管显示器类CRTMonitor自然也是Monitor的子类:

package a.b;

public class CRTMonitor extends Monitor {

public void displayText() {

System.out.println("CRT display
text");

}

public void displayGraphics() {

System.out.println("CRT display
graphics");

}

}

等离子显示器PlasmaMonitor也是Monitor的子类:

package a.b;

public class PlasmaMonitor extends Monitor {

public void displayText() {

System.out.println("Plasma display
text");

}

public void displayGraphics() {

System.out.println("Plasma display
graphics");

}

}

现在有一个MyMonitor类。假设没有向上转型,MyMonitor类代码如下:

package a.b;

public class MyMonitor {

public static void main(String[] args) {

run(new LCDMonitor());

run(new CRTMonitor());

run(new PlasmaMonitor());

}

public static void run(LCDMonitor monitor) {

monitor.displayText();

monitor.displayGraphics();

}

public static void run(CRTMonitor monitor) {

monitor.displayText();

monitor.displayGraphics();

}

public static void run(PlasmaMonitor monitor) {

monitor.displayText();

monitor.displayGraphics();

}

}

可能你已经意识到上述代码有很多重复代码,而且也不易维护。有了向上转型,代码可以更为简洁:

package a.b;

public class MyMonitor {

public static void main(String[] args) {

run(new LCDMonitor());
                   
//向上转型

run(new
CRTMonitor());                    
//向上转型

run(new
PlasmaMonitor());           
//向上转型

}

public static void run(Monitor monitor) { //父类实例作为参数

monitor.displayText();

monitor.displayGraphics();

}

}

我们也可以采用接口的方式,例如:

package a.b;

public interface Monitor {

abstract void displayText();

abstract void displayGraphics();

}

将液晶显示器类LCDMonitor稍作修改:

package a.b;

public class LCDMonitor implements Monitor {

public void displayText() {

System.out.println("LCD display
text");

}

public void displayGraphics() {

System.out.println("LCD display
graphics");

}

}

CRTMonitor、PlasmaMonitor类的修改方法与LCDMonitor类似,而MyMonitor可以不不作任何修改。

可以看出,向上转型体现了类的多态性,增强了程序的简洁性。

5.13.2 向下转型

子类转型成父类是向上转型,反过来说,父类转型成子类就是向下转型。但是,向下转型可能会带来一些问题:我们可以说麻雀是鸟,但不能说鸟就是麻雀。来看下面的例子:

A类:

package a.b;

public class A {

void aMthod() {

System.out.println("A method");

}

}

A的子类B:

package a.b;

public class B extends A {

void bMethod1() {

System.out.println("B method 1");

}

void bMethod2() {

System.out.println("B method 2");

}

}

C类:

package a.b;

public class C {

public static void main(String[] args) {

A a1 = new
B(); // 向上转型

a1.aMthod();    // 调用父类aMthod(),a1遗失B类方法bMethod1()、bMethod2()

B b1 = (B)
a1; // 向下转型,编译无错误,运行时无错误

b1.aMthod();    // 调用父类A方法

b1.bMethod1(); // 调用B类方法

b1.bMethod2(); // 调用B类方法

A a2 = new
A();

B b2 = (B)
a2; // 向下转型,编译无错误,运行时将出错

b2.aMthod();

b2.bMethod1();

b2.bMethod2();

}

}

从上面的代码我们可以得出这样一个结论:向下转型需要使用强制转换。运行C程序,控制台将输出:

Exception in thread "main" java.lang.ClassCastException: a.b.A cannot be cast
to a.b.B at
               
a.b.C.main(C.java:14)

A method

A method

B method 1

B method 2

其实黑体部分的向下转型代码后的注释已经提示你将发生运行时错误。为什么前一句向下转型代码可以,而后一句代码却出错?这是因为a1指向一个子类B的对象,所以子类B的实例对象b1当然也可以指向a1。而a2是一个父类对象,子类对象b2不能指向父类对象a2。那么如何避免在执行向下转型时发生运行时ClassCastException异常?使用5.7.7节学过的instanceof就可以了。我们修改一下C类的代码:

A a2 = new A();

if (a2 instanceof B) {

B b2 = (B) a2;

b2.aMthod();

b2.bMethod1();

b2.bMethod2();

}

这样处理后,就不用担心类型转换时发生ClassCastException异常了。

时间: 2024-10-15 22:00:20

java(向上向下转型)的相关文章

2.25 Java基础总结 ①多态②向上向下转型③instanceof

①多态②向上向下转型③instanceof 一.多态即相同行为,不同实现有两种方法:重载和重写分类:①静态多态:编译时已经确定效果,所用重载实现(不是指static)②动态多态:编译未知,运行已知(使用动态绑定和重写实现) 动态绑定:父类的引用指向子类的对象,执行相应的子类方法,而不是父类的,从而实现多态性 二.向上转型,向下转型向上转型:一个父类的引用可以指向不同的子类对象,或者说一个子类的对象可以被当做一个父类类型低精度向高精度转pet = cat;自动转,子类向父类 向下转型:强制转,有很

从向上向下转型到----抽象类接口(一)

对象的多态性-向上向下转型 向上转型:子类对象变为父类对象,格式:父类 父类对象 = 子类实例,自动转换; 向下转型:父类对象变为子类对象,格式:子类 子类对象 = (子类) 父类实例,强制转换; 注意:对象的多态性和方法复写是联系在一起的 向上转型: class A{ public void print(){ System.out.println("a") } } class B extends A{ public void print(){ System.out.println(&

Java之路 - 抽象类、接口、多态、向上向下转型

1.抽象类 如果父类当中的方法不确定如何进行{}方法实现,那么这就是一个抽象方法 抽象方法所在的类必须是抽象类 使用方法: (1)不能直接创建new抽象类对象 (2)必须用一个子类来继承抽象父类 (3)子类必须覆盖重写抽象父类当中所有的抽象方法 覆盖重写(实现):去掉抽象方法的abstract关键字,然后补上方法体大括号: (4)创建子类对象进行使用 public abstract class animal { //抽象类 public abstract void eat(); //这是一个抽象

Java面向对象之多态(向上向下转型) 入门实例

一.基础概念 多态: 重点是对象的多态性.某一事物的多种体现形态. 多态的作用: 1.提高了代码的扩展性,后期出现的功能,可以被之前的程序所执行. 2.不能使用子类特有的功能.只能使用覆盖父类的功能. 多态的前提: 1.必须要有继承关系或者实现关系. 2.通常对方法进行重写.覆盖. 3.父类或者接口要引用指向子类对象. 多态向上转型: 1.提高程序的扩展性,隐藏了具体子类型 2.只能使用父类中的功能,不能使用子类特有的功能.功能被限定了. 多态向下转型: 1.可以使用子类型的特有功能. 2.必须

对象的向上向下转型规则

对象的转型:向上转型:子类-->父类向下转型:父类-->子类 例如: Class B extends AA a;B b;向上转型是自动的:b = new B();a = b; 向下转型要强制转换:a = new B();b = (B)a; 正确 a = new A();b = (B)a; 错误   *并且在向下转型之前要进行向上转型:即通过a=new B();得到的: *否则会报java.lang.ClassCastException: note.A cannot be cast to not

java-多态的向上向下转型

package com.多态; public class Demo1 { /** * @param args * int i=10; * byte j=20; * i=j;//自动类型提升 * j=(byte)i;//自动类型转换 */ public static void main(String[] args) { Animal2 a=new Cat();//父类引用指向子类对象.就是向上转型 System.out.println(a.num);//10,a引用只能看到父类对象属性值 a.ea

JAVA 多态向下转型

package Demo513.Multi; public abstract class Animal { public static void main(String[] args) { Animal animal =new Cat(); animal.eat(); //往下转型:必须保证对象创建的就是猫, Cat cat=(Cat) animal; //就可以引用子类:Cat类的方法 cat.CatchMice(); Animal Dog=new Dog(); Dog.eat(); //测试

Java 多态 向下转型

向下转型: 子类引用指向父类对象,此处必须强制转换,可以调用子类特有方法.例: Animal two = new Cat(); Cat temp = (Cat)two; 若满足转型条件时才能进行强转. 判断一个对象是否是某个类的实例: 原文地址:https://www.cnblogs.com/CPU-Easy/p/12262276.html

8.JAVA-向上转型、向下转型

父子对象之间的转换分为了向上转型和向下转型,它们区别如下: 向上转型 : 通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换 向下转型 : 通过父类对象(大范围)实例化子类对象(小范围),这种属于强制转换 1. 向上转型 示例1-向上转型 class A { public void print() { System.out.println("A:print"); } } class B extends A { public void print() { System.ou