精华内容
下载资源
问答
  • 主要介绍了 Java 向上转型和向下转型的详解的相关资料,需要的朋友可以参考下
  • Java向上转型和向下转型

    千次阅读 多人点赞 2017-07-20 15:43:38
    Java向上转型和向下转型


    (尊重劳动成果,转载请注明出处:http://blog.csdn.net/qq_25827845/article/details/75530403冷血之心的博客)



    向上转型:父类引用指向子类对象                             向下转型:子类引用指向父类对象


    举例:Father是父类,Son是子类

    Father f1 = new Son();   // 这就叫 upcasting (向上转型), 现在f1引用指向一个Son对象

    Son s1 = (Son) f1;   // 这就叫 downcasting (向下转型),现在f1还是指向Son对象


    举例:Father是父类,Son是子类

    Father f2 = new Father();

    Son s2 = (Son) f2;       // 编译不出错,运行时出错(除非子类和父类拥有相同的属性和方法),子类引用不能指向父类对象


    向上转型:父类引用指向子类对象,将会丢失子类和父类中不一致的方法,并且父类引用调用的变量只能是父类中的。

    举例:

    class Person{
        private String name = "Person";
        int age=0;
        public void function() {
    		System.out.println("this is person");
    	}
    }
    public class Child extends Person{
    	
        public String grade;
        int age=10;
        public void function() {
    		System.out.println("this is child");
    	}
        public void b1(){
        	System.out.println("子类新方法");
        } //B类定义了自己的新方法
        @Test
        public  void test(){
            Person p = new Child();
            p.function();
            System.out.println(p.age);
        	
        }
    }

    此时将输出:

    “this is child”  

    0

    并且我们是不能使用p.b1()的,编译错误,因为,此时该对象p已经失去了该方法。


    向上转型的作用:

    这里以父类为参数,调有时用子类作为参数,就是利用了向上转型。这样使代码变得简洁。

    public class Main{  
        
        public static void main(String[] args) {  
            dosleep(new Male());  
            dosleep(new Female());  
        }  
          
        public static void dosleep(Human h) {  
            h.sleep();  
        }  
    }  
    class Human {  
        public void sleep() {  
            System.out.println("Human sleep..");  
        }  
    }  
    class Male extends Human {  
        @Override  
        public void sleep() {  
            System.out.println("Male sleep..");  
        }  
    }  
    class Female extends Human {  
        @Override  
        public void sleep() {  
            System.out.println("Female sleep..");  
        }  
    }  

    如果dosleep以子类对象为参数,则有多少个子类就需要写多少个函数。这也体现了JAVA的抽象编程思想。




    如果对你有帮助,记得点赞哦~欢迎大家关注我的博客,可以进群366533258一起交流学习哦~



    本群给大家提供一个学习交流的平台,内设菜鸟Java管理员一枚、精通算法的金牌讲师一枚、Android管理员一枚、蓝牙BlueTooth管理员一枚、Web前端管理一枚以及C#管理一枚。欢迎大家进来交流技术。



    展开全文
  • 主要介绍了Java向上转型和向下转型实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 向上转型和向下转型

    2018-07-14 09:27:49
    1、向上转型:子类对象赋值给父类类型的变量,即父类对象引用,指向子类对象;2、向下转型:是将抽象类转换为较具体的类。在执行向下转型时,需用instanceof操作符判断父类对象是否为子类对象的实例。...

    1、向上转型:子类对象赋值给父类类型的变量,即父类对象引用,指向子类对象;

    2、向下转型:是将抽象类转换为较具体的类。在执行向下转型时,需用instanceof操作符判断父类对象是否为子类对象的实例。

    展开全文
  • 一、向上转型和向下转型 向上转型和向下转型是在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 强制类型转换异常

     

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

    展开全文
  • 1.向上转型:就是你定义了一个子类对象但是...2.向下转型向下转型就相反,创建父类的对象,声明为子类类型 Child obj = (child)object ;object 是刚才创建的父类对象 强制转换 注意: 1.向上转型的父类类...

    1.向上转型:就是你定义了一个子类对象但是声明它的类型为父类的 Parent object = new Child(); 本来是一个子类对象,却是父类类型的,这不就是向上转型了么。 不用强制转换
    2.向下转型:向下转型就相反,创建父类的对象,声明为子类类型 Child obj = (child)object ;object 是刚才创建的父类对象 强制转换


    注意:
    1.向上转型的父类类型子类对象只能调用父类的方法,如果子类重写了父类方法的话,name*调用的是子类的方法*,也就是说除了与父类同名的方法,其他子类扩展的方法全浪费了。。
    2.向下转型的 子类类型父类方法可以调用父类方法,也可以调用子类方法*,但是不能调用父类中的私有方法,即*private声明的方法,如果子类重写父类方法,那么调同名方法其实调用的是子类的方法。

    ——————————示例代码如下———————————————————–

    
    public class PandaTest {//父类
        public static void main(String args[]) {
            PandaTest panda = new pandaChild();//向上转型 定义一个父类类型的子类对象,只能引用父类中的方法
            panda.talk();//如果子类重写则调用子类方法
            pandaChild panda2 = (pandaChild)panda;//向下转型 定义一个子类类型的父类对象,既可以引用父类方法,也可以调子类方法
            panda2.speak();
            panda2.talk();//如果子类重写则调用子类里的方法
           //不能调用父类中私有方法
        }
        public void talk(){
            System.out.println("i am a panda parent");
        }
        private void cry(){ //父类私有方法
            System.out.println("i am a crying panda");
        }
    }
    class pandaChild extends PandaTest{//子类  继承了父类
        pandaChild(){//无参构造方法
    
        }
        public void talk(){//重写父类方法
            System.out.println("i am a panda child");
        }
        public void speak(){//子类自己的方法
            System.out.println("i am a panda child who is confident");
        }
    
    }
    

    运行结果:
    i am a panda child //这个是向上转型的panda对象调用子类重写了父类talk()方法
    i am a panda child who is confident //这个是向下转型的panda2对象调用子类的speak()方法
    i am a panda child//这个是向下转型的panda2对象调用子类重写了父类talk()方法


    tip: 在写代码时,eclipse有个快捷键,就是敲完对象.之后按alt+?就会提示所有对象能调用的方法,
    你会发现panda2.之后没有父类的cry()方法,就是说向下转型的对象不能调用父类中private 方法。


    你可能发现了向下转型是这样写的 pandaChild panda2 = (pandaChild)panda;而不是pandaChild panda3 = (pandaChild)new PandaTest();后面写法编译没问题,运行时就报错了:

    childException in thread "main" java.lang.ClassCastException: PandaTest cannot be cast to pandaChild
        at PandaTest.main(PandaTest.java:9)
    展开全文
  • 刚接触Java,关于多态下向上转型和向下转型,以及父类子类的调用很混乱,看了一天资料,终于搞明白了 关于多态向上转型和向下转型的要点 一、向上转型后子类不能调用自己的私有属性私有方法,只能调用父类...
  • Java的向上转型和向下转型利弊

    千次阅读 2018-12-04 18:29:00
    java的向上转型和向下转型 一、向上转型 好处:隐藏了子类型,提高了代码的扩展性。 坏处:只能使用父类的功能,不能使用子类特有功能,功能被限定。 使用场景:不需要面对子类型,通过提高扩展性,或者使用父类的...
  • 多态: 对于用一个事物具有多种表现形式,比如动物的叫声有多种,鸟叫声,狗叫声,猪叫声等多种不同结果,称之为多态。...向下转型: 将父类对象转化为子类对象的称为向下转型向下转型是从一个较抽象的...
  • 在Java编程中经常碰到类型转换,对象类型转换主要包括向上转型和向下转型。  向上转型 我们在现实中常常这样说:这个人会唱歌。在这里,我们并不关心这个人是黑人还是白人,是成人还是小孩,也就是说我们更倾向于...
  • Java对象类型向上转型和向下转型

    万次阅读 多人点赞 2019-03-20 19:16:43
    在一个子类被创建的时候,首先会在内存中创建一个父类对象,然后在父类对象外部放上子类独有的属性,两者合起来形成一个子类的对象,所以子类可以继承父类中所有的属性方法,包括private修饰的属性方法,但是...
  • 向上转型 将子类对象转为父类对象 class C{ public void play() { System.out.println("我想玩"); } } class D extends C{ public void play() { System.out.println("我看电视"); } }...
  • 对象的向上转型和向下转型

    千次阅读 2018-07-13 15:17:16
    对象的向上转型 对象的向上转型,就是多态的写法。 格式: 父类名称 对象名 = new 子类对象名称(); Animal animal = new Cat(); 含义: 右侧创建一个子类对象,把它当做父类来看。 注意事项: 向上转型一定是...
  • 向上转型: 父类类型 变量名=new 子类类型(); //父类是animal,子类是cat Animal animal=new Cat();...向下转型: 子类类型 变量名=(子类类型)父类变量名;(类似于强转) Cat c=(Cat) a; ...
  • java数据类型,向上转型和向下转型定义与概念。
  • (尊重劳动成果,转载请注明出处:http://blog.csdn.net/qq_25827845/article/details/75530403冷血之心的博客)向上转型:父类引用指向子类对象向下转型:子类引用指向父类对象举例:Father是父类,Son是子类Father ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,841
精华内容 12,736
关键字:

向上转型和向下转型的区别