Java基础之面向对象机制底层实现的示例分析

这篇文章主要介绍Java基础之面向对象机制底层实现的示例分析，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！

Java的特点有哪些

Java的特点有哪些1.Java语言作为静态面向对象编程语言的代表，实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。2.Java具有简单性、面向对象、分布式、安全性、平台独立与可移植性、动态性等特点。3.使用Java可以编写桌面应用程序、WEB应用程序、分布式系统和嵌入式系统应用程序等。

一、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; 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);}}

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

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

五、重写

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

package test; public class DynamicDispatch {    static abstract class Animal{protected abstract void sayHello();}static class Bird extends Animal{ @Overrideprotected void sayHello() {System.out.println("Bird say hello");}}static class Eagle extends Animal{@Overrideprotected 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();}}

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

>javap -c DynamicDispatch.classCompiled 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$Bird."<init>":()V       7: astore_1       8: new           #4                  // class com/carmall/DynamicDispatch$Eagle      11: dup      12: invokespecial #5                  // Method com/carmall/DynamicDispatch$Eagle."<init>":()V      15: astore_2      16: aload_1      17: invokevirtual #6                  // Method com/carmall/DynamicDispatch$Animal.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.*;@Target(ElementType.METHOD)@Retention(RetentionPolicy.SOURCE)public @interface Override {}

以上是“Java基础之面向对象机制底层实现的示例分析”这篇文章的所有内容，感谢各位的阅读！希望分享的内容对大家有帮助，更多相关知识，欢迎关注编程网精选频道！