1.開發環境的搭建
a)下載安裝JDK
b)JDK—java develop kitjava開發工具包
JDK中包含JRE
c)JRE—java runtime environmentjava執行時環境
2.配置環境變數
3.第一個java程式
public class HelloWorld{// 一個公有類HelloWorld
public static void main(String[] args){// 程式的入口
System.out.println(“Hello World”);// 輸出一句話
}
}
開始執行CMD，切換到D盤目錄下，
執行javac HelloWorld.java
我們會在D盤個目錄下發現生成一個HelloWorld.class位元組碼檔案，然後再執行java HelloWorld，得到程式執行後的結果
一個原始檔中，至多有一個公有類，若一個原始檔中有公有類，那麼這個原始檔的名字就必須和這個公有類名一致，若原始檔沒有公有類，那原始檔的名字不需要和任何一個類的名字一致
公司編碼規範：一個原始檔中必須有公有類
類庫檔案都是以jar結尾的，所以我們一般稱它為架包。
IDE開發工具
–Eclipse—免費

SRC工程的原始碼目錄
我們在SRC目錄下一般不直接寫我們的原始檔，先建包，包就是一級一級的目錄，我們在包目錄下編寫我們的原始檔
Java塊
1.定義類的塊稱為類塊，定義方法的稱為方法塊，我們所有的變數，方法等都在塊中宣告和定義。
2.識別符號的命名規則
類 —– 所有單詞的首字母大寫
方法、變數 —- 第一個單詞首字母小寫，其餘單詞首字母大寫
包名 —- 全小寫
常量 —- 全大寫
3.資料型別及分類
基本資料型別：1)數值型：a.整型(byte,short,int,long)
b.浮點型(float,double)
2)字元型(char)
3)布林型(boolean)
引用資料型別：陣列，介面，類
4.變數定義在方法塊中必須要初始化才能使用
5.變數的三大要素：資料型別，名稱，作用域
作用域越小，優先順序越高
強型別語言：
變數使用前一定要宣告，並且初始化；
變數一旦宣告，型別不可變；
相同的作用域不能定義重名變數；
宣告明確的資料型別。
6.三大特性，封裝，繼承，多型

====================================================
資料的原碼、反碼、補碼
[+1] = [0000 0001]原=[0000 0001]反=[0000 0001]補
[- 1] = [1000 0001]原=[1111 1110]反=[1111 1111]補
計算1-1
原碼計算
[+1+(-1)] = [0000 0001]原+[1000 0001]原=[1000 0010]原=-2
反碼計算
[+1+(-1)] = [0000 0001]反+[1111 1110]反=[1111 1111]反
=[1000 0000]原=-0
問題:首先0是不該有符號的，其次表示0的原碼就有兩個了，分別是[0000 0000]和[1000 0000]，這就歧義了
補碼計算
[+1+(-1)] = [0000 0001]補+[1111 1111]補=[0000 0000]補
=[0000 0000]原 = 0

補碼的計算解決了正負0的問題，同時還解放了[1000 0000], [1000 0000]就用來表示-128了

資料型別轉換
自動資料型別轉換
1.兩種型別彼此相容
2.目標資料類型範圍大於原型別資料範圍

5
0000 0101
3
0000 0011

==========
0000 0110 6
按位與
0000 0001
按位或
0000 0111
異或
0000 0110

=================================================
If(條件表示式){
}
If(條件表示式){
}else{
}
If(條件表示式1){
}else if(條件表示式2){
}else if(條件表示式3){
}

Switch(表示式)//注意程式碼冗餘(表示式的資料型別只能是int、byte、short、char)
Case 表示式值1：
Do something;
Break;
Case 表示式值2：
Do something;
Break;
Default:
Do something;
For迴圈
Do while迴圈
While迴圈

陣列
1.陣列的宣告
陣列型別[] 陣列名稱
陣列型別 陣列名稱[]
a)int[] array;
b)int array[];
宣告陣列時，不能指定長度
2.陣列的建立
陣列名稱 = new 元素資料型別[元素個數];
array = new int[5];
建立陣列的時候，必須指定長度
多維陣列s
int a[][] = new int[3][];
{1,2,3,4} {5,6,7} {8,9}

定義方法
此處的int為方法的返回值型別
square是方法的名字
x是square方法的形式引數，int是形式引數的型別
public static int square(int x){
int y = x*x;
return y;
}

return 除了可以返回資料之外，還能結束方法的執行，在void方法中，也是可以使用的，它的意義就僅剩結束方法的執行。

面向物件程式設計思想：就是以人類的正常思維去分析、設計以及編碼的一種思想

抽象
類：生成物件的模板，它用來描述一類群體
屬性：屬性用來描述這類群體的特徵，定義在類塊當中（全域性變數或者成員變數），全域性變數有預設值。
注意：只有引用資料型別的值可以為null
方法：用來描述這類群體的行為
這些屬性和方法又叫物件屬性、物件方法
物件：用來描述具體的一個個體

構造器/構造方法
構造方法作用：它是給物件屬性初始化的
構造方法是這樣的方法：
1.首先，方法的名字必須和類名一致；
2.構造方法可以有參，也可以無參；
3.構造方法一般都是public的
4.構造方法沒有返回值，連void也不可以寫。

例項化物件有兩個必不可少的步驟：
1.在記憶體當中開闢記憶體空間儲存物件
2.呼叫構造方法給物件初始化

如果我們在類中沒有定義任何的構造方法，系統會自動給這個類分配一個空的、無參的構造方法；如果這個類已經定義了構造方法，系統就不會自動分配了。

的地方，子類一定可以出現，子類必須能夠完全替代其父類所有特徵和行為的情況下，這兩個類才有繼承關係。
繼承是程式碼重用的一種重要手段，它還是達到開閉原則的基礎。
開閉原則：對拓展開放，對修改關閉。
程式碼重用不是繼承最大的優點，它的最大優點是拓展。

【子類不能繼承父類的構造方法】
【子類不能繼承父類的私有成員】

例項化的過程：
如果一個類有父類，在例項化的過程當中，先例項化父類物件，然後例項化子類物件，子類構造方法預設呼叫的是父類的無參構造方法例項化的物件，如果父類當中沒有無參的構造方法，子類就必須顯式呼叫父類的其他有參構造方法

super關鍵字
代表父類物件
super()—>父類的無參構造方法,只能使用在子類當中，並且在子類構造方法內只能使用一次，且只能使用在第一行

===============================================
包
com.neuedu.chapter1一級一級資料夾
匯入包
import 包名.類名
//7包下Student類物件
Student s = new Student();
//6包寫Student類物件
com.neuedu.chapter6.Student s1 = new com.neuedu.chapter6.Student();

==========================================
封裝
public
protected
friendly default(預設的)
private

修飾類
public friendly 可以修飾類
public:公有的，在工程當中都能看到的，一個類至多有一個公有類，可以有多個非公有類，如果有公有類，原始檔的名字必須和這個公有類名字一樣，若一個原始檔沒有公有類，原始檔的名字就不需要和任何一個類的名字相同。
protected private 不能修飾
friendly：預設的，一個原始檔當中可以有多個訪問許可權符是預設的類
修飾屬性、方法

修飾屬性、方法 public  protected   預設的 private
當前類         可見       可見     可見    可見
相同包的類      可見       可見      可見  不可見
相同包的子類      可見      可見      可見  不可見
不同包的類       可見      不可見     不可見 不可見
不同包的子類      可見      可見      不可見 不可見

JavaBean 就是一個普通的類，但是需要滿足三個條件
1.所有屬性全私有；—- 保護屬性的作用
2.有無參構造方法；—- 跟框架相關
3.有公有的get、set方法。—- get方法獲取屬性，set方法為屬性賦值
方法的重寫：
發生在子類當中，方法名稱一樣，引數列表一樣，返回值型別一樣，子類重寫方法的訪問許可權符不小於父類被重寫方法。

=====================================================
過載（編譯時多型）和重寫（執行時多型）的區別？
過載發生在同一個類當中，重寫發生在子類當中；
過載方法名相同，引數列表必須不同，返回值型別可以相同可以不同
重寫方法名稱一樣，引數列表一樣，返回值型別一樣，子類重寫方法的訪問許可權符不小於父類被重寫方法。

=====================================================
多型（解耦合）
1.字面意義：一個事物的不同形態
2.編碼意義：一個方法的不同實現
3.設計意義：把做什麼和怎麼做分開

多型的前提
1.有泛化關係（繼承或實現）
2.有方法的重寫
3.有父類引用指向子類物件（上溯造型）

多型優點：解耦合，提高了程式的可維護性、靈活性和拓展性
開閉原則是絕對的

靜態static
Static 可以修飾屬性，用Static修飾的屬性，可以直接用
類名.屬性名 直接訪問
屬性和方法我們說必須要通過物件才能訪問，但靜態變數直接可以通過類名.屬性名直接進行訪問，所以靜態變數的儲存位置就不在堆區當中，而是在方法區中的靜態區。（靜態區儲存靜態屬性）
靜態屬性對所有類物件都是共享的
Static 可以修飾方法—靜態方法
靜態方法只能訪問靜態變數，不能訪問非靜態變數，因為訪問非靜態變數需要物件，而靜態方法的訪問不需要物件。
Static{
//靜態塊
}

單例模式
保證一個類只有一個例項
1.因為例項化物件需要呼叫構造方法，那麼我們只要讓這個構造方法不可見就行構造方法私有化
private Singleton(){
}
2.在這個類中例項化一個私有的、靜態的類物件。
private static Singleton s = new Singleton();
3.構造方法私有化之後，得有一個返回這個類物件的方法，這個方法是公有的、靜態的、返回值型別是當前類物件型別的（但不能是 return new Singleton();）。
public static Singleton getInstance(){
//錯的
//return new Singleton();
return s;
}

final—最終的
修飾屬性:代表常量，在整個程式執行過程中不可變，系統不會自動給它賦初始值，所以必須手動賦值。
在方法中用final定義常量時，可以在宣告時不賦初始值，一旦賦值只能賦值一次
修飾方法：用final修飾的方法不能被重寫。如果想在眾多方法中保護一個或幾個方法的時候，可以用final修飾。
修飾類：最終的類，不能被繼承。

抽象
修飾方法：
抽象方法,用abstract修飾，抽象方法沒有實現，也就是說抽象方法沒有方法塊
public abstract void h();
如果一個類當中有抽象方法，那麼這個類就必須是抽象類（反之不成立）
如果一個類當中有抽象方法，那麼這個類的子類，必須實現這個抽象方法，除非這個子類也是抽象類。
抽象類不能例項化物件—-所以它的作用就只剩被繼承了。
抽象方法不能用static修飾。

什麼樣的類適合定義成抽象類？
因為抽象類作用只是被繼承了，所以父類適合定義成抽象類。

能否用final和abstract同時修飾一個類？
不能，抽象類作用是被繼承，final類不能被繼承，一個類不能例項化物件又不能被繼承，這個類就徹底失去意義了。
介面interface
如果一個抽象類當中的方法全都是抽象方法，那麼這個類就是純抽象類，純抽象類可以定義成一個介面。

問題：介面是不是類？
介面不是類

特點：
1.抽象類中可以包含非抽象方法，但介面中的方法必須是抽象方法。
2.介面中的變數預設是public static final的
介面中的方法預設是public abstract的
3.介面也不可以例項化物件
4.一個類可以實現介面（implements）
如果一個類實現了介面，這個類就必須實現這個介面中所有的抽象方法，除非這個類是抽象類。
5.為什麼要用介面？
類的繼承是單繼承，一個類最多隻有一個父類，介面就是用來彌補單繼承的缺點的，因為介面是可以多實現的。
6.我們通常用類描述一類群體，用介面描述一類角色。
如果一個類既有繼承，又有實現，繼承在前，實現在後。

7.類和類之間是繼承關係，並且是單繼承。
類和介面之間的關係是實現，一個類可以實現多個介面。
介面和介面之間是繼承關係，一個介面可以繼承多個介面。
8.介面和抽象類的區別
介面當中只包含常量和抽象方法，抽象類中可以包含非抽象方法，類可以實現多個介面，但只能有一個父類，介面之間可以多繼承
內部類
內部類就是在一個類中內部的類，它嚴重破壞了良好的程式碼結構，但為什麼要用它？因為它能隨意的訪問外部類的所有成員，包括私有的成員。
內部類可以用public、protected、預設的、private去修飾，並且這個內部類可以是靜態的。

工具類
Java當中為我們提供了API，API當中包含了大量的開發中所需要的包。
類的全限定名包名.類名
1.java.lang 這個包不需要匯入就可以直接使用