热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

如何解决Java中向上造型向下造型和接口回调中的问题

这篇文章主要介绍如何解决Java中向上造型向下造型和接口回调中的问题,文中介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们一定要看完!最近

这篇文章主要介绍如何解决Java中向上造型向下造型和接口回调中的问题,文中介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们一定要看完!

最近回顾了一下java继承中的问题,下面贴代码:

public class Base {

 protected String temp = "base";
 public void fun(){
 System.out.print("BASE fun()");
 }

 public static void main(String[] args) {
 Base b =new Base();//实例化Base对象
 b.fun();   //调用父类中fun()的方法
 System.out.println(b.temp);//访问父类中的成员变量temp 
 
    /*****************************************************/ 
 System.out.println("/***************/");
 Son son = new Son();//实例化Son对象
 son.fun();  //调用son的fun方法
 System.out.println(son.temp);//访问son的成员变量temp
 
 Son S_son=new Son();    //实例化Son对象
 Base B_s =(Base)S_son;   //向上造型-----------相当于Base s =new Son();
 B_s.fun();      //调用子类的fun()方法
 System.out.println(B_s.temp);//访问父类的成员变量temp 
 
    /******************************************************/
 System.out.println("/***************/");
 Base s =new Son();//向上造型
 s.fun();     //调用子类的方法
 System.out.println(s.temp);//调用父类的成员变量temp
 
 Base ba =new Son();
 Son so = (Son)ba;      //向下造型
 so.fun();       //调用子类的fun()方法
 System.out.println(so.temp);//访问子类的成员变量temp 
 }
}
class Son extends Base{
 protected String temp = "Son";
 public void fun(){
 System.out.print("SON fun()");
 }
}

运行结果:

BASE fun()base
/***************/
SON fun()Son
SON fun()base
/***************/
SON fun()base
SON fun()Son

结论总结:

1、父类的引用变量可以指向子类对象,子类的引用变量不能指向父类对象。

2、向上造型(upcasting):把子类对象直接赋给父类引用,向上转型不用强制转型。如:

Base base = new Son(); 向上造型–隐式

3、向下造型(downcasting):把指向子类对象的父类引用赋给子类引用,要强制转型。

Base b= new Son();

Son s = (Son)base;----------向下造型–必须强制转换,且必须有继承关系

4、upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法,子类对象去 调用方法有效

5、调用方法或成员变量的规律:

前提:子类存在重写方法,父类和子类中同时有相同名称的成员变量。

(1)当进行了向上造型的引用型变量—父类引用变量只能调用子类的重写方法,但父类的引用变量只能访问父类中的成员变量

(2)当进行了向下造型的引用型变量—子类引用变量只调用子类重写方法,子类的引用变量只能访问子类的成员变量。

(3)自己想了个通俗的说法,调用方法,得当前的引用变量指向的对象;调用变量,得看当前引用变量的类型。

即,调方法,看对象,调变量,看类型。(可以试验一下)

接口回调与向上造型

/**
 * 接口回调,和向上造型的对比
 * @author Character_Painter
 *
 */
public class Inter extends Father implements Person,Teacher{
 public void study(){
 System.out.println("学习");
 }
 public void sleep(){
 System.out.println("子类sleep()方法");
 }
 
public static void main(String[] args) {
 Father f = new Inter();
 f.sleep();//向上转型---调用
 
 Person p=new Inter();
 p.eat(); //接口回调方法
 
 Teacher t = new Inter();
 t.teach(); //接口回调方法

}

@Override
public void eat() {
 System.out.println("重写eat()方法"); 
}

@Override
public void teach() {
 System.out.println("重写teache()方法"); 
 
}

}
 
interface Person{
 public void eat();
}
interface Teacher{
 public void teach();
}
class Father{
 public void sleep(){
 System.out.println("父类sleep()方法");
 }
}

运行结果

子类sleep()方法

重写eat()方法

重写teache()方法

总结:

使用接口方式,其目的应该是实现多个父类型的方法实现,强调一个多种实现,而向上造型,针对的是一对一的继承关系,向上造型后,可以调用子类的重写的方法。这就是我认为他们的区别。

补充知识: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 mlist = new ArrayList();
  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 的泛型,而不是放Thinkpad,Mouse,Keyboard,Phone等?

那么如果是List,肯定是放不进鼠标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();
  }

}

运行截图:

如何解决Java中向上造型向下造型和接口回调中的问题

举个例子分析就好

//开始测试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中向上造型向下造型和接口回调中的问题的所有内容,感谢各位的阅读!希望分享的内容对大家有帮助,更多相关知识,欢迎关注编程笔记行业资讯频道!


推荐阅读
  • 如何自行分析定位SAP BSP错误
    The“BSPtag”Imentionedintheblogtitlemeansforexamplethetagchtmlb:configCelleratorbelowwhichi ... [详细]
  • 在Android开发中,使用Picasso库可以实现对网络图片的等比例缩放。本文介绍了使用Picasso库进行图片缩放的方法,并提供了具体的代码实现。通过获取图片的宽高,计算目标宽度和高度,并创建新图实现等比例缩放。 ... [详细]
  • SpringBoot uri统一权限管理的实现方法及步骤详解
    本文详细介绍了SpringBoot中实现uri统一权限管理的方法,包括表结构定义、自动统计URI并自动删除脏数据、程序启动加载等步骤。通过该方法可以提高系统的安全性,实现对系统任意接口的权限拦截验证。 ... [详细]
  • Java容器中的compareto方法排序原理解析
    本文从源码解析Java容器中的compareto方法的排序原理,讲解了在使用数组存储数据时的限制以及存储效率的问题。同时提到了Redis的五大数据结构和list、set等知识点,回忆了作者大学时代的Java学习经历。文章以作者做的思维导图作为目录,展示了整个讲解过程。 ... [详细]
  • 本文讨论了一个关于cuowu类的问题,作者在使用cuowu类时遇到了错误提示和使用AdjustmentListener的问题。文章提供了16个解决方案,并给出了两个可能导致错误的原因。 ... [详细]
  • 1,关于死锁的理解死锁,我们可以简单的理解为是两个线程同时使用同一资源,两个线程又得不到相应的资源而造成永无相互等待的情况。 2,模拟死锁背景介绍:我们创建一个朋友 ... [详细]
  • XML介绍与使用的概述及标签规则
    本文介绍了XML的基本概念和用途,包括XML的可扩展性和标签的自定义特性。同时还详细解释了XML标签的规则,包括标签的尖括号和合法标识符的组成,标签必须成对出现的原则以及特殊标签的使用方法。通过本文的阅读,读者可以对XML的基本知识有一个全面的了解。 ... [详细]
  • 个人学习使用:谨慎参考1Client类importcom.thoughtworks.gauge.Step;importcom.thoughtworks.gauge.T ... [详细]
  • Java太阳系小游戏分析和源码详解
    本文介绍了一个基于Java的太阳系小游戏的分析和源码详解。通过对面向对象的知识的学习和实践,作者实现了太阳系各行星绕太阳转的效果。文章详细介绍了游戏的设计思路和源码结构,包括工具类、常量、图片加载、面板等。通过这个小游戏的制作,读者可以巩固和应用所学的知识,如类的继承、方法的重载与重写、多态和封装等。 ... [详细]
  • Mac OS 升级到11.2.2 Eclipse打不开了,报错Failed to create the Java Virtual Machine
    本文介绍了在Mac OS升级到11.2.2版本后,使用Eclipse打开时出现报错Failed to create the Java Virtual Machine的问题,并提供了解决方法。 ... [详细]
  • 本文介绍了如何在给定的有序字符序列中插入新字符,并保持序列的有序性。通过示例代码演示了插入过程,以及插入后的字符序列。 ... [详细]
  • JavaSE笔试题-接口、抽象类、多态等问题解答
    本文解答了JavaSE笔试题中关于接口、抽象类、多态等问题。包括Math类的取整数方法、接口是否可继承、抽象类是否可实现接口、抽象类是否可继承具体类、抽象类中是否可以有静态main方法等问题。同时介绍了面向对象的特征,以及Java中实现多态的机制。 ... [详细]
  • Spring特性实现接口多类的动态调用详解
    本文详细介绍了如何使用Spring特性实现接口多类的动态调用。通过对Spring IoC容器的基础类BeanFactory和ApplicationContext的介绍,以及getBeansOfType方法的应用,解决了在实际工作中遇到的接口及多个实现类的问题。同时,文章还提到了SPI使用的不便之处,并介绍了借助ApplicationContext实现需求的方法。阅读本文,你将了解到Spring特性的实现原理和实际应用方式。 ... [详细]
  • 本文详细介绍了Java中vector的使用方法和相关知识,包括vector类的功能、构造方法和使用注意事项。通过使用vector类,可以方便地实现动态数组的功能,并且可以随意插入不同类型的对象,进行查找、插入和删除操作。这篇文章对于需要频繁进行查找、插入和删除操作的情况下,使用vector类是一个很好的选择。 ... [详细]
  • Java学习笔记之面向对象编程(OOP)
    本文介绍了Java学习笔记中的面向对象编程(OOP)内容,包括OOP的三大特性(封装、继承、多态)和五大原则(单一职责原则、开放封闭原则、里式替换原则、依赖倒置原则)。通过学习OOP,可以提高代码复用性、拓展性和安全性。 ... [详细]
author-avatar
刻骨铭心2502914183_610
这个家伙很懒,什么也没留下!
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有