精华内容
下载资源
问答
  • 但是向上转型的应用场景是什么呢?我看到网上的说是为了获取父类的方法,子类也可以访问父类的方法啊,就算是覆盖的方法,也可以通过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());

    }

    展开全文
  • 对于继承来说,向上转型好处有哪些? 未向上转型: public static void main(String[] args) { Son_1 son_1 = new Son_1(); Son_2 son_2 = new Son_2(); // 当不知道输入的对象是何种类型时,introduce需要把所有...

    方法重写,适应不同的子类

    对于父类来说,统一规范好子类常用的属性和方法。
    针对不同的子类能够根据子类的情况适当的重写属性和方法,同时能够增加一些属性和方法。

    父类代码:

    /**
     * 父类
     */
    public class Person {
        // 将要被子类重写的属性
        int age;
        // 将要被子类重写的方法
        public void say() {}
        // 没有被子类重写的方法
        public void dance() {
            System.out.println("我喜欢跳舞!");
        }
    }
    

    子类1代码:

    
    /**
     * 子类1
     */
    public class Son_1 extends Person{
        // age属性被子类1重写
        int age = 6;
        // say方法被子类1重写
        public void say() {
            System.out.print("我是大儿子!");
        }
    }
    

    子类2代码:

    /**
     * 子类2
     */
    public class Son_2 extends Person{
        // age属性被子类2重写
        int age = 4;
        // say方法被子类2重写
        public void say() {
            System.out.print("我是二儿子!");
        }
    }
    

    父类为子类提供了子类公共的属性和方法,如果不重写,则使用的是父类的方法体和属性值,这样各个子类就无需多次重复写公用不变的属性和方法

    向上转型,统一调用子类的属性和方法

    首先在理解向上转型的好处之前我们来了解下,向上转型和不向上转型以及向下转型的区别:

    1. 子类向父类转型:`
    		// 向上转型
            Person son_1 = new Son_1();
    
            // 可以向下强制转型
            Son_1 temp = (Son_1) son_1;
            // 能够输出hobby属性,未报错(说明类型变化后,变量仍然指向子类地址)
            System.out.println(temp.hobby);
    
    1. 父类向子类转型:
    // 直接新建父类类型的对象
            Person person = new Person();
            // 能够进行向下转型,不过执行报错(说明类型变化后,变量仍然指向父类地址)
            Son_1 son = (Son_1) person;
            System.out.println(son.hobby); // 该语句报错
    

    说明,即使类型变化了,但是变量的指向地址并没有发生改变。

    1. 对于继承来说,向上转型的好处有哪些?

    未向上转型:

     public static void main(String[] args) {
            Son_1 son_1 = new Son_1();
            Son_2 son_2 = new Son_2();
    
            // 当不知道输入的对象是何种类型时,introduce需要把所有的子类类型都写一遍
            introduce(son_1);
            introduce(son_2);
        }
    
        // 下面为introduce的重载方法,可能出现的有两种类型子类,则重载两遍
        public static void introduce(Son_1 son_1) {
            son_1.say();
            System.out.print("今年"+son_1.age+"岁了");
        }
    
        public static void introduce(Son_2 son_2) {
            son_2.say();
            System.out.print("今年"+son_2.age+"岁了");
        }
    

    此时可以看出,如果子类的类型比较多的话,则需要写好多introduce的方法,这很繁琐。

    那如何通过一个introduce将所有的子类都包括呢?

    向上转型:

    public static void main(String[] args) {
            // 子类向父类转型
            Person son_1 = new Son_1();
            Person son_2 = new Son_2();
            
            introduce(son_1);
            introduce(son_2);
        }
    
        // 为了统一调用被子类重写的公共属性和方法,此方法只写了一遍
        public static void introduce(Person per) {
            per.say();
            System.out.print("今年"+per.age+"岁了");
        }
    

    从代码可以看出,introduce只写了一遍,可以将所有子类包括,这提高了代码的简洁性。

    展开全文
  • 在定义中是子类向父类转型称为向上转型,父类向子类转型是向下转型(必须先向上转型过,才能向下转型),但是在下面类定义后,我得到的结果却不同。求大佬解惑class superclass{public int x = 100;public void ...

    在定义中是子类向父类转型称为向上转型,父类向子类转型是向下转型(必须先向上转型过,才能向下转型),

    但是在下面类定义后,我得到的结果却不同。求大佬解惑

    class superclass{

    public int x = 100;

    public void printinfo() {

    System.out.println("x = "+this.x);

    }

    }

    class sonclass extends superclass{

    public int x = 50;

    public int y = 200;

    public void printinfo() {

    System.out.println("x = "+this.x+" y = "+this.y);

    }

    }

    import java.util.*;

    public class zhuanxing {

    public zhuanxing() {

    // TODO Auto-generated constructor stub

    }

    public static void main(String[] args) {

    superclass c1 = new superclass();

    sonclass c2 = new sonclass();

    c1.printinfo();

    c2.printinfo();

    c1 = c2;

    c1.printinfo();

    c1.printinfo();

    c2 = (sonclass)c1;

    System.out.println("向上转型后,能向下转型!");

    c1.printinfo();

    c2.printinfo();

    }

    }

    运行结果:

    x = 100

    x = 50 y = 200

    x = 50 y = 200

    x = 50 y = 200

    向上转型后,能向下转型!

    x = 50 y = 200

    x = 50 y = 200

    感觉所谓的向上转型和实际不符合,例如:

    c1=c2,这个语句是向上转型;但是实际结果是c1变成了子类类型(c1自动调用子类函数,且有了y值),这感觉是父类向子类转型把,不是子类向父类转型,求大佬解惑。

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

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

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

    展开全文
  • 展开全部java 转型问题其实并不复杂,只要记住一句62616964757a686964616fe...从2个名词开始说起:向上转型(upcasting) 、向下转型(downcasting).举个例子:2个类,Father是父类,Son类继承自Father。Father f1 = ...
  • 还有一种情况的向上转型,new出来一个类的对象赋值给了此类实现的一个接口,我称之为瘦身,只不过,接口的向上转型和类的向上转型区别的。 在这里,我们只讨论类和接口的转型。同样向下转型也两种,一种是new...
  • 向上转型和向下转型是在JAVA继承操作中用到的东西,在讲到转型之前我们需要认识到继承过程中的对象类型转换,这种转换两个特点: 1.这是继承过程中发生的操作 2.新类是现有类的一种类型。这种说法主要是因为...
  • java的继承很好理解就是子类拥有父类的非private方法和变量可以拿来就用不用再写别的方法或者不满意就可以重写可是这个向上转型就不明白了的人解释在父类定义一个方法对不同的子类对...java的继承很好理解 就是...
  • java向上转型的问题

    2021-03-13 20:45:53
    } } 结果: B2 B1 A2 结论: 类在向上转型后,private的属性依然是子类的属性,因为private不能直接访问,需要提供对外方法,而方法在向上转型后依然是子类的方法,所以private的属性不会改变而非private的属性在向上转型...
  • java向上转型实质

    2021-03-11 15:51:43
    展开全部java 转型问题其实并不复杂,只要记62616964757a686964616fe4b893...从2个名词开始说起:向上转型(upcasting) 、向下转型(downcasting).举个例子:2个类,Father是父类,Son类继承自Father。Father f1 = ...
  • Java向上转型

    2021-03-22 13:54:35
    通俗理解向上转型:就是子类转型成父类。classA{}classBextendsA { }Ab=newB();这个就是向上转型向上转型可以像下面这条语句这么简单:Shape s =new Circle();这里,创建一个Circle对象,并把得到的引用立即赋值给S...
  • 下面的文章内容要给大家讲到的就是java对象类型转换方面的知识,主要是向上转型和向下转型方面的知识,一起来了解一下吧。1、向上转型父类引用指向子类对象为向上转型。下面是语法格式:fatherClassobj=newsonClass...
  • 展开全部java里面的向上转型和向下转型的具体好处如下:1.转型是在继承的基础上而言的,继承是面e69da5e887aa3231313335323631343130323136353331333337623364向对象语言中,代码复用的一种机制,通过继承,子类可以...
  • 向上转型:子类引用的对象转换为父类类型称为向上转型。通俗地说就是是将子类对象转为父类对象。此处父类对象可以是接口向下转型:父类引用的对象转换为子类类型称为向下转型。前者是一个向上转型,Animal dog 引用...
  • 先来看看定义:向上转型(upcasting):子类引用的对象转换为父类类型称为向上转型。Father f= new Father();son s=new son();f=s; //Father f= new Son();以下特点:1、只能调用父类的成员(除private成员),如果...
  • 1 向上转型(子类转型成父类)举例: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(...
  • 学习向上转型和向下转型怎么用没多难,但是为什么那样用,我搞了很多次没弄明白。没弄明白的原因是平时学习时之看例子,而例子一般都比较简单,没有对象之间的调用,一般就是一个对象调用自己的方法。首先看下怎么用...
  • 1.向上转型 里氏替换原则:所有要求父类对象出现的地方,子类对象都可以替换他(子类比父类更强大)。 结构: 父类类型 应用 = new 子类类型(); ---------自动转型 (父类引用指向子类实例对象) 向上...
  • 向上转型和向下转型

    2021-05-08 05:05:34
    简单使用声明一个父类Father,子类Son继承FatherFather a = new Son() // 父类引用、子类对象(向上转型)Son b = (Son)a // 向下转型,强制转换// 父类引用转成子类引用向上转型实例public class Animal {public void ...
  • 简单理解Java中转型问题(向上转型和向下转型) —————————————————————————— 本文内容仅仅为个人的理解,仅供大家参考。如果本文中存在一些错误的地方还请大佬们指出,感激不尽。 ————...
  • 在讨论向上转型和向下转型之前,先复习下多态。如果错误的地方,希望能够指出,大家共同进步!什么是多态?多态(Polymorphism)即同一操作作用于不同的对象,可以不同的解释,产生不同的结果。多态的分类多态一般...
  • //向上转型 animalCry(d2); Animal c1 = new Cat(); animalCry(c1); Animal c2 = new Cat(); animalCry(c2); }static voidanimalCry(Animal a) { a.shout(); } } 结果: 2. d2作为Animal对象转成Dog对象可行。如d3...
  • 本篇文章给大家带来的内容是关于Java向上转型和向下转型的使用介绍(附代码),一定的参考价值,需要的朋友可以参考一下,希望对你有所帮助。1 向上转型(子类转型成父类)举例:package a.b;public class A {public...
  • 向上转型 派生类对象转型为基类对象(包括指针和对象),直接转化由编译器自动完成,不用cast,并且是绝对安全的。 内存里面:基类对象相当于只是换了个地址。换成了派生类对象中存储基类成员的内存地址。但是派生类...
  • 向下转型:Cat cat = (Cat) a,必须要先经过向上转型的变量–再向下转型,此时cat就拥有子类自己定义的特有方法cat.sleep() instanceof用法:a instanceof Cat 这里a必须是经过向上转型后的父类对
  • 这篇文章主要介绍了简单了解Java多态向上转型相关原理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下多态性是面向对象的第三大特征。多态的优点改善代码的组织...
  • 在谈转型之前我们需要了解,关于引用变量的类型和具体实例之间的关系. 举个例子: public class Person { protected String name; protected Integer age; //在构建属性和方法的时候需要注意,访问权限控制符.需要...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,208
精华内容 22,083
关键字:

向上转型有什么好处