Java基础之面向对象机制（多态、继承）底层实现

一、Java的前世

为什么会产生Java？Java的特点是什么？

从C语言开始讲，C语言是一种结构化语言，模块化编程，便于程序的调试，依靠非常全面的运算符和多样的数据类型，可以轻易完成各种数据结构的构建，通过指针类型更可对内存直接寻址以及对硬件进行直接操作，因此既能够用于开发系统程序，也可用于开发应用软件。其缺点就是封装性弱，程序的安全性上不是很好。C语言的异常处理一般使用setjmp()与longjmp()，在捕获到异常时进行跳转；或者使用abort()和exit()两个函数，强行终止程序的运行。如果要实现多线程，应该要直接操作底层操作系统，语言本身没有封装该机制。

C语言是一门面向过程的语言，所谓面向过程指的是以“事件过程”为中心的编程思想，即按照事件的解决步骤，在函数中一步一步实现。其实，生活中大部分事情都可以用面向过程的思想来解决。然而，当问题的规模变大，且问题中有多个部分是共同的特征时，我们仍然需要对这件事情建立一步一步操作，此时面向过程就显得繁重冗余，因此产生了面向对象的思想。

面向对象的思想是将事件中的一些共同特征抽象出来作为一个对象，一个对象包括属性和方法，比如说一个班级中的同学，大家都拥有姓名、成绩、年龄、兴趣爱好，在操作这些数据的时候，我们只需要将共同的部分抽象出来，然后给每个同学一个对象的实例。如果是面向过程的方法，我们需要为每一个同学定义属性变量，执行某个动作需要定义独立的方法。因此，产生了C++语言。

C++继承自C语言，可以进行面向过程的程序设计，也可以抽象化出对象进行基于对象的程序设计，也可以进行继承、多态为特点的面向对象的程序设计。在C++的面向对象设计中，将数据和相关操作封装在一个类中，类的实例为一个对象。支持面向对象开发的四个特性：封装、抽象、继承、多态。在C++语言中，内存分为堆（程序运行时分配内存）和栈（函数内部声明的变量）两部分，往往需要手动管理内存，通过new,delete动态划分内存并进行内存的回收；类中包含构造函数和析构函数，分别为建立对象和删除对象释放资源。

Java也是一门面向对象的语言，不仅吸收了C++的各种优点，同时摒弃了C++种难以理解的多继承、指针等概念，功能更加强大且简单易上手。其特点：简单、OOP、平台无关性（JVM的功劳）；相比于面向对象的语言C++而言，Java JVM的动态内存管理非常优秀。在发展的过程中，逐渐更新了更多强大的功能：XML支持、安全套接字soket支持、全新的I/O API、正则表达式、日志与断言；泛型、基本类型的自动装箱、改进的循环、枚举类型、格式化I/O及可变参数。

在C语言、C++、Java的演化过程中，并不会导致新语言取代旧语言，每种语言按照自身的特点有了自己适合的领域。如追求程序的性能和执行效率，如系统底层开发，就需要使用C++，甚至C语言；安卓开发、网站、嵌入式、大数据技术等领域，一般使用Java语言，由于其安全性、便携性、可移植性、可维护性等，很容易实现多线程，代码的可读性高。

C语言和C++是编译型的语言，而Java是解释型的语言：

• 编译型语言：程序在执行之前需要一个专门的编译过程，把程序编译成为机器语言的文件。

程序执行效率高，依赖编译器，跨平台性差

• 解释型语言：程序不需要编译，程序运行时才翻译成机器语言，每执行一次都要翻译一次。

效率比较低，依赖解释器，跨平台性好

Java是静态-强类型语言。

二、多态

多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作。

一般实现形式：

• 重载@Overload：同一类种方法名相同，参数不同；返回类型不要求
• 重写@Override：子类继承自父类的方法重写实现过程，返回值、形参不能变、只能重写函数体内的语句，便于子类根据自身需要定义自己的行为。Animal b = new Dog();
• 接口
• 抽象类、抽象方法

重写规则：

final，static方法不可被重写

参数列表：与被重写方法的参数列表必须完全相同

返回类型：与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类

访问权限：不能比父类中被重写的方法的访问权限更低（public > protected > private > ）

抛异常：如果父类方法抛异常，子类不能抛更广泛的异常

同包：除了private final可以重写所有父类方法

不同包：只能重写public 或者 protected的非final方法

子类中调用父类被重写方法可以用super.method()

三、Java中多态的底层实现

多态性特征的最基本体现有“重载”和“重写”，其实这两个体现在Java虚拟机中时分派的作用。分派又分为静态分派和动态分派，静态分派是指所有依赖静态类型来定位方法执行版本的分派动作，动态分派是指在运行期根据实际类型确定方法执行版本的分派过程。

 Animal animal = new Bird();

在上面代码中Animal是父类，Bird是继承Animal的子类；那么在定义animal对象时前面的“Animal”称为变量的静态类型（Static Type），或者叫外观类型（Apparent Type），后面的“Bird”则称为变量的实际类型（Actual Type），静态类型和实际类型在程序中都可以发生一些变化，区别是静态类型的变化仅仅在使用时发生，变量本身的静态类型不会被改变，并且最终的静态类型是在编译器可知的；而实际类型变化的结果在运行期才可以确定，编译器在编译程序的时候并不知道一个对象的实际对象是什么。

//实际类型变化
Animal bird = new Bird();
Animal eagle = new Eagle();
//静态类型变化
sd.sayHello((Bird)bird);
sd.sayHello((Eagle)eagle);

animal对象的静态类型是Animal，实际类型是Bird。静态类型在编译期可知，实际类型在运行时可知。

四、重载

同一个类中相同方法名的不同方法。

重载，使用哪个重载版本，就完全取决于传入参数的数量和数据类型。
方法重载是通过静态分派实现的，静态分派是发生在编译阶段，因此匹配到静态类型Animal。

例如下面代码：

package test;
 
/**
* @Description: 方法静态分派演示
* @version: v1.0.0
 */
public class StaticDispatch {
    
	static abstract class Animal{ }
	
	static class Bird extends Animal{ }
	
	static class Eagle extends Animal{ }
	
	public void sayHello(Animal animal) {
		System.out.println("hello,animal");
	}
	
	public void sayHello(Bird bird) {
		System.out.println("hello,I'm bird");
	}
	
	public void sayHello(Eagle eagle) {
		System.out.println("hello,I'm eagle");
	}
	
	public static void main(String[] args){
	    Animal bird = new Bird(); // 静态类型Animal（编译期可知）--实际类型Bird（运行期可知）
	    Animal eagle = new Eagle(); // 静态类型Animal（编译期可知）--实际类型Eagle（运行期可知）
	    StaticDispatch sd = new StaticDispatch();
	    sd.sayHello(bird);
	    sd.sayHello(eagle);
	}
}
/* 结果：
hello,animal
hello,animal
*/

代码中刻意地定义了两个静态类型相同Animal，实际类型不同的变量，但虚拟机(准确的是编译器)在重载时是通过参数的静态类型而不是实际类型来作为判断依据的。并且静态类型是编译期可知的，因此，在编译阶段，Javac编译器会根据参数的静态类型决定使用哪个重载版本，因此选择了sayHello(Animal)作为调用目标。

方法重载是通过静态分派实现的，并且静态分派是发生在编译阶段，所以确定静态分派的动作实际上不是由虚拟机来执行的；另外，编译器虽然能确定出方法重载的版本，但在很多情况下这个版本并不是“唯一的”,往往只能确定一个“更加适合”的版本。

五、重写

方法的重写：与虚拟机中动态分派的过程有着密切联系。

package test;
 
/**
* @Description: 方法动态分派演示
* @version: v1.0.0
 */
public class DynamicDispatch {
    
	static abstract class Animal{
		protected abstract void sayHello();
	}
	
	static class Bird extends Animal{
 
		@Override
		protected void sayHello() {
			System.out.println("Bird say hello");
		}
		
	}
	
	static class Eagle extends Animal{
		@Override
		protected void sayHello() {
			System.out.println("Eagle say hello");
		}
		
	}
	
	public static void main(String[] args){
	    Animal bird = new Bird();
	    Animal eagle = new Eagle();
	    bird.sayHello();
	    eagle.sayHello();
	    bird = new Eagle();
	    bird.sayHello();
	}
}

/* 结果：
Bird say hello
Eagle say hello
Eagle say hello
*/

通过javap反编译命令来看一段该代码的字节码：

>javap -c DynamicDispatch.class
Compiled from "DynamicDispatch.java"
public class com.carmall.DynamicDispatch {
  public com.carmall.DynamicDispatch();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class com/carmall/DynamicDispatch$Bird

       3: dup
       4: invokespecial #3                  // Method com/carmall/DynamicDispatch$Bir
d."<init>":()V
       7: astore_1
       8: new           #4                  // class com/carmall/DynamicDispatch$Eagl
e
      11: dup
      12: invokespecial #5                  // Method com/carmall/DynamicDispatch$Eag
le."<init>":()V
      15: astore_2
      16: aload_1
      17: invokevirtual #6                  // Method com/carmall/DynamicDispatch$Ani
mal.sayHello:()V
      20: aload_2
      21: invokevirtual #6                  // Method com/carmall/DynamicDispatch$Animal.sayHello:()V
      24: new           #4                  // class com/carmall/DynamicDispatch$Eagle
      27: dup
      28: invokespecial #5                  // Method com/carmall/DynamicDispatch$Eagle."<init>":()V
      31: astore_1
      32: aload_1
      33: invokevirtual #6                  // Method com/carmall/DynamicDispatch$Animal.sayHello:()V
      36: return
}

上面的指令，invokevirtual表示运行时按照对象的类来调用实例方法；invokespecial根据编译时类型来调用实例方法，也就是会调用父类。

0~15行的字节码是准备动作，作用时建立bird和eagle的内存空间、调用Bird和Eagle类型的实例构造器，将这两个实例的引用存放在第1、2个局部变量表Slot之中。

接下来的16~21行时关键部分；这部分把刚刚创建的两个对象的引用压到栈顶，这两个对象是将要执行的sayHello()方法的所有者，称为接收者(Receiver)；17和21句是方法调用命令，这两条调用命令单从字节码角度来看，无论是指令(invokevirtual)还是参数(都是常量池中第6项的常量，注释显示了这个常量是sayHello方法的符号引用)完全一样的，但是这两句执行的目标方法并不同，这是因为invokevirtual指令的多态查找过程引起的，该指令运行时的解析过程可分为以下几个步骤：

• 找到操作数栈第一个元素所指向的对象的实际类型，记为C。如果在类型C中找到了与常量中描述符和简单名称都一样的方法，则进行访问权限校验，如果通过则返回该方法的的直接引用，查找过程结束；如果不通过，则返回java.lang.IllegalAccessError异常。
• 否则，按照继承关系从下往上一次对C的各个父类进行第二步的搜索和验证过程。
• 如果始终都没有找到合适的方法，则抛出java.lang.AbstractMethodError异常。
• 由于invokevirtual指令执行的第一步就是在运行期确定接收者的实际类型，所以两次调用的invokevirtual指令把常量池中的类方法符号引用解析到了不同的直接引用上，这个过程就是Java语言中重写的本质。

package java.lang;

import java.lang.annotation.*;

/**
 * Indicates that a method declaration is intended to override a
 * method declaration in a supertype. If a method is annotated with
 * this annotation type compilers are required to generate an error
 * message unless at least one of the following conditions hold:
 *
 * <ul><li>
 * The method does override or implement a method declared in a
 * supertype.
 * </li><li>
 * The method has a signature that is override-equivalent to that of
 * any public method declared in {@linkplain Object}.
 * </li></ul>
 *
 * @author  Peter von der Ah&eacute;
 * @author  Joshua Bloch
 * @jls 9.6.1.4 @Override
 * @since 1.5
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

到此这篇关于Java基础之面向对象机制（多态、继承）底层实现的文章就介绍到这了,更多相关Java面向对象机制底层实现内容请搜索猪先飞以前的文章或继续浏览下面的相关文章希望大家以后多多支持猪先飞！