精华内容
下载资源
问答
  •  到底有什么区别?这是上转型。 上转型对象不是父类创建的对象,而是子类对象的“简化”状态,它不关心子类新增的功能,只关心子类继承和重写的功能。当一个类很多子类时,并且这些子类都重写了父类中的某个方法...
    
     
     List<String> lists = new ArrayList(); ArrayList<String> lists = new ArrayList(); 
    到底有什么区别?这是上转型。
    上转型对象不是父类创建的对象,而是子类对象的“简化”状态,它不关心子类新增的功能,只关心子类继承和重写的功能。
    当一个类有很多子类时,并且这些子类都重写了父类中的某个方法。
    当使用上转型对象在调用这个方法时就可能具有多种形态。因为不同的子类在重写父类的方法时可能产生不同的行为。也就是说,不同对象的上转型对象调用同一方法可能产生不同的行为。

    例如下面的程序你测试一下就可以理解这样的用法。以下的程序输出为
    Wang!Wang!......
    miao~~miao~~...
    package com.vince.testJava;
    
    class Animal {
    	void cry() {
    	}
    }
    
    class Dog extends Animal {
    	void cry() {
    		System.out.println("Wang!Wang!......");
    	}
    }
    
    class Cat extends Animal {
    	void cry() {
    		System.out.println("miao~~miao~~...");
    	}
    }
    
    public class Test01 {
    	public static void main(String args[]) {
    		Animal animal;
    		animal = new Dog(); // animal是Dog对象的上转型对象
    		animal.cry();
    		animal = new Cat(); // animal是Cat对象的上转型对象
    		animal.cry();
    	}
    }


    展开全文
  • 什么向上转型什么是向下转型? 向上转型是安全的,父类型的引用指向子类型的对象,直接转换。 Animal animal = new Dog(); 向上转型则是不安全的,需要强转。 Dog dog = (Dog)new Animal(); 一般出现选择题,...

    什么是向上转型?什么是向下转型?

    向上转型是安全的,父类型的引用指向子类型的对象,直接转换。
    Animal animal = new Dog();
    向上转型则是不安全的,需要强转。
    Dog dog = (Dog)new Animal();
    一般出现选择题,举例说明即可。

    展开全文
  • 假如你在一个物流运输公司,个客户要求你为他运输一定数量的产品到某地,使用某种交通工具. 那我们假设你的管理程序中Truck类,Train类,Plane类专门用来实现 使用不同交通工具的成本计算,都方法cost...

    假如你在一个物流运输公司,有个客户要求你为他运输一定数量的产品到某地,使用某种交通工具.

    那我们假设你的管理程序中有Truck类,Train类,Plane类专门用来实现

    使用不同交通工具的成本计算,都有方法cost(Double weight,Double space);

    那么,问题出来了.客户对于运输器种类是可选择的,

    你是不是要对每种运输器new个实例放到不同的service方法中为客户服务呢?

    很明显这么做有很多代码重复,而且效率太低.

    那么为什么不构造一个运输工具的父类:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    public  class  Conveyance
    {
    protected  weight;
    protected  space;
    public  abstract  Double cost(Double weight,Double space);
    }
    //然后子类Truck,Plane,Train分别实现cost方法再构造一个工厂类为客户制造子类实例
    public  class  ConveyanceFactory
    {
         public  static  Conveyance getConveyance(String which)
         {
           if (which.equils( "Truck" ))
           {
           return  new  Truck();
           }
           else  if (which.equils( "Train" ))
           {
           return  new  Train();
           }
           else  if (which.equils( "Plane" ))
           {
           return  new  Plane();
           }
           else
           { return  null ;}
        }
    //服务程序的方法实现:
    public  double  transportCost(String type,Double weight,Double space)
    {
    Conveyance c;
    Double cost;
    c = ConveyanceFactory.getConveyance( "type" );
    cost = c.cost(weight,space);
    return  cost;
    }


    看上面服务层的代码多简单‘,而且在MVC层次结构中方法和类的设计也和面向对象.

    这就是上塑造型给我们带来的好处咯这回就方便了

    ,需要Truck的时候,客户只要告诉你他要用卡车运输运多少距离多远.

    那业务员就在option按扭里面选择”卡车”在文本框里输入重量多少距离多远.

    veiw层把数据传给controler处理成我们的服务程序需要的数据类型.

    然后服务程序被controler调用,用transportCost方法计算出成本返回给veiw,显示给业务员,业务员就可以告诉客户需要支付多少钱啦

    展开全文
  • 向上转型

    2017-04-11 14:01:10
    通过阅读TKJ和csdn上其他大神的文章,我对向上转型的理解如下。 在子类继承父类之后,子类可以向上转换成父类。比如TKJ中的管弦乐器继承乐器,乐器拥有的属性管弦乐器一定会。转换成我们人类的语言就是,管弦乐器...

      通过阅读TKJ和csdn上其他大神的文章,我对向上转型的理解如下。

    在子类继承父类之后,子类可以向上转换成父类。比如TKJ中的管弦乐器继承乐器,乐器拥有的属性管弦乐器一定会有。转换成我们人类的语言就是,管弦乐器一定是乐器。

    但是在使用向上转型的时候,子类拥有的自己独有的方法,即父类没有的方法的时候,是会在转型的中被干掉的。

    package xszx;
    //向上转型的父类A
    public class A {
    	public void print(){
    		System.out.println("this is A's printMethon");
    	}
    }

    package xszx;
    //转型中的子类
    public class B extends A{
    
    public void print(){
    System.out.println("this is B's printMethon");
    }
    
    public void b(){
    System.out.println("this is only B's methon");
    }
    }


    package xszx;
    //测试
    public class C  {
    	public static void main(String args[]){
    		A a=new B();
    		a.print();
    		//a是没有B中独有的b()的
    		
    	}
    }




    展开全文
  • java向上转型

    2017-07-11 11:16:38
    Java向上转型的妙下面这段代码摘自《java编程思想》,内容稍修改 class Sharp{ public void erase(){ ... }; public void draw(){ ... }; } class Circle extends Sharp{
  • 什么是向下转型和向上转型
  • Java语言面向对象和向上转型有什么区别,是不是类型的转换的问题,不太理解,请指教。
  • Java向上转型和向下转型

    千次阅读 多人点赞 2017-07-20 15:43:38
    Java向上转型和向下转型
  • 向上转型: 一般来说就是: 父类引用指向子类对象,是多态实现的一个基础。也就是说,父类引用可以自动地包装子类对象。例如:Student类 继承了 Person 类 Person person = new Student(); 向下转型: 与向上转型...
  • 类的向上转型: 父类(包括抽象类)创建的引用类型变量可以调用子类对象 父类引用类型变量应用子类对象时,调用方法只能调用父类中出现过的方法,如果方法被重写,调用的是子类中重写的方法。 普通类示例 父类:...
  • 这道题目一般出现在(笔试-选择题) 举例说明即可: 向上转型:Person person = new Student(); 安全的 向下转型:Teacher teacher = (Teacher)person; 不安全的
  • java向上转型

    千次阅读 2015-09-30 11:11:52
    向上转型:将子类对象的引用转换为父类对象的引用,这就是向上转型。 ”为新的类提供方法“这并不是继承中最重要的方面,其最重要的是用来表现新类和基类之间的关系。这种关系是”新类是现有类的一种类型“ 也就是is...
  • 向上转型和下转型

    2019-07-22 20:28:56
    1. 基本数据类型向上转型和下转型 就是基本数据类型的自动类型转换(隐式类型转换)和强制类型转换(显示类型转换)。 自动类型转换(隐式类型转换) 概念:低类型自动转换为高类型,叫做向上转型 语法: 数据类型 ...
  • Java语言经常听到人说向上转型,向下转型,是什么意思,两者什么时候
  • 向上转型和向下转型

    2018-11-30 00:09:08
    向上转型是指将子类的实例赋值给父类类型的变量。 向下转型是指将父类的实例赋值给子类类型的变量。 二、向上转型 1、向上转型后父类的引用所指向的属性是父类的属性。 2、如果子类重写了父类的方法,那么父类引用...
  • 1.向上转型:为什么需要向上转型 如方案1所示,当测试各个子类的eat()方法时,只需要写一个eatTest()方法即可,其会通过向上...因此,通常在向下转型前常有向上转型,而向下转型通常也会结合instanceof一起使用;
  • java之向上转型

    2020-12-21 08:22:36
    向上转型经典案例向上转型向上转型应注意的问题向上转型的好处静态方法的调用 经典案例 public class Animal { public void eat(){ System.out.println("animal eatting..."); } } public class Cat extends ...
  • Java向上转型

    2020-01-15 12:07:10
    Java向上转型 很多初学java的小伙伴可能会对java中向上转型的使用有点疑惑,据我敲了不怎么多的代码发现,向上转型如:父类 Animal ,子类 Dog 继承父类, Animal a = new Dog();(向上转型),引用对象a调用的方法可以...
  • 多态的向上转型与向下转型

    千次阅读 2019-04-20 10:25:48
    A:向上转型:当子类对象赋值给一个父类引用时,便是向上转型,多态本身就是向上转型的过程。 使用格式: 父类类型 变量名 = new 子类类型(); 例如:Person p = new Student(); B:向下转型:一个已经向上转型...
  • 大家都来说说安卓java中什么向上转型?请问安卓中的向上转型的用途是什么

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 50,248
精华内容 20,099
关键字:

向上转型有什么用