精华内容
下载资源
问答
  • 向上转型的作用

    2019-08-10 17:02:10
    一、什么是向上转型 上转型对象不是父类创建对象,而是子类对象“简化”状态,它不关心子类新增功能,只关心子类继承和重写功能。 当一个类有很多子类时,并且这些子类都重写了父类中某个方法。 当使用...

    一、什么是向上转型

    上转型对象不是父类创建的对象,而是子类对象的“简化”状态,它不关心子类新增的功能,只关心子类继承和重写的功能。

    当一个类有很多子类时,并且这些子类都重写了父类中的某个方法。

    当使用上转型对象在调用这个方法时就可能具有多种形态。因为不同的子类在重写父类的方法时可能产生不同的行为。也就是说,不同对象的上转型对象调用同一方法可能产生不同的行为。

    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.run();
           //car.price();程序报错
        }
    }
    

    当我们用car这个对象去调用Benz类中price这个方法时,就会报错: 
     
    这就是因为我们此处进行的向上转型,car这个对象虽然指向子类,但是子类由于进行了向上转型,就失去了使用父类中所没有的方法的“权利”,在此处就是不能调用price()这个方法。

    那么向上转型到底有什么用呢,到目前为止我们不仅看不到它的好处,反而发现使用了向上转型后反而不能调用子类所特有的方法了。那么向上转型的作用到底是什么呢?

    二、向上转型的作用

    • 传参,当你不知道要传什么类型的参数时,可以直接将参数定义成Object类型的,这样就可以接收任意类型的参数(JAVA中所有的类都继承自java.lang.Object),但使用时要转换回来。
    class Car {
        public void run() {
            System.out.println("这是父类run()方法");
        }
    
        public void speed() {
            System.out.println("speed:0");
        }
    
    }
    
    class BMW extends Car {
        public void run() {
            System.out.println("这是BMW的run()方法");
        }
    
        public void speed() {
            System.out.println("speed:80");
        }
    }
    
    public class Benz extends Car {
        public void run() {
            System.out.println("这是Benz的run()方法");
    
        }
    
        public void speed() {
            System.out.println("speed:100");
        }
    
        public void price() {
            System.out.println("Benz:800000$");
        }
    
        public static void main(String[] args) {
            show(new Benz());//向上转型实现
            show(new BMW());
        }
    
        public static void show(Car car) {//父类实例作为参数
            car.run();
            car.speed();
        }
    }

    如果此处没有向上转型,要实现show每个子类的功能,那么有几个子类就要写多少函数。

    • 接口与抽象编程时使用
    interface a{
        aa();
    }
    b implements a {
        aa(){}
    }
    c implements a {
        aa(){}
    }

    当你不确定要实例化的是b类还是c类,但又一定要返回一个对象并且有aa方法,就可以用类似上面的做法,然后在需要对象时这样使用即可获得对象:   return a a1= new b();
     

    总结 (还是前几章里提到的)

    1.在调用方法的时候,用那个引用就调用那个引用的方法,然后观察子类是否重写,若重写了就调用子类的,否则就调用父类的。

    2.在对象当做参数遇到重载的时候,它会选择与它最接近的类型参数的方法匹配。通俗点说就是,找与自己类型一致的,没有找到则父类,以此类推。

    3.注意子类中没有被重写的父类方法。

     

     

    参考博客:https://zhidao.baidu.com/question/72034787.html

    https://blog.csdn.net/guchenjun789/article/details/81055317

    展开全文
  • java向上转型的作用

    2019-08-22 17:38:32
    java向上转型的作用 关于向上转型的作用,我们从一段代码引入: public class Animal { String name = "我是动物"; static int age = 20; public void eat() { System.out.println("动物可以吃饭"); } ...

    java向上转型的作用

    关于向上转型的作用,我们从一段代码引入:

    public class Animal {
    	
    	    String name = "我是动物";
    	    static int age = 20;
    	    public void eat() {
    	        System.out.println("动物可以吃饭");
    	    }
    	    public static void sleep() {
    	        System.out.println("动物可以睡觉");
    	    }
    
    	    public void run(){
    	        System.out.println("动物可以奔跑");
    	    }
    
    	    public static void main(String[] args) {
    	        Animal am = new Dog();
    	        am.eat();
    	        am.sleep();
    	        am.run();
    	        //am.watchdog();这里会报错
    	        System.out.println(am.name);
    	        System.out.println(am.age);
    	    }
    
    }
    class Dog extends Animal {
        String name = "小狗";
        static int age = 60;
        public void eat() {
            System.out.println("小狗可以吃饭");
        }
        public static void sleep() {
            System.out.println("小狗可以睡觉");
        }
        public void watchdog() {
            System.out.println("小狗可以看门");
        }
    
    }
    
    

    运行结果:
    在这里插入图片描述
    但是可以看到代码块中,直接调用Dog的watchdog()方法会报错,
    在这里插入图片描述
    这就是因为我们此处进行的向上转型,am这个对象虽然指向子类,但是子类由于进行了向上转型,就失去了使用父类中所没有的方法的“权利”,在此处就是不能调用watchdog()这个方法。
    而且结果里也可以看到,睡觉是引用的父类“Animal”的睡觉方法,这是因为Animal的睡觉方法为静态方法,可以总结如下:
    如果是访问成员变量,编译的话就是看父类,运行同样是看父类
    如果访问的方法,编译就看父类,运行则看子类
    如果是静态方法,编译和运行都是看父类

    那么向上转型的具体作用是什么,可以通过下面两端代码做个比较:

    class Animal {
        public void run() {
            System.out.println("这是父类run()方法");
        }
    
        public void sleep() {
            System.out.println("这是父类sleep()方法");
        }
    
    }
    
    class Dog extends Animal {
        public void run() {
            System.out.println("小狗在跑");
        }
    
        public void sleep() {
            System.out.println("小狗睡觉");
        }
    }
    
    public class Cat extends Animal {
        public void run() {
            System.out.println("小猫在跑");
    
        }
    
        public void sleep() {
            System.out.println("小猫在睡觉");
        }
    
        public void eat() {
            System.out.println("小猫在吃");
        }
    
        public static void main(String[] args) {
            show(new Dog());//向上转型实现
            show(new Cat());
        }
    
        public static void show(Animal am) {//父类实例作为参数
            am.run();
            am.sleep();
        }
    }
    
    

    以上代码中:

        public static void main(String[] args) {
            show(new Dog());//向上转型实现
            show(new Cat());
        }
    
        public static void show(Animal am) {//父类实例作为参数
            am.run();
            am.sleep();
        }
    
    

    就体现了向上转型的优点,这也体现了Java抽象编程的思想。如果此处没有向上转型,要实现show每个子类的功能,那么有几个子类就要写多少函数。代码如下:

    public static void main(String[] args) {
            show(new Dog());
            show(new Cat());
        }
    
        public static void show(Dog dog) {
            dog.run();
            dog.sleep();
        }
        public static void show(Cat cat) {
            cat.run();
            cat.sleep();
        }
    
    

    试想一下,一旦有很多子类,那么这个工作量将会比没有使用向上转型大很多。这也表明向上转型还有个优点就是提高了代码的简洁性。
    总结
    向上类型转换(小转大):
    语法规则:<父类型> <引用变量名> = new <子类型>();
    1.此时通过父类引用变量调用的方法是子类覆盖或继承
    父类的方法,不是父类的方法。
    2.此时通过父类引用变量无法调用子类特有的方法。

    Q:
    向上转型虽然使代码变得简洁,体现了JAVA的抽象编程思想,但是也出现了上面提到的子类无法调用其独有的方法,这要怎么解决呢?所以就有了与之对应的向下转型,弥补了向上转型所带来的缺陷。

    借鉴博客:
    https://blog.csdn.net/TNTZS666/article/details/80273986

    展开全文
  • 但是向上转型的应用场景是什么呢?我看到网上有的说是为了获取父类的方法,子类也可以访问父类的方法啊,就算是覆盖的方法,也可以通过super.方法()来访问父类的方法啊。2.代码代码来源是《深入剖析Tomcat》第二章的...

    1.问题描述

    向下转型的应用场景是面向接口编程的时候,经常需要向下转型。但是向上转型的应用场景是什么呢?

    我看到网上有的说是为了获取父类的方法,子类也可以访问父类的方法啊,就算是覆盖的方法,也可以通过super.方法()来访问父类的方法啊。

    2.代码

    代码来源是《深入剖析Tomcat》第二章的代码。

    package ex02.pyrmont;

    import java.net.URL;

    import java.net.URLClassLoader;

    import java.net.URLStreamHandler;

    import java.io.File;

    import java.io.IOException;

    import javax.servlet.Servlet;

    import javax.servlet.ServletRequest;

    import javax.servlet.ServletResponse;

    public class ServletProcessor1 {

    public void process(Request request, Response response) {

    String uri = request.getUri();

    String servletName = uri.substring(uri.lastIndexOf("/") + 1);

    URLClassLoader loader = null;

    try {

    // create a URLClassLoader

    URL[] urls = new URL[1];

    URLStreamHandler streamHandler = null;

    File classPath = new File(Constants.WEB_ROOT);

    // the forming of repository is taken from the createClassLoader

    // method in

    // org.apache.catalina.startup.ClassLoaderFactory

    String repository = (new URL("file", null,

    classPath.getCanonicalPath() + File.separator)).toString();

    // the code for forming the URL is taken from the addRepository

    // method in

    // org.apache.catalina.loader.StandardClassLoader class.

    urls[0] = new URL(null, repository, streamHandler);

    loader = new URLClassLoader(urls);

    } catch (IOException e) {

    System.out.println(e.toString());

    }

    Class myClass = null;

    try {

    myClass = loader.loadClass(servletName);

    } catch (ClassNotFoundException e) {

    System.out.println(e.toString());

    }

    展开全文
  • A是父类,B是子类。A x=new B(); 这样声明x是A类对象,属性和方法都是A类。用父类申明对象,创建子类实例有什么用。 求创建对象到实例对象详细理解。
  • Java向上转型的作用(有详细代码介绍)

    千次阅读 多人点赞 2018-05-11 11:04:58
    今天看到一道Java的练习题,题目如下 当时对于主函数中 ... 在经过阅读书籍和查看别的博主写的关于向上向下转型的博客后,发现题目中这么写完全就是为了出题用,它和仅仅写Car car = new Benz(); ...

    今天看到一道Java的练习题,题目如下
    这里写图片描述
    当时对于主函数中
    Car car =(Car) new Benz();
    不是很理解,也并不知道有什么意义,因为如果仅仅写Car car = new Benz(); 程序运行结果是一样的。
    在经过阅读书籍和查看别的博主写的关于向上向下转型的博客后,发现题目中这么写完全就是为了出题用,它和仅仅写Car car = new Benz(); 是一样的,都是向上转型。但是相信还是会有人对于向上转型意义不太明白,所以我这里就这道题写一下关于向上转型的用法。
    首先为了大家更好的理解,我对题目的程序进行了改动,增加一个price()方法。
    改动后的程序如下:

    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.run();
           //car.price();程序报错
        }
    }

    此时程序运行后输出:这里写图片描述

    但是当我们用car这个对象去调用Benz类中price这个方法时,就会报错:
    这里写图片描述
    这就是因为我们此处进行的向上转型,car这个对象虽然指向子类,但是子类由于进行了向上转型,就失去了使用父类中所没有的方法的“权利”,在此处就是不能调用price()这个方法。

    那么向上转型到底有什么用呢,到目前为止我们不仅看不到它的好处,反而发现使用了向上转型后反而不能调用子类所特有的方法了。那么向上转型的作用到底是什么呢,我们一起来看下面的代码:

    class Car {
        public void run() {
            System.out.println("这是父类run()方法");
        }
    
        public void speed() {
            System.out.println("speed:0");
        }
    
    }
    
    class BMW extends Car {
        public void run() {
            System.out.println("这是BMW的run()方法");
        }
    
        public void speed() {
            System.out.println("speed:80");
        }
    }
    
    public class Benz extends Car {
        public void run() {
            System.out.println("这是Benz的run()方法");
    
        }
    
        public void speed() {
            System.out.println("speed:100");
        }
    
        public void price() {
            System.out.println("Benz:800000$");
        }
    
        public static void main(String[] args) {
            show(new Benz());//向上转型实现
            show(new BMW());
        }
    
        public static void show(Car car) {//父类实例作为参数
            car.run();
            car.speed();
        }
    }
    

    上面代码中

        public static void main(String[] args) {
            show(new Benz());
            show(new BMW());
        }
    
        public static void show(Car car) {
            car.run();
            car.speed();
        }

    就体现了向上转型的优点,这也体现了Java抽象编程的思想。如果此处没有向上转型,要实现show每个子类的功能,那么有几个子类就要写多少函数。代码如下:

        public static void main(String[] args) {
            show(new Benz());
            show(new BMW());
        }
    
        public static void show(Benz benz) {
            benz.run();
            benz.speed();
        }
        public static void show(BMW bmw) {
            bmw.run();
            bmw.speed();
        }

    试想一下,一旦有很多子类,那么这个工作量将会比没有使用向上转型大很多。这也表明向上转型还有个优点就是提高了代码的简洁性。


    总结
    向上类型转换(小转大):
    语法规则:<父类型> <引用变量名> = new <子类型>();
    1.此时通过父类引用变量调用的方法是子类覆盖或继承
    父类的方法,不是父类的方法。
    2.此时通过父类引用变量无法调用子类特有的方法。


    敲黑板
    向上转型虽然使代码变得简洁,体现了JAVA的抽象编程思想,但是也出现了上面提到的子类无法调用其独有的方法,这要怎么解决呢?所以就有了与之对应的向下转型,弥补了向上转型所带来的缺陷。关于向下转型我会在下一次的博客中给出例子。希望对大家有帮助。

    展开全文
  • Java向上转型作用的理解

    万次阅读 多人点赞 2018-07-15 18:00:15
    今天看到一道Java的练习题,题目如下 当时对于主函数中 Car car =(Car) new Benz(); 不是很理解,也并不知道有什么意义,因为... 在经过阅读书籍和查看别的博主写的关于向上向下转型的博客后,发现题目中这么...
  • java继承很好理解就是子类拥有父类非private方法和变量可以拿来就用不用再写别方法或者不满意就可以重写可是这个向上转型就不明白了有人解释在父类定义一个方法对不同子类对...java继承很好理解 就是...
  • 目录一、向上转型1、向上转型中的方法调用2、向上转型的作用二、向下转型。1、向下转型中的方法调用2、向下转型的作用三、当转型遇到重写和同名数据四、多态存在的三个必要条件 一、向上转型 通俗地讲即是将子类对象...
  • Java向上、向下转型的作用 一、向上转型 这个是我们平时用的最多的,比如我们要定义某一个方法的时候,经常使用一个抽象类(父类)或者接口作为参数把他们的子类传递过去,在传递的过程中,这个子类默认就是进行向上...
  • 向上转型:父类引用指向子类对象,例如:Father f1 = new Son(); 当子类向上造型后对象方法中不存在子类自己特色方法,只有父类方法。而且子类对于父类进行重写方法。向上造型对象方法为重写后新...
  • 多态的作用: ·大大提高程序的可复用性。 ·可以提高可扩充性和可维护性。 2. 向上转型和向下转型 向上转型很安全,子类转成父类(父类出面,而子类做事) 向下转型:父类再转成原有的子类,通过强制转换 ...
  • java中向上转型,向下转型以及多态

    千次阅读 2019-03-28 16:52:40
    转自:Java向上转型的作用(有详细代码介绍) 先来讲一下向上转型,向下转型下次再补充 1.向上转型的格式父类名 父类对象名=new 子类对象() 2.此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法,而不是...
  • 向上转型的作用在于让代码复用,提高代码简洁性,同个继承链的类可以用同个顶层类型表示参数。 如将子类对象作为实参,传进父类为形参的函数,即可不必为每一个子类都写一个子类形参的函数。 向上转型后方法调用 ...
  • 向上转型作用于泛型

    2017-08-11 16:19:34
    可将子类对象放入保存父类对象容器内。 package com.htxx.action.business; import java.util.ArrayList; import java.util.List; public class Cycle { void ride(Cycle c){ System.out.println("ride"); ...
  • 向上转型的作用,减少重复代码,父类为参数,调有时用子类作为参数,就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。 我给你讲讲啊,哈哈。父类类型的引用指向子类的对象。就你这个test3,...
  • 首先学习每一种知识都需要弄明白这知识是用来干...向上转型的作用:1、为了能够向上转型为多个基类型(由此而带来的灵活性) 2、使用接口的第二个原因却是与使用抽象基类相同,防止客户端创建该类的对象,并确保这仅仅
  • java有关多态的知识点和注意事项多态的格式与使用多态中成员变量的使用特点多态中成员方法的使用特点多态的作用,为什么用多态写法对象的向上转型对象的向下转型 多态的格式与使用 代码当中体现多态性,其实就是:...
  • (从实现了某个接口对象,得到对此接口引用,与向上转型为这个对象基类,实质上效果是一样。)这是因为此内部类--某个接口实现--能够完全不可见,并且不可用。所得到只是指向基类或接口引用,所以能够...
  • 对象转型(casting) 向上转型 向下转型 –instanceofAnimal a = new Cat(); //自动类型提升,猫对象提升为了动物类型。但是特有功能无法s访问。 //作用就是限制对特有功能访问。 //专业讲:向上转型。将子类型...
  • 按照目前的理解,向上转型的一个重要作用就是方便实现多态,在向上转型的过程中,相对于父类来说,子类多余的方法丢失,也就是访问不到了。不过再通过向下转型就可以访问了。 2)父类对象引用转化为子类引用,称为向...
  • 在讨论向上转型和向下转型之前,先复习下多态。如果有错误地方,希望能够指出,大家共同进步!什么是多态?多态(Polymorphism)即同一操作作用于不同对象,可以有不同解释,产生不同结果。多态分类多态一般...
  • 向上转型Parent parent=new Son(); 主要作用:参数统一 向下转型(Son)parent.SonMethod(); 主要作用:调用子类特有方法   public class Parent { private static final String TAG = "Parent"; ...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 354
精华内容 141
关键字:

向上转型的作用