这篇文章主要介绍Java基础之面向对象机制底层实现的示例分析，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！
Java的特点有哪些 1.Java语言作为静态面向对象编程语言的代表，实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。 2.Java具有简单性、面向对象、分布式、安全性、平台独立与可移植性、动态性等特点。 3.使用Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。
为什么会产生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虚拟机中时分派的作用。分派又分为静态分派和动态分派，静态分派是指所有依赖静态类型来定位方法执行版本的分派动作，动态分派是指在运行期根据实际类型确定方法执行版本的分派过程。
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é
* @author Joshua Bloch
* @jls 9.6.1.4 @Override
* @since 1.5
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}以上是“Java基础之面向对象机制底层实现的示例分析”这篇文章的所有内容，感谢各位的阅读！希望分享的内容对大家有帮助，更多相关知识，欢迎关注亿速云行业资讯频道！
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
