浅谈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<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中向上造型向下造型和接口回调中的问题就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持。