第一章：開發簡單Java應用程序
1、 計算機程序：一組有序指令的集合
2、Java語言分為3個領域：
javaSE是Java技術核心（指桌面應用程序）：QQ、百度雲…
javaEE是企業標准（面向Internet的應用程序）：京東、淘寶….
javaME(移動設備、小型嵌入開發)：手機上的軟件
3、 三步驟：
編寫源程序（程序以.java結尾）
編譯（使用javac指令編譯源程序 ，編譯后的文件 以.class結尾）
運行（使用java指令運行編譯后的文件）
4、 使用Myeclipse開發java程序步驟：
1）創建項目
2）編寫源代碼
3）編譯
4） 運行
5、 外層框架
Public class 類名{
}
注意：類名和文件一致
6、 內層框架
Public static void main (String[] args) {
}
注意：方法名必須是main
主方法四要素：public static void String[] args
7、 輸出指令
System.out.println(“女”);
System.out.println(“18’);
注意：System首字母大寫，
Println和print區別：println輸出后換行；print只輸出不換行
（建議用Println）
8、\n和\t
（1）\n換行；
（2）\t制表位，4個字符作為一個單位
9、注釋：
1）// 單行注釋 以//開始到行末結束
2）/**
*
*/文本注釋
3）\*……*\ 多行注釋 多行用於注釋代碼塊
10、java相關的技術：
Javascript jquery mysql 前台
jsp servlet hibernet spring struts2后台
orcale ……數據庫
第二章：變量、數據類型和運算符
1、變量：存儲數據的一個基本單元。
2、變量的聲明和賦值：
1）聲明並賦值：數據類型 變量名=值; 例：int price=1000;
2）聲明、賦值分兩步：數據類型 變量名; 例： int price;
變量名=值; price=1000;
3、數據類型2種：
（1）基本數據類型8種：
1）byte 長度：-128~127（-2的7次方到2的7次方減1）
2）short -2的15次方到2的15次方減1
3） int -2的31次方到2的31次方減1
4） long -2的63次方到2的63次方減1 99l
5）foat 99f
6）double 雙精度double price=32.5;
7）boolean 真（true） 假（false） bolean isBrand=true
8）char 一個字符 ，兩個字節 范圍0~65535 參照ASCII字符編碼表 char sex=’男’; char num=65;(輸出A)
（2）引用數據類型：
1）String 字符串 例： String name=”張三”;
2）類
3）接口
4）數組
4、變量命名規范：
（1）英文單詞或拼音
（2）首字母：以字母、下划線、$開頭；
（3）當多個單詞組成的變量名：以駝峰式命名法取名，例：studentName
（4）變量名要起到見名知義的效果
5、賦值運算符：= 把右邊的值賦給左邊
6、算術運算符：+ - * / %(取余)
7、num++;//num=num+1;num+=1;
num--;//num=num-1;num-=1;
System.out.println(--num);//先計算再輸出，（++num同理）
System.out.println(num--);//先輸出再計算，（num++同理）
8、double avg=(90+99)/3.0 發生自動類型轉換
自動類型轉換的條件;
1) 類型兼容：(int和double都是數值型)
2) 目標類型大於源類型
9、強制類型轉換：（數據類型）變量名 （數據類型）值
例：double num=5.5; int result=(int)num;
或者int result=(int)5.5;
第三章：運算符和條件結構
1、保存真或假，使用boolean 變量
boolean 有兩個值：true真、false 假
2、從控制台接受輸入信息，通過創建掃描器
Scanner input=new Scanner(System.in);
Int age=input.memtInt();//接受int類型
String name=input.next();//接受String類型
3、關系運算符
> 、< 、 >= 、 <= 、 == 、 !=
4、==和=的區別
==比較，=賦值
5、條件判斷if
if(表達式){
語句
}//當表達式為true真時執行語句
6、運算符分為單目、雙目、三目
單目：！ ++ --
雙目：= + - * / % | || & && ==
三目：?://int sign=java>90?1:0;三目表達式
7、邏輯運算符
| 、 & 、 || 、 && 、 ！
優先級順序：()>！>算術運算符>&&>||>賦值運算符=
多使用()控制優先級
8、if—else
if（表達式）{
語句1；
}else{
語句2；
}
當表達式為真，執行語句1 ；當表達式為假，執行語句2
9、多重if—else if—else
if(條件1){
語句1；
}else if(條件2){
語句2；
}else if（條件3）{
語句3；
}else{
語句4；
}
10、switch(表達式){
case 值1：
語句1；
Break;
case 值2：
語句2；
Break;
case 值3：
語句3；
Break;
default:
語句4；
Break;
}
jdk版本在1.7或者1.7以上，表達式是值可以是String類型；值不能相同；
break的作用是跳出switch結構。
11、多重if 結構和switch結構的使用場合：
多重if判斷區間值，switch判斷等值
第四章：循環結構（一）
1、while循環：
語法：while（循環條件）{
循環操作；
}
特點：先判斷，在執行。
2、==：用於數字比較，比較的是地址；
.equals：用於字符串比較，比較的是字符；
（如：！anwer.equals(“y”)）
3、do while
語法：do{
循環操作；
}while(循環條件);
特點：先執行，再判斷
4、while和do while的區別：
除了語法上不同外；
當條件不滿足時：while一次都不執行；而do while至少會執行一次
5、調試方法：設置斷點 、單步執行、 觀察變量
6、調試步驟：
1）猜測出錯位置，設置斷點
2）單步運行
3）觀察變量的值
4）發現問題
5）修正代碼，重新運行
6）解決問題
第五章：循環結構（二）
1、for語法
for（1參數初始化；2條件；3參數疊加）{
//4循環操作
}
特點：先判斷，再執行
順序：1 2 4 3
2、break：改變程序的控制流，多用於循環中；結合條件結構和分支結構，跳出整個循環
Continue：只能用在循環中；跳過循環體剩下的語句去執行下一個循環，結束當前的循環，進行下一步循環
3、while、do-while、for的區別：
（1）while語法：while（循環條件）{循環操作}
特點：先判斷再執行
（2）do-while:do{循環操作}while（循環條件）；
特點：先操作再執行
（3）for語法：for(參數初始化；條件；參數改變){循環體}
特點：先判斷再執行
使用場景：確定循環次數
4、使用循環的步驟：
（1）確定循環條件和循環體
（2）套用語法
（3）檢查能否正常退出
第六章：數組
1、數組：是一個變量，存儲相同數據類型的一組數據。
2、數據優點：減少代碼量，容易查找
3、數據的步驟：
（1）聲明數據：例：int score[];或者int[] score;
（2）開辟空間：例：scores=new int[5];
（3）賦值：例：scores[0]=100;
（4）使用：例：scores[0]=scores[0]+20;//最終的結果是：scores[0]=120;
4、數組聲明的三種方式：
（1）Int num []=new [4]{1,2,3,4};
（2）int [] num=new int[4]；
（3）int num []={1,2,3,4}
5、引用數組元素的方式：
數據名稱[下標];
例：num[0];
6、值傳遞和引用傳遞的區別：
值傳遞：不同的變量會分配不同的存儲空間；不同的變量會分配不同的存儲空間。
引用傳遞：賦值是把原對象的引用傳遞給另一個引用；兩個引用指向同一塊內存空間。
7、二維數組：
語法：數據類型[][]數組名=new 數據類型[一維數組的長度][二維數組的最大長度]；
數據類型 數組名[][]=new 數據類型[一維數組的長度][二維數組的最大長度];
例：int score[][]=new int[5][10];//int [][]score=new int[5][10]
結論：二維數組實際上是一個一維數組，它的每一個元素又是一個一維數組
8、賦值方式：scores={{1,5,8,9,10},{123,120}};
第七章：類和對象
1、對象的特征→指：類的屬性 （每個對象的每個屬性都有特定的值）
對象的操作→指：類的方法
2、封裝
對象同時具有屬性和方法兩項特性。
對象的屬性和方法通常被封裝在一起，共同體現事物的特性，二者相輔相成，不能分割。
3、類和對象的區別：
類：是抽象的概念，僅僅是一個模子，確定了對象的屬性和方法；
對象：能夠看得見摸得着的實物，具有靜態和動態特性。
4、定義類的步驟：
（1）定義類名
（2）定義類的屬性：訪問修飾符 屬性類型 屬性名稱=默認值；
（3）定義類的方法：訪問修飾符 返回值類型 方法名稱（）{
方法體；
}
5、成員變量和局部變量：
成員變量：上級是類，作用域是整個類中
局部變量：上級是方法，作用域是當前的方法
6、類名命名規則：
（1）不能使用Java的關鍵字
（2）首字母可以是字母，也可以是_或$
（3）不能包含空格和標點符號
7、創建對象：關鍵字：new
類名 對象名=new 類名（）；
例：YuntuSchool Beijing=new YuntuSchool();
8、使用對象：關鍵符號：.
對象名.屬性=值；例：beijing.schoolName=”雲圖智聯北京中心”;
對象名.方法; 例：beijing.showInfo();
9、面向對象的優點：
（1）便於程序模擬現實世界中的實體；
（2）隱藏細節（封裝）：對象的行為和屬性被封裝在類中，外界通過調用類的方法類獲得，不需要關注內部細節如何實現。
（3）可重用
可以通過類的模板，創建多個類的對象。
10、類是引用數據類型：
在傳值時，對象2=對象1傳的是地址，一個改變，另一個也變；
對象2.name =對象1.name；傳的是值，相互獨立。
第八章：類的方法（一）
1、類的方法語法：
訪問修飾符 返回值類型 方法名（）{
方法主體；
}
2、方法名的規范：
1.必須以字母、“_”或“$”開頭
2.可以有數字，但不能以數字開頭。
3.如果方法名是多個單詞組成 ，第一個單詞的首字母小寫， 其后單詞首字母單詞大寫。
4.方法名一般都采用動詞。
3、方法的返回值
1.有返回值：必須告知返回值的數據類型，並且返回相應的值。
例：public String getName(){
return"張三"；
}
2.無返回值：void
例:public void showInfo(){
}
4、調用方法：
1. 不同類中：對象名.方法名（）；
2.同類中：方法名（）；
方法之間可以相互調用
5、變量聲明的位置決定了方法的作用域
（1） 在方法中聲明的變量叫做局部變量，作用域是當前的方法中。
（2）在類中聲明的變量叫做成員變量，如屬性，作用域是整個類中。
6、包的命名規范：
（1）包名由小寫字母組成，不能以遠點開頭或結尾
（2）自己設定的包名之前最好加上唯一的前綴，通常使用組織倒置的網絡域名。如：域名 javagroup.net
（3）自己設定的包名部分依據不同機構各自內部的規范不同而不同
7、包的命名方式：package
公司的網址倒過來寫，后加上項目名稱，再加上所屬的文件夾名稱。
com.zhaopin.ts.entity
com.zhaopin.ts.servlet
com.zhaopin.ts.dao
com.zhaopin.ts.dao.imp1
com.zhaopin.ts.biz
com.zhaopin.ts.biz.imp1
8、doc注釋：多用於注釋類的信息
/** 開始
*/結束
第九章：類的方法（二）
1、帶參的語法：
訪問修飾符 返回值類型 方法名稱（參數列表）{
方法體；
}
例：public String getFuirt(String fuirt){
String zhi=fuirt+m+"汁";
return zhi;
}
2、調用帶參方法：
同類中， 非靜態方法，方法名（參數列表）；
不同類中，對象.方法名（參數列表）；
3、帶參方法的參數需要注意：
1.形參的數據類型和實參的數據類型一致。
2.方法形參的數量和調用方法實參的數量要一致。
第十章：字符串
1、 聲明字符串的方法：（2種）
（1）String s=”您好”;
（2）String s=new String (你好);
2、 字符串是長度：
字符串.length();
3、 equals 比較的是值，一般用於字符串的比較；
== 比較的是地址，一般用於數字的比較。
4、字符串的方法比較：
（1）equlasIgnoreCase() 比較時忽略大小寫
例：name.equlasIgnoreCase()
（2）toLoerCase()轉換成小寫
例：name. toLoerCase()
（3）toUpperCase()轉換成大寫
例：name. toUpperCase()
5、\叫轉義符
6、拼接字符串：
用”+”或”concat()”方法，當原字符串是有效字符串時，在其后拼接新的字符串時，會創建副本。
例如：String str=”你好”;str=str+”北京”;
String str=new String(“你好”);str.concat(“北京”);
特點：使用”+”和”concat()”方法，會造成內存浪費，性能比較差，線程安全。
7、indexOf（參數）；獲取字符或字符串的下標；
（1）indexOf（int ch）
例如：str.indexOf(’你’);
（2）indexOf(String s);
例如：str.indexOf(“.java”);
8、lastIndexOf(參數);獲取最后一個字符或字符串的下標
（1）lastIndexOf(int ch);
例如： lastIndexOf(’你’);
（2）lastIndexOf (int ch);
例如： lastIndexOf(“.java”);
9、subString(參數);截取字符串
（1）subString(int index);
下標從0開始，從index開始截取到最后結束。
（2）subString(int beginIndex,int endIndex);
下標從0開始，從beginIdex開始截取，包括beginIdex位置，到endIdex結束，不包括endIndex位置。
10、trim()方法： 去掉字符串前后空格。
11、split()方法： 分割字符串 ，返回數組
例如：String st="長亭外-古道邊-芳草碧連天-天外天-人外人";
String [] wor=st.split("-");
for (int i = 0; i < wor.length; i++) {
System.out.println(wor[i]);
}
12、StringBuffer類： 用於頻繁拼接字符串時使用。
例如：StringBuffer sb=new StringBuffer(“你”);
Sb.append(“好嗎？”);
Sb.insert(1.”們”)；
String word=sb.toString();
System.out.println(word);//你們好嗎？
特點：在自身上追加字符串，不會產生副本，所以節省內存，性能高，線程安全。
13、String Builder類： 用於頻繁拼接字符串時使用。在自身上追加字符串，不會產生副本，所以節省內存，性能高，線程不安全。
14、String 、StringBuffer、String Builder三者間的區別：
1） 原理：
String 頻繁拼接時產生大量對象（副本），
StringBuffer 和String Builder 都是在當前對象上操作，所以不會產生大量對象（副本）；
2） 性能：
String< StringBuffer< String Builder
3） 線程：
String 和StringBuffer安全，String Builder非安全。
15、小結：
if(操作的數據較少){
String
}else {
If(多線程){
StringBuffer
}else{
String Builder
}
}
第十一章：抽象和封裝
1、面向對象設計和開發程序的好處：
（1）交流更加流暢
（2）提高設計和開發效率
2、從現實中抽象出類分三步：
（1） 找出它的種類————（類名）
（2） 找出它的屬性————（字段的名稱）
（3）找出它的行為————（方法名）
3、抽象的原則：
（1）根據面向對象的思想抽象出類。
4、類圖的好處：
（1）直觀
（2）容易理解
5、構造方法：
（1）系統默認的無參構造：
例如：public Dog(){}
注意：當程序寫了自定義構造方法時，系統自帶的無參構造將消失。
（2）自定義的無參和有參構造：
a.自定義無參構造：
例如：public Dog(){
this.name=”大黃”;
this .love=100;
}
b. 自定義的有參構造：
例如：public Dog(String name,int love){
this.name=”大黃”;
this .love=100;
}
特點：a.訪問修飾符是public
b．無返回值
c.構造函數方法名和類名一致
語法：
訪問修飾符 函數名稱 ([參數列表]){
[方法體;]
}//[]代表可以省略（不寫）
5、this的含義：當前對象的引用。
this的使用：
this.屬性
this.方法
this()構造函數：
例如：this();調用了無參構造
this.(參數1[參數列表]);調用了有參構造
6、static 靜態的，可以修飾屬性、方法、代碼塊。
被static 修飾過的屬性、方法的調用方法：
類名.屬性
類名.方法
被修飾過的代碼塊：類加載時，就加載代碼塊。
注意：方法里的變量不能被static修飾。
7、Final 最終的，可修飾屬性，被修飾后叫常量。常量的是不可以被修改的。
常量的命名方式全部大寫。
8、在開發中，一般一個完整的實體類包括：
（1）私有化的屬性
（2）創建getter setter 方法[有參/無參]
（3）給getter setter方法添加控制語句
（4）創建[有參/無參]構造方法
第十二章：繼承
1、使用繼承：
1）方便修改代碼
2）減少代碼量
2、super 繼承object 類：
super 訪問父類的無參構造；super 指的是object 的無參構造。
例：子類調用父類：super.屬性 / super.方法
注意：子類不能繼承父類私有屬性；得用set、get方法來調用；
super只能寫在代碼塊的第一句；super只能調用非私有的方法；
super只能出現在子類的方法和構造方法中。
3、不能被繼承的父類成員：
private成員、子類與父類不在同包，使用默認訪問權限成員，構造方法。
| 訪問修飾符 |
本類 |
同包 |
子類 |
其他 |
| Private |
√ |
|
|
|
| 默認（friendly） |
√ |
√ |
|
|
| Protected（受保護的） |
√ |
√ |
√ |
|
| Public |
√ |
√ |
√ |
√
|
4、繼承：先執行父類的構造，在執行子類的構造。
順序：父類屬性 →父類構造方法→ 子類屬性 → 子類構造方法
（符合is_a的關系就可以使用繼承）
5、方法重載與方法重寫：
|
|
位置 |
方法名 |
參數表 |
返回值 |
訪問修飾符 |
| 方法重載 |
同類 |
相同 |
不相同 |
無關 |
無關 |
| 方法重寫 |
子類 |
相同 |
相同 |
相同或是其子類 |
不能比父類更嚴格 |
6、多重繼承關系的初始化順序：
父類屬性 → 父類構造 → 子類構造
7、當父類不需要實例化時，把父類聲明為抽象類；
例：public abstract class 類名（）{}
8、當子類必須重寫父類方法時，可以把父類的方法聲明抽象方法。
抽象方法要求：
（1）抽象方法沒有方法體
（2）抽象方法必須在類中
（3）加final(最終)不需要被賦值