精华内容
下载资源
问答
  • 主要介绍了Java向上转型和向下转型实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了浅谈Java向下转型的意义,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了Java 转型(向上或向下转型)详解及简单实例的相关资料,需要的朋友可以参考下
  • 主要介绍了 Java 向上转型和向下转型的详解的相关资料,需要的朋友可以参考下
  • 一、向上转型和向下转型 向上转型和向下转型是在JAVA继承操作中用到的东西,在讲到转型之前我们需要认识到继承过程中的对象类型转换,这种转换有两个特点: 1.这是继承过程中发生的操作 2.新类是现有类的一种...

    一、向上转型和向下转型

           向上转型和向下转型是在JAVA继承操作中用到的东西,在讲到转型之前我们需要认识到继承过程中的对象类型转换,这种转换有两个特点:

                 1.这是继承过程中发生的操作

                 2.新类是现有类的一种类型。这种说法主要是因为现有类的方法必定存在于新类中,所以通过现有类发送的信息(就是通过创建一个对象进行操作)可以直接通过新类发送。

     二、向上转型

            向上转型:创建一个基类的引用,但是在创建对象的时候是用的导出类的。示意图如下:

                                    

             由图可知:由导出类转型成基类,在继承图上是向上移动的。同时由于是从较专用类型向较通用类型转换,所以是安全的,因为专用类型肯定包含通用类型。

             特点:

                1.把导出类对象直接赋给基类类引用,不用强制转换

                2.引用可以直接使用基类中的方法,但是不能使用导出类的方法

                3.从导出类向上转型,永远不需要知道正在处理的对象的确切类型

                4.在向上转型过程中可能发生类接口中方法丢失

            示例 :

    class Fupcasting{
    	public Fupcasting(String ident) {
    		System.out.println("i am " + ident);
    	}
    	public void count() {
    		
    	}
    }
    public class Upcasting extends Fupcasting{
    	public Upcasting(String ident) {
    		super(ident);
    		// TODO Auto-generated constructor stub
    	}
    	public void add() {}
    	public static void main(String[] args) {
    		String  name = "fatherupcasting";
    		// TODO Auto-generated method stub
    		Fupcasting fupcasting = new Upcasting(name);    //向上转型
    		fupcasting.count();
    		//fupcasting.add();   //使用导出类的方法报错
    	}
    
    }

     三、向下转型

            向下转型可以参照向上转型,二者正好相反。这里使用向下转型的原因是因为上述的向上转型的第三条的关系:从导出类向上转型,永远不需要知道正在处理的对象的确切类型!

            解释如下:

    可知:导出类可以完全代替基类,在使用它们的时候,完全不需要知道关于子类的任何信息。

    这里如果你清楚  引用对象  的概念,你就会明白,当我们在向上转型的时候,你处理的导出类的对象你完全不清楚确切类型,这里的类型可以是 基类,也可以是导出类,也就是这一步:

    Fupcasting fupcasting = new Upcasting(name);  

    你也可以写成这样:

    Fupcasting fupcasting = (Fupcasting)new Upcasting(name);    

    或者这样:

    Fupcasting fupcasting = (Upcasting)new Upcasting(name);    

    这里的   (Upcasting)  和 (Fupcasting)  都声明了我们创建的对象的类型,但是在向上转型的过程中我们是这样做的:

    Fupcasting fupcasting = new Upcasting(name);  

    通过上面的步骤我们知道我们并不清楚这个对象是什么类型的,所以如果在一定的情况下要获取类型信息,就会用到向下转型!

    向下转型示意图:

    借用上面的shape图,如果现在我们知道有一个几何图形,但是我们不清楚它是圆、正方形等,但是它的形状肯定是唯一确定的。

    实例:

    class Fupcasting{
    	public Fupcasting(String ident) {
    		System.out.println("i am " + ident);
    	}
    	public void count() {
    		
    	}
    }
    public class Upcasting extends Fupcasting{
    	public Upcasting(String ident) {
    		super(ident);
    		// TODO Auto-generated constructor stub
    	}
    	public void add() {}
    	public static void main(String[] args) {
    		String  name = "fatherupcasting";
    		// TODO Auto-generated method stub
    	//	Fupcasting fupcasting = (Upcasting)new Upcasting(name);    //向上转型
    	//	fupcasting.count();
    		//fupcasting.add();   //使用导出类的方法报错
    		 Upcasting upcasting = (Upcasting) new Fupcasting(name);   //向下转型
    		 upcasting.add();
    	}
    
    }

    特点:

       1.向下转型可以调用子类类型中所有的成员

       2.父类引用对象指向的是子类对象,那么在向下转型的过程中是安全的,就是编译是不会出错误。但是如果父类引用对象是父类本身,那么在向下转型的过程中是不安全的,编译不会出错,但是运行时会             出现 Java 强制类型转换异常

     

    如果觉得对你有帮助,点个赞再走吧!

    展开全文
  • Java 向下转型的意义

    2020-12-22 18:16:27
    一开始学习 Java 时不重视向下转型。一直搞不清楚向下转型的意义和用途,不清楚其实是不会,那开发的过程肯定也想不到用向下转型。  其实向上转型和向下转型都是很重要的,可能我们平时见向上转型多一点,向上转型...
  • Java对象类型向上转型和向下转型

    万次阅读 多人点赞 2019-03-20 19:16:43
    上述代码虽然能够编译成功,但是在运行的时候会报错,因为fruit对象是由Apple对象向上转型得到的,只能够向下转型成Apple对象,不能够向下转型成Orange对象。 3.转型的好处 通过向上向下转型肯定是有好处的,...

    基础知识:Java中的继承机制使得一个类可以继承另一个类,继承的类称为子类,被继承的类称为父类。在一个子类被创建的时候,首先会在内存中创建一个父类对象,然后在父类对象外部放上子类独有的属性,两者合起来形成一个子类的对象,所以子类可以继承父类中所有的属性和方法,包括private修饰的属性和方法,但是子类只是拥有父类private修饰的属性和方法,却不能直接使用它,也就是无法直接访问到它(子类可以通过调用父类的public声明的get方法来获取父类的private属性,但无法访问父类的private方法)。同时子类可以对继承的方法进行重写(@Override),并且新建自己独有的方法。

    1.向上转型:

    假设有一个Fruit类,Fruit类中有一个show()方法,代码如下:

    class Fruit{
    	public void show() {
    		System.out.println("this is a fruit");
    	}
    }

    有一个Apple类继承自Fruit类,该类有自己的方法test(),并且重写了父类的show()方法,代码如下:

    class Apple extends Fruit{
        @Override
        public void show() {
    	System.out.println("this is a apple");
        }
        public void test() {
    	System.out.println("i am a apple");
        }
    }

    实例化Apple类,并新建一个Fruit类的引用变量引用该实例,调用实例的show()方法:

    Fruit fruit = new Apple();
    fruit.show();

    结果为:

    调用实例的test()方法:

    fruit.test();

    结果报错:

    分析:这里用到了向上转型,换言之,就是用父类的引用变量去引用子类的实例,这是允许的。当向上转型之后,父类引用变量可以访问子类中属于父类的属性和方法,但是不能访问子类独有的属性和方法。例子中由于子类重写了父类的show()方法,所以调用的show()方法是子类的show()方法,输出结果为:“this is a apple”,而调用子类的test()方法则会报错。

    2.向下转型

    并不是所有的对象都可以向下转型,只有当这个对象原本就是子类对象通过向上转型得到的时候才能够成功转型。

    实例化Apple类,并新建一个Fruit类的引用变量“fruit”引用该实例,然后新建一个Apple类的引用变量,引用向下转型的“fruit”变量,代码如下:

    Fruit fruit = new Apple();
    Apple apple = (Apple) fruit;

    上述代码是允许的,因为fruit引用的对象原本就是Apple对象向上转型得到的,在对fruit向下转型后得到的还是Apple类的对象,能够被Apple类的引用变量引用。

    假设有一个Orange类继承自Fruit类,代码如下:

    class Orange extends Fruit{
        @Override
        public void show() {
    	System.out.println("this is a Orange");
        }
        public void test() {
    	System.out.println("i am a Orange");
        }
    }

    实例化Apple类,并新建一个Fruit类的引用变量“fruit”引用该实例,然后新建一个Orange类的引用变量,引用向下转型的“fruit”变量,代码如下:

    Fruit fruit = new Apple();
    Orange orange = (Orange) fruit;

    上述代码虽然能够编译成功,但是在运行的时候会报错,因为fruit对象是由Apple对象向上转型得到的,只能够向下转型成Apple对象,不能够向下转型成Orange对象。

    3.转型的好处

    通过向上向下转型肯定是有好处的,比如可以减少编程代码。

    假设在主类中定义了一个run()方法,该方法传入一个Fruit参数,并调用了Fruit对象的show()方法,代码如下:

    public static void run(Fruit fruit) {
    	fruit.show();
       }

    在main()方法中的代码如下:

    public static void main(String[] args) {
        run(new Fruit());
        run(new Apple());
        run(new Orange());
        }

    上述代码中,调用run()方法时的参数不仅是Fruit对象,也可以是Apple对象和Orange对象,当传入的是Apple对象和Orange对象时,就会向上转型成Fruit对象,但是调用的show()方法还是Apple对象和Orange对象的show()方法。这样就不需要在主类中同时重载三个run()方法,减少了代码量。

    展开全文
  • Java向下转型以及如何判断能否向下转型

    千次阅读 多人点赞 2018-05-11 11:04:37
    那我们怎么样才能既实现向上转型,又能使子类可以调用其独有的方法呢,这就需要使用向下转型了。 注意 向下转型必须是在向上转型之后才能进行。 我们还是以汽车为例。 首先是Car这个父类。...

    上一条博客中我们一起了解了Java向上转型的意思以及它的优点,但同时也知道了在向上转型的过程中子类对象将不能调用其独有的方法。那我们怎么样才能既实现向上转型,又能使子类可以调用其独有的方法呢,这就需要使用向下转型了。
    注意
    向下转型必须是在向上转型之后才能进行。

    我们还是以汽车为例。代码如下:

    class Car {
        public void run() {
            System.out.println("这是父类run()方法");
        }
    }
    
    public class Benz extends Car {
        public void run() {
            System.out.println("这是Benz的run()方法");
        }
    
        public void price() {
            System.out.println("Benz:800000$");
        }
    
        public static void main(String[] args) {
            Car car = new Benz();// 先进行向上类型转换
            // car.price(); 此时还不能调用子类独有方法
            Benz benz = (Benz) car;// 向下类型转换
            benz.price();// 经过向下类型转换后可以调用子类中独有的方法
        }
    }

    运行结果:这里写图片描述
    此时我们通过向下转型成功的调用了子类中独有的方法,但是倘若我们没有先进行向上转型,也就是如下的代码:

        public static void main(String[] args) {
            Car car2 = new Car();
            Benz benz2 = (Benz)car2;
            benz2.price();
        }

    编译使未报错,但运行后程序出现错误:
    这里写图片描述
    这个是指类型转换异常,因为我们一开始直接new了一个父类的对象,当我们后面去使用Benz去强制类型转换的时候,由于benz2是子类的对象,而car2是父类的对象,前者的域小于后者,这个时候我们直接向下转型就会发生这个错误。
    所以使用向下转型之前必须先进行向上转型


    对于上面这个异常,我们可以通过使用instanceof这个关键字来解决。
    instanceof用法:
    对象名 instanceof 类名 ,判断这个对象是否是属于这个类或是其子类
    代码如下

    public static void main(String[] args) {
            Car car2 = new Car();
            boolean result = car2 instanceof Benz;// 判断car2这个对象是否是Benz的类(或是其子类),返回的是一个布尔值
            if (result) {// 如果是(true),则可以进行向下类型转换
                Benz benz2 = (Benz) car2;
                benz2.price();
            } else {// false,输出
                System.out.println("不能进行向下类型转换");
            }
    
        }

    运行结果:这里写图片描述
    总结

    向下转型在Java的泛型编程中应用较多,只要记住向下转型之前必须进行向上转型,且配合instanceof关键字一起使用就可以了。
    展开全文
  • java 向下转型与instanceof关键字-总结 文章目录java 向下转型与instanceof关键字-总结1. 向下转型和instanceof关系1.1. 为什么要有向下转型1.2. 向下转型和instanceof有什么关系2. 向下转型和instanceof示例Demo2.1...

    java 向下转型与instanceof关键字-总结

    1. 向下转型和instanceof关系

    1.1. 为什么要有向下转型

    向下转型出现的原因:有了对象的多态性以后,内存中实际上是加载了子类特有的属性和方法的,但是由于变量声明为父类类型,导致编译时,只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
    如何才能调用子类特有的属性和方法:向下转型:使用强制类型转换。

    		//Person是父类;Man是子类;Woman是子类;
    		//对象的多态性:父类的引用指向子类的对象
            Person per = new Man();
            //强制将Person类型装换为Man类型
            Man man = (Man) per;
            man.setManId(111);
            System.out.println("使用向下转型调用子类特有的属性和方法");
    

    1.2. 向下转型和instanceof有什么关系

    使用强转时,可能出现ClassCastException的异常。
    为了避免在向下转型时出现ClassCastException的异常,我们在向下转型之前,先进行instanceof的判断,一旦返回true,就进行向下转型。如果返回false,不进行向下转型。

    		//使用强转时,出现 java.lang.ClassCastException 异常
            Woman woman = (Woman) per;
            woman.setWomanId(222);
    

    2. 向下转型和instanceof示例Demo

    2.1. 父类 Person

    package tepmdemo.instanseof;
    
    /**
     * @author bruce
     * 
     */
    public class Person {
        protected String name;
        protected int age;
    
        protected void eat() {
            System.out.println("人吃饭");
        }
    
        protected void walk() {
            System.out.println("人走路");
        }
    }
    

    2.2. 子类 Man

    package tepmdemo.instanseof;
    
    /**
     * @author bruce
     *
     */
    public class Man extends Person{
        private int manId;
    
        //重写父类eat方法
        @Override
        public void eat() {
            System.out.println("男人吃饭是为了挣钱");
        }
    
        //重写父类walk方法
        @Override
        protected void walk() {
            System.out.println("男人走路去上班");
        }
    
        //Man子类特有的方法
        protected void setManId(int manId) {
            this.manId = manId;
            System.out.println("男人的ID:"+this.manId);
        }
    }
    

    2.3.子类Woman

    package tepmdemo.instanseof;
    
    /**
     * @author bruce
     * 
     */
    public class Woman extends Person {
        private int womanId;
    
        //重写父类eat方法
        @Override
        protected void eat() {
            System.out.println("女人吃饭是为了购物");
        }
        
        //重写父类walk方法
        @Override
        protected void walk() {
            System.out.println("女人走路去逛街");
        }
    
        //WoMan子类特有的方法
        public void setWomanId(int womanId) {
            this.womanId = womanId;
            System.out.println("女人ID:"+this.womanId);
        }
    }
    

    2.4. 多态向下转型和instanceof

    package tepmdemo.instanseof;
    
    /**
     * @author bruce
     * 
     */
    public class App {
        public static void main(String[] args) {
            System.out.println("--------------------多态的应用-------------------------");
            //对象的多态性:父类的引用指向子类的对象
            Person per = new Man();
            //多态的使用:当调用子父类同名同参数的方法时,实际执行的是子类重写父类的方法 ---虚拟方法调用
            per.walk();
            per.eat();
    
            System.out.println("--------------------向下转型应用-----------------------");
            /**
             * 1.有了对象的多态性以后,内存中实际上是加载了子类特有的属性和方法的,但是由于变量声明为父类类型,导致
             * 编译时,只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
             * 2.如何才能调用子类特有的属性和方法?
             * 3.向下转型:使用强制类型转换符,向下转型原理和基本类型的double类型转int类型一样都需要强制装换。
             */
            //强制将Person类型装换为Man类型
            Man man = (Man) per;
            man.setManId(111);
            System.out.println("使用向下转型调用子类特有的属性和方法");
    
            System.out.println("--------------------instanceof关键字-----------------------");
    
            //使用强转时,可能出现 java.lang.ClassCastException 异常
    //        Woman woman = (Woman) per;
    //        woman.setWomanId(222);
    
            /*
             * instanceof关键字的使用
             *
             * a instanceof A:判断对象a是否是类A的实例。如果是,返回true;如果不是,返回false。
             *
             *
             *  使用情境:为了避免在向下转型时出现ClassCastException的异常,我们在向下转型之前,先
             *  进行instanceof的判断,一旦返回true,就进行向下转型。如果返回false,不进行向下转型。
             *
             *  如果 a instanceof A返回true,则 a instanceof B也返回true.
             *  其中,类B是类A的父类。
             */
    
            if (per instanceof Man) {
                Man mans = (Man) per;
                mans.setManId(1);
            }
    
            // 向下转型判断per不属于Woman,不执行里面的语句。
            if (per instanceof Woman) {
                Woman womans = (Woman) per;
                womans.setWomanId(2);
            }
        }
    }
    
    展开全文
  • Java向下转型的意义

    万次阅读 多人点赞 2016-08-17 16:13:01
    一开始学习 Java 时不重视向下转型。一直搞不清楚向下转型的意义和用途,不清楚其实就是不会,那开发的过程肯定也想不到用向下转型。其实向上转型和向下转型都是很重要的,可能我们平时见向上转型多一点,向上转型也...
  • 刚接触Java,关于多态下向上转型和向下转型,以及父类和子类的调用很混乱,看了一天资料,终于搞明白了 关于多态向上转型和向下转型的要点 一、向上转型后子类不能调用自己的私有属性和私有方法,只能调用父类...
  • java对象转型(向上转型和向下转型向下转型和向上转型是什么意思向上转型和向下转型的基本公式: 向下转型和向上转型是什么意思 基本数据类型,转换可以通过隐性和显性(强制)类型转换,例如float类型转成int类型...
  • 向下转型的前提是父类对象指向的是子类对象(也就是说,在向下转型之前,它得先向上转型) 向下转型只能转型为本类对象(猫是不能变成狗的)。 大概你会说,我特么有病啊,我先向上转型再向下转型?? ...
  • 我的处女作《Canvas系列教程》在我的Github上正在连载更新,希望能得到您...其他网上关于向上转型和向下转型并不能完全使读者透彻的了解,因此我决定重写一篇教程来让大家简单理解。 向上转型:将子类转化为父类。...
  • 多态的向上转型与向下转型

    千次阅读 2019-04-20 10:25:48
    多态的向上转型与向下转型 多态的转型分为向上转型与向下转型两种: A:向上转型:当有子类对象赋值给一个父类引用时,便是向上转型,多态本身就是向上转型的过程。 使用格式: 父类类型 变量名 = new 子类类型()...
  • 向上转型和向下转型

    2018-11-30 00:09:08
    向下转型是指将父类的实例赋值给子类类型的变量。 二、向上转型 1、向上转型后父类的引用所指向的属性是父类的属性。 2、如果子类重写了父类的方法,那么父类引用指向的或者调用的方法是子类的方法,这个叫动态绑定...
  • [JAVA]向上转型与向下转型

    千次阅读 2019-03-06 16:00:07
    要理解多态性,首先要知道什么是“向上转型”、“向下转型”。 对象的多态性:父子类对象的转换 **向上转型:**子类对象变为父类对象,语法: 父类 父类对象 = 子类实例, 自动; **向下转型:**父类对象变为子类...
  • Java向下转型的几种方法

    千次阅读 2019-02-25 17:25:36
    Java向下转型的几种方法 众说周知:Java可以自动向上转型,子对象赋值给父类型,直接可以操作。但是向下转型如何处理呢? 使用场景:对引用的sdk中的API类型进行二次封装,回调接口类型二次封装。说明:这里面的...
  • Java向下转型的意义详解

    千次阅读 多人点赞 2018-10-14 23:29:59
    牢牢记住一句话:无论向上向下转型,编译看左边,运行看右边。 意思就是:编译时候左边的对象有没有该方法(不严谨),运行时候看new的对象是谁,就调用谁的方法   为了解决上述问题,引入强制向下转型: ...
  • 向上转型就是子类对象被父类引用,例如动物和小鸟的关系,小鸟属于动物,动物不仅仅只包含小鸟,还包含猫和狗等,例如: Animal birdAnimal = new Bird();这种方式就是向上转型,代码如下: class Animal { ...
  • 向上转型与向下转型详解

    千次阅读 2020-03-25 17:21:19
    让我们先来了解一下,怎么用转型。 转型 要转型,首先要有继承。继承是面向对象语言中一个代码复用的机制,简单说就是子类继承了父类中的非私有属性和可以继承...向下转型: 通过父类对象 (大范围) 实例化子类对象 ...
  • Java的向上转型和向下转型利弊

    千次阅读 2018-12-04 18:29:00
    java的向上转型和向下转型 一、向上转型 好处:隐藏了子类型,提高了代码的扩展性。 坏处:只能使用父类的功能,不能使用子类特有功能,功能被限定。 使用场景:不需要面对子类型,通过提高扩展性,或者使用父类的...
  • Java多态性(向上转型、向下转型

    千次阅读 多人点赞 2018-11-05 17:26:44
    文章目录多态1.1 方法的多态性1.2 对象的多态性(抽象类和接口)1.2.1 对象的向上转型1.2.2 对象的向下转型1.2.3 一个向上转型的实例1.3 多态性的总结 多态 在Java中,对于多态的核心表现主要有一下两点: 1.1 方法...
  • java 向下转型 程序

    2012-11-21 22:17:12
    java 向下转型 程序 学习java必须要学习的经典案例,加油学习把
  • 有关向上造型和向下造型的核心精髓就是一句话:在创建实例的时候到底是子类的实例还是父类的实例。如果是子类的实例,则就完全可以进行强制类型转换。 向上造型 父类的引用指向子类的对象。实例化成子类,可用方法使...
  • 向下转型,向上转型

    2019-06-12 13:38:17
    * 向下转型:当我们使用父类引用指向子类对象的时候,我们想把父类对象转为子类对象时,需要向下转型 * 向下转型就是一个还原动作。 * * 格式:子类名称 对象名 = (子类名称) 父类对象 * * 注意:一个父类有多个子.....
  • Java中的向上转型和向下转型

    千次阅读 2016-11-13 18:58:46
    转型是在继承的基础上而言的,继承是面向对象语言中,代码复用的一种机制,通过继承,子类可以复用父类的功能,如果父类不能满足当前子类的需求,则子类可以重写父类中的方法来加以扩展。 向上转型:子类引用的对象...
  • 向上转型 向下转型

    千次阅读 2018-07-12 17:30:30
    如父类Animal,子类Cat,Dog。...理解多态,首先要知道“向上转型”。我定义了一个子类Cat,它继承了Animal类,那么后者就是前者是父类。我可以通过 Cat c = new Cat(); 实例化一个Cat的对象,这...
  • 向上转型和向下转型 对象既可作为它本身的类型使用,也可作为它的基类型使用,通过类型转换(转型)来实现,对象的类型转换分两种,把对某个对象的引用视为对其基类型的引用的做法称为“向上转型”,反之则称为“...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 114,526
精华内容 45,810
关键字:

向下转型