1.Java跨平臺的原理：

1）編譯之后會生成與平臺無關(guān)的字節(jié)碼文件
2）得依賴不同平臺的虛擬機（JVM）
JVM是不跨平臺的

編譯工具：javac
啟動JVM工具：Java

JRE（Java Runtime Environment）：Java運行環(huán)境，如果要運行Java程序，就需要JRE的支持，JRE里邊包含JVM
JDK（Java Development Kit）：Java開發(fā)工具，包含開發(fā)Java的所有工具，如javac和java等，JDK里包含JRE
Java虛擬機（Java Virtual Machine），簡稱JVM，它是運行所有Java程序的虛擬計算機，好比是街機游戲的模擬器。
JVM是Java語言的運行環(huán)境，也是Java最具吸引力的特性之一。JVM用于讀取并處理編譯過的與平臺無關(guān)的字節(jié)碼(class)文件，從而實現(xiàn)Java的可移植性。但是值得注意的是Java虛擬機是不跨平臺的，也就是說在Win下得安裝Win版本的JVM，在Linux下得安裝Linux版本的JVM
JVM是Java程序的解釋和執(zhí)行器

2.Java安裝后各個文件夾的含義

（1）bin：存放了Java的操作工具，比如編譯工具javac,啟動JVM的java等
（2）db：存放了Java測試的數(shù)據(jù)庫derby，企業(yè)不用
（3）include：存儲C++頭文件
（4）jre：Java的運行環(huán)境，里面有JVM
（5）lib：Java運行和依賴的核心庫
（6）src.zip：Java的源代碼

3.安裝jre運行java程序

（1）jre-8u121-macosx-x64.dmg（下載安裝，在系統(tǒng)偏好設(shè)置的面板上）
（2）創(chuàng)建一個空文本，命名為.java文件(比如123.java 文件中有一個名為Hello的類，.java是后綴名或者拓展名)
（3）在終端找到文件路徑執(zhí)行javac 123.java，對文件進行編譯，編譯成功后此時路徑下會生成一個Hello.class的字節(jié)碼文件
（4）啟動JVM，并加載Hello.class這份字節(jié)碼，并解釋執(zhí)行（執(zhí)行命令 java Hello），注意不要帶后綴.class，就會執(zhí)行字節(jié)碼文件中的代碼
（5）每次修改代碼都需要進行編譯

代碼解釋
// Java程序的開始，表示定義一個公共的類，類的名字是Hello，編譯后會生成一個和該名字一樣的class文件
public class Hello {
    // 主方法，Java程序的入口，執(zhí)行Java命令后，程序自動執(zhí)行主方法代碼
    public static void main(String[] args) {
        // 功能執(zhí)行代碼，表示打印一個文本信息“Hello World”，最后要以分號結(jié)束，表示語句結(jié)束
        System.out.println("Hello World");
    }
}

4.Java編譯和運行機制

源文件（.java） ->編譯-> 字節(jié)碼文件（.class）->輸出-> Hello World
Java語言編譯型語言

5.CLASSPATH（一般不用配這個環(huán)境變量）一般默認(rèn)在當(dāng)前目錄下

環(huán)境變量：指在操作系統(tǒng)中用來指定操作系統(tǒng)運行環(huán)境的一些參數(shù)

JAVA_HOME: 指JDK的安裝根目錄，如D:\OpenSource\jdk1.8.0
PATH: 指Java開發(fā)工具的位置，如D:\OpenSource\jdk1.8.0\bin
CLASSPATH: 指JVM在運行時去哪一個目錄路徑加載字節(jié)碼文件

如果在當(dāng)前路徑下希望把字節(jié)碼文件統(tǒng)一到一個文件夾中，可以新建一個文件夾命名為classes 編譯的時候使用命令javac -d classes 123.java 就可以將123.java的編譯文件放在classes的文件夾下，解釋字節(jié)碼文件的命令此時換成java -classpath classes Hello就可以得到程序執(zhí)行的結(jié)果

6.Java基本語法

1）Java語言嚴(yán)格區(qū)分大小寫，好比main和Main是完全兩個不同的概念。
2）一個Java源文件里可以定義多個Java類，但其中最多只有一個類被定義成public類。若源文件中包含public類，源文件必須和該public類同名
3）一個源文件中包含N個Java類時，成功編譯后會生成N份字節(jié)碼文件，即每個類都會生成一份單獨的class文件，且字節(jié)碼文件名和其對應(yīng)的類名相同
4）若一個類必須運行，則必須擁有main方法，因為main方法是程序的入口

編程建議：
一個Java源文件只定義一個類，不同的類使用不同的源文件定義；
將每個源文件中單獨定義的類定義成public的；
保持Java源文件的主文件名與源文件中的類名一致；

7.標(biāo)識符

在寫代碼的時候為了增強代碼的閱讀性會自定義很多名字,比如類名,方法名,變量名等.這些自定義的名稱,成為標(biāo)識符
標(biāo)識符命名規(guī)則:
（1）由字母、數(shù)字、下劃線、$組成，但不能以數(shù)字開頭（注：此處的字母可以是中文、日文等，類名首字母大寫）
（2）大小寫敏感
（3）不能使用Java的關(guān)鍵字和保留字
（4）不用Java API里的類名作為自己的類名

8.變量分類-作用域-使用規(guī)則:

變量的分類:
隨著變量定義在類中的位置的不同,故把變量分為兩類:
（1）成員變量:直接定義在類里的變量,又稱為全局變量或字段.
（2）局部變量:變量除了成員變量以外,其他就是局部變量.根據(jù)定義位置不同有3種表現(xiàn)形式:方法形參,方法內(nèi)變量,代碼塊變量

變量的作用域:
根據(jù)變量的存在范圍,只有在這個范圍內(nèi),程序代碼才能訪問它.當(dāng)一個變量被定義時,他的作用域就被確定了
作用域是定義開始到定義所在的花括號結(jié)束;

變量的使用規(guī)則:
（1）變量必須先聲明,并且初始化后才能使用;
（2）聲明變量必須有數(shù)據(jù)類型
（3）同一作用域內(nèi)變量名不能重復(fù)定義
先聲明賦值后使用,并且可重復(fù)使用

//變量分類-作用域-使用規(guī)則
public class VarDemo2{
    //成員變量,字段(不叫屬性)
    static int age=17;
    public static void main(String[] args){
        /*
         變量的分類:
         變量依據(jù)定義的位置的不同,分為兩大類:
         1.成員變量/字段(Field):直接定義在類的{}中的變量(在方法外)
         --報錯:無法從靜態(tài)上下文中引用非靜態(tài)變量

         2.局部變量(定義在方法中的變量)
         變量除了成員變量,就是局部變量.

         3.變量的作用域:可以起作用的領(lǐng)域.
         1.成員變量:在所定義的類中起作用
         2.局部變量:從定義的那個地方開始,到緊跟著結(jié)束的"}"之間
         */

        int age=18; // 局部變量
        System.out.println(age);/*輸出18,當(dāng)成員變量和局部變量同名時,編譯不會出錯,得到的結(jié)果采取就近原則*/
    }
}

9.表達(dá)式(expression):是由數(shù)字、運算符、數(shù)字分組符號（括號）、變量、常量等以能求得結(jié)果的有意義排列的組合。

用運算符號連接的變量/常量可稱為表達(dá)式.那么也就是說表達(dá)式是由常量、變量、運算符、括號組成能求得之的有意義結(jié)果的語句。
如：
a+b
3.14+a
(x+y)*z+100
表達(dá)式中操作數(shù)進行運算得到的最終結(jié)果就是表達(dá)式的結(jié)果
表達(dá)式的運算順序(大多和數(shù)學(xué)一樣,參照后面的運算符操作優(yōu)先級);
a + 110 -->表達(dá)式
操作數(shù) 運算符 操作數(shù)

10.在JAVA中數(shù)據(jù)類型整體上分為兩大類:

   1):基本數(shù)據(jù)類型/原生數(shù)據(jù)類型:共8個
        1>:數(shù)值型
            1/:整數(shù)類型: byte short int long;(不同正數(shù)類型在內(nèi)存中占用空間大小是不一樣的,整數(shù)常量默認(rèn)是int類型)
            2/:小數(shù)類型:float double;
        2>:字符型:char (字符:字母/符號)
        3>:布爾型:boolean,表示對錯:ture false;

   2):引用數(shù)據(jù)類型/對象數(shù)據(jù)類型:
        類 / 接口 / 數(shù)組

11.小數(shù)的默認(rèn)常量為double類型，若要聲明小數(shù)常量衛(wèi)float類型，就在后面加F或f

float表示單精度
double表示雙精度
但是兩者均不能表示精確的小數(shù)，那么在精度要求很高的系統(tǒng)如銀行系統(tǒng)中，就需要使用BigDecimal類型，它表示任意精度的數(shù)據(jù)

Java的浮點類型常量有兩種表現(xiàn)形式：
（1）十進制形式：例如：3.14，168.0，.618
（2）科學(xué)計數(shù)法形式：例如：3.14e2，3.14E2，1000E-2
科學(xué)計數(shù)法表達(dá)式返回的結(jié)果是Double類型的

默認(rèn)情況下，一個浮點類型的字面量默認(rèn)是double類型，若要聲明一個常量為float類型，則需要在常量后加上f或者F，double常量后面的D或者d可省略。注意：Java只有浮點型的變量才可以接受科學(xué)計算數(shù)的結(jié)果

12.字符類型:字符、字母和符號

char類型：表示16位的無符號整數(shù)或者Unicode字符，Java對字符占用兩個字節(jié)，可以表示一個漢字

什么是編碼？
計算機只能表示0和1兩個數(shù)，于是規(guī)定使用一個數(shù)字去表示一個特定的字符，比如a使用97表示 char前256個字符和ASICC（美國信息交互標(biāo)準(zhǔn)編碼）碼中的字符重復(fù)

13.基本數(shù)據(jù)類型的轉(zhuǎn)換

在8大基本數(shù)據(jù)類型（byte-1字節(jié),short-2字節(jié),int-4字節(jié),long-8字節(jié),double,float,char-2字節(jié),boolean）,boolean不屬于數(shù)值類型，不參與轉(zhuǎn)換
字節(jié)數(shù) byte < short(=char) < int < long < float < double （一般的byte short char不參與轉(zhuǎn)換 char雖然也是2字節(jié)但是不包含負(fù)數(shù)跟short比起來數(shù)量少，因此short和char不能相互轉(zhuǎn)換）
轉(zhuǎn)換規(guī)則其實就是各自數(shù)據(jù)類型的空間大小，把不同的數(shù)據(jù)類型看成是不同容量的容器
自動類型轉(zhuǎn)換，也稱為“隱式類型轉(zhuǎn)換”（從小到大）

強制類型轉(zhuǎn)換（從大到小 顯式類型轉(zhuǎn)換）：當(dāng)把大范圍類型的數(shù)值賦給另一個小范圍變量時，此時系統(tǒng)不能自動完成轉(zhuǎn)換，需要加上強制轉(zhuǎn)換符，但這樣的操作可能造成數(shù)據(jù)精度的降低或溢出，所以使用時要格外注意

byte b2 = 125; 把一個int類型常量賦值給byte類型變量，編譯時，發(fā)現(xiàn)125在byte的范圍之內(nèi)，底層就會轉(zhuǎn)換成byte類型的但是如果設(shè)置成byte b2 = 128; 則就會報錯了

14.表達(dá)式類型的自動提升

當(dāng)一個算數(shù)表達(dá)式中包含多個基本數(shù)據(jù)類型（boolean除外）的值時，整個算數(shù)表達(dá)式的數(shù)據(jù)類型將在數(shù)據(jù)運算時出現(xiàn)類型自動提升，其規(guī)則是：所有的byte,short,char類型自動提升到int類型 整個表達(dá)式的最終結(jié)果類型提升到表達(dá)式中類型最高的類型

String和任意數(shù)據(jù)使用，連接起來就是String（字符串）

double d2 = 123 + 1.1F + 99L + 3.14;
System.out.println(d2); // 輸出226.2400061035156

System.out.println('A' + 1); // 輸出66

byte b4 = 25;
// b4 = b4 + 3; // 表達(dá)式運算后已經(jīng)提升到int類型了，在賦值給byte類型，編譯會報錯
// 為了避免這種情況 將會用到賦值運算符
b4 += 3;  // 這里就體現(xiàn)出了+=賦值運算符的好處了
System.out.println(b4); // 28

b4 += 3 等價于 b4 = (byte)(b4 + 3)
查看第16點筆記

15.算術(shù)運算符

取模（求余數(shù)）：模數(shù)的符號忽略不計，結(jié)果的正負(fù)取決于被模數(shù)
注意：無窮大和NaN都屬于double浮點類型，但是所有的正無窮大都是相等的，所有的負(fù)無窮大也是相等的，NaN永遠(yuǎn)不相等，也不等于自己

public class ArithmeticOperatorsDemo {
    public static void main(String[] args) {
        // 操作數(shù)字
        System.out.println(10 + 2); // 12
        System.out.println(10 - 2); // 8
        System.out.println(10 * 2); // 20
        System.out.println(10 / 2); // 5
        System.out.println("----------------------");
        // 操作字符
        System.out.println('A' + 'B'); // 131
        // 操作字符串
        System.out.println("AAA" + "BBB"); // AAABBB
        System.out.println("----------------------");

        System.out.println(10 / 3); // 3
        System.out.println(9876 / 1000 * 1000); // 9000
        System.out.println("----------------------");
        // System.out.println(100 / 0);  // 報錯  by zero
        System.out.println(100.0 / 0); // Infinity正無窮大
        double d1 = 100.0 / 0;
        double d2 = 200.0 / 0;
        System.out.println("所有的正無窮大都相等嗎？");
        System.out.println(d1 == d2); // true
        double d3 = -100.0 / 0;
        double d4 = -200.0 / 0;
        System.out.println("所有的負(fù)無窮大都相等嗎？");
        System.out.println(d3 == d4); // true
        System.out.println("正無窮大和負(fù)無窮大相等嗎？");
        System.out.println(d1 == d3); // false

        System.out.println(100 / 0.0); // Infinity正無窮大
        System.out.println(-100 / 0.0); // -Infinity負(fù)無窮大
        System.out.println(0.0 / 0.0); // NaN Not a Number 自己都不等于自己
        double d5 = 0.0 / 0.0;
        System.out.println(d5 == d5); // false
        // 取模（求余數(shù)）：模數(shù)的符號忽略不計，結(jié)果的正負(fù)取決于被模數(shù)
        System.out.println(10 % 3); // 1

        // 自增 ++
        /*
        * ++前置情況
        *   ++a
        *   表示a變量自身先加1，再運算
        * ++后置情況
        *   a++
        *   表示a變量自身先加1，把遞增1之前的原始值拿去做運算
        * */
        // --道理一樣
        System.out.println("---------------");
        int a1 = 5;
        int b1 = ++a1;
        System.out.println("a1 = " + a1 + " b1 = " + b1); // a1 = 6 b1 = 6
        System.out.println("---------------");
        int a2 = 5;
        int b2 = a2++;
        System.out.println("a2 = " + a2 + " b2 = " + b2); // a2 = 6 b2 = 5
    }
}

16.賦值運算符

public class AssigningOperatorsDemo {
    public static void main(String[] args) {
        short a = 10;
        //a = a + 5; // 編譯報錯
        a += 5;
        // a += 5 等價于  a = (short)(a + 5);
        System.out.println(a); // 15
    }
}

17.比較運算符

==, !=, >, <, >=, <=, instanceof(檢查是否是類的對象) "Hello" istanceof String true
比較運算符用于比較兩個常量或者變量之間的關(guān)系，比較運算的結(jié)果都是boolean類型

18.三元運算符

三元運算符表示有三個元素參與的表達(dá)式，又稱為三目運算符，其語義表示為if-else。
語法格式為：X ? Y : Z 其中X為boolean類型表達(dá)式，先計算X的值，若X計算結(jié)果為true，則整個三目運算表達(dá)式的結(jié)果是Y,否則就是Z。三目運算符結(jié)果的類型是由Y和Z決定的

19.邏輯運算符

語法格式為：boolean result = 表達(dá)式A 邏輯運算符 表達(dá)式B
&：表示并且，當(dāng)操作數(shù)A和B都為true結(jié)果才為true，否則結(jié)果result是false
&&：和&結(jié)果相同，具有短路效果，如果左邊操作數(shù)A是false，result一定是false，且不運行B的運算
|：表示或者，當(dāng)操作數(shù)A和B都為false結(jié)果才為false，只要有A或者B為true，結(jié)果result是true
||：和|結(jié)果相同，具有短路效果，如果左邊操作數(shù)A是true，result一定是true，且不運行B的運算
^：判斷A和B是否相同，不同則為true，相同則為false
!：取反，!true結(jié)果是false，!false結(jié)果是true

20.位運算符

&：參與運算的兩個數(shù)，若相應(yīng)位數(shù)的值都為1，則該位結(jié)果值是1，否則是0.
|：參與運算的兩個數(shù)相應(yīng)位中只要有一個1，結(jié)果就是1.
^：參與運算的兩個數(shù)相應(yīng)位相同則結(jié)果為0，否則為1.
~：表示把兩個二進制位的“1”換成“0”，把“0”換成1.
<<：將操作數(shù)的二進制碼整體左移指定位數(shù)，左移之后的空位用“0”來補充.

：將操作數(shù)的二進制碼整體右移指定位數(shù)，右移之后的空位用“符號位”來補充：
若是正數(shù)用“0”來補充
若是負(fù)數(shù)用“1”來補充（操作負(fù)數(shù)：取反，求補）

：將操作數(shù)的二進制碼整體右移指定位數(shù)，右移之后的空位用“0”來補充：

boolean的true和false，在底層使用一位的1和0表示

public class BitOperatorsDemo {
    public static void main(String[] args) {
        System.out.println(3 & 5);
        System.out.println(3 | 5);
        System.out.println(3 ^ 5);
        System.out.println(~3);

        System.out.println(2 << 3);
        System.out.println(16 >> 3);
        System.out.println(-16 >> 3);
        
        // 交換兩個數(shù)
        int a = 10;
        int b = 20;
        System.out.println("a = " + a + " b = " + b);
        a = a ^ b;
        b = a ^ b;
        a = a ^ b;
        System.out.println("a = " + a + " b = " + b);
    }
}