mirror of
https://github.com/Snailclimb/JavaGuide
synced 2025-06-20 22:17:09 +08:00
SnailClimb
GitHub
commit
6b9d7b4c0f
@ -1,78 +1,32 @@
|
|||||||
点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java 面试突击》以及 Java 工程师必备学习资源。
|
点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java 面试突击》以及 Java 工程师必备学习资源。
|
||||||
<!-- TOC -->
|
<!-- TOC -->
|
||||||
|
|
||||||
- [1. 面向对象和面向过程的区别](#1-面向对象和面向过程的区别)
|
- [1. Java基本功](#1-Java基本功)
|
||||||
- [2. Java 语言有哪些特点?](#2-java-语言有哪些特点)
|
- [1.1 Java入门（基础概念与常识）](#1.1Java入门（基础概念与常识）)
|
||||||
- [3. 关于 JVM JDK 和 JRE 最详细通俗的解答](#3-关于-jvm-jdk-和-jre-最详细通俗的解答)
|
- [1.2 Java语法](#1.2Java语法)
|
||||||
- [JVM](#jvm)
|
- [1.3 Java流程控制](#1.3Java流程控制)
|
||||||
- [JDK 和 JRE](#jdk-和-jre)
|
- [1.4 数组](#1.4数组)
|
||||||
- [4. Oracle JDK 和 OpenJDK 的对比](#4-oracle-jdk-和-openjdk-的对比)
|
- [1.5 方法（函数）](#1.5方法（函数）)
|
||||||
- [5. Java 和 C++的区别?](#5-java-和-c的区别)
|
|
||||||
- [6. 什么是 Java 程序的主类 应用程序和小程序的主类有何不同?](#6-什么是-java-程序的主类-应用程序和小程序的主类有何不同)
|
- [2. Java面向对象](#2-Java面向对象)
|
||||||
- [7. Java 应用程序与小程序之间有哪些差别?](#7-java-应用程序与小程序之间有哪些差别)
|
- [2.1 类和对象](#2.1类和对象)
|
||||||
- [8. 字符型常量和字符串常量的区别?](#8-字符型常量和字符串常量的区别)
|
- [2.2 面向对象三大特征](#2.2面向对象三大特征)
|
||||||
- [9. 构造器 Constructor 是否可被 override?](#9-构造器-constructor-是否可被-override)
|
- [2.3 修饰符](#2.3修饰符)
|
||||||
- [10. 重载和重写的区别](#10-重载和重写的区别)
|
- [2.4 接口](#2.4接口)
|
||||||
- [重载](#重载)
|
- [2.5 类的扩展](#2.5类的扩展)
|
||||||
- [重写](#重写)
|
- [3. Java核心技术](#3-关于-jvm-jdk-和-jre-最详细通俗的解答)
|
||||||
- [11. Java 面向对象编程三大特性: 封装 继承 多态](#11-java-面向对象编程三大特性-封装-继承-多态)
|
- [3.1 集合](#3.1集合)
|
||||||
- [封装](#封装)
|
- [3.2 异常](#3.2异常)
|
||||||
- [继承](#继承)
|
- [3.3 多线程](#3.3多线程)
|
||||||
- [多态](#多态)
|
- [3.4 文件与I\O流](#3.4文件与I\O流)
|
||||||
- [12. String StringBuffer 和 StringBuilder 的区别是什么? String 为什么是不可变的?](#12-string-stringbuffer-和-stringbuilder-的区别是什么-string-为什么是不可变的)
|
- [【附录】参考](#参考)
|
||||||
- [13. 自动装箱与拆箱](#13-自动装箱与拆箱)
|
- [【附录】公众号](#公众号)
|
||||||
- [14. 在一个静态方法内调用一个非静态成员为什么是非法的?](#14-在一个静态方法内调用一个非静态成员为什么是非法的)
|
|
||||||
- [15. 在 Java 中定义一个不做事且没有参数的构造方法的作用](#15-在-java-中定义一个不做事且没有参数的构造方法的作用)
|
|
||||||
- [16. import java 和 javax 有什么区别？](#16-import-java-和-javax-有什么区别)
|
|
||||||
- [17. 接口和抽象类的区别是什么？](#17-接口和抽象类的区别是什么)
|
|
||||||
- [18. 成员变量与局部变量的区别有哪些？](#18-成员变量与局部变量的区别有哪些)
|
|
||||||
- [19. 创建一个对象用什么运算符?对象实体与对象引用有何不同?](#19-创建一个对象用什么运算符对象实体与对象引用有何不同)
|
|
||||||
- [20. 什么是方法的返回值?返回值在类的方法里的作用是什么?](#20-什么是方法的返回值返回值在类的方法里的作用是什么)
|
|
||||||
- [21. 一个类的构造方法的作用是什么? 若一个类没有声明构造方法，该程序能正确执行吗? 为什么?](#21-一个类的构造方法的作用是什么-若一个类没有声明构造方法该程序能正确执行吗-为什么)
|
|
||||||
- [22. 构造方法有哪些特性？](#22-构造方法有哪些特性)
|
|
||||||
- [23. 静态方法和实例方法有何不同](#23-静态方法和实例方法有何不同)
|
|
||||||
- [24. 对象的相等与指向他们的引用相等,两者有什么不同?](#24-对象的相等与指向他们的引用相等两者有什么不同)
|
|
||||||
- [25. 在调用子类构造方法之前会先调用父类没有参数的构造方法,其目的是?](#25-在调用子类构造方法之前会先调用父类没有参数的构造方法其目的是)
|
|
||||||
- [26. == 与 equals(重要)](#26--与-equals重要)
|
|
||||||
- [27. hashCode 与 equals (重要)](#27-hashcode-与-equals-重要)
|
|
||||||
- [hashCode（）介绍](#hashcode介绍)
|
|
||||||
- [为什么要有 hashCode](#为什么要有-hashcode)
|
|
||||||
- [hashCode（）与 equals（）的相关规定](#hashcode与-equals的相关规定)
|
|
||||||
- [28. 为什么 Java 中只有值传递？](#28-为什么-java-中只有值传递)
|
|
||||||
- [29. 简述线程、程序、进程的基本概念。以及他们之间关系是什么?](#29-简述线程程序进程的基本概念以及他们之间关系是什么)
|
|
||||||
- [30. 线程有哪些基本状态?](#30-线程有哪些基本状态)
|
|
||||||
- [31 关于 final 关键字的一些总结](#31-关于-final-关键字的一些总结)
|
|
||||||
- [32 Java 中的异常处理](#32-java-中的异常处理)
|
|
||||||
- [Java 异常类层次结构图](#java-异常类层次结构图)
|
|
||||||
- [Throwable 类常用方法](#throwable-类常用方法)
|
|
||||||
- [异常处理总结](#异常处理总结)
|
|
||||||
- [33 Java 序列化中如果有些字段不想进行序列化，怎么办？](#33-java-序列化中如果有些字段不想进行序列化怎么办)
|
|
||||||
- [34 获取用键盘输入常用的两种方法](#34-获取用键盘输入常用的两种方法)
|
|
||||||
- [35 Java 中 IO 流](#35-java-中-io-流)
|
|
||||||
- [Java 中 IO 流分为几种?](#java-中-io-流分为几种)
|
|
||||||
- [既然有了字节流,为什么还要有字符流?](#既然有了字节流为什么还要有字符流)
|
|
||||||
- [BIO,NIO,AIO 有什么区别?](#bionioaio-有什么区别)
|
|
||||||
- [36. 常见关键字总结:static,final,this,super](#36-常见关键字总结staticfinalthissuper)
|
|
||||||
- [37. Collections 工具类和 Arrays 工具类常见方法总结](#37-collections-工具类和-arrays-工具类常见方法总结)
|
|
||||||
- [38. 深拷贝 vs 浅拷贝](#38-深拷贝-vs-浅拷贝)
|
|
||||||
- [参考](#参考)
|
|
||||||
- [公众号](#公众号)
|
|
||||||
|
|
||||||
<!-- /TOC -->
|
<!-- /TOC -->
|
||||||
|
|
||||||
|
## 1. Java基本功
|
||||||
## 1. 面向对象和面向过程的区别
|
### 1.1 Java入门（基础概念与常识）
|
||||||
|
#### 1.1.1 Java 语言有哪些特点?
|
||||||
- **面向过程** ：**面向过程性能比面向对象高。** 因为类调用时需要实例化，开销比较大，比较消耗资源，所以当性能是最重要的考量因素的时候，比如单片机、嵌入式开发、Linux/Unix 等一般采用面向过程开发。但是，**面向过程没有面向对象易维护、易复用、易扩展。**
|
|
||||||
- **面向对象** ：**面向对象易维护、易复用、易扩展。** 因为面向对象有封装、继承、多态性的特性，所以可以设计出低耦合的系统，使系统更加灵活、更加易于维护。但是，**面向对象性能比面向过程低**。
|
|
||||||
|
|
||||||
参见 issue : [面向过程 ：面向过程性能比面向对象高？？](https://github.com/Snailclimb/JavaGuide/issues/431)
|
|
||||||
|
|
||||||
> 这个并不是根本原因，面向过程也需要分配内存，计算内存偏移量，Java 性能差的主要原因并不是因为它是面向对象语言，而是 Java 是半编译语言，最终的执行代码并不是可以直接被 CPU 执行的二进制机器码。
|
|
||||||
>
|
|
||||||
> 而面向过程语言大多都是直接编译成机器码在电脑上执行，并且其它一些面向过程的脚本语言性能也并不一定比 Java 好。
|
|
||||||
|
|
||||||
## 2. Java 语言有哪些特点?
|
|
||||||
|
|
||||||
1. 简单易学；
|
1. 简单易学；
|
||||||
2. 面向对象（封装，继承，多态）；
|
2. 面向对象（封装，继承，多态）；
|
||||||
@ -85,9 +39,9 @@
|
|||||||
|
|
||||||
> 修正（参见： [issue#544](https://github.com/Snailclimb/JavaGuide/issues/544)）：C++11 开始（2011 年的时候）,C++就引入了多线程库，在 windows、linux、macos 都可以使用`std::thread`和`std::async`来创建线程。参考链接：http://www.cplusplus.com/reference/thread/thread/?kw=thread
|
> 修正（参见： [issue#544](https://github.com/Snailclimb/JavaGuide/issues/544)）：C++11 开始（2011 年的时候）,C++就引入了多线程库，在 windows、linux、macos 都可以使用`std::thread`和`std::async`来创建线程。参考链接：http://www.cplusplus.com/reference/thread/thread/?kw=thread
|
||||||
|
|
||||||
## 3. 关于 JVM JDK 和 JRE 最详细通俗的解答
|
#### 1.1.2 关于 JVM JDK 和 JRE 最详细通俗的解答
|
||||||
|
|
||||||
### JVM
|
##### JVM
|
||||||
|
|
||||||
Java 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。
|
Java 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。
|
||||||
|
|
||||||
@ -107,7 +61,7 @@ Java 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不
|
|||||||
|
|
||||||
Java 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。
|
Java 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。
|
||||||
|
|
||||||
### JDK 和 JRE
|
##### JDK 和 JRE
|
||||||
|
|
||||||
JDK 是 Java Development Kit，它是功能齐全的 Java SDK。它拥有 JRE 所拥有的一切，还有编译器（javac）和工具（如 javadoc 和 jdb）。它能够创建和编译程序。
|
JDK 是 Java Development Kit，它是功能齐全的 Java SDK。它拥有 JRE 所拥有的一切，还有编译器（javac）和工具（如 javadoc 和 jdb）。它能够创建和编译程序。
|
||||||
|
|
||||||
@ -115,7 +69,7 @@ JRE 是 Java 运行时环境。它是运行已编译 Java 程序所需的所有
|
|||||||
|
|
||||||
如果你只是为了运行一下 Java 程序的话，那么你只需要安装 JRE 就可以了。如果你需要进行一些 Java 编程方面的工作，那么你就需要安装 JDK 了。但是，这不是绝对的。有时，即使您不打算在计算机上进行任何 Java 开发，仍然需要安装 JDK。例如，如果要使用 JSP 部署 Web 应用程序，那么从技术上讲，您只是在应用程序服务器中运行 Java 程序。那你为什么需要 JDK 呢？因为应用程序服务器会将 JSP 转换为 Java servlet，并且需要使用 JDK 来编译 servlet。
|
如果你只是为了运行一下 Java 程序的话，那么你只需要安装 JRE 就可以了。如果你需要进行一些 Java 编程方面的工作，那么你就需要安装 JDK 了。但是，这不是绝对的。有时，即使您不打算在计算机上进行任何 Java 开发，仍然需要安装 JDK。例如，如果要使用 JSP 部署 Web 应用程序，那么从技术上讲，您只是在应用程序服务器中运行 Java 程序。那你为什么需要 JDK 呢？因为应用程序服务器会将 JSP 转换为 Java servlet，并且需要使用 JDK 来编译 servlet。
|
||||||
|
|
||||||
## 4. Oracle JDK 和 OpenJDK 的对比
|
#### 1.1.3 Oracle JDK 和 OpenJDK 的对比
|
||||||
|
|
||||||
可能在看这个问题之前很多人和我一样并没有接触和使用过 OpenJDK 。那么 Oracle 和 OpenJDK 之间是否存在重大差异？下面我通过收集到的一些资料，为你解答这个被很多人忽视的问题。
|
可能在看这个问题之前很多人和我一样并没有接触和使用过 OpenJDK 。那么 Oracle 和 OpenJDK 之间是否存在重大差异？下面我通过收集到的一些资料，为你解答这个被很多人忽视的问题。
|
||||||
|
|
||||||
@ -134,7 +88,7 @@ JRE 是 Java 运行时环境。它是运行已编译 Java 程序所需的所有
|
|||||||
5. Oracle JDK 不会为即将发布的版本提供长期支持，用户每次都必须通过更新到最新版本获得支持来获取最新版本；
|
5. Oracle JDK 不会为即将发布的版本提供长期支持，用户每次都必须通过更新到最新版本获得支持来获取最新版本；
|
||||||
6. Oracle JDK 根据二进制代码许可协议获得许可，而 OpenJDK 根据 GPL v2 许可获得许可。
|
6. Oracle JDK 根据二进制代码许可协议获得许可，而 OpenJDK 根据 GPL v2 许可获得许可。
|
||||||
|
|
||||||
## 5. Java 和 C++的区别?
|
#### 1.1.4 Java 和 C++的区别?
|
||||||
|
|
||||||
我知道很多人没学过 C++，但是面试官就是没事喜欢拿咱们 Java 和 C++ 比呀！没办法！！！就算没学过 C++，也要记下来！
|
我知道很多人没学过 C++，但是面试官就是没事喜欢拿咱们 Java 和 C++ 比呀！没办法！！！就算没学过 C++，也要记下来！
|
||||||
|
|
||||||
@ -144,15 +98,22 @@ JRE 是 Java 运行时环境。它是运行已编译 Java 程序所需的所有
|
|||||||
- Java 有自动内存管理机制，不需要程序员手动释放无用内存
|
- Java 有自动内存管理机制，不需要程序员手动释放无用内存
|
||||||
- **在 C 语言中，字符串或字符数组最后都会有一个额外的字符‘\0’来表示结束。但是，Java 语言中没有结束符这一概念。** 这是一个值得深度思考的问题，具体原因推荐看这篇文章： [https://blog.csdn.net/sszgg2006/article/details/49148189](https://blog.csdn.net/sszgg2006/article/details/49148189)
|
- **在 C 语言中，字符串或字符数组最后都会有一个额外的字符‘\0’来表示结束。但是，Java 语言中没有结束符这一概念。** 这是一个值得深度思考的问题，具体原因推荐看这篇文章： [https://blog.csdn.net/sszgg2006/article/details/49148189](https://blog.csdn.net/sszgg2006/article/details/49148189)
|
||||||
|
|
||||||
## 6. 什么是 Java 程序的主类 应用程序和小程序的主类有何不同?
|
#### 1.1.5 什么是 Java 程序的主类 应用程序和小程序的主类有何不同?
|
||||||
|
|
||||||
一个程序中可以有多个类，但只能有一个类是主类。在 Java 应用程序中，这个主类是指包含 main（）方法的类。而在 Java 小程序中，这个主类是一个继承自系统类 JApplet 或 Applet 的子类。应用程序的主类不一定要求是 public 类，但小程序的主类要求必须是 public 类。主类是 Java 程序执行的入口点。
|
一个程序中可以有多个类，但只能有一个类是主类。在 Java 应用程序中，这个主类是指包含 main（）方法的类。而在 Java 小程序中，这个主类是一个继承自系统类 JApplet 或 Applet 的子类。应用程序的主类不一定要求是 public 类，但小程序的主类要求必须是 public 类。主类是 Java 程序执行的入口点。
|
||||||
|
|
||||||
## 7. Java 应用程序与小程序之间有哪些差别?
|
#### 1.1.6 Java 应用程序与小程序之间有哪些差别?
|
||||||
|
|
||||||
简单说应用程序是从主线程启动(也就是 `main()` 方法)。applet 小程序没有 `main()` 方法，主要是嵌在浏览器页面上运行(调用`init()`或者`run()`来启动)，嵌入浏览器这点跟 flash 的小游戏类似。
|
简单说应用程序是从主线程启动(也就是 `main()` 方法)。applet 小程序没有 `main()` 方法，主要是嵌在浏览器页面上运行(调用`init()`或者`run()`来启动)，嵌入浏览器这点跟 flash 的小游戏类似。
|
||||||
|
|
||||||
## 8. 字符型常量和字符串常量的区别?
|
#### 1.1.7 import java 和 javax 有什么区别？
|
||||||
|
|
||||||
|
刚开始的时候 JavaAPI 所必需的包是 java 开头的包，javax 当时只是扩展 API 包来使用。然而随着时间的推移，javax 逐渐地扩展成为 Java API 的组成部分。但是，将扩展从 javax 包移动到 java 包确实太麻烦了，最终会破坏一堆现有的代码。因此，最终决定 javax 包将成为标准 API 的一部分。
|
||||||
|
|
||||||
|
所以，实际上 java 和 javax 没有区别。这都是一个名字。
|
||||||
|
|
||||||
|
### 1.2 Java语法
|
||||||
|
#### 1.2.1 字符型常量和字符串常量的区别?
|
||||||
|
|
||||||
1. 形式上: 字符常量是单引号引起的一个字符; 字符串常量是双引号引起的若干个字符
|
1. 形式上: 字符常量是单引号引起的一个字符; 字符串常量是双引号引起的若干个字符
|
||||||
2. 含义上: 字符常量相当于一个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置)
|
2. 含义上: 字符常量相当于一个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置)
|
||||||
@ -160,18 +121,24 @@ JRE 是 Java 运行时环境。它是运行已编译 Java 程序所需的所有
|
|||||||
|
|
||||||
> java 编程思想第四版：2.2.2 节
|
> java 编程思想第四版：2.2.2 节
|
||||||
> 
|
> 
|
||||||
|
### 1.3 Java流程控制
|
||||||
|
### 1.4 数组
|
||||||
|
### 1.5 方法（函数）
|
||||||
|
#### 1.5.1 什么是方法的返回值?返回值在类的方法里的作用是什么?
|
||||||
|
|
||||||
## 9. 构造器 Constructor 是否可被 override?
|
方法的返回值是指我们获取到的某个方法体中的代码执行后产生的结果！（前提是该方法可能产生结果）。返回值的作用:接收出结果，使得它可以用于其他的操作！
|
||||||
|
|
||||||
Constructor 不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况。
|
#### 1.5.2 为什么 Java 中只有值传递？
|
||||||
|
|
||||||
## 10. 重载和重写的区别
|
[为什么 Java 中只有值传递？](https://juejin.im/post/5e18879e6fb9a02fc63602e2)
|
||||||
|
|
||||||
|
#### 1.5.3 重载和重写的区别
|
||||||
|
|
||||||
> 重载就是同样的一个方法能够根据输入数据的不同，做出不同的处理
|
> 重载就是同样的一个方法能够根据输入数据的不同，做出不同的处理
|
||||||
>
|
>
|
||||||
> 重写就是当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法
|
> 重写就是当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法
|
||||||
|
|
||||||
#### 重载
|
###### 重载
|
||||||
|
|
||||||
发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同。
|
发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同。
|
||||||
|
|
||||||
@ -181,7 +148,7 @@ Constructor 不能被 override（重写）,但是可以 overload（重载）,所
|
|||||||
|
|
||||||
**综上：重载就是同一个类中多个同名方法根据不同的传参来执行不同的逻辑处理。**
|
**综上：重载就是同一个类中多个同名方法根据不同的传参来执行不同的逻辑处理。**
|
||||||
|
|
||||||
#### 重写
|
###### 重写
|
||||||
|
|
||||||
重写发生在运行期，是子类对父类的允许访问的方法的实现过程进行重新编写。
|
重写发生在运行期，是子类对父类的允许访问的方法的实现过程进行重新编写。
|
||||||
|
|
||||||
@ -202,15 +169,98 @@ Constructor 不能被 override（重写）,但是可以 overload（重载）,所
|
|||||||
| 访问修饰符 | 可修改 | 一定不能做更严格的限制（可以降低限制） |
|
| 访问修饰符 | 可修改 | 一定不能做更严格的限制（可以降低限制） |
|
||||||
| 发生阶段 | 编译期 | 运行期 |
|
| 发生阶段 | 编译期 | 运行期 |
|
||||||
|
|
||||||
## 11. Java 面向对象编程三大特性: 封装 继承 多态
|
#### 1.5.4 深拷贝 vs 浅拷贝
|
||||||
|
|
||||||
### 封装
|
1. **浅拷贝**：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。
|
||||||
|
2. **深拷贝**：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。
|
||||||
|
|
||||||
封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如果属性不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。
|
|
||||||
|
|
||||||
### 继承
|
## 2. Java面向对象
|
||||||
|
### 2.1 类和对象
|
||||||
|
#### 2.1.1 面向对象和面向过程的区别
|
||||||
|
|
||||||
继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码。
|
- **面向过程** ：**面向过程性能比面向对象高。** 因为类调用时需要实例化，开销比较大，比较消耗资源，所以当性能是最重要的考量因素的时候，比如单片机、嵌入式开发、Linux/Unix 等一般采用面向过程开发。但是，**面向过程没有面向对象易维护、易复用、易扩展。**
|
||||||
|
- **面向对象** ：**面向对象易维护、易复用、易扩展。** 因为面向对象有封装、继承、多态性的特性，所以可以设计出低耦合的系统，使系统更加灵活、更加易于维护。但是，**面向对象性能比面向过程低**。
|
||||||
|
|
||||||
|
参见 issue : [面向过程 ：面向过程性能比面向对象高？？](https://github.com/Snailclimb/JavaGuide/issues/431)
|
||||||
|
|
||||||
|
> 这个并不是根本原因，面向过程也需要分配内存，计算内存偏移量，Java 性能差的主要原因并不是因为它是面向对象语言，而是 Java 是半编译语言，最终的执行代码并不是可以直接被 CPU 执行的二进制机械码。
|
||||||
|
>
|
||||||
|
> 而面向过程语言大多都是直接编译成机械码在电脑上执行，并且其它一些面向过程的脚本语言性能也并不一定比 Java 好。
|
||||||
|
|
||||||
|
#### 2.1.2 构造器 Constructor 是否可被 override?
|
||||||
|
|
||||||
|
Constructor 不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况。
|
||||||
|
|
||||||
|
#### 2.1.3 在 Java 中定义一个不做事且没有参数的构造方法的作用
|
||||||
|
|
||||||
|
Java 程序在执行子类的构造方法之前，如果没有用 `super()`来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 `super()`来调用父类中特定的构造方法，则编译时将发生错误，因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。
|
||||||
|
|
||||||
|
#### 2.1.4 成员变量与局部变量的区别有哪些？
|
||||||
|
|
||||||
|
1. 从语法形式上看:成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。
|
||||||
|
2. 从变量在内存中的存储方式来看:如果成员变量是使用`static`修饰的，那么这个成员变量是属于类的，如果没有使用`static`修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
|
||||||
|
3. 从变量在内存中的生存时间上看:成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。
|
||||||
|
4. 成员变量如果没有被赋初值:则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。
|
||||||
|
|
||||||
|
#### 2.1.5 创建一个对象用什么运算符?对象实体与对象引用有何不同?
|
||||||
|
|
||||||
|
new 运算符，new 创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。一个对象引用可以指向 0 个或 1 个对象（一根绳子可以不系气球，也可以系一个气球）;一个对象可以有 n 个引用指向它（可以用 n 条绳子系住一个气球）。
|
||||||
|
|
||||||
|
#### 2.1.6 一个类的构造方法的作用是什么? 若一个类没有声明构造方法，该程序能正确执行吗? 为什么?
|
||||||
|
|
||||||
|
主要作用是完成对类对象的初始化工作。可以执行。因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。如果我们自己添加了类的构造方法（无论是否有参），Java就不会再添加默认的无参数的构造方法了，这时候，就不能直接new一个对象而不传递参数了，所以我们一直在不知不觉地使用构造方法，这也是为什么我们在创建对象的时候后面要加一个括号（因为要调用无参的构造方法）。如果我们重载了有参的构造方法，记得都要把无参的构造方法也写出来（无论是否用到），因为这可以帮助我们在创建对象的时候少踩坑。
|
||||||
|
|
||||||
|
#### 2.1.7 构造方法有哪些特性？
|
||||||
|
|
||||||
|
1. 名字与类名相同。
|
||||||
|
2. 没有返回值，但不能用 void 声明构造函数。
|
||||||
|
3. 生成类的对象时自动执行，无需调用。
|
||||||
|
|
||||||
|
#### 2.1.8 在调用子类构造方法之前会先调用父类没有参数的构造方法,其目的是?
|
||||||
|
|
||||||
|
帮助子类做初始化工作。
|
||||||
|
|
||||||
|
#### 2.1.9 对象的相等与指向他们的引用相等,两者有什么不同?
|
||||||
|
|
||||||
|
对象的相等，比的是内存中存放的内容是否相等。而引用相等，比较的是他们指向的内存地址是否相等。
|
||||||
|
|
||||||
|
### 2.2 面向对象三大特征
|
||||||
|
|
||||||
|
#### 2.2.1 封装
|
||||||
|
封装是指把一个对象的状态信息（也就是属性）隐藏在对象内部，不允许外部对象直接访问对象的内部信息。但是可以提供一些可以被外界访问的方法来操作属性。就好像我们看不到挂在墙上的空调的内部的零件信息（也就是属性），但是可以通过遥控器（方法）来控制空调。如果属性不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。就好像如果没有空调遥控器，那么我们就无法操控空凋制冷，空调本身就没有意义了（当然现在还有很多其他方法 ，这里只是为了举例子）。
|
||||||
|
|
||||||
|
```java
|
||||||
|
public class Student {
|
||||||
|
private int id;//id属性私有化
|
||||||
|
private String name;//name属性私有化
|
||||||
|
|
||||||
|
//获取id的方法
|
||||||
|
public int getId() {
|
||||||
|
return id;
|
||||||
|
}
|
||||||
|
|
||||||
|
//设置id的方法
|
||||||
|
public void setId(int id) {
|
||||||
|
this.id = id;
|
||||||
|
}
|
||||||
|
|
||||||
|
//获取name的方法
|
||||||
|
public String getName() {
|
||||||
|
return name;
|
||||||
|
}
|
||||||
|
|
||||||
|
//设置name的方法
|
||||||
|
public void setName(String name) {
|
||||||
|
this.name = name;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
#### 2.2.2 继承
|
||||||
|
|
||||||
|
不同类型的对象，相互之间经常有一定数量的共同点。例如，小明同学、小红同学、小李同学，都共享学生的特性（班级、学号等）。同时，每一个对象还定义了额外的特性使得他们与众不同。例如小明的数学比较好，小红的性格惹人喜爱；小李的力气比较大。继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承，可以快速地创建新的类，可以提高代码的重用，程序的可维护性，节省大量创建新类的时间 ，提高我们的开发效率。
|
||||||
|
|
||||||
**关于继承如下 3 点请记住：**
|
**关于继承如下 3 点请记住：**
|
||||||
|
|
||||||
@ -218,15 +268,64 @@ Constructor 不能被 override（重写）,但是可以 overload（重载）,所
|
|||||||
2. 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
|
2. 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
|
||||||
3. 子类可以用自己的方式实现父类的方法。（以后介绍）。
|
3. 子类可以用自己的方式实现父类的方法。（以后介绍）。
|
||||||
|
|
||||||
### 多态
|
#### 2.2.3 多态
|
||||||
|
多态，顾名思义，表示一个对象具有多种的状态。具体表现为父类的引用指向子类的实例。
|
||||||
|
|
||||||
所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。
|
**多态的特点:**
|
||||||
|
|
||||||
在 Java 中有两种形式可以实现多态：继承（多个子类对同一方法的重写）和接口（实现接口并覆盖接口中同一方法）。
|
- 对象类型和引用类型之间具有继承（类）/实现（接口）的关系；
|
||||||
|
- 对象类型不可变，引用类型可变；
|
||||||
|
- 方法具有多态性，属性不具有多态性；
|
||||||
|
- 引用类型变量发出的方法调用的到底是哪个类中的方法，必须在程序运行期间才能确定；
|
||||||
|
- 多态不能调用“只在子类存在但在父类不存在”的方法；
|
||||||
|
- 如果子类重写了父类的方法，真正执行的是子类覆盖的方法，如果子类没有覆盖父类的方法，执行的是父类的方法。
|
||||||
|
|
||||||
## 12. String StringBuffer 和 StringBuilder 的区别是什么? String 为什么是不可变的?
|
### 2.3 修饰符
|
||||||
|
#### 2.3.1 在一个静态方法内调用一个非静态成员为什么是非法的?
|
||||||
|
|
||||||
**可变性**
|
由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。
|
||||||
|
|
||||||
|
#### 2.3.2 静态方法和实例方法有何不同
|
||||||
|
|
||||||
|
1. 在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
|
||||||
|
|
||||||
|
2. 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。
|
||||||
|
|
||||||
|
#### 2.3.3 常见关键字总结:static,final,this,super
|
||||||
|
|
||||||
|
详见笔主的这篇文章: https://snailclimb.gitee.io/javaguide/#/docs/java/basic/final,static,this,super
|
||||||
|
|
||||||
|
#### 2.3.4 关于 final 关键字的一些总结
|
||||||
|
|
||||||
|
final 关键字主要用在三个地方：变量、方法、类。
|
||||||
|
|
||||||
|
1. 对于一个 final 变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
|
||||||
|
2. 当用 final 修饰一个类时，表明这个类不能被继承。final 类中的所有成员方法都会被隐式地指定为 final 方法。
|
||||||
|
3. 使用 final 方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的 Java 实现版本中，会将 final 方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的 Java 版本已经不需要使用 final 方法进行这些优化了）。类中所有的 private 方法都隐式地指定为 final。
|
||||||
|
|
||||||
|
### 2.4 接口
|
||||||
|
|
||||||
|
#### 2.4.1 接口和抽象类的区别是什么？
|
||||||
|
|
||||||
|
1. 接口的方法默认是 public，所有方法在接口中不能有实现(Java 8 开始接口方法可以有默认实现），而抽象类可以有非抽象的方法。
|
||||||
|
2. 接口中除了 static、final 变量，不能有其他变量，而抽象类中则不一定。
|
||||||
|
3. 一个类可以实现多个接口，但只能实现一个抽象类。接口自己本身可以通过 extends 关键字扩展多个接口。
|
||||||
|
4. 接口方法默认修饰符是 public，抽象方法可以有 public、protected 和 default 这些修饰符（抽象方法就是为了被重写所以不能使用 private 关键字修饰！）。
|
||||||
|
5. 从设计层面来说，抽象是对类的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为的规范。
|
||||||
|
|
||||||
|
> 备注：
|
||||||
|
>
|
||||||
|
> 1. 在 JDK8 中，接口也可以定义静态方法，可以直接用接口名调用。实现类和实现是不可以调用的。如果同时实现两个接口，接口中定义了一样的默认方法，则必须重写，不然会报错。(详见 issue:[https://github.com/Snailclimb/JavaGuide/issues/146](https://github.com/Snailclimb/JavaGuide/issues/146)。
|
||||||
|
> 2. jdk9 的接口被允许定义私有方法 。
|
||||||
|
|
||||||
|
总结一下 jdk7~jdk9 Java 中接口概念的变化（[相关阅读](https://www.geeksforgeeks.org/private-methods-java-9-interfaces/)）：
|
||||||
|
|
||||||
|
1. 在 jdk 7 或更早版本中，接口里面只能有常量变量和抽象方法。这些接口方法必须由选择实现接口的类实现。
|
||||||
|
2. jdk8 的时候接口可以有默认方法和静态方法功能。
|
||||||
|
3. Jdk 9 在接口中引入了私有方法和私有静态方法。
|
||||||
|
|
||||||
|
### 2.5 类的扩展
|
||||||
|
#### 2.5.1 String StringBuffer 和 StringBuilder 的区别是什么? String 为什么是不可变的?
|
||||||
|
|
||||||
简单的来说：String 类中使用 final 关键字修饰字符数组来保存字符串，`private final char value[]`，所以 String 对象是不可变的。
|
简单的来说：String 类中使用 final 关键字修饰字符数组来保存字符串，`private final char value[]`，所以 String 对象是不可变的。
|
||||||
|
|
||||||
@ -252,9 +351,10 @@ abstract class AbstractStringBuilder implements Appendable, CharSequence {
|
|||||||
|
|
||||||
AbstractStringBuilder(int capacity) {
|
AbstractStringBuilder(int capacity) {
|
||||||
value = new char[capacity];
|
value = new char[capacity];
|
||||||
}
|
}}
|
||||||
```
|
```
|
||||||
|
|
||||||
|
|
||||||
**线程安全性**
|
**线程安全性**
|
||||||
|
|
||||||
String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。
|
String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。
|
||||||
@ -269,86 +369,7 @@ String 中的对象是不可变的，也就可以理解为常量，线程安全
|
|||||||
2. 单线程操作字符串缓冲区下操作大量数据: 适用 StringBuilder
|
2. 单线程操作字符串缓冲区下操作大量数据: 适用 StringBuilder
|
||||||
3. 多线程操作字符串缓冲区下操作大量数据: 适用 StringBuffer
|
3. 多线程操作字符串缓冲区下操作大量数据: 适用 StringBuffer
|
||||||
|
|
||||||
## 13. 自动装箱与拆箱
|
#### 2.5.2 == 与 equals(重要)
|
||||||
|
|
||||||
- **装箱**：将基本类型用它们对应的引用类型包装起来；
|
|
||||||
- **拆箱**：将包装类型转换为基本数据类型；
|
|
||||||
|
|
||||||
更多内容见：[深入剖析 Java 中的装箱和拆箱](https://www.cnblogs.com/dolphin0520/p/3780005.html)
|
|
||||||
|
|
||||||
## 14. 在一个静态方法内调用一个非静态成员为什么是非法的?
|
|
||||||
|
|
||||||
由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。
|
|
||||||
|
|
||||||
## 15. 在 Java 中定义一个不做事且没有参数的构造方法的作用
|
|
||||||
|
|
||||||
Java 程序在执行子类的构造方法之前，如果没有用 `super()`来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 `super()`来调用父类中特定的构造方法，则编译时将发生错误，因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。
|
|
||||||
|
|
||||||
## 16. import java 和 javax 有什么区别？
|
|
||||||
|
|
||||||
刚开始的时候 JavaAPI 所必需的包是 java 开头的包，javax 当时只是扩展 API 包来使用。然而随着时间的推移，javax 逐渐地扩展成为 Java API 的组成部分。但是，将扩展从 javax 包移动到 java 包确实太麻烦了，最终会破坏一堆现有的代码。因此，最终决定 javax 包将成为标准 API 的一部分。
|
|
||||||
|
|
||||||
所以，实际上 java 和 javax 没有区别。这都是一个名字。
|
|
||||||
|
|
||||||
## 17. 接口和抽象类的区别是什么？
|
|
||||||
|
|
||||||
1. 接口的方法默认是 public，所有方法在接口中不能有实现(Java 8 开始接口方法可以有默认实现），而抽象类可以有非抽象的方法。
|
|
||||||
2. 接口中除了 static、final 变量，不能有其他变量，而抽象类中则不一定。
|
|
||||||
3. 一个类可以实现多个接口，但只能实现一个抽象类。接口自己本身可以通过 extends 关键字扩展多个接口。
|
|
||||||
4. 接口方法默认修饰符是 public，抽象方法可以有 public、protected 和 default 这些修饰符（抽象方法就是为了被重写所以不能使用 private 关键字修饰！）。
|
|
||||||
5. 从设计层面来说，抽象是对类的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为的规范。
|
|
||||||
|
|
||||||
> 备注：
|
|
||||||
>
|
|
||||||
> 1. 在 JDK8 中，接口也可以定义静态方法，可以直接用接口名调用。实现类和实现是不可以调用的。如果同时实现两个接口，接口中定义了一样的默认方法，则必须重写，不然会报错。(详见 issue:[https://github.com/Snailclimb/JavaGuide/issues/146](https://github.com/Snailclimb/JavaGuide/issues/146)。
|
|
||||||
> 2. jdk9 的接口被允许定义私有方法 。
|
|
||||||
|
|
||||||
总结一下 jdk7~jdk9 Java 中接口概念的变化（[相关阅读](https://www.geeksforgeeks.org/private-methods-java-9-interfaces/)）：
|
|
||||||
|
|
||||||
1. 在 jdk 7 或更早版本中，接口里面只能有常量变量和抽象方法。这些接口方法必须由选择实现接口的类实现。
|
|
||||||
2. jdk8 的时候接口可以有默认方法和静态方法功能。
|
|
||||||
3. Jdk 9 在接口中引入了私有方法和私有静态方法。
|
|
||||||
|
|
||||||
## 18. 成员变量与局部变量的区别有哪些？
|
|
||||||
|
|
||||||
1. 从语法形式上看:成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。
|
|
||||||
2. 从变量在内存中的存储方式来看:如果成员变量是使用`static`修饰的，那么这个成员变量是属于类的，如果没有使用`static`修饰，这个成员变量是属于实例的。对象存于堆内存，如果局部变量类型为基本数据类型，那么存储在栈内存，如果为引用数据类型，那存放的是指向堆内存对象的引用或者是指向常量池中的地址。
|
|
||||||
3. 从变量在内存中的生存时间上看:成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。
|
|
||||||
4. 成员变量如果没有被赋初值:则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。
|
|
||||||
|
|
||||||
## 19. 创建一个对象用什么运算符?对象实体与对象引用有何不同?
|
|
||||||
|
|
||||||
new 运算符，new 创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。一个对象引用可以指向 0 个或 1 个对象（一根绳子可以不系气球，也可以系一个气球）;一个对象可以有 n 个引用指向它（可以用 n 条绳子系住一个气球）。
|
|
||||||
|
|
||||||
## 20. 什么是方法的返回值?返回值在类的方法里的作用是什么?
|
|
||||||
|
|
||||||
方法的返回值是指我们获取到的某个方法体中的代码执行后产生的结果！（前提是该方法可能产生结果）。返回值的作用:接收出结果，使得它可以用于其他的操作！
|
|
||||||
|
|
||||||
## 21. 一个类的构造方法的作用是什么? 若一个类没有声明构造方法，该程序能正确执行吗? 为什么?
|
|
||||||
|
|
||||||
主要作用是完成对类对象的初始化工作。可以执行。因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。
|
|
||||||
|
|
||||||
## 22. 构造方法有哪些特性？
|
|
||||||
|
|
||||||
1. 名字与类名相同。
|
|
||||||
2. 没有返回值，但不能用 void 声明构造函数。
|
|
||||||
3. 生成类的对象时自动执行，无需调用。
|
|
||||||
|
|
||||||
## 23. 静态方法和实例方法有何不同
|
|
||||||
|
|
||||||
1. 在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
|
|
||||||
|
|
||||||
2. 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。
|
|
||||||
|
|
||||||
## 24. 对象的相等与指向他们的引用相等,两者有什么不同?
|
|
||||||
|
|
||||||
对象的相等，比的是内存中存放的内容是否相等。而引用相等，比较的是他们指向的内存地址是否相等。
|
|
||||||
|
|
||||||
## 25. 在调用子类构造方法之前会先调用父类没有参数的构造方法,其目的是?
|
|
||||||
|
|
||||||
帮助子类做初始化工作。
|
|
||||||
|
|
||||||
## 26. == 与 equals(重要)
|
|
||||||
|
|
||||||
**==** : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象(基本数据类型==比较的是值，引用数据类型==比较的是内存地址)。
|
**==** : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象(基本数据类型==比较的是值，引用数据类型==比较的是内存地址)。
|
||||||
|
|
||||||
@ -384,23 +405,30 @@ public class test1 {
|
|||||||
- String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是比较的对象的内存地址，而 String 的 equals 方法比较的是对象的值。
|
- String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是比较的对象的内存地址，而 String 的 equals 方法比较的是对象的值。
|
||||||
- 当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。
|
- 当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。
|
||||||
|
|
||||||
## 27. hashCode 与 equals (重要)
|
#### 2.5.2 自动装箱与拆箱
|
||||||
|
|
||||||
|
- **装箱**：将基本类型用它们对应的引用类型包装起来；
|
||||||
|
- **拆箱**：将包装类型转换为基本数据类型；
|
||||||
|
|
||||||
|
更多内容见：[深入剖析 Java 中的装箱和拆箱](https://www.cnblogs.com/dolphin0520/p/3780005.html)
|
||||||
|
|
||||||
|
#### 2.5.3 hashCode 与 equals (重要)
|
||||||
|
|
||||||
面试官可能会问你：“你重写过 hashcode 和 equals 么，为什么重写 equals 时必须重写 hashCode 方法？”
|
面试官可能会问你：“你重写过 hashcode 和 equals 么，为什么重写 equals 时必须重写 hashCode 方法？”
|
||||||
|
|
||||||
### hashCode（）介绍
|
##### hashCode（）介绍
|
||||||
|
|
||||||
hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个 int 整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在 JDK 的 Object.java 中，这就意味着 Java 中的任何类都包含有 hashCode() 函数。
|
hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个 int 整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在 JDK 的 Object.java 中，这就意味着 Java 中的任何类都包含有 hashCode() 函数。
|
||||||
|
|
||||||
散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）
|
散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）
|
||||||
|
|
||||||
### 为什么要有 hashCode
|
##### 为什么要有 hashCode
|
||||||
|
|
||||||
**我们先以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：** 当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与该位置其他已经加入的对象的 hashcode 值作比较，如果没有相符的 hashcode，HashSet 会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 `equals()`方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。（摘自我的 Java 启蒙书《Head first java》第二版）。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。
|
**我们先以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：** 当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与该位置其他已经加入的对象的 hashcode 值作比较，如果没有相符的 hashcode，HashSet 会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 `equals()`方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。（摘自我的 Java 启蒙书《Head first java》第二版）。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。
|
||||||
|
|
||||||
通过我们可以看出：`hashCode()` 的作用就是**获取哈希码**，也称为散列码；它实际上是返回一个 int 整数。这个**哈希码的作用**是确定该对象在哈希表中的索引位置。**`hashCode()`在散列表中才有用，在其它情况下没用**。在散列表中 hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。
|
通过我们可以看出：`hashCode()` 的作用就是**获取哈希码**，也称为散列码；它实际上是返回一个 int 整数。这个**哈希码的作用**是确定该对象在哈希表中的索引位置。**`hashCode()`在散列表中才有用，在其它情况下没用**。在散列表中 hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。
|
||||||
|
|
||||||
### hashCode（）与 equals（）的相关规定
|
##### hashCode（）与 equals（）的相关规定
|
||||||
|
|
||||||
1. 如果两个对象相等，则 hashcode 一定也是相同的
|
1. 如果两个对象相等，则 hashcode 一定也是相同的
|
||||||
2. 两个对象相等,对两个对象分别调用 equals 方法都返回 true
|
2. 两个对象相等,对两个对象分别调用 equals 方法都返回 true
|
||||||
@ -410,50 +438,37 @@ hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返
|
|||||||
|
|
||||||
推荐阅读：[Java hashCode() 和 equals()的若干问题解答](https://www.cnblogs.com/skywang12345/p/3324958.html)
|
推荐阅读：[Java hashCode() 和 equals()的若干问题解答](https://www.cnblogs.com/skywang12345/p/3324958.html)
|
||||||
|
|
||||||
## 28. 为什么 Java 中只有值传递？
|
#### 2.5.4 Java 序列化中如果有些字段不想进行序列化，怎么办？
|
||||||
|
|
||||||
[为什么 Java 中只有值传递？](https://juejin.im/post/5e18879e6fb9a02fc63602e2)
|
对于不想进行序列化的变量，使用 transient 关键字修饰。
|
||||||
|
|
||||||
## 29. 简述线程、程序、进程的基本概念。以及他们之间关系是什么?
|
transient 关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被 transient 修饰的变量值不会被持久化和恢复。transient 只能修饰变量，不能修饰类和方法。
|
||||||
|
|
||||||
**线程**与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
|
#### 2.5.5 获取用键盘输入常用的两种方法
|
||||||
|
|
||||||
**程序**是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。
|
方法 1：通过 Scanner
|
||||||
|
|
||||||
**进程**是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如 CPU 时间，内存空间，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。
|
```java
|
||||||
线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。
|
Scanner input = new Scanner(System.in);
|
||||||
|
String s = input.nextLine();
|
||||||
|
input.close();
|
||||||
|
```
|
||||||
|
|
||||||
## 30. 线程有哪些基本状态?
|
方法 2：通过 BufferedReader
|
||||||
|
|
||||||
Java 线程在运行的生命周期中的指定时刻只可能处于下面 6 种不同状态的其中一个状态（图源《Java 并发编程艺术》4.1.4 节）。
|
```java
|
||||||
|
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
|
||||||
|
String s = input.readLine();
|
||||||
|
```
|
||||||
|
|
||||||
|
## 3. Java核心技术
|
||||||
|
### 3.1 集合
|
||||||
|
#### 3.1.1 Collections 工具类和 Arrays 工具类常见方法总结
|
||||||
|
|
||||||
线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换。Java 线程状态变迁如下图所示（图源《Java 并发编程艺术》4.1.4 节）：
|
详见笔主的这篇文章: https://gitee.com/SnailClimb/JavaGuide/blob/master/docs/java/basic/Arrays,CollectionsCommonMethods.md
|
||||||
|
|
||||||
|
### 3.2 异常
|
||||||
|
#### 3.2.1 Java 异常类层次结构图
|
||||||
由上图可以看出：
|
|
||||||
|
|
||||||
线程创建之后它将处于 **NEW（新建）** 状态，调用 `start()` 方法后开始运行，线程这时候处于 **READY（可运行）** 状态。可运行状态的线程获得了 cpu 时间片（timeslice）后就处于 **RUNNING（运行）** 状态。
|
|
||||||
|
|
||||||
> 操作系统隐藏 Java 虚拟机（JVM）中的 READY 和 RUNNING 状态，它只能看到 RUNNABLE 状态（图源：[HowToDoInJava](https://howtodoinjava.com/)：[Java Thread Life Cycle and Thread States](https://howtodoinjava.com/java/multi-threading/java-thread-life-cycle-and-thread-states/)），所以 Java 系统一般将这两个状态统称为 **RUNNABLE（运行中）** 状态 。
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
当线程执行 `wait()`方法之后，线程进入 **WAITING（等待）**状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而 **TIME_WAITING(超时等待)** 状态相当于在等待状态的基础上增加了超时限制，比如通过 `sleep（long millis）`方法或 `wait（long millis）`方法可以将 Java 线程置于 TIMED WAITING 状态。当超时时间到达后 Java 线程将会返回到 RUNNABLE 状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到 **BLOCKED（阻塞）** 状态。线程在执行 Runnable 的`run()`方法之后将会进入到 **TERMINATED（终止）** 状态。
|
|
||||||
|
|
||||||
## 31 关于 final 关键字的一些总结
|
|
||||||
|
|
||||||
final 关键字主要用在三个地方：变量、方法、类。
|
|
||||||
|
|
||||||
1. 对于一个 final 变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
|
|
||||||
2. 当用 final 修饰一个类时，表明这个类不能被继承。final 类中的所有成员方法都会被隐式地指定为 final 方法。
|
|
||||||
3. 使用 final 方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的 Java 实现版本中，会将 final 方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的 Java 版本已经不需要使用 final 方法进行这些优化了）。类中所有的 private 方法都隐式地指定为 final。
|
|
||||||
|
|
||||||
## 32 Java 中的异常处理
|
|
||||||
|
|
||||||
### Java 异常类层次结构图
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@ -475,14 +490,14 @@ final 关键字主要用在三个地方：变量、方法、类。
|
|||||||
|
|
||||||
**注意：异常和错误的区别：异常能被程序本身处理，错误是无法处理。**
|
**注意：异常和错误的区别：异常能被程序本身处理，错误是无法处理。**
|
||||||
|
|
||||||
### Throwable 类常用方法
|
##### Throwable 类常用方法
|
||||||
|
|
||||||
- **public string getMessage()**:返回异常发生时的简要描述
|
- **public string getMessage()**:返回异常发生时的简要描述
|
||||||
- **public string toString()**:返回异常发生时的详细信息
|
- **public string toString()**:返回异常发生时的详细信息
|
||||||
- **public string getLocalizedMessage()**:返回异常对象的本地化信息。使用 Throwable 的子类覆盖这个方法，可以生成本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与 getMessage（）返回的结果相同
|
- **public string getLocalizedMessage()**:返回异常对象的本地化信息。使用 Throwable 的子类覆盖这个方法，可以生成本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与 getMessage（）返回的结果相同
|
||||||
- **public void printStackTrace()**:在控制台上打印 Throwable 对象封装的异常信息
|
- **public void printStackTrace()**:在控制台上打印 Throwable 对象封装的异常信息
|
||||||
|
|
||||||
### 异常处理总结
|
##### 异常处理总结
|
||||||
|
|
||||||
- **try 块：** 用于捕获异常。其后可接零个或多个 catch 块，如果没有 catch 块，则必须跟一个 finally 块。
|
- **try 块：** 用于捕获异常。其后可接零个或多个 catch 块，如果没有 catch 块，则必须跟一个 finally 块。
|
||||||
- **catch 块：** 用于处理 try 捕获到的异常。
|
- **catch 块：** 用于处理 try 捕获到的异常。
|
||||||
@ -501,6 +516,7 @@ final 关键字主要用在三个地方：变量、方法、类。
|
|||||||
**注意：** 当 try 语句和 finally 语句中都有 return 语句时，在方法返回之前，finally 语句的内容将被执行，并且 finally 语句的返回值将会覆盖原始的返回值。如下：
|
**注意：** 当 try 语句和 finally 语句中都有 return 语句时，在方法返回之前，finally 语句的内容将被执行，并且 finally 语句的返回值将会覆盖原始的返回值。如下：
|
||||||
|
|
||||||
```java
|
```java
|
||||||
|
public class Test {
|
||||||
public static int f(int value) {
|
public static int f(int value) {
|
||||||
try {
|
try {
|
||||||
return value * value;
|
return value * value;
|
||||||
@ -510,36 +526,43 @@ final 关键字主要用在三个地方：变量、方法、类。
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
```
|
```
|
||||||
|
|
||||||
如果调用 `f(2)`，返回值将是 0，因为 finally 语句的返回值覆盖了 try 语句块的返回值。
|
如果调用 `f(2)`，返回值将是 0，因为 finally 语句的返回值覆盖了 try 语句块的返回值。
|
||||||
|
|
||||||
## 33 Java 序列化中如果有些字段不想进行序列化，怎么办？
|
### 3.3 多线程
|
||||||
|
#### 3.3.1 简述线程、程序、进程的基本概念。以及他们之间关系是什么?
|
||||||
|
|
||||||
对于不想进行序列化的变量，使用 transient 关键字修饰。
|
**线程**与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
|
||||||
|
|
||||||
transient 关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被 transient 修饰的变量值不会被持久化和恢复。transient 只能修饰变量，不能修饰类和方法。
|
**程序**是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。
|
||||||
|
|
||||||
## 34 获取用键盘输入常用的两种方法
|
**进程**是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如 CPU 时间，内存空间，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。
|
||||||
|
线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。
|
||||||
|
|
||||||
方法 1：通过 Scanner
|
#### 3.3.2 线程有哪些基本状态?
|
||||||
|
|
||||||
```java
|
Java 线程在运行的生命周期中的指定时刻只可能处于下面 6 种不同状态的其中一个状态（图源《Java 并发编程艺术》4.1.4 节）。
|
||||||
Scanner input = new Scanner(System.in);
|
|
||||||
String s = input.nextLine();
|
|
||||||
input.close();
|
|
||||||
```
|
|
||||||
|
|
||||||
方法 2：通过 BufferedReader
|
|
||||||
|
|
||||||
```java
|
线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换。Java 线程状态变迁如下图所示（图源《Java 并发编程艺术》4.1.4 节）：
|
||||||
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
|
|
||||||
String s = input.readLine();
|
|
||||||
```
|
|
||||||
|
|
||||||
## 35 Java 中 IO 流
|
|
||||||
|
|
||||||
### Java 中 IO 流分为几种?
|
由上图可以看出：
|
||||||
|
|
||||||
|
线程创建之后它将处于 **NEW（新建）** 状态，调用 `start()` 方法后开始运行，线程这时候处于 **READY（可运行）** 状态。可运行状态的线程获得了 cpu 时间片（timeslice）后就处于 **RUNNING（运行）** 状态。
|
||||||
|
|
||||||
|
> 操作系统隐藏 Java 虚拟机（JVM）中的 READY 和 RUNNING 状态，它只能看到 RUNNABLE 状态（图源：[HowToDoInJava](https://howtodoinjava.com/)：[Java Thread Life Cycle and Thread States](https://howtodoinjava.com/java/multi-threading/java-thread-life-cycle-and-thread-states/)），所以 Java 系统一般将这两个状态统称为 **RUNNABLE（运行中）** 状态 。
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
当线程执行 `wait()`方法之后，线程进入 **WAITING（等待）**状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而 **TIME_WAITING(超时等待)** 状态相当于在等待状态的基础上增加了超时限制，比如通过 `sleep（long millis）`方法或 `wait（long millis）`方法可以将 Java 线程置于 TIMED WAITING 状态。当超时时间到达后 Java 线程将会返回到 RUNNABLE 状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到 **BLOCKED（阻塞）** 状态。线程在执行 Runnable 的`run()`方法之后将会进入到 **TERMINATED（终止）** 状态。
|
||||||
|
|
||||||
|
### 3.3 文件与I\O流
|
||||||
|
#### 3.3.1 Java 中 IO 流分为几种?
|
||||||
|
|
||||||
- 按照流的流向分，可以分为输入流和输出流；
|
- 按照流的流向分，可以分为输入流和输出流；
|
||||||
- 按照操作单元划分，可以划分为字节流和字符流；
|
- 按照操作单元划分，可以划分为字节流和字符流；
|
||||||
@ -558,33 +581,18 @@ Java Io 流共涉及 40 多个类，这些类看上去很杂乱，但实际上
|
|||||||
|
|
||||||
|
|
||||||
|
|
||||||
### 既然有了字节流,为什么还要有字符流?
|
##### 3.3.2 既然有了字节流,为什么还要有字符流?
|
||||||
|
|
||||||
问题本质想问：**不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么 I/O 流操作要分为字节流操作和字符流操作呢？**
|
问题本质想问：**不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么 I/O 流操作要分为字节流操作和字符流操作呢？**
|
||||||
|
|
||||||
回答：字符流是由 Java 虚拟机将字节转换得到的，问题就出在这个过程还算是非常耗时，并且，如果我们不知道编码类型就很容易出现乱码问题。所以， I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。
|
回答：字符流是由 Java 虚拟机将字节转换得到的，问题就出在这个过程还算是非常耗时，并且，如果我们不知道编码类型就很容易出现乱码问题。所以， I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。
|
||||||
|
|
||||||
### BIO,NIO,AIO 有什么区别?
|
##### 3.3.3 BIO,NIO,AIO 有什么区别?
|
||||||
|
|
||||||
- **BIO (Blocking I/O):** 同步阻塞 I/O 模式，数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机 1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的 I/O 并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。因此，我们需要一种更高效的 I/O 处理模型来应对更高的并发量。
|
- **BIO (Blocking I/O):** 同步阻塞 I/O 模式，数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机 1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的 I/O 并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。因此，我们需要一种更高效的 I/O 处理模型来应对更高的并发量。
|
||||||
- **NIO (Non-blocking/New I/O):** NIO 是一种同步非阻塞的 I/O 模型，在 Java 1.4 中引入了 NIO 框架，对应 java.nio 包，提供了 Channel , Selector，Buffer 等抽象。NIO 中的 N 可以理解为 Non-blocking，不单纯是 New。它支持面向缓冲的，基于通道的 I/O 操作方法。 NIO 提供了与传统 BIO 模型中的 `Socket` 和 `ServerSocket` 相对应的 `SocketChannel` 和 `ServerSocketChannel` 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞 I/O 来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞模式来开发
|
- **NIO (Non-blocking/New I/O):** NIO 是一种同步非阻塞的 I/O 模型，在 Java 1.4 中引入了 NIO 框架，对应 java.nio 包，提供了 Channel , Selector，Buffer 等抽象。NIO 中的 N 可以理解为 Non-blocking，不单纯是 New。它支持面向缓冲的，基于通道的 I/O 操作方法。 NIO 提供了与传统 BIO 模型中的 `Socket` 和 `ServerSocket` 相对应的 `SocketChannel` 和 `ServerSocketChannel` 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞 I/O 来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞模式来开发
|
||||||
- **AIO (Asynchronous I/O):** AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的 IO 模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。AIO 是异步 IO 的缩写，虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是同步的。对于 NIO 来说，我们的业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程自行进行 IO 操作，IO 操作本身是同步的。查阅网上相关资料，我发现就目前来说 AIO 的应用还不是很广泛，Netty 之前也尝试使用过 AIO，不过又放弃了。
|
- **AIO (Asynchronous I/O):** AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的 IO 模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。AIO 是异步 IO 的缩写，虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是同步的。对于 NIO 来说，我们的业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程自行进行 IO 操作，IO 操作本身是同步的。查阅网上相关资料，我发现就目前来说 AIO 的应用还不是很广泛，Netty 之前也尝试使用过 AIO，不过又放弃了。
|
||||||
|
|
||||||
## 36. 常见关键字总结:static,final,this,super
|
|
||||||
|
|
||||||
详见笔主的这篇文章: https://snailclimb.gitee.io/javaguide/#/docs/java/basic/final,static,this,super
|
|
||||||
|
|
||||||
## 37. Collections 工具类和 Arrays 工具类常见方法总结
|
|
||||||
|
|
||||||
详见笔主的这篇文章: https://gitee.com/SnailClimb/JavaGuide/blob/master/docs/java/basic/Arrays,CollectionsCommonMethods.md
|
|
||||||
|
|
||||||
## 38. 深拷贝 vs 浅拷贝
|
|
||||||
|
|
||||||
1. **浅拷贝**：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。
|
|
||||||
2. **深拷贝**：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
## 参考
|
## 参考
|
||||||
|
|
||||||
- https://stackoverflow.com/questions/1906445/what-is-the-difference-between-jdk-and-jre
|
- https://stackoverflow.com/questions/1906445/what-is-the-difference-between-jdk-and-jre
|
||||||
@ -599,4 +607,4 @@ Java Io 流共涉及 40 多个类，这些类看上去很杂乱，但实际上
|
|||||||
|
|
||||||
**Java 工程师必备学习资源:** 一些 Java 工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。
|
**Java 工程师必备学习资源:** 一些 Java 工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。
|
||||||
|
|
||||||
|
|
||||||
Loading…
x
Reference in New Issue
Block a user