因為後面可能要接觸 flink
文章目錄
- 零、IDEA環境配置
- 0.1 java項目跑起來
- 一、基礎内容
- 1.1 java基本功
- （1）Java 入門(基礎概念與常識)
- （2）Java 文法
- （3）基本資料類型
- （4）方法(函數)
- （5）java源程式與編譯型運作的差別
- 1.2 Java 面向對象
- （1）類和對象
- （2）面向對象三大特征
- 1）繼承
- 2）多态
- 3）封裝
- （3）修飾符
- （4）接口和抽象類
- （5）Java包
- 1.3 Java 核心技術
- （1）集合
- 1）ArrayList
- （2）異常
- （3）多線程
- （4）檔案與 I\O 流
- 二、并發
- 2.1 并發容器
- 2.2 線程池
- 2.3 樂觀鎖與悲觀鎖
- 三、JVM
- 四、網絡、linux、資料結構、資料庫、系統設計
- Reference
零、IDEA環境配置
0.1 java項目跑起來
首先建立項目，不用建立模闆，然後打開項目中的
src
檔案夾：
右擊src選擇new->Package：
得到如圖：
在剛才建立的
com.java.demo
中右鍵new，java class，名字随便寫個
hello_andy
：
在建立好的類中寫一個
main
方法，和其他語言類似，java項目從這裡開始執行：
最終的結果：
一、基礎内容
1.1 java基本功
（1）Java 入門(基礎概念與常識)
一個 Java 程式可以認為是一系列對象的集合，而這些對象通過調用彼此的方法來協同工作。認識幾個概念：
- 對象：對象是類的一個執行個體，有狀态和行為。例如，一條狗是一個對象，它的狀态有：顔色、名字、品種；行為有：搖尾巴、叫、吃等。
- 類：類是一個模闆，它描述一類對象的行為和狀态。
- 方法：方法就是行為，一個類可以有很多方法。邏輯運算、資料修改以及所有動作都是在方法中完成的。
- 執行個體變量：每個對象都有獨特的執行個體變量，對象的狀态由這些執行個體變量的值決定。
注意：
- 一個
.java
public
- 一個檔案中可以不含
public
簡單案例，循環，其中的列印
System.out.print()
，
print()
是一個方法，
System
是系統類，
out
是标準輸出對象：
package com.java.demo;
public class loop_test {
public static void main(String[] args){
int x = 10;
while (x < 15){
System.out.print("value of x: " + x);
x++;
System.out.print("\n");
}
}
}
//value of x: 10
//value of x: 11
//value of x: 12
//value of x: 13
//value of x: 14 （2）Java 文法
java基本文法：
- 大小寫敏感：Java 是大小寫敏感的，這就意味着辨別符 Hello 與 hello 是不同的。
- 類名：對于所有的類來說，類名的首字母應該大寫。如果類名由若幹單詞組成，那麼每個單詞的首字母應該大寫，例如
MyFirstJavaClass
- 方法名：所有的方法名都應該以小寫字母開頭。如果方法名含有若幹單詞，則後面的每個單詞首字母大寫。
- 源檔案名：源檔案名必須和類名相同。當儲存檔案的時候，你應該使用類名作為檔案名儲存（切記 Java 是大小寫敏感的），檔案名的字尾為 .java。（如果檔案名和類名不相同則會導緻編譯錯誤）。
- 主方法入口：所有的 Java 程式由
public static void main(String[] args)
Java修飾符：像其他語言一樣，Java可以使用修飾符來修飾類中方法和屬性。主要有兩類修飾符：
- 通路控制修飾符 : default, public , protected, private
- 非通路控制修飾符 : final, abstract, static, synchronized
Java 中主要有如下幾種類型的變量
- 局部變量
- 類變量（靜态變量）
- 成員變量（非靜态變量）
//java 的注釋
public class HelloWorld {
/* 這是第一個Java程式
* 它将輸出 Hello World
* 這是一個多行注釋的示例
*/
public static void main(String[] args){
// 這是單行注釋的示例
/* 這個也是單行注釋的示例 */
System.out.println("Hello World");
}
} （3）基本資料類型
六種數字類型（四個整數型，兩個浮點型），一種字元類型，還有一種布爾型：
byte
、
short
、
int
、
long
、
double
、
boolean
、
char
。其中注意
byte
類型是8位，有符号的，以二進制補碼表示的整數，即最小值是-128，最大值是127。
（4）方法(函數)
一個方法的定義：
修飾符 傳回值類型 方法名(參數類型 參數名){
...
方法體
...
return 傳回值;
} 和C++語言不同的是，java可以定義
finalize()
方法來清除回收對象，關鍵字 protected 是一個限定符，它確定 finalize() 方法不會被該類以外的代碼調用。Java 的記憶體回收可以由 JVM 來自動完成。如果你手動使用，則可以使用
finalize
方法：
package com.java.demo;
public class FinalizationDemo {
public static void main(String[] args){
Cake c1 = new Cake(1);
Cake c2 = new Cake(2);
Cake c3 = new Cake(3);
c2 = c3 = null;
// 調用java垃圾收集器
System.gc();
}
}
class Cake extends Object{
private int id;
public Cake(int id){
this.id = id;
System.out.println("Cake Object " + id + "is created");
}
protected void finalize() throws java.lang.Throwable{
super.finalize();
System.out.println("Cake Object " + id + "is disposed");
}
} （5）java源程式與編譯型運作的差別
1.2 Java 面向對象
（1）類和對象
一個類可以包含以下類型變量：
- 局部變量：在方法、構造方法或者語句塊中定義的變量被稱為局部變量。變量聲明和初始化都是在方法中，方法結束後，變量就會自動銷毀。
- 成員變量：成員變量是定義在類中，方法體之外的變量。這種變量在建立對象的時候執行個體化。成員變量可以被類中方法、構造方法和特定類的語句塊通路。
- 類變量：類變量也聲明在類中，方法體之外，但必須聲明為 static 類型。
java中是通過
new
執行個體化對象，和其他oop一樣，同時會調用構造方法初始化對象。
（1）栗子1：通路執行個體變量和調用成員方法：
package com.java.demo;
public class Puppy{
int puppyAge;
public Puppy(String name){
// 這個構造器僅有一個參數：name
System.out.println("小狗的名字是 : " + name );
}
public void setAge( int age ){
puppyAge = age;
}
public int getAge( ){
System.out.println("小狗的年齡為 : " + puppyAge );
return puppyAge;
}
public static void main(String[] args){
/* 建立對象 */
Puppy myPuppy = new Puppy( "tommy" );
/* 通過方法來設定age */
myPuppy.setAge( 2 );
/* 調用另一個方法擷取age */
myPuppy.getAge( );
/*你也可以像下面這樣通路成員變量 */
System.out.println("變量值 : " + myPuppy.puppyAge );
}
}
//小狗的名字是 : tommy
//小狗的年齡為 : 2
//變量值 : 2 （2）import外部檔案的類：
import java.io.*;
将會指令編譯器載入 java_installation/java/io 路徑下的所有類：
首先是員工類：
package com.java.demo;
import java.io.*;
public class Employee {
// public: name執行個體變量對子類可見
public String name;
int age;
String designation;
// private: 私有變量，僅在該類可見
private double salary;
// Employee 類的構造器
public Employee(String name) {
this.name = name;
}
// 設定age的值
public void empAge(int empAge) {
age = empAge;
}
/* 設定designation的值*/
public void empDesignation(String empDesig) {
designation = empDesig;
}
/* 設定salary的值*/
public void empSalary(double empSalary) {
salary = empSalary;
}
/* 列印資訊 */
public void printEmployee() {
System.out.println("名字:" + name);
System.out.println("年齡:" + age);
System.out.println("職位:" + designation);
System.out.println("薪水:" + salary);
}
} 接着是
main
函數，同樣是開頭有句
import java.io.*;
找到我們上面的員工類：
package com.java.demo;
import java.io.*;
public class EmployeeTest{
public static void main(String[] args){
/* 使用構造器建立兩個對象 */
Employee empOne = new Employee("RUNOOB1");
Employee empTwo = new Employee("RUNOOB2");
// 調用這兩個對象的成員方法
empOne.empAge(26);
empOne.empDesignation("進階程式員");
empOne.empSalary(1000);
empOne.printEmployee();
empTwo.empAge(21);
empTwo.empDesignation("菜鳥程式員");
empTwo.empSalary(500);
empTwo.printEmployee();
}
} （2）面向對象三大特征
1）繼承
- Java通過
extends
private
- Java是單一繼承，即不支援多繼承（子類繼承多個父類），但是支援多重繼承（如下圖）。
- C++和Java中調用自身類是用
this
this.xxx_function
self.xxx_function
- Java和python調用父類的方法可以直接用
super
super
- 在C++中，子類和父類函數名一樣的函數fun，如果參數不一樣，不管加不加
virtual
Java的抽象類和C++那邊是差不多的：
- 當涉及父類時，父類的具體的方法無法确定，可以設定為抽象類，如
public abstract class Employee
- 抽象類中不一定包含抽象方法，但是有抽象方法的類必定是抽象類。
- 抽象類中的抽象方法隻是聲明，不包含方法體，就是不給出方法的具體實作也就是方法的具體功能。
- 構造方法，類方法（用 static 修飾的方法）不能聲明為抽象方法。
- 抽象類的子類必須給出抽象類中的抽象方法的具體實作，除非該子類也是抽象類。
2）多态
多态存在的三個必要條件
- 繼承
- 重寫
- 父類引用指向子類對象：
Parent p = new Child();
java中的多态：當使用多态方式調用方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，再去調用子類的同名方法。
package com.java.demo;
public class DuotaiTest {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 對象調用 show 方法
show(new Dog()); // 以 Dog 對象調用 show 方法
//父類引用指向子類對象
A a = new Cat(); // 向上轉型
a.eat(); // 調用的是 Cat 的 eat
Cat c = (Cat)a; // 向下轉型
c.work(); // 調用的是 Cat 的 work
}
public static void show(A a) {
a.eat();
// 類型判斷
if (a instanceof Cat) { // 貓做的事情
Cat c = (Cat)a;
c.work();
} else if (a instanceof Dog) { // 狗做的事情
Dog c = (Dog)a;
c.work();
}
}
}
//父類animal
abstract class A {
abstract void eat();
}
class Cat extends A {
public void eat() {
System.out.println("吃魚");
}
public void work() {
System.out.println("抓老鼠");
}
}
class Dog extends A {
public void eat() {
System.out.println("吃骨頭");
}
public void work() {
System.out.println("看家");
}
} 結果為：
吃魚
抓老鼠
吃骨頭
看家
吃魚
抓老鼠 3）封裝
略。
（3）修飾符
（4）接口和抽象類
（5）Java包
1.3 Java 核心技術
（1）集合
先浏覽下圖的Java集合架構圖，Java 集合架構主要包括兩種類型的容器：
- 一種是集合（Collection），存儲一個元素集合。Collection 接口又有 3 種子類型，List、Set 和 Queue，再下面是一些抽象類，最後是具體實作類，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。
- 另一種是圖（Map），存儲鍵/值對映射。
所有的集合架構都包括（參照下圖，java集合架構位于
java.util
包中， 是以當使用集合架構的時候需要進行導包）：
- 接口：是代表集合的抽象資料類型。例如 Collection、List、Set、Map 等。之是以定義多個接口，是為了以不同的方式操作集合對象
- 實作（類）：是集合接口的具體實作。從本質上講，它們是可重複使用的資料結構，例如：
ArrayList
LinkedList
HashSet
HashMap
- 算法：是實作集合接口的對象裡的方法執行的一些有用的計算，例如：搜尋和排序。這些算法被稱為多态，那是因為相同的方法可以在相似的接口上有着不同的實作。
1）ArrayList
ArrayList
類是一個可以動态修改的數組，與普通數組的差別就是它是沒有固定大小的限制，我們可以添加或删除元素。
ArrayList
繼承了
AbstractList
，并實作了 List 接口。
package com.java.demo;
import java.util.ArrayList;
import java.util.Collections;
public class ArrayListTest {
public static void main(String[] args) {
ArrayList<String> sites = new ArrayList<String>();
//如果是存儲數字
ArrayList<Integer> myNumbers = new ArrayList<Integer>();
sites.add("Google");
sites.add("Weibo");
sites.add("AndyGuo");
sites.add("AAAA");
System.out.println(sites);
//通路第二個元素
System.out.println(sites.get(1));
//将下标為2的元素改為Wiki
sites.set(2, "Wiki");
System.out.println(sites);
//删除下标為1的元素
sites.remove(1);
System.out.println(sites);
//疊代數組清單
//for(int i = 0; i < sites.size(); i++){
// System.out.println(sites.get(i));
//}
//也可以用for-each來疊代元素
for (String i: sites){
System.out.println(i);
}
System.out.println("==========排序後：=========");
Collections.sort(sites);
for (String i: sites){
System.out.println(i);
}
}
} （2）異常
略。
（3）多線程
一個線程的生命周期：
（4）檔案與 I\O 流
一個流被定義為一個資料序列。輸入流用于從源讀取資料，輸出流用于向目标寫資料。下圖是一個描述輸入流和輸出流的類層次圖。
二、并發
2.1 并發容器
JDK 提供的并發容器總結
ConcurrentHashMap
CopyOnWriteArrayList
ConcurrentLinkedQueue
BlockingQueue
ConcurrentSkipListMap
2.2 線程池
使用線程池的好處
Executor 架構
(重要)ThreadPoolExecutor 類簡單介紹
(重要)ThreadPoolExecutor 使用示例
幾種常見的線程池詳解
ScheduledThreadPoolExecutor 詳解
線程池大小确定
2.3 樂觀鎖與悲觀鎖
何謂悲觀鎖與樂觀鎖
樂觀鎖常見的兩種實作方式
樂觀鎖的缺點
CAS與synchronized的使用情景
三、JVM
（1）Java記憶體區域
概述
運作時資料區域
HotSpot 虛拟機對象探秘
重點補充内容
（2）JVM垃圾回收
揭開 JVM 記憶體配置設定與回收的神秘面紗
對象已經死亡?
垃圾收集算法
垃圾收集器
（3）JDK 監控和故障處理工具
JDK 指令行工具
JDK 可視化分析工具