Editplus：Editplus與jdk的連接配置，如：javac（編譯）、java（運行）、javap(查看字節碼)
a) 配置內容：
i. javac（編譯）：參數為 -d .
ii. java（運行）：參數為
：
a) 通過HelloWorld類講解了關鍵字、命名規范、修飾符；
pubic class HelloWorld{
public static void main(String[] args){
System.out.println(“Hello World!”);
}
}
b) jdk與jre的區別；內容、范圍///開發、運行//裡面包含了各種類庫和工具、java程序的運行環境JVM
jar；java下的壓縮文件
javac；編譯
javadoc；可形成幫助文檔
共有：java；運行
native2ascii；本地碼改成ASCII碼
javap;查看字節碼文件
c) 字節碼；是java跨平台的一個機制，是一段二進制代碼，是一種包含執行程序、
由一序列 op 代碼(操作碼)/數據對組成的二進制文件。字節碼是一種中間碼，它比機器碼更抽象，是包含一個執行程序的二進制文件（.class）
數據單位的進制；K是千 M是兆 G是吉咖 T是太拉 8bit(位)=1Byte(字節)
1024Byte(字節)=1KB 1024KB=1MB 1024MB=1GB 1024GB=1TB
java中，字節碼是CPU構架（JVM）的具有可移植性的機器語言。
d) 四個目標；
1、java簡介；歷史和地位—跨平台純面向對象的語言–第三代語言：繼承、封裝、多態：方法同名，體不同
C++ — 類函數
.NET—跨語言的平台
SQL–結構化查詢語言–第四代語言
Lisp、Prolog人工智能語言—第五代語言
自身發展：95年後變成javaSE
java體系：javase、javaee、javame
特點：面向對象、平台無關、健壯性：無指針、內存的申請與釋放（內存分配）
2、工作原理
I java虛擬機
Java虛擬機（JVM）是以 字節碼 為機器指令的系統，編譯虛擬機的指令集與編譯微處理器的指令集非常類似。
Java虛擬機包括一套字節碼指令集、一組寄存器、一個棧、一個垃圾回收堆和一個存儲方法域。——堆，棧，本地方法棧，方法區，pc寄存器
.java—.class
Ii 垃圾回收機制(GC);不再使用的內存空間應該回收起來
java 的垃圾回收機制：Java的垃圾回收機制是Java虛擬機提供的能力，用於在空閒時間以不定時的方式動態回收無任何引用的對象占據的內存空間。需要注意的是：垃圾回收回收的是無任何引用的對象占據的內存空間而不是對象本身
1.垃圾回收是由虛擬機自動執行，不能人為地干預。
2.系統比較空閒（垃圾回收線程）執行
3.對象不在被引用.對象處於引用的隔離島狀態（隔離引用），對象具備了回收的條件
4.gc()方法，可以建議虛擬機執行垃圾回收，但是不能確定是否會執行回收。
iii、開發環境搭建
tools:JCreator\Eclipse\MyEclipse\Jbuilder\NetBeans
iv、第一個java程序
java源文件；.java
基本組成是class，只能有一個public類，命名與其一致
java運行（JVM）： 類裝載器、字節碼校驗、解釋器
java中只有值傳遞
（標示符和關鍵字、常量與變量、基本數據類型，自動轉換，強制轉換、轉義字符、表達式）
a) 標示符:標示符的格式要求：
i. 定義：java對各種變量、方法和類等要素的命名時使用的字符序列，均須遵守標示符的規則
ii. 規則：
1. 由字母、下劃線_、美元符$、數字組成
2. 開頭不能是數字
3. 大小寫敏感，長度無限制(區別C)
4. 類名首字母一般要大寫，方法名一般要小寫，並且遵循駱駝命名規則，如：ActiveDemo
b) 關鍵字
i. 定義：java中一些賦以特定的含義，用作專門用途的字符串
ii. 所有關鍵字都必須小寫
iii. 常用的關鍵字用
1. 用於數據類型的：int、long、short、String、byte、char、float、double、boolean
2. 用於流程控制的：if、else、for、switch、case、do、while、break、continue
3. 訪問控制符：public、protected、default、private
4. 用於異常的：try、catch、finally、throw、throws
5. 返回類型的：native、super、null、void、return、synchronized(同步)
6. 實例：instanceof、this、new
7. 面向對象：class、extends、interface、abstract、final、implements、import、package、static
8. goto和const用來破壞程序入口，也是關鍵字
c) 常量與變量
i. 常量：（public static final 常量名；）
1. 定義：始終不變的值，可以是數值、字符、字符串
2. 規則：習慣上命名時要大寫
ii. 變量：（type varName [=value]；）
1. 注意：局部變量使用前必須先初始化不然編譯失敗！
iii. 調用格式：
1. 調用同文件中的其他類的變/常量格式為：對象.變量
2. 同類中調用其它函數的實例變/常量格式為:new 對象（）.變量名
3. 同類中調用其它函數的類變/常量格式為: 類名.變量名
d) 數據類型
i. 基本數據類型：byte、short、int、long、char、float、double、boolean
1. 默認值(范圍是-2^(n-1)∽2^(n-1)-1)
a) Byte//1、short//2、int//4、long//8——默認值為0
b) char //2——–字符0—–范圍是0~65535—unicode編碼
c) float//4、double//8——–0.0
d) Boolean//2—————false
ii. 引用數據類型：數組、類、接口
e) 自動轉換（隱式轉換）(由小轉大)
i. 定義：自動類型轉換，也稱隱式類型轉換，是指不需要書寫代碼，由系統自動完成的類型轉換
ii. 轉換規則：byte?short（char）?int?long?float?double
iii. 示例代碼：
1. int i = 4;
2. float n = i;
f) 強制轉換（由大轉小）
i. 轉換規則：double→float→long→int→short(char)→byte
ii. 格式：（轉換到的類型）需要轉換的數值
iii. 示例代碼：
1. double d = 3.10;
2. int n = (int)d;
iv. 注意：強制轉換通常都會導致精度的損失
g) 轉義字符
i. \b退格
ii. \n換行
iii. \r回車
iv. \’單引號
v. \”雙引號
vi. \反斜槓
h) 運算符——表達式
i. 定義：表達式是由數字、算符、數字分組符號(括號)、自由變量和約束變量等以能求得數值的有意義排列方法所得的組合。約束變量在表達式中已被指定數值，而自由變量則可以在表達式之外另行指定數值
ii. 算術運算符：
1. 單目: ++（自加1）、–（自減1）、+（取正）、-（取負）
2. 雙目: ＋ 、－ 、* 、/、 ％
3. 三目: ？： 如：a>b?a:b
iii. 關系運算符：——-返回結果true/false
1. 等於符號:==
2. 不等於符號:!=
3. 大於符號:>
4. 小於符號:<
5. 大於等於符號:>=
6. 小於等於符號:<=
iv. 邏輯運算符：——返回結果true/false
1. 與（&&）：假短路
2. 或（||）：真短路
3. 非（！）：
v. 位運算符：—–將原數轉化為二進制計算
1. 與（&）： 如 1100&1010=1000
2. 或（|）： 如 1100|1010=1110
3. 非（！）： 如 !1100=0011
4. 異或（^）： 如 1100^1010=0110
5. << 帶符號左移 ——相當於乘以2
6. >>帶符號右移 ——-相當於除以2
7. >>> 無號右移
8. 異或的規律：
a) a ^ a = 0
b) a ^ b = b ^ a
c) a ^ b ^ c = a ^ (b ^ c) = (a ^ b) ^ c;
d) d = a ^ b ^ c 可以推出 a = d ^ b ^ c.
e) a ^ b ^ a = b
vi. 賦值運算符：
1. =、+=、-=、*=、/=、%=、&=、^=、|=、<<=、>>=
vii. Intanceof:—-歸屬
1. 定義：為雙目運算符，左邊操作元是一個對象，右邊是一個類。當左邊的對象是右邊類的對象時，返回true
2. 格式：result = object instanceof class 如：a = b instaceof B;//true
viii. 優先級：（從高到低、從左到右）
1. () []
2. ! +(正) -(負) ~ ++ –
3. * / %
4. +(加) -(減)
5. << >> >>>
6. < <= > >= instanceof
7. == !=
8. &(按位與)
9. ^（位異或）
10. |（位非）
11. &&
12. ||
13. ？：
14. = += -= *= /= %= &= |= ^= ~= <<= >>=>>>=
a) If…else: 例1.1:
i. If（a>b）{
ii. System.out.println(a);
iii. }else if(b>c){
iv. System.out.println(b);
v. }else{
vi. System.out.println(b);
vii. }
b) 分支：（switch）
i. 格式：switch（條件語句）{
case ：
case ：
…..
default ：
}
ii. 例1.2:switch(month){
case 1：System.out.println(“spring”);break;
case 1：System.out.println(“spring”);break;
case 1：System.out.println(“spring”);break;
case 1：System.out.println(“spring”);break;
default: System.out.println(“spring”);break;//一定會執行的語句
}
c) For循環
i. 格式：For(初始化語句;條件語句;控制語句){
循環體；
}
ii. 例1.3：for（int i=1;i<101;i++）{
int sum = 0;
sum += i;
}
d) while
i. 格式：while(條件語句){
//初始化語句；
循環體；
//控制語句；
}
ii. 例1.4：int i=1;
while(i<101){
int sum=0;
sum += i;
}
e) Do….while()
i. 格式: do{
循環體；
}while(條件語句);
ii. 例1.5：int i =1;
do{
int sum = 0;
sum += i;
}while(i>101);
f) 增強型for循環———-主要用於打印數組元素
i. 格式：for(e:數組名){
循環體
}
ii. 例1.6：int[] a = new int[10];
for(e:a){
System.out.println(e);
}
a) 方法—函數
i. 定義：一段用來完成特定功能的代碼片段
ii. 聲明格式：【修飾符】返回類型 方法名（形參列表）{
方法體；
}
iii. 語法解釋：
1. 形式參數：在方法被調用時用於接收外界輸入的數據
2. 實參：調用方法時實際傳給方法的數據
3. 返回值：方法在執行完畢後返回給調用它的環境的數據
4. 返回值類型：事先約定的返回值的數據類型，無返回值，必須給出返回類型void
5. return語句中止方法的運行並指定要返回的數據
iv. 調用格式：
1. 靜態方法（又稱類方法）的調用：類名.方法名(實際參數)
2. 實例方法的調用：對象名.方法名(實際參數)
3. 調用中傳遞參數時，遵循的規則是：基本數據類型是該數據本身，引用數據類型傳遞的是對象的引用（地址），不是對象本身—-基本數據類型：值傳遞；引用數據類型：地址傳遞。
v. 例1：
public class DemoMethod{
public static void main(String[] args){//靜態方法（又稱類方法）的調用：類名.方法名(實際參數)
show(“i am a girl”);
//實例方法的調用：對象名.方法名(實際參數)//如何產生對象(Object)，格式：new 構造方法()
//和類同名的方法稱為構造方法
//什麼是構造方法(Constructor)？每個類都有一個和類名相同的構造方法，且自動產生
// new DemoMethod().display();
new DemoMethod().visiable(12,”aaa”,3.0f);
}
//靜態方法的定義【有關鍵字static修飾的方法】
public static void show(String s){//自定義方法
System.out.println(s);
}
//實例方法的定義【沒有關鍵字static修飾的方法】
public int display(){System.out.println(“welcome to jiangxi”);return (85);//返回結果，可以用括弧，也可以不用}
//多個參數的實例方法
public void visiable(int x,String y,float f){System.out.println(“=======================”);}
}
b) 遞歸———-必須要有出口
i. 定義：遞歸用於讓一個函數從其內部調用其自身
ii. 特點：
1. 程序代碼簡練，易於理解但浪費內存
2. 一定要有返回類型
3. 一定有if…….else……且if中有終止條件
a) 面向對象技術基礎
i. 面向對象設計的方法論【OOA（分析）?OOD(設計)?OOP（編程）?Test（測試）?部署】
ii. 面向對象（Object Oriented,OO）特點：
1. 對象唯一性：每個對象都有自身唯一的標識，通過這種標識，可以找到相應的對象。在對象的整個生命期中，它的標志都是不改變的，不同的對象不能有相同的標識（地址）。
2. 封裝性（抽象性）：把客觀事物封裝成抽象的類，並且類可以把自己的數據和方法只讓可信的類或者對象操作，對不可信的進行信息隱藏。
3. 繼承性：繼承性是子類自動共享父類數據結構和方法的機制，這是類之間的一種關系，java中的類只支持單繼承，接口支持多繼承
4. 多態性（多形性）：多態性是指相同的操作或方法、過程可作用於多種類型的對象上並獲得不同的結果。不同的對象，收到同一消息可以產生不同的結果，這種現象稱為多態性
5. 總結作用：封裝可以隱藏實現細節，使得代碼模塊化；繼承可以擴展已存在的代碼模塊（類）；它們的目的都是為了——代碼重用。而多態則是為了實現另一個目的——接口重用！多態的作用，就是為了類在繼承和派生的時候，保證使用“家譜”中任一類的實例的某一屬性時的正確調用。
iii. 面向對象（OO）基本特征
1. 封裝（package）
2. 繼承（inheritance）——關聯關系
a) 繼承（泛化generalize）
i. 實現繼承
ii. 可視繼承
b) 組合（聚合）
i. 接口繼承
3. 多態（Polymorphism）
a) 重寫（override）
i. 方法
ii. 接口（interface）
b) 重載（overload）
i. 同名函數
b) 類的聲明和使用
i. 聲明格式：
【修飾符】class【類名】{
方法體；
}
ii. 例1：
public static class Demo{
System.out.println()；
}
c) 對象的聲明與使用
i. 格式：類名 對象的引用變量 = new 類名（）;
ii. 例2：Demo d = new Demo();
d) 類與對象的比較
i. 類就是對象的模板，對象是類的實例
e) 構造方法
i. 定義：定義在類中，用來初始化對象的成員變量的方法，返回的是內存地址
ii. 格式：
1. 【修飾符】方法名（）{}
2. 例3：public Demo（）{}
iii. 要求：
1. 與類同名；2、沒有返回值（無void 的修飾）；必須要先創建對象，在對象上進行調用（new）
a) UML定義：（Unified Modeling Language）統一建模語言，一種用於面向對象的軟件工程的分析與設計階段的一種可視化建模語言
b) UML關系（類與類之間的關系）：關聯對屬性，依賴對方法
i. 關聯關系：菱形指向整體 has a
1. 關聯關系——若在邏輯上A是B的“一部分”（a part of），則不允許B從A派生，而是要用A和其它東西組合出B
2. 聚合（aggregation）—實線空心菱形
3. 組合—整體與部分不可分開，實線實心菱形
ii. 泛化（Generalization）關系（繼承）：用實線空心三角形指向父類 is a
1. 若在邏輯上B是A的“一種”，並且A的所有功能和屬性對B而言都有意義，則允許B繼承A的功能和屬性
iii. 實現關系（接口）：虛線
iv. 依賴(Dependency)關系： A”————>”B(A依賴於B) use a 虛線箭頭
c) 修飾符圖形
i. + public - private # protected ~ 默認訪問
d) 建模圖形（9種）：
i. 用例圖（Use Case Diagram）：展示系統外部的各類執行者與系統提供的各種用例之間的關系
ii. 類圖（Class Diagram）：展示系統中類的靜態結構（類是指具有相同屬性和行為的對象），類圖用來描述系統中各種類之間的靜態結構
iii. 對象圖（Object Diagram）：是類圖中的一種實例化圖（是對類圖的實例化）
iv. 順序圖（時序圖）序列圖（Sequence Diagram）：展示對象之間的一種動態協作關系（一組對象組成，隨時間推移對象之間交換消息的過程，突出時間關系）
v. 協作圖（合作圖）（Collaboration Diagram）：從另一個角度展示對象之間的動態協作關系（對象間動態協作關系，突出信息收發關系）
vi. 狀態圖（Statechart Diagram）：描述一類對象具有的所有可能的狀態及其轉移關系（展示對象所具有的所有可能的狀態以及特定事件發生時狀態的轉移情況）
vii. 活動圖（Activity Diagram）：展示系統中各種活動的執行流程（各種活動的執行順序、執行流程）
viii. 構件圖（Component Diagram）：展示程序代碼的物理結構（描述程序代碼的組織結構，各種構件之間的依賴關系）
ix. 部署圖（Deployment Diagram）：展示軟件在硬件環境中（特別是在分布式及網絡環境中）的配置關系（系統中硬件和軟件的物理配置情況和系統體系結構）
a) 類的定義：類是具有相同屬性和相同操作的對象集合，類是對象的模板，一個類可以產生對個對象，產生單個對象的話就是單例模式，類是對現實世界中實體的抽象，對象是對現實世界中實體的實例
b) 類的組成：字段（成員變量）+方法+初始化塊（靜態初始化塊+對象初始化塊）
c) 命名規則：類名的首字母大寫；變量名和方法名（構造方法除外）的首字母小寫，采用駱駝名命名標識
d) 字段（實例變量+類變量（靜態變量））的定義格式：
【修飾符（4p、static、final）】 數據類型 屬性名【=默認值】；
e) 方法的定義格式：【修飾符（4p、static、final、abstract）】 返回值 方法名（【參數列表】）{ 代碼塊；}
f) 初始化順序：靜態初始化塊?類變量，實例變量初始化?對象初始化塊和成員變量初始化（在程序代碼中的先後順序來定）?構造方法
g) JavaBean規范：
i. 必須是公共類，並將其訪問屬性設置為public,如：public class Stu{}
ii. 必須有一個空的構造方法（public、無參）：必須有一個不帶參數的公共構造器
iii. 字段（實例變量）要私有化，首字母要小寫，用private修飾 如：private int id；
iv. 字段應該通過一組存取方法（getter和setter）來訪問，一般是用Eclipse、JBuilder、IDE等工具生成getter和setter方法
v. setter和getter規范：字段首字母小寫——如：
1. public class Demo{
a) private String name;
b) public Demo(){}
c) public Demo(){
System.out.println(“不錯”);
d) }
e) public void setName(String name){
this.name = name;
f) }
g) public String getName(){
return name;
h) }
}
a) 一維數組
i. 定義：數組就是相同類型元素的集合
ii. 數組變量是引用類型，棧stack（FILO，自動回收）引用堆heap（new出來的，樹形結構，JVM回收）中的數據；
iii. 格式：int[] a = new int[3];
int[] a = {1,2,4};
iv. 使用for循環遍歷輸出，獲得數組長度length，訪問元素
For…each: 增強型for循環
for(String i:a){//增強型for循環System.out.println(i);}
//冒泡排序
public class SortTest {
public void sort(int[] args){
System.out.println(“排序前 “);
for(int m : args){System.out.print(args[m]+”,”);}
int time1 = 0,time2 = 0;
for(int i = 0 ; i < args.length-1 ; i++){for(int j = i+1 ; j < args.length ; j++){int temp ;if(args[i] > args[j]){temp = args[j];args[j] = args[i];args[i] = temp;}}}System.out.println();System.out.println(“排序後 “);for(int n : args){System.out.print(n+”,”);}}public static void main(String[] args) {int[] arg = new int[]{2,1,4,5,8,7,6,3,9,0};new SortTest().sort(arg);}
}
b) 二維數組—–實質是一維數組引用另一維數組
i. 聲明：Int[][] arr;//4個字節
ii. 創建時必須創建行，初始化就是對每個元素進行初始化，使用增強型for循環
a) Object類是所有類的超類；
b) 常用方法：HashCode()—-哈希值，如：
i. IntegertoHexString(p1.hashCode());//把哈希碼的無符號十六進制轉換成十進制
c) getClass()//獲取運行時的類
d) toString()//返回字符，相當於getClass().getName()+”@”+Integer.toHexString(HashCode());
e) clone()//創建一個與源對象完全相同的對象，但新對相象與源對象不相等
i. 子類重寫clone（）要求：1、創建一個類A實現cloneable接口；2、重寫Object的clone()，調用super.clone()
ii. 代碼實現：如
public class Person implements Cloneable{
int as ;
protected Object clone() throws CloneNotSupportedException{Person p = (Person)super.clone();
}
}
public class PersonDemo{public static void main()throws CloneNotSupportedException{Person p = new Person();p.as=11；System.out.println(“Before clone”+p.as);Person p1 = (Person)p1.clone();p1.as=22;System.out.println(“After clone”+p.as);}}
