精华内容
参与话题
问答
  • 向下转型

    2020-03-05 15:26:11
    public class 向下转型 { public static void main(String[] args) { Father5 father5= new Son5(); // Son5 son5= (Son5)father5;// 这个过程就叫做向下转型。 // System.out.println(son5.name); } } class.....
    package Jicheng;
    
    public class 向下转型 {
    public static void main(String[] args) {
    	Father5 father5= new Son5();
    	//
    	Son5 son5= (Son5)father5;// 这个过程就叫做向下转型。
    	//
    	System.out.println(son5.name);
    }
    }
    class Father5{
    	String name = "FATHER";
    }
    class Son5 extends Father5{
    	String name = "SON";
    }
    
    展开全文
  • 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中的向下转型问题

    2017-07-11 15:19:34
    我想问就是标红的那一行我传入的是Integer类的数据(int自动装箱成Integer) 然后调用方法向上转型成了Object类 然后Object类按道理可以向下转型成String类啊? package com.xyh.Demo; class Point{ private ...
  • 多态,大概每个人都知道。但是,又有几个人真的理解什么是多态、多态有哪些细节呢?如果你看到这篇文章的名字,脑海中对多态没有一个清晰的概念,不妨点进来看看,也许会有收获。

    多态,大概每个人都知道。但是,又有几个人真的理解什么是多态、多态有哪些细节呢?如果你看到这篇文章的名字,脑海中对多态没有一个清晰的概念,不妨点进来看看,也许会有收获。

    什么是多态

    简单的理解多态

    多态,简而言之就是同一个行为具有多个不同表现形式或形态的能力。比如说,有一杯水,我不知道它是温的、冰的还是烫的,但是我一摸我就知道了。我摸水杯这个动作,对于不同温度的水,就会得到不同的结果。这就是多态。

    那么,java中是怎么体现多态呢?我们来直接看代码:

    public class Water {
        public void showTem(){
            System.out.println("我的温度是: 0度");
        }
    }
    
    public class IceWater extends Water {
        public void showTem(){
            System.out.println("我的温度是: 0度");
        }
    }
    
    public class WarmWater extends Water {
        public void showTem(){
            System.out.println("我的温度是: 40度");
        }
    }
    
    public class HotWater extends Water {
        public void showTem(){
            System.out.println("我的温度是: 100度");
        }
    }
    
    public class TestWater{
        public static void main(String[] args) {
            Water w = new WarmWater();
            w.showTem();
    
            w = new IceWater();
            w.showTem();
    
            w = new HotWater();
            w.showTem();
    
        }
    }
    
    //结果:
    //我的温度是: 40度
    //我的温度是: 0度
    //我的温度是: 100度

    这里的方法showTem()就相当于你去摸水杯。我们定义的water类型的引用变量w就相当于水杯,你在水杯里放了什么温度的水,那么我摸出来的感觉就是什么。就像代码中的那样,放置不同温度的水,得到的温度也就不同,但水杯是同一个。

    想必你也看出来了,这段代码中最关键的就是这一句

    Water w = new WarmWater();

    看过我前几篇文章的应该知道,我说在讲多态的时候,会讲一个很重要的知识点 — 向上转型。

    这句代码体现的就是向上转型。后面我会详细讲解这一知识点。

    多态的分类

    已经简单的认识了多态了,那么我们来看一下多态的分类。

    多态一般分为两种:重写式多态和重载式多态。重写和重载这两个知识点前面的文章已经详细将结果了,这里就不多说了。

    • 重载式多态,也叫编译时多态。也就是说这种多态再编译时已经确定好了。重载大家都知道,方法名相同而参数列表不同的一组方法就是重载。在调用这种重载的方法时,通过传入不同的参数最后得到不同的结果。

      但是这里是有歧义的,有的人觉得不应该把重载也算作多态。因为很多人对多态的理解是:程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,这种情况叫做多态。 这个定义中描述的就是我们的第二种多态—重写式多态。并且,重载式多态并不是面向对象编程特有的,而多态却是面向对象三大特性之一(如果我说的不对,记得告诉我。。)。

      我觉得大家也没有必要在定义上去深究这些,我的理解是:同一个行为具有多个不同表现形式或形态的能力就是多态,所以我认为重载也是一种多态,如果你不同意这种观点,我也接受。

    • 重写式多态,也叫运行时多态。这种多态通过动态绑定(dynamic binding)技术来实现,是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。也就是说,只有程序运行起来,你才知道调用的是哪个子类的方法。
      这种多态通过函数的重写以及向上转型来实现,我们上面代码中的例子就是一个完整的重写式多态。我们接下来讲的所有多态都是重写式多态,因为它才是面向对象编程中真正的多态。

      动态绑定技术涉及到jvm,暂时不讲(因为我也不懂,哈哈哈哈),感兴趣的可以自己去研究一下,我暂时还没有时间去研究jvm。。

    多态的条件

    前面说过,我们接下来说的多态,都是运行时多态。

    • 继承。在多态中必须存在有继承关系的子类和父类。
    • 重写。子类对父类中某些方法进行重新定义,在调用这些方法时就会调用子类的方法。
    • 向上转型。在多态中需要将子类的引用赋给父类对象,只有这样该引用才能够具备技能调用父类的方法和子类的方法。

    继承也可以替换为实现接口。

    继承和重写之前都说过了,接下来我们来看一下转型是什么。

    向上转型与向下转型

    向上转型

    子类引用的对象转换为父类类型称为向上转型。通俗地说就是是将子类对象转为父类对象。此处父类对象可以是接口。

    案例驱动

    看一个大家都知道的例子:

    public class Animal {
        public void eat(){
            System.out.println("animal eatting...");
        }
    }
    
    public class Cat extends Animal{
    
        public void eat(){
    
            System.out.println("我吃鱼");
        }
    }
    
    public class Dog extends Animal{
    
        public void eat(){
    
            System.out.println("我吃骨头");
        }
    
        public void run(){
            System.out.println("我会跑");
        }
    }
    
    public class Main {
    
        public static void main(String[] args) {
    
            Animal animal = new Cat(); //向上转型
            animal.eat();
    
            animal = new Dog();
            animal.eat();
        }
    
    }
    
    //结果:
    //我吃鱼
    //我吃骨头
    

    这就是向上转型,Animal animal = new Cat();将子类对象Cat转化为父类对象Animal。这个时候animal这个引用调用的方法是子类方法。

    关于方法调用的顺序,我们后面会详细讲解。

    转型过程中需要注意的问题

    • 向上转型时,子类单独定义的方法会丢失。比如上面Dog类中定义的run方法,当animal引用指向Dog类实例时是访问不到run方法的,animal.run()会报错。
    • 子类引用不能指向父类对象。Cat c = (Cat)new Animal()这样是不行的。

    向上转型的好处

    • 减少重复代码,使代码变得简洁。
    • 提高系统扩展性。

    举个例子:比如我现在有很多种类的动物,要喂它们吃东西。如果不用向上转型,那我需要这样写:

    public void eat(Cat c){
        c.eat();
    }
    
    public void eat(Dog d){
        d.eat();
    }
    //......
    
    eat(new Cat());
    eat(new Cat());
    eat(new Dog());
    //......

    一种动物写一个方法,如果我有一万种动物,我就要写一万个方法,写完大概猴年马月都过了好几个了吧。好吧,你很厉害,你耐着性子写完了,以为可以放松一会了,突然又来了一种新的动物,你是不是又要单独为它写一个eat方法?开心了么?

    那如果我使用向上转型呢?我只需要这样写:

    public void eat(Animal a){
        a.eat();
    }
    
    eat(new Cat());
    eat(new Cat());
    eat(new Dog());
    //.....

    恩,搞定了。代码是不是简洁了许多?而且这个时候,如果我又有一种新的动物加进来,我只需要实现它自己的类,让他继承Animal就可以了,而不需要为它单独写一个eat方法。是不是提高了扩展性?

    向下转型

    与向上转型相对应的就是向下转型了。向下转型是把父类对象转为子类对象。(请注意!这里是有坑的。)

    案例驱动

    先看一个例子:

    //还是上面的animal和cat dog
    Animal a = new Cat();
    Cat c = ((Cat) a);
    c.eat();
    //输出  我吃鱼
    Dog d = ((Dog) a);
    d.eat();
    // 报错 : java.lang.ClassCastException:com.chengfan.animal.Cat cannot be cast to com.chengfan.animal.Dog
    Animal a1 = new Animal();
    Cat c1 = ((Cat) a1);
    c1.eat();
    // 报错 : java.lang.ClassCastException:com.chengfan.animal.Animal cannot be cast to com.chengfan.animal.Cat

    为什么第一段代码不报错呢?相比你也知道了,因为a本身就是Cat对象,所以它理所当然的可以向下转型为Cat,也理所当然的不能转为Dog,你见过一条狗突然就变成一只猫这种操蛋现象?

    而a1为Animal对象,它也不能被向下转型为任何子类对象。比如你去考古,发现了一个新生物,知道它是一种动物,但是你不能直接说,啊,它是猫,或者说它是狗。

    向下转型注意事项

    • 向下转型的前提是父类对象指向的是子类对象(也就是说,在向下转型之前,它得先向上转型)
    • 向下转型只能转型为本类对象(猫是不能变成狗的)。

      大概你会说,我特么有病啊,我先向上转型再向下转型??

      我们回到上面的问题:喂动物吃饭,吃了饭做点什么呢?不同的动物肯定做不同的事,怎么做呢?

    public void eat(Animal a){
        if(a instanceof Dog){  
            Dog d = (Dog)a;
            d.eat();
            d.run();//狗有一个跑的方法      
        } 
        if(a instanceof Cat){  
            Cat c = (Cat)a;
            c.eat();
            System.out.println("我也想跑,但是不会"); //猫会抱怨    
        } 
        a.eat();//其他动物只会吃
    }
    
    eat(new Cat());
    eat(new Cat());
    eat(new Dog());
    //.....

    现在,你懂了么?这就是向下转型的简单应用,可能举得例子不恰当,但是也可以说明一些问题。

    敲黑板,划重点!看到那个instanceof了么?

    经典案例分析多态

    基本的多态和转型我们都会了,最后加点餐。看一个经典案例:

    class A {
        public String show(D obj) {
            return ("A and D");
        }
    
        public String show(A obj) {
            return ("A and A");
        }
    
    }
    
    class B extends A{
        public String show(B obj){
            return ("B and B");
        }
    
        public String show(A obj){
            return ("B and A");
        }
    }
    
    class C extends B{
    
    }
    
    class D extends B{
    
    }
    
    public class Demo {
        public static void main(String[] args) {
            A a1 = new A();
            A a2 = new B();
            B b = new B();
            C c = new C();
            D d = new D();
    
            System.out.println("1--" + a1.show(b));
            System.out.println("2--" + a1.show(c));
            System.out.println("3--" + a1.show(d));
            System.out.println("4--" + a2.show(b));
            System.out.println("5--" + a2.show(c));
            System.out.println("6--" + a2.show(d));
            System.out.println("7--" + b.show(b));
            System.out.println("8--" + b.show(c));
            System.out.println("9--" + b.show(d));
        }
    }
    //结果:
    //1--A and A
    //2--A and A
    //3--A and D
    //4--B and A
    //5--B and A
    //6--A and D
    //7--B and B
    //8--B and B
    //9--A and D
    
    //能看懂这个结果么?先自分析一下。

    前三个,强行分析,还能看得懂。但是第四个,大概你就傻了吧。为什么不是b and b呢?

    这里就要学点新东西了。

    当父类对象引用变量引用子类对象时,被引用对象的类型决定了调用谁的成员方法,引用变量类型决定可调用的方法。如果子类中没有覆盖该方法,那么会去父类中寻找。

    可能读起来比较拗口,我们先来看一个简单的例子:

    class X {
        public void show(Y y){
            System.out.println("x and y");
        }
    
        public void show(){
            System.out.println("only x");
        }
    }
    
    class Y extends X {
        public void show(Y y){
            System.out.println("y and y");
        }
        public void show(int i){
    
        }
    }
    
    class main{
        public static void main(String[] args) {
            X x = new Y();
            x.show(new Y());
            x.show();
        }
    }
    //结果
    //y and y
    //only x

    Y继承了X,覆盖了X中的show(Y y)方法,但是没有覆盖show()方法。

    这个时候,引用类型为X的x指向的对象为Y,这个时候,调用的方法由Y决定,会先从Y中寻找。执行x.show(new Y());,该方法在Y中定义了,所以执行的是Y里面的方法;

    但是执行x.show();的时候,有的人会说,Y中没有这个方法啊?它好像是去父类中找该方法了,因为调用了X中的方法。

    事实上,Y类中是有show()方法的,这个方法继承自X,只不过没有覆盖该方法,所以没有在Y中明确写出来而已,看起来像是调用了X中的方法,实际上调用的还是Y中的。

    这个时候再看上面那句难理解的话就不难理解了吧。X是引用变量类型,它决定哪些方法可以调用;show()和show(Y y)可以调用,而show(int i)不可以调用。Y是被引用对象的类型,它决定了调用谁的方法:调用y的方法。

    上面的是一个简单的知识,它还不足以让我们理解那个复杂的例子。我们再来看这样一个知识:

    继承链中对象方法的调用的优先级:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

    如果你能理解这个调用关系,那么多态你就掌握了。我们回到那个复杂的例子:

    abcd的关系是这样的:C/D —> B —> A

    我们先来分析4 : a2.show(b)

    • 首先,a2是类型为A的引用类型,它指向类型为B的对象。A确定可调用的方法:show(D obj)和show(A obj)。
    • a2.show(b) ==> this.show(b),这里this指的是B。
    • 然后.在B类中找show(B obj),找到了,可惜没用,因为show(B obj)方法不在可调用范围内,this.show(O)失败,进入下一级别:super.show(O),super指的是A。
    • 在A 中寻找show(B obj),失败,因为没用定义这个方法。进入第三级别:this.show((super)O),this指的是B。
    • 在B中找show((A)O),找到了:show(A obj),选择调用该方法。
    • 输出:B and A

    如果你能看懂这个过程,并且能分析出其他的情况,那你就真的掌握了。

    我们再来看一下9:b.show(d)

    • 首先,b为类型为B的引用对象,指向类型为B的对象。没有涉及向上转型,只会调用本类中的方法。
    • 在B中寻找show(D obj),方法。现在你不会说没找到了吧?找到了,直接调用该方法。
    • 输出 A and D。

    总结

    本篇文章的内容大体上就是这些了。我们来总结一下。

    1. 多态,简而言之就是同一个行为具有多个不同表现形式或形态的能力。
    2. 多态的分类:运行时多态和编译时多态。
    3. 运行时多态的前提:继承(实现),重写,向上转型
    4. 向上转型与向下转型。
    5. 继承链中对象方法的调用的优先级:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

    事实上,当你使用向上转型的时候,你就使用了多态。关于多态还有一些其他的知识点,比如几个关键字:static、final等,我们后面会一一讲解。下一篇《重新认识java(六) —-java中的另类:static关键字》不定期更新。

    如果文章内容有什么问题,或者哪里出错,请及时与我联系。不保证文章内容的完全正确性。如果你有更好的简洁或者更好的理解方式,欢迎一起交流。

    原文地址:http://blog.csdn.net/qq_31655965/article/details/54746235
    欢迎转载~转载请注明出处!
    看完了随手点个赞呗~

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

    万次阅读 多人点赞 2016-08-17 16:13:01
    一开始学习 Java 时不重视向下转型。一直搞不清楚向下转型的意义和用途,不清楚其实就是不会,那开发的过程肯定也想不到用向下转型。其实向上转型和向下转型都是很重要的,可能我们平时见向上转型多一点,向上转型也...

    一开始学习 Java 时不重视向下转型。一直搞不清楚向下转型的意义和用途,不清楚其实就是不会,那开发的过程肯定也想不到用向下转型。

    其实向上转型和向下转型都是很重要的,可能我们平时见向上转型多一点,向上转型也比较好理解。
    但是向下转型,会不会觉得很傻,我是要用子类实例对象,先是生成子类实例赋值给父类引用,在将父类引用向下强转给子类引用,这不是多此一举吗?我不向上转型也不向下转型,直接用子类实例就行了。
    我开始学习Java时也是这么想的,这误区导致我觉得向下转型就是没用的。
    随着技术的提升,我在看开源的项目学习,发现很多地方都用了向下转型的技术,这就让我重视了起来,想要重新来复习(学习)这个知识点。也是搜索了许多博客文章,但都没具体说明向下转型,只是给了例子演示怎么使用,反而是向上转型讲了一堆(可能是我没找到)。

    这篇博客就是讲向下转型的,那我们就来学习下向下转型,了解下这种特性的意义和使用场景

    新建一个电子产品接口,如下:

    public interface Electronics{
    
    }
    

    很简单,什么方法都没有。

    新建一个Thinkpad笔记本类,并实现电子产品接口:

    public class Thinkpad implements Electronics{
    
        //Thinkpad引导方法
        public void boot(){
            System.out.println("welcome,I am Thinkpad");        
        }
    
        //使用Thinkpad编程  
        public void program(){
            System.out.println("using Thinkpad program");
        }
    
    }
    

    新建一个Mouse鼠标类,并实现电子产品接口:

    public class Mouse implements Electronics{
    
        //鼠标移动
        public void move(){
            System.out.println("move the mouse");       
        }
    
        //鼠标点击  
        public void onClick(){
            System.out.println("a click of the mouse");
        }
    
    }

    新建一个Keyboard键盘类,并实现电子产品接口:

    public class Keyboard implements Electronics{
    
        //使用键盘输入    
        public void input(){
            System.out.println("using Keyboard input");
        }
    
    }

    这里子类比较多,是为了更好的理解。每个类的方法的逻辑实现也很简单。打印了一行信息

    接下来,我们想象一个情景:我们去商城买电子产品,电子产品很多吧,比如笔记本电脑,鼠标,键盘,步步高点读机哪里不会点哪里,我们用的手机,等等,这些都属于电子产品。电子产品是抽象的。好,那么我们决定买一台Thinkpad,一个鼠标和一个键盘。
    这时,我们需要一个购物车来装这些电子产品吧。我们可以添加进购物车,然后通过购物车还能知道存放的电子产品数量,能拿到对应的电子产品。
    那么,一个购物车类就出来了,如下:

    import java.util.ArrayList;
    import java.util.List;
    
    public class ShopCar{
    
        private List<Electronics> mlist = new ArrayList<Electronics>();
    
        public void add(Electronics electronics){
    
            mlist.add(electronics);
    
        }
    
        public int getSize(){
    
            return mlist.size();
        }
    
    
        public Electronics getListItem(int position){
    
            return mlist.get(position);
    
        }
    
    
    }
    

    List 集合是用来存放电子产品的,add 方法用来添加电子产品到购物车,getSize 方法用来获取存放的电子产品数量,getListItem 方法用来获取相应的电子产品。

    可以看到 List<Electronics> 用了泛型的知识,至于为什么要用泛型?这个不做介绍了,泛型很重要的。
    而我觉得比较疑惑的是为什么是放 Electronics 的泛型,而不是放Thinkpad,Mouse,Keyboard,Phone等?
    那么如果是List<Thinkpad>,肯定是放不进鼠标Mouse的吧,难道要生成3个集合?这里是定义了3个电子产品类,但是我如果有100种电子产品呢,要定义100个集合?
    这太可怕了。所以之前,我们写了一个Electronics接口,提供了一个Electronics的标准,然后让每一个Electronics子类都去实现这个接口。

    实际上这里又涉及到了向上转型的知识点,我们虽然在add 方法将子类实例传了进来存放,但子类实例在传进去的过程中也进行了向上转型
    所以,此时购物车里存放的子类实例对象,由于向上转型成Electronics,已经丢失了子类独有的方法,以上述例子来分析,Thinkpad实例就是丢失了boot() 和program() 这两个方法,而Mouse实例就是丢失了move()和onClick()这两个方法

    但是实际使用Thinkpad或Mouse或Keyboard时,这种情况肯定不是我们想要的

    接着我们写一个测试类 Test 去测试购物车里的电子产品。

    测试类 Test 如下:

    public class Test{
    
        public static final int THINKPAD = 0;
        public static final int MOUSE = 1;
        public static final int KEYBOARD = 2;
    
        public static void main(String[] args){
    
            //添加进购物车
            ShopCar shopcar = new ShopCar();
            shopcar.add(new Thinkpad());
            shopcar.add(new Mouse());
            shopcar.add(new Keyboard());
    
            //获取大小
            System.out.println("购物车存放的电子产品数量为 ——> "+shopcar.getSize());
    
    
            //开始测试thinkpad电脑
            Thinkpad thinkpad = (Thinkpad)shopcar.getListItem(THINKPAD);
            thinkpad.boot();
            thinkpad.program();
    
            System.out.println("-------------------");
    
            //开始测试Mouse鼠标
            Mouse mouse = (Mouse)shopcar.getListItem(MOUSE);
            mouse.move();
            mouse.onClick();
    
            System.out.println("-------------------");
    
            //开始测试Keyboard键盘
            Keyboard keyboard = (Keyboard)shopcar.getListItem(KEYBOARD);
            keyboard.input();
        }
    
    }

    运行截图:


    这里写图片描述
    举个例子分析就好

    //开始测试thinkpad电脑
    Thinkpad thinkpad = (Thinkpad)shopcar.getListItem(THINKPAD);
    thinkpad.boot();
    thinkpad.program();
    

    shopcar.getListItem(THINKPAD)这句代码是获取到Electronics类型的实例。不是Thinkpad的实例

    通过向下转型,赋值给子类引用

    Thinkpad thinkpad = (Thinkpad)shopcar.getListItem(THINKPAD);

    这样子类实例又重新获得了因为向上转型而丢失的方法(boot 和program)

    总结一下吧,很多时候,我们需要把很多种类的实例对象,全部扔到一个集合。(这句话很重要)
    在这个例子里就是把Thinkpad笔记本,Mouse鼠标,KeyBoard键盘等实例对象,全部扔到一个Shopcar购物车集合。
    但是肯定不可能给他们每个种类都用一个独立的集合去存放吧,这个时候我们应该寻找到一个标准,接口就是一个标准。这些都是各种电子产品,抽象成电子产品。然后一个Electronics接口就出来了。
    在回到刚才,我们把很多种类的实例对象全部扔到一个集合。或许这样比较好理解:把很多种类的子类实例对象全部扔到存放父类实例的集合。
    经过了这个过程,子类实例已经赋值给了父类引用(即完成了向上转型),但很遗憾的丢失了子类扩展的方法。
    很好的是Java语言有个向下转型的特性,让我们可以重新获得丢失的方法,即强转回子类
    所以我们需要用到子类实例的时候,就从那个父类集合里拿出来向下转型就可以了,一样可以使用子类实例对象

    ……

    我在搜索java向下转型的意义时,得到一个比较好的答案是这样的:
    最大的用处是java的泛型编程,用处很大,Java的集合类都是这样的。

    而在Android开发中,我们在Layout文件夹,用xml写的控件。为什么能在Activity等组件中通过 findViewById() 方法找到呢?为什么 findViewById(R.id.textview) 方法传入TextView的id后,还要转型为TextView呢?这就是 Java 向下转型的一个应用

    展开全文
  • 主要介绍了Java向上转型和向下转型实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 那我们怎么样才能既实现向上转型,又能使子类可以调用其独有的方法呢,这就需要使用向下转型了。 注意 向下转型必须是在向上转型之后才能进行。 我们还是以汽车为例。 首先是Car这个父类。...
  • 主要介绍了 Java 向上转型和向下转型的详解的相关资料,需要的朋友可以参考下
  • 向上转型 向下转型

    2018-07-12 17:30:30
    如父类Animal,子类Cat,Dog。...理解多态,首先要知道“向上转型”。我定义了一个子类Cat,它继承了Animal类,那么后者就是前者是父类。我可以通过 Cat c = new Cat(); 实例化一个Cat的对象,这...
  • 向上转型和向下转型

    2018-07-14 09:27:49
    1、向上转型:子类对象赋值给父类类型的变量,即父类对象引用,指向子类对象;2、向下转型:是将抽象类转换为较具体的类。在执行向下转型时,需用instanceof操作符判断父类对象是否为子类对象的实例。...
  • package com.hh2; public class Father {  private User user=new User(30);  private String name="zhh";  public void setName(String name){  this.name=name;  }  public String getName(){ ... 
  • 向上转型与向下转型

    多人点赞 2018-04-17 22:10:32
    什么是多态简单的理解多态多态,简而言之就是同一个行为具有多个不同表现形式或形态的能力。比如说,有一杯水,我不知道它是温的、冰的还是烫的,但是我一摸我就知道了。我摸水杯这个动作,对于不同温度的水,就会...
  • 新建people类 public interface People { } 新建China类 public class China implements People { public String name; public China() { } public China(String name) { ...public void ge...

空空如也

1 2 3 4 5 ... 20
收藏数 4,420
精华内容 1,768
关键字:

向下转型