auto commit

2018-03-17 21:58:16 +08:00 · 2018-03-17 21:58:16 +08:00 · 7e07f80081
commit 7e07f80081
parent 70e033098b
1 changed files with 79 additions and 80 deletions
--- a/notes/Java
+++ b/notes/Java
@ -1,74 +1,74 @@
 <!-- GFM-TOC -->
-* [关键字](#关键字)
-    * [1. final](#1-final)
-    * [2. static](#2-static)
-* [Object 通用方法](#object-通用方法)
-    * [1. 概览](#1-概览)
-    * [2. clone()](#2-clone)
-    * [3. equals()](#3-equals)
-* [继承](#继承)
-    * [1. 访问权限](#1-访问权限)
-    * [2. 抽象类与接口](#2-抽象类与接口)
-    * [3. super](#3-super)
-    * [4. 重载与重写](#4-重载与重写)
-* [String](#string)
-    * [1. String, StringBuffer and StringBuilder](#1-string,-stringbuffer-and-stringbuilder)
-    * [2. String 不可变的原因](#2-string-不可变的原因)
-    * [3. String.intern()](#3-stringintern)
-* [基本类型与运算](#基本类型与运算)
-    * [1. 包装类型](#1-包装类型)
-    * [2. switch](#2-switch)
-* [反射](#反射)
-* [异常](#异常)
-* [泛型](#泛型)
-* [注解](#注解)
-* [特性](#特性)
-    * [1. 三大特性](#1-三大特性)
-    * [2. Java 各版本的新特性](#2-java-各版本的新特性)
-    * [3. Java 与 C++ 的区别](#3-java-与-c++-的区别)
-    * [4. JRE or JDK](#4-jre-or-jdk)
+* [一、关键字](#一关键字)
+    * [final](#final)
+    * [static](#static)
+* [二、Object 通用方法](#二object-通用方法)
+    * [概览](#概览)
+    * [clone()](#clone)
+    * [equals()](#equals)
+* [四、继承](#四继承)
+    * [访问权限](#访问权限)
+    * [抽象类与接口](#抽象类与接口)
+    * [super](#super)
+    * [重载与重写](#重载与重写)
+* [五、String](#五string)
+    * [String, StringBuffer and StringBuilder](#string,-stringbuffer-and-stringbuilder)
+    * [String 不可变的原因](#string-不可变的原因)
+    * [String.intern()](#stringintern)
+* [六、基本类型与运算](#六基本类型与运算)
+    * [包装类型](#包装类型)
+    * [switch](#switch)
+* [七、反射](#七反射)
+* [八、异常](#八异常)
+* [九、泛型](#九泛型)
+* [十、注解](#十注解)
+* [十一、特性](#十一特性)
+    * [面向对象三大特性](#面向对象三大特性)
+    * [Java 各版本的新特性](#java-各版本的新特性)
+    * [Java 与 C++ 的区别](#java-与-c++-的区别)
+    * [JRE or JDK](#jre-or-jdk)
 <!-- GFM-TOC -->


-# 关键字
+# 一、关键字

-## 1. final
+## final

-**数据** 
+### 1. 数据

 声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量。

 - 对于基本类型，final 使数值不变；
 - 对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。

-**方法** 
+### 2. 方法

 声明方法不能被子类覆盖。

 private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是覆盖基类方法，而是重载了。

-**类** 
+### 3. 类

 声明类不允许被继承。

-## 2. static
+## static

-**静态变量** 
+### 1. 静态变量

 静态变量在内存中只存在一份，只在类第一次实例化时初始化一次。

 - 静态变量： 类所有的实例都共享静态变量，可以直接通过类名来访问它；
 - 实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。

-**静态方法** 
+### 2. 静态方法

 静态方法在类加载的时候就存在了，它不依赖于任何实例，所以 static 方法必须实现，也就是说它不能是抽象方法（abstract）。

-**静态语句块** 
+### 3. 静态语句块

 静态语句块和静态变量一样在类第一次实例化时运行一次。

-**初始化顺序** 
+### 4. 初始化顺序

 静态数据优先于其它数据的初始化，静态变量和静态语句块哪个先运行取决于它们在代码中的顺序。

@ -111,9 +111,9 @@ public InitialOrderTest() {
 5. 子类（实例变量、普通语句块）
 6. 子类（构造函数）

-# Object 通用方法
+# 二、Object 通用方法

-## 1. 概览
+## 概览

 ```java
 public final native Class<?> getClass()
@ -139,15 +139,15 @@ public final void wait() throws InterruptedException
 protected void finalize() throws Throwable {}
 ```

-## 2. clone()
+## clone()

-**浅拷贝** 
+### 1. 浅拷贝

 引用类型引用同一个对象。clone() 方法默认就是浅拷贝实现。

 <div align="center"> <img src="../pics//d990c0e7-64d1-4ba3-8356-111bc91e53c5.png"/> </div><br>

-**深拷贝** 
+### 2. 深拷贝

 可以使用序列化实现。

@ -155,21 +155,21 @@ protected void finalize() throws Throwable {}

 > [How do I copy an object in Java?](https://stackoverflow.com/questions/869033/how-do-i-copy-an-object-in-java)

-## 3. equals()
+## equals()

-**== 与 equals() 区别** 
+### 1. == 与 equals() 区别

- 对于基本类型，== 就是判断两个值是否相等；
+- 对于基本类型，== 判断两个值是否相等；

- 对于引用类型，== 是判断两个引用是否引用同一个对象，而 equals() 是判断引用的对象是否等价。
+- 对于引用类型，== 判断两个引用是否引用同一个对象，而 equals() 判断引用的对象是否等价。

-**等价性** 
+### 2. 等价性

 [散列](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/Java%20%E5%AE%B9%E5%99%A8.md#%E6%95%A3%E5%88%97)

-# 继承
+# 四、继承

-## 1. 访问权限
+## 访问权限

 Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。

@ -179,7 +179,7 @@ protected 用于修饰成员，表示在继承体系中成员对于子类可见

 更详细的内容：[浅析 Java 中的访问权限控制](http://www.importnew.com/18097.html)

-## 2. 抽象类与接口
+## 抽象类与接口

 抽象类和抽象方法都使用 abstract 进行声明。抽象类一般会包含抽象方法，但是少数情况下可以不包含，例如 HttpServlet 类，但是抽象方法一定位于抽象类中。抽象类和普通类最大的区别是，抽象类不能被实例化，需要继承抽象类才能实例化其子类。

@ -220,9 +220,9 @@ public interface Externalizable extends Serializable {

 > [Java 抽象类与接口的区别](http://www.importnew.com/12399.html)

-## 3. super
+## super

-**访问父类的成员** 
+### 1. 访问父类的成员

 如果子类覆盖了父类的中某个方法的实现，那么就可以通过使用 super 关键字来引用父类的方法实现。

@ -248,7 +248,7 @@ public class Subclass extends Superclass {
 }
 ```

-**访问父类的构造函数** 
+### 2. 访问父类的构造函数

 可以使用 super() 函数访问父类的构造函数，从而完成一些初始化的工作。

@ -261,21 +261,21 @@ public MountainBike(int startHeight, int startCadence, int startSpeed, int start

 > [Using the Keyword super](https://docs.oracle.com/javase/tutorial/java/IandI/super.html)

-## 4. 重载与重写
+## 重载与重写

 - 重写存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法；

 - 重载即存在于继承体系中，也存在于同一个类中，指一个方法与已经存在的方法或者父类的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。应该注意的是，返回值不同，其它都相同不算是重载。

-# String
+# 五、String

-## 1. String, StringBuffer and StringBuilder
+## String, StringBuffer and StringBuilder

-**是否可变** 
+### 1. 是否可变

 String 不可变，StringBuffer 和 StringBuilder 可变。

-**是否线程安全** 
+### 2. 是否线程安全

 String 不可变，因此是线程安全的。

@ -283,37 +283,37 @@ StringBuilder 不是线程安全的；StringBuffer 是线程安全的，使用 s

 > [String, StringBuffer, and StringBuilder](https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder)

-## 2. String 不可变的原因
+## String 不可变的原因

-**可以缓存 hash 值** 
+### 1.1 可以缓存 hash 值

 因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 等。不可变的特性可以使得 hash 值也不可变，因此就只需要进行一次计算。

-**String Pool 的需要** 
+### 2. String Pool 的需要

 如果 String 已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。

 <div align="center"> <img src="../pics//f76067a5-7d5f-4135-9549-8199c77d8f1c.jpg"/> </div><br>

-**安全性** 
+### 3. 安全性

 String 经常作为参数，String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的，那么在网络连接过程中，String 被改变，改变 String 对象的那一方以为现在连接的是其它主机，而实际情况却不一定是。

-**线程安全** 
+### 4. 线程安全

 String 不可变性天生具备线程安全，可以在多个线程中使用。

 > [Why String is immutable in Java?](https://www.programcreek.com/2013/04/why-string-is-immutable-in-java/)

-## 3. String.intern()
+## String.intern()

 使用 String.intern() 可以保证所有相同内容的字符串变量引用相同的内存对象。

 更详细的内容：[揭开 String.intern() 那神秘的面纱](https://www.jianshu.com/p/95f516cb75ef)

-# 基本类型与运算
+# 六、基本类型与运算

-## 1. 包装类型
+## 包装类型

 八个基本类型：boolean 1 byte 8 char 16 short 16 int 32 float 32 long 64 double 64

@ -374,7 +374,7 @@ System.out.println(c==d); // true
 > [Differences between new Integer(123), Integer.valueOf(123) and just 123
 ](https://stackoverflow.com/questions/9030817/differences-between-new-integer123-integer-valueof123-and-just-123)

-## 2. switch
+## switch

 A switch works with the byte, short, char, and int primitive data types. It also works with enumerated types and a few special classes that "wrap" certain primitive types: Character, Byte, Short, and Integer.

@ -410,7 +410,7 @@ public static void main(java.lang.String[]);

 > [How does Java's switch work under the hood?](https://stackoverflow.com/questions/12020048/how-does-javas-switch-work-under-the-hood)

-# 反射
+# 七、反射

 每个类都有一个  **Class**  对象，包含了与类有关的信息。当编译一个新类时，会产生一个同名的 .class 文件，该文件内容保存着 Class 对象。

@ -425,13 +425,13 @@ IDE 使用反射机制获取类的信息，在使用一个类的对象时，能
 更详细的内容：[深入解析 Java 反射（1）- 基础](http://www.sczyh30.com/posts/Java/java-reflection-1/)


-**Advantages of Using Reflection:** 
+### Advantages of Using Reflection:

 -  **Extensibility Features**  : An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
 -  **Class Browsers and Visual Development Environments**  :  A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.
 -  **Debuggers and Test Tools**  : Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

-**Drawbacks of Reflection** 
+### Drawbacks of Reflection

 Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

@ -441,8 +441,7 @@ Reflection is powerful, but should not be used indiscriminately. If it is possib

 > [Trail: The Reflection API](https://docs.oracle.com/javase/tutorial/reflect/index.html)

-
-# 异常
+# 八、异常

 Throwable 可以用来表示任何可以作为异常抛出的类，分为两种： **Error**  和 **Exception**，其中 Error 用来表示编译时系统错误。

@ -454,7 +453,7 @@ Exception 分为两种： **受检异常**  和 **非受检异常**。受检异
 - [Java 入门之异常处理](https://www.tianmaying.com/tutorial/Java-Exception)
 - [Java 异常的面试问题及答案 -Part 1](http://www.importnew.com/7383.html)

-# 泛型
+# 九、泛型

 ```java
 public class Box<T> {
@ -470,19 +469,19 @@ public class Box<T> {
 - [Java 泛型详解](https://www.ziwenxie.site/2017/03/01/java-generic/)
 - [10 道 Java 泛型面试题](https://cloud.tencent.com/developer/article/1033693)

-# 注解
+# 十、注解

 Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。

 更多详细内容：[注解Annotation实现原理与自定义注解例子](https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html)

-# 特性
+# 十一、特性

-## 1. 三大特性
+## 面向对象三大特性

 [封装、继承、多态](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E6%80%9D%E6%83%B3.md#%E5%B0%81%E8%A3%85%E7%BB%A7%E6%89%BF%E5%A4%9A%E6%80%81)

-## 2. Java 各版本的新特性
+## Java 各版本的新特性

 New highlights in Java SE 8

@ -511,7 +510,7 @@ New highlights in Java SE 7

 更详细的内容：[Java 8 特性 ](http://www.importnew.com/19345.html)

-## 3. Java 与 C++ 的区别
+## Java 与 C++ 的区别

 Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，C++ 为了兼容 C 即支持面向对象也支持面向过程。

@ -533,7 +532,7 @@ Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Obje

 > [What are the main differences between Java and C++?](http://cs-fundamentals.com/tech-interview/java/differences-between-java-and-cpp.php)

-## 4. JRE or JDK
+## JRE or JDK

 - JRE is the JVM program, Java application need to run on JRE.
 - JDK is a superset of JRE, JRE + tools for developing java programs. e.g, it provides the compiler "javac"