第一篇：JAVA課程總結

DAY01

JavaSE第一天課程安排

##### 目標：開發第一個JAVA小程序，了解掌握相關概念

#####

內容：

1、了解計算機相關概念

2、下載安裝Java開發環境

3、開發第一個Java程序

4、開發環境設置優化

5、掌握Java程序的開發運行流程

6、掌握Java相關概念

7、練習

#####----------------計算機相關概念----------------

1、計算機

1、機器

2、軟件

3、數據輸入----> 數據處理----> 數據輸出-----（重要不緊急）

2、軟件----

A、系統軟件-----操作系統---windows linux B、應用軟件-----QQ、CF、計算器（數據）軟件的功能： 數據輸入----> 數據處理----> 數據輸出 數據-----123、文件、文件夾----泛稱

3、計算機操作

物理操作 軟件操作 GUI/CUI GUI-----圖形用戶接口-----Graphics User Interface(常用)CUI-----命令行用戶接口---Command User Interface(了解)A、如何啟動CUI

1、開始----> 附件-----> 命令提示符

2、開始----> 搜索CMD

3、win7----> shift 右擊----> 打開命令行

B、DOS命令----CUI和GUI有對應關系

按規律記憶

電腦上數據分兩類： 切換盤符：盤符號: 進入文件夾： cd 文件夾名

cd 路徑名（進入多級）

返回上一級:cd..返回根目錄:cd

1、文件

增

-----notepad/write/edit 查

-----type 文件名---查看內容 改

-----notepad/write/edit

刪

-----del 文件名稱

2、文件夾---dir

增----md XXX 查----dir--查看文件夾下所有文件

改----修改名稱 ren 刪----rd 要求：

1、簡單調用----記住一個 help

2、調用 time date 等命令

3、命令如何使用--命令 /? DOS啟動程序

1、DOS下進入程序所在路徑

2、敲入程序名稱

3、回車

需求：任意目錄下啟動程序，notepad可以，QQ不可以 edit cd cd..cd help 命令 /?----------不重要緊急

4、鍵盤使用------------重要不緊急

快捷鍵: 全選： ctrl + A

撤銷： ctrl + Z 復制： ctrl + C 粘貼： ctrl + V 保存： ctrl + S------剪切： ctrl + X eclipse: ctrl + D----刪除一整行

5、計算機語言

6、軟件開發

使用計算機語言開發程序 學習計算機語言：語法

總結：了解-----

緊急-----常見的DOS命令

----------------下載安裝Java開發環境----------

1、Java簡介

A、詹姆斯 格斯林 B、開源----開放源代碼 C、ONE體系

Open Net Environment----開放的網絡環境

JavaSE-----桌面應用程序開發----核心----就業機會不多 JavaEE-----企業的分布式系統開發1）----（N從右向左數的位數）

4、負數的轉換----（不不）

-10 0000 0000 概念：原反補

正數：源碼反碼補碼都一樣

負數：原碼----標志位是1，計數位和正數一樣

反碼----計數位取反，1變0,0變1

補碼----反碼基礎之上 +1 101 0111 1111 1111 1111 1111 1111 1111 1111----2^311 = 127 short-----2個字節16bit----最小值：-2^15=-32768 最大值：2^15* / %

++--（重點）DAY03 一.算數運算符：

1.+ 2.-

3.* 4./

/ 3 : 3 10 / 0 : 運行時異常；

10.0 / 0 :Infinity(無窮)不是異常

5.%

% 3 : 1 10 % 0 : 運行時異常

10.0 % 0 : NaN(Not A Number)不是異常-10 %-3 :-1 10 % 3 :1-10 % 3:-1 10 %-3:1 6.++: 7.--: 如果表達式中，只做++或--一件事情，那么前++/--和后++/--效果一樣的； 但如果表達式中做多件事情：

前++/--:先自增/自減，然后再參與表達式的其它運算； 后++/--:先參與表達式的運算，然后在自增/自減；

二.賦值運算符

1.=：執行順序，從右至左，并且最后返回變量； 2.+=： 3.-=： 4.*=： 5./=： 6.%=：

特點：帶隱式強制轉換；

byte b1 = 10;b1 = b1 + 20;//編譯錯誤

b1 += 20;//OK的-->b1 =(byte)(b1 + 20);三.關系運算符：

1.==：判斷是否相等 2.!=：判斷是否不等；

3.<:左操作數是否小于右操作數； 4.>:左操作數是否大于右操作數；

5.<=:左操作數是否小于或者等于右操作數； 6.>=:左操作數是否大于或者等于右操作數；

四.邏輯運算符：

&&、||和&、|的區別：

1.邏輯&&和||具有短路行為，一旦確定整個表達式的結果，那么將不再執行剩余表達式； 1.&&(語意：并且):兩邊都為true，結果為：true； 2.||(語意：或者)：有一邊為true，結果為true;3.!(語意：不是)：!true：false；!false:true 位運算符：

4.&(并且):結果同&& 5.|(或者):結果同|| DAY04 一.運算符：

1.位運算符：

1).<<(左移)： 2).>>(有符號右移):

3).>>>(無符號右移)4).&(按位與):兩位都是1，結果為1； 5).|(按位或):有1位為1，結果為1；

6).^(按位異或):兩位相同結果為0，否則為1； 7).~(取反):1變0，0變1 2.位運算符的考點：

1).高效的計算某數 * 2 : << 2).高效的計算某數 / 2 : >> 3).&、|同&&、||的區別： 邏輯與&&、||：具有短路行為；

4).將兩個變量的值交換：三次異或；

3.三目運算符： 條件表達式 ？ 表達式1 ： 表達式2；

二.鍵盤錄入：

步驟：

1.import java.util.Scanner;2.Scanner sc = new Scanner(System.in);3.int : int num = sc.nextInt();

double : double d = sc.nextDouble();

String : String s = sc.next();三.選擇結構：

1.if語句：

1)格式1：

if(條件表達式){ } 注意：如果if體內只有一條語句，可以省略大括號，但不建議；

2)格式2：

if(條件表達式){ //為true，執行這里

}else{ } //為false，執行這里

3)格式3：

if(條件表達式){ }else if(條件表達式2){ }else if(條件表達式3){ }else{ } 2.switch語句：

1).格式：

switch(表達式）{

} case 值1: //代碼 break;case 值2：

//代碼 break;default: //代碼 break;2).注意事項：

1.“表達式”可以產生的值：byte,short,int,char,枚舉(JDK5以后),String(JDK7以后)2.case語句后跟“常量表達式”，不能是“變量”；而且不能出現相同的常量值；

3.break;語句“不是必須的”。如果不寫，如果一旦case相應的值成功，但內部沒有break語句，那么將會無條件(不再進行case匹配)的繼續向下執行其它case中的語句，直到遇到break;語句

或者到達switch語句結束。4.多個case之間，沒有順序關系；

5.default語句“不是必須的”。可以不寫，它就相當于多重if語句中最后的else。6.default語句和case語句“沒有順序關系”。

DAY05 一.while循環：

while(條件表達式){ } 二.do_while循環：

do{ }while(條件表達式);三.for循環：

for(定義循環變量表達式

;

條件表達式

;增量表達式){ } 說明：

1.三個表達式都不是必須的；但分號必須要寫； 2.執行順序：

1).定義循環變量表達式； 2).條件表達式;3).進入循環； 4).增量表達式； 5).條件表達式；

6).進入循環 7).增量表達式......四.三種循環的區別：

1.只有do_while循環是先無條件的進入循環體執行一次，然后再判斷；

while和for循環都先判斷，后進入循環體； 2.一般對于有明顯的遍歷范圍的，建議首選for循環。

對于沒有明顯遍歷范圍的，一般使用while。

對于循環體中的內容，如果需要先執行一次，再判斷，那么可以使用do_while DAY06 一.方法：

1.方法的作用：代碼復用； 2.方法定義的格式：

修飾符 返回值類型 方法名([形參列表]){ } 修飾符：目前只需要寫：public static 返回值類型：可以是任何的Java類型(基本數據類型、引用數據類型)。

如果沒有返回值，這里要寫void

方法名：自定義標識符；

形參列表：可以沒有，但是一定寫一對小括號。

如果有，每個形參是由：數據類型 形參名

多個形參，中間用逗號隔開；

3.方法內，可以寫什么？

1).定義變量；

2).if語句，switch語句； 3).各種循環語句；

總之：除了不能定義方法，其它都可以； 4.方法的注意事項：

1).方法不調用不執行;2).方法與方法是平級關系，不能嵌套定義;3).方法定義的時候參數之間用逗號隔開;4).方法調用的時候不用在傳遞數據類型;5).如果方法有明確的返回值，一定要有return帶回一個值;5.方法的重載：

1).在一個類中，可以定義多個同名的方法，但形參列表不能完全相同； 2).方法重載，跟返回值類型無關；跟形參名無關；

二.數組：

1.一維數組：

1).定義的格式：

1.動態初始化：數據類型[] 數組名 = new 數據類型[數組長度];2.靜態初始化：

數據類型[] 數組名 = new 數據類型[]{值1，值2，值3，.....，值n};

數據類型[] 數組名 = {值1，值2，值3.....值n};2).數組是“引用數據類型”，變量存儲的是“引用(地址)”；

3).當new(實例化)一個數組對象時，其“值”的空間是在堆中分配的，對于各種數據類型，都會分配一個

默認值：

整數：0 小數：0.0 字符：'u0000' 布爾：false String：null 其它引用類型：null 4).數組的訪問方式：使用：數組名[索引] DAY07 一.二維數組：

1.定義的格式：

數據類型[][] 數組名 = new 數據類型[第一維的長度][第二維的長度];左邊也可以寫成：

數據類型 數組名[][] 數據類型[] 數組名[] 數據類型[][] 數組名 = new 數據類型[][]{{值1，值2},{值3，值4},{值5，值6，值7}};數據類型[][] 數組名 = {{值1，值2},{值3，值4},{值5，值6，值7}};二.方法的值傳遞和引用傳遞： 1.當一個方法接收的是一個“基本數據類型”時，調用方法傳遞實參時，是將“值”復制到方法內；

在方法內，如修改其值，修改的只是“副本”，原值不會被改變；

2.當一個方法接收的是一個“引用數據類型”是，調用方法傳遞實參時，是將“引用”復制到方法內；

在方法內，是可以通過這個引用修改“堆”空間的內容，即使方法結束，修改會影響到原堆中的值；

DAY08

一.類：是一組相關的“屬性”和“行為”的集合；

對象：是該類事物的具體體現； 二.類和對象的關系：

1.現實：

類 對象 貓 波斯貓

折耳貓 加菲貓

---------

狗 金毛

藏獒 沙皮

2.代碼：

類 對象

Cat c1 = new Cat();c1.name = “波斯貓”;class Cat{

}

String name;int age;c1.age = 2;

----Cat c2 = new Cat();c2.name = “折耳貓”;c2.age = 3;----------------------------class Dog{

}

Dog d1 = new Dog();d1.name = “金毛”;String name;int age;d1.age = 2;

----Dog d2 = new Dog();d2.name = “藏獒”;d2.age = 3;

三.類的定義：

1.使用關鍵字：class(注意小寫)2.一個java源文件中：

1).如果定義多個類，但只有一個是public的；而且源文件名必須與這個public的類名一致； 2).如果定義多個類，可以沒有public類；源文件名沒有一致性要求；

3).main()方法不是必須放在public類中；

3.類中可以定義什么：

1).成員變量：

A.可以是基本數據類型，也可以是任何引用數據類型； B.可以顯示初始化；

class Student{

} String name = “張三”;int age = 20;C.可以隱式初始化；

整型：0 浮點：0.0 字符：'u0000' 布爾：false 引用類型：null 2).成員方法： A.可以有參數，可以沒參數；

可以有返回值，可以沒有返回值；

B.方法的“形參”可以是任何Java類型(基本數據類型、引用數據類型)C.方法的“返回值”可以是任何Java類型(基本數據類型、引用數據類型)D.一個類中可以定義多個同名的方法，但形參列表不完全相同，叫：方法的重載；

3).內部類(后面講)；

4.成員變量和局部變量的區別：

1).成員變量： A.定義在“類體”中；可以是任何數據類型；

B.會被自動初始化；

class Student{

} String name;void show(){ } System.out.println(“我叫：” + num);

//打印：我叫：null C.當實例化對象后，被存儲在“堆”中；

D.當“對象”不被使用(沒有任何引用)，并被垃圾回收器回收時被清理；

2).局部變量：

A.定義在某個方法、或其它代碼塊中； B.必須顯示初始化，否則不能訪問其值；

class Student{

void show(){ String name;System.out.println(“我叫：” + name);

//編譯錯誤。局部變量必須顯示初始化才能訪問其值；

} } name = “張三”;//OK。可以被賦值。

C.當方法或其它代碼塊被執行時，基本數據類型的“值”和引用數據類型的“引用”都是存儲在“棧”中； D.當方法或代碼塊執行完畢時，會被立即清理；

四.對象的使用：

1.創建對象使用new關鍵字；會在堆中分配內存空間； 格式：

類名

變量名 = new 類名();2.一個類可以創建多個對象；

3.每個“對象”的“成員變量”在“堆”中都有一份獨立的空間；

每個“對象”的“成員方法”被存儲在“方法區”中，多個對象只有一個“方法空間”； 4.對象的“引用(地址)”被存儲在“棧”中；

五.方法的形參：

1.可以是“基本數據類型”：

1).調用時，必須傳遞此類型的“值”； 2).調用時，是將值復制一份到方法內部； 3).在方法內，使用形參接收此值的副本； 4).在方法內，如果更改此值，對原值沒有影響；

int a = 10;show(a);System.out.println(a);//10---public void show(int n){//n = 10 } n = 20;//對原來的a的值是沒有影響的；

2.可以是“引用數據類型”：

1).調用時，必須傳遞此類型的“引用”；

2).調用時，是將“引用(地址)”復制一份到方法內部； 3).在方法內，使用形參接收此“引用”的副本；

4).在方法內，如果通過此引用更改堆中的值，對原堆中的值將會產生影響；

int[] arr = {14,324,435};//arr = 0x2233 show(arr);//show(0x2233)System.out.println(arr[0]);//1000

----public void show(int[] array){//array = 0x2233 } array[0] = 1000;六.匿名對象：

1.匿名對象：沒有名字的對象：new Student();2.匿名對象的兩種使用情況：

1).對象調用方法僅僅一次的時候:new Student().show();2).作為實際參數傳遞:printStudent(new Student());七.封裝：

1.直接對外部暴露成員變量是很不安全的，這時可以將成員變量“私有化”，對外提供公有的 get和set方法； 2.封裝的好處：

1)隱藏實現細節，提供公共的訪問方式 2)提高了代碼的復用性 3)提高安全性。

3.封裝的原則：

1)將不需要對外提供的內容都隱藏起來。2)把屬性隱藏，提供公共方法對其訪問。

八.private關鍵字：

1.是一種“訪問修飾符”(將在day10講到)；

Java中一共有四種訪問修飾符：從寬到窄：public，protected，(默認)，private 2.用于修飾“成員變量”和“成員方法”；

3.被private修飾的成員，只能在類的內部被其它成員訪問。在類外部無法訪問；

九.this關鍵字： 1.每個類都有一個“隱式”的變量：this；

2.它是在實例化對象時，由虛擬機自動賦值的，會被自動賦值為當前對象的“引用”。

所以每個對象內的this變量的值是不同的；

3.this關鍵字可以調用本對象的“成員屬性”、“成員方法”、“構造方法”； 4.以下情況必須顯示的使用this：

1).“局部變量”覆蓋“成員變量”時，可以使用this顯示的訪問被覆蓋的“成員變量”；

否則訪問的是“局部變量”；

2).在一個構造方法中調用本類的其它構造方法；this()或this(實參)；

DAY09

一.構造方法：

1.當實例化一個類的對象時，JVM會自動調用本類的一個方法：構造方法；

2.定義類時，可以不定義構造方法，編譯器會自動添加一個無參，什么都不做的構造方法； 3.如果類中定義了構造方法，編譯器就不會添加任何構造方法了； 4.構造方法的格式要求：

1).構造方法名必須與類名一致；

2).構造方法不能定義“返回值類型”，甚至是void；

3).構造方法不能返回一個具體的值，但內部可以使用return;語句； 注意：

1).以下代碼可以編譯通過：

class Student(){

} public void Student(){ }

//普通成員方法，不是構造方法；

2).以下代碼不能通過編譯：

class Student(){ public student(){ }

//構造方法必須同類名一致，包括大小寫；

} 5.一個類中可以定義多個“構造方法”，但每個構造方法的形參列表不能完全相同，叫：構造方法的重載； 6.在一個構造方法中可以調用另一個構造方法，使用this關鍵字； 7.構造方法可以調用“成員方法”，但“成員方法”不能調用構造方法；

構造方法也可以調用其它構造方法；

二.static關鍵字：

1.static關鍵字：靜態的，全局的。

2.可以修飾“成員變量”和“成員方法”。被static修飾的成員變量存儲在方法區的“靜態存儲區”，只有

一份拷貝，被多個對象共享；

3.特點：

1).隨著類的加載而加載

2).優先于對象存在3).被類的所有對象共享

4).可以通過類名調用，也可以通過對象名調用； 4.static關鍵字注意事項：

1).在靜態方法中是沒有this關鍵字的

2).靜態方法只能訪問靜態的成員變量和靜態的成員方法

三.靜態變量和成員變量的區別：

1.所屬不同

1).靜態變量屬于類，所以也稱為為類變量

2).成員變量屬于對象，所以也稱為實例變量(對象變量)2.內存中位置不同

1).靜態變量存儲于方法區的靜態區 2).成員變量存儲于堆內存

3.內存出現時間不同 1).靜態變量隨著類的加載而加載，隨著類的消失而消失

2).成員變量隨著對象的創建而存在，隨著對象的消失而消失

4.調用不同

1).靜態變量可以通過類名調用，也可以通過對象調用 2).成員變量只能通過對象名調用

DAY10 一.代碼塊(理解)：

1.普通代碼塊(類體中)：包含：局部代碼塊(方法或其它代碼塊內)2.靜態代碼塊：(類體中)作用：

1.初始化成員變量。執行流程：

1.普通構造代碼塊：每次實例化此類對象時，會被執行。它會先于“構造方法”被執行； 2.靜態代碼塊：第一次實例化此類對象時； 3.靜態代碼塊-->普通構造代碼塊-->構造方法：

二.繼承(必須掌握)：

1.使用關鍵字:extends 2.作用：代碼重用。為多態提供了前提； 3.this和super的區別：

1).this:

1).在任何類中使用； 2).存儲的是本類對象的引用；

3).可以訪問本對象的成員變量、成員方法、構造方法；

2).super:

1).在子類中使用；

2).存儲的是父類對象的引用；

3).可以訪問父類對象的成員變量、成員方法、構造方法；

4.類的初始化過程：

加載class文件 堆中開辟空間 變量的默認初始化 變量的顯示初始化 構造代碼塊初始化 構造方法初始化

成員變量-->構造代碼塊-->構造方法 5.Java中繼承的特點：

1).Java中只能單繼承； 2).Java中可以多級繼承；

6.繼承的好處和弊端：

好處： 1).代碼復用

2).為多態提供了前提； 弊端：

1).由于繼承，子類對父類產生了依賴；

三.方法重寫:

1.在子類中，定義跟父類一模一樣的方法，這叫：方法重寫； 2.重寫的規則：

1).返回值類型、方法名、形參列表：要完全一致； 2).子類的訪問修飾符可以跟父類的相同，或更寬；

3.重寫的意義： 1).子類保留了父類的方法，具有了自己特有的行為；

4.重寫和重載的區別： 1).重寫：在子類中定義跟父類一模一樣的方法；

2).重載：在一個類中，定義：方法名相同，參數列表不完全相同的方法，叫：重載。跟返回值類型無關；

四.final關鍵字：

1.可以修飾： 成員變量：表示其變量擁有最終的值，不能被更改，成為“常量”。修飾基本數據類型：表示其值不能被修改。修飾引用數據類型，表示地址不能被修改；

成員方法：表示最終的方法。不能被重寫； 類：

表示最終類。不能被繼承；

局部變量：表示其值不能改變；區分：基本類型和引用類型； 方法形參：表示其值不能改變；區分：基本類型和引用類型；

DAY11

一.多態：

1.父類的引用指向子類的對象； 2.多態前提和體現

1).有繼承關系 2).有方法重寫

3).有父類引用指向子類對象

3.多態的轉型：

1).自動轉型：子類的引用轉為父類的引用；Person p = new Student();2).強制轉型：父類的引用轉為它所指向的子類對象的引用；Student stu =(Student)p;3).在進行強制轉型前，為保證安全，可以使用instanceof關鍵字進行判斷：

if(p instanceof Student){ } Student stu =(Student)p;4.多態的好處：

1).提高了程序的維護性(由繼承保證)2).提高了程序的擴展性(由多態保證)

5.多態的弊端： 1).不能訪問子類特有功能(可以向下轉型)6.多態時的訪問規則：

1).總體規則：訪問的任何成員父類中必須要有，否則編譯錯誤；

例如：

class A{ } class B extends A{ } main(){

} A a = new B();System.out.println(a.n);//編譯錯誤，父類中沒有n int n = 20;int num = 10;2).成員變量：如果子、父類中都有，訪問的是“父類”的；

class A{ } class B extends A { } main(){

} A a = new B();//多態

System.out.println(a.num);//打印10；

int num = 20;int num = 10;

普通方法：如果子、父類中都有(重寫)，訪問的是“子類”的；

class A{

} class B extends A{

} main(){

} A a = new B();a.show();

//打印：B-->show()(訪問的是子類的show());void show(){ } System.out.println(“B-->show()”);void show(){ } System.out.println(“A-->show()”);

靜態方法：如果子、父類中都有(重寫)，訪問的是“父類”的；

二.抽象類：

1.使用abstract關鍵字修飾；可以修飾“類”，可以修飾“成員方法”；

abstract class A{ } abstract void show();2.“抽象類”的特點：

1).不能被實例化，只能用于被繼承；

2).可以包含：成員變量、構造方法、成員方法、抽象方法； 3).可以不包含抽象方法；

3.“抽象方法”的特點：

1).沒有方法體；abstract void show();2).必須被子類重寫。除非子類也是個抽象類；

3.子類繼承抽象類使用關鍵字：extends，仍然是單繼承；

4.一個子類繼承 了一個抽象類，必須實現抽象類中所有的抽象方法；

否則子類也必須是抽象的。

例如：

abstract class A{ } class B extends A{ }

//編譯錯誤。類B不是抽象的，繼承類抽象類必須重寫抽象類中的所有abstract void show();抽象方法。abstract class B extends A{ } //編譯通過。類B沒有重寫父類中的抽象方法，但類B是抽象的。

5.abstract關鍵字不能和哪些關鍵字共存：

1.private:抽象方法就是用來被子類重寫的，而私有方法不能被子類重寫；

2.final：抽象類和抽象方法就是用來被子類繼承和重寫的，而fianl類和final方法不能

被繼承和重寫； 3.static：static修飾的方法在沒有任何對象的情況下就會被分配內存空間；而抽象方法

沒有方法體，無法分配空間；

三.接口：

1.使用interface關鍵字定義：只能修飾“類”：

interface IA{ } 2.“接口”的特點：

1).不能被實例化，沒有構造方法，只能用于子類“實現”； 2).可以包含：

A.成員變量(常量)：隱式的定義為：public static final。

例如： interface IA{

} public int num1 = 10;

//OK

上述三個關鍵字中任何一個都可以不寫，系統會自動添加；

static final int num2 = 20;//OK final int num3 = 30;

//OK

//OK public final num4 = 40;int num5 = 50;

//OK B.抽象方法：隱式的定義為：public abstract。可以省略，系統會自動添加

例如： interface IA{

} void show1();

//OK

//OK;public void show2();abstract void show3();//OK;3).接口的功能是：擴展功能；

3.子類實現接口使用關鍵字：implements 4.一個子類可以同時實現多個接口；

interface IA{} interface IB{} class C implements IA,IB{ //OK的。} 5.子類實現接口時，必須重寫接口中所有的抽象方法，而且必須是public的--因為

接口中抽象方法的定義隱式的是public的。

例如：

interface IA{ } class B implements IA{ void show(){ }

//編譯錯誤。父接口的show()隱式的為public的，子類重寫時void show();必須是public的；

} 5.接口編譯后一樣會生成.class文件。

四.多態的形式：

1.父類的多態； 2.抽象類多態； 3.接口多態；

五.類與類，類與接口，接口與接口的關系：

1.類與類：繼承關系，關鍵字：extends，只能單繼承，但是可以多層繼承

2.類與接口：實現關系，關鍵字：implements，可以單實現，也可以多實現。還可以在繼承一個類的同時實現多個接口

3.接口與接口：繼承關系，關鍵字：extends，可以單繼承，也可以多繼承

例如：

interface IA{} interface IB{} interface IC extends IA,IB{} //OK的

六.抽象類和接口的區別：

1.成員區別 1).抽象類 變量,常量;有抽象方法;抽象方法,非抽象方法

七.2).接口 常量;抽象方法

2.關系區別

1).類與類 繼承，單繼承

2).類與接口 實現，單實現，多實現 3).接口與接口 繼承，單繼承，多繼承

3.設計理念區別

1).抽象類 被繼承體現的是：”is a”的關系。共性功能 2).接口 被實現體現的是：”like a”的關系。擴展功能

一.類名作為形參：

1.實參可以是：

1).此類對象的引用;2).null;3).此類子類對象的引用；

二.抽象類作為形參：

1.實參可以是：

1).此類子類對象的引用； 2).null;

三.接口作為形參：

1.實參可以是：

1).此接口子類對象的引用； 2).null;

四.類名作為返回值：

1.可以返回的類型：

1).此類對象的引用； 2).null;

3).此類子類對象的引用；

2.可以用什么類型接收：

1).使用此類類型；

2).不能使用某個子類類型接收；

五.抽象類作為返回值：

1.可以返回的類型：

1).null;2).此類子類對象的引用；

2.可以用什么類型接收：

1).使用此類類型；(多態)2).不能使用某個子類類型接收；

六.接口作為返回值：

1.可以返回的類型：

1).null;2).此接口子類對象的引用；

2.可以用什么類型接收：

1).使用此接口類型；(多態)2).不能使用某個子類類型接收；

DAY12

一.包：

1.定義包使用關鍵字：package；

1).注意事項：

A.package語句必須是程序的第一條可執行的代碼 B.package語句在一個java文件中只能有一個 C.如果沒有package，默認表示無包名

2.導入包使用關鍵字：import；

1).注意事項：

A.導入到最終的類；

B.可以使用通配符：*，只統配包下的類，不包括子包下的其它類； C.在一個類文件中，可以有多條import語句；

D.import語句必須在package語句之后，在定義類之前；

3.package,import,class有沒有順序關系？ 有：package-->import-->class 二.訪問修飾符：

1.用于限定“類”和“成員”被其它包下的其它類訪問的； 2.四種訪問修飾符：

1).public(公有)：可以修飾類、成員。可以被任何包下的其它類訪問； 2).protected(保護)：可以修飾成員。可以被同包下的其它類訪問。如果在包外

只能被子類訪問；

3).(默認)：可以修飾類、成員。只能被包內的其它類訪問； 4).private(私有)：可以修飾成員。只能被類中的其它方法訪問；

3.類及成員可用的修飾符：

1).類：

默認，public，final，abstract 我們自己定義：public居多

2).成員變量：

四種權限修飾符均可,final,static 我們自己定義：private居多

3).構造方法：

四種權限修飾符均可,其他不可 我們自己定義：public 居多

4).成員方法：

四種權限修飾符均可，fianl,static,abstract 我們自己定義：public居多

三.內部類：

1.成員內部類：

1).定義在類體中，作為類的成員；

2).可以使用同類“成員方法”相同的修飾符；

2.局部內部類：

1).定義在某個方法或代碼塊內部；

2).不能使用“訪問修飾符”，不能使用static修飾符；可以使用final和abstract 3).注意：局部內部類訪問“局部變量”，要求局部變量必須是final的(常量)；（重點）

3.匿名內部類：

1).就是內部類的簡化寫法。2).前提：存在一個類或者接口 這里的類可以是具體類也可以是抽象類。

3).格式： new 類名或者接口名(){重寫方法;} 4).本質： 是一個繼承了類或者實現了接口的子類匿名對象

DAY14 一.Object類：

1.所有引用數據類型(包括類庫中的類，自定義類，數組)的超類； 2.定義在java.lang包，使用時不需要導包； 3.常用方法：

public class Object{ public Object(){

內存的操作；

} public int hashCode(){ //功能：用于哈希表結構的鍵值

//默認實現：將此對象的地址轉換為int值返回；

//此方法建議子類重寫；

} public final Class getClass(){ //功能：獲取此對象的Class對象，在day27講解

//此方法不能被子類重寫 } public String toString(){ //功能：返回此對象的字符串表現形式；

//默認實現：全名限定的類名 + @ + hashCode(無意義)//此方法建議子類重寫；

} public boolean equals(Object obj){ //功能：將當前對象與參數對象進行比較

//默認實現：比較地址(跟==的結果是一樣的)//此方法建議子類重寫；

} protected void finalize(){ //功能：當前對象在被垃圾回收器回收前，由垃圾回收器自動調用的方法。一般用于做些釋放 //默認實現：無

//此方法根據需要由子類重寫(一般我們不用)}

} protected Object clone(){

} //功能：復制此對象的副本； //默認實現：本地方法 //一般子類無需重寫；

--

二.java.lang.String類：

1.一個“字符串”對象； 2.一個“引用數據類型”； 3.使用方式：

String s1 = “abc”;(常用、存儲的是常量池中的地址)或：

String s1 = new String(“abc”);(存儲的是堆中的地址)(在內存中創建了兩個對象：1.常量池：“abc”；

class Student(extends Object){ } //默認就擁有了Object類中可以繼承的方法；

2.堆：new String())

4.特點：其“值”的內容不能改變(地址可以改變)；

String str = “你好”;str = “Java”;//原值被丟棄，存儲了新的地址；

5.常見面試題： String s1 = “abc”;

String s2 = “abc”;System.out.println(s1 == s2);//true--------

String s1 = “Hello”;String s2 = “World”;String s3 = “HelloWorld”;String s4 = “Hello” + “World”;String s5 = s1 + s2;String s6 = “Hello” + s2;String s7 = s1 + “World”;String s8 = new String(“Hello”);System.out.println(s3 == s4);//true System.out.println(s3 == s5);//false System.out.println(s3 == s6);//false System.out.println(s3 == s7);//false System.out.println(s1 == s8);//false;6.構造方法：

public String()：構造一個空字符串。效果同String str = “";public String(byte[] bytes):使用一個byte[]數組構造一個字符串；

public String(byte[] bytes,int offset,int length)：使用byte[]數組的一部分構造一個字符串； public String(char[] value)：使用一個字符數組構造一個字符串；

public String(char[] value,int offset,int count)：使用字符數組的一部分構造一個字符串； public String(String original)：使用一個字符串構造一個字符串；

7.常用方法：----注意：以下方法返回String的，都是生成一個新字符串，原字符串不變； 1).判斷功能：

boolean equals(Object obj):重寫父類的方法。與參數字符串比較，如果包含一樣的字符序列則返回true，否則返回false;

boolean equalsIgnoreCase(String str):作用與equals()相同；但此方法不區分大小寫； boolean contains(String str):判斷是否包含參數字符串；

boolean startsWith(String str):判斷字符串是否以參數字符串開頭； boolean endsWith(String str):判斷字符串是否以參數字符串結尾； boolean isEmpty():判斷字符串是否是”空字符串“；

----

String s1 = ”“;String s2 = new String();String s3 = new String(”“);String s4 = null;String s5 = ”“;String s6;System.out.println(s1.isEmpty());System.out.println(s2.isEmpty());System.out.println(s3.isEmpty());// System.out.println(s4.isEmpty());

System.out.println(s1.equals(s2));System.out.println(s2.equals(s3));System.out.println(s3.equals(s1));System.out.println(s1 == s2);System.out.println(s2 == s3);System.out.println(s1 == s3);System.out.println(s1 == s5);

System.out.println(s4 == s6);-----2).獲取功能：

int length()：獲取此字符串內部的字符數量。(區分數組的length屬性)char charAt(int index)：獲取此字符串中index位置的字符char;int indexOf(int ch)：從左向右查找，獲取字符ch在字符串中第一次出現的位置。如果不包含，則返回：false

int indexOf(String str)：獲取字符串str在此字符串中第一次出現的位置。int indexOf(int ch,int fromIndex)：從fromIndex位置開始，查找字符ch。int indexOf(String str,int fromIndex)：從fromIndex位置開始，查找str。

String substring(int start)：從start(包含)開始，截取到此字符串的末尾；返回一個新字符串，原字符串不變； String substring(int start,int end)：從start(包含)到end(不包含)截取字符串；返回一個新字符串，原字符串不變；

3).轉換功能：

byte[] getBytes()：將字符串轉換為一個byte[]數組。char[] toCharArray()：將字符串轉換為一個char[]數組；

static String valueOf(char[] chs)：靜態方法，將一個char[]數組轉換為一個String static String valueOf(int i)：靜態方法，將一個int轉換為一個String String toLowerCase()：轉換為小寫； String toUpperCase()：轉換為大寫；

String concat(String str)：將參數字符串添加到本字符串的末尾。

4).替換功能：

String replace(char old,char new)：使用new字符替換本字符串中的所有old字符； String replace(String old,String new)：使用new字符串替換本字符串中的所有old字符串；

5).其它功能：

String trim():去掉字符串兩邊的空格；不包括中間的。

int compareTo(String str)：重寫Comparable接口的方法。按Unicode編碼表的順序與參數字符串比較；

System.out.println(”a“.compareTo(”b“));//-1 System.out.println(”a“.compareTo(”a“));//0 System.out.println(”b“.compareTo(”a“));//1 int compareToIgnoreCase(String str):不區分大小寫的比較；

DAY15 一.StringBuffer類：

1.String的緩沖池類。

2.String和StringBuffer的區別：

1).String:其”值“不可變； 2).StringBuffer:其”值"可變；

當我們多次進行字符串的拼接等操作時，使用String會產生大量的垃圾空間。建議使用此類； 2.構造方法：

public StringBuffer()：初始容量16 public StringBuffer(int capacity)：初始容量capacity public StringBuffer(String str):使用String構造一個StringBuffer。

3.添加功能：

public StringBuffer append(String str)：及各種重載的方法。將任何類型的參數添加到末尾； public StringBuffer insert(int offset,String str)：將一個String插入到offset位置。原位置上的字符依次后移；

4.刪除功能：

public StringBuffer deleteCharAt(int index)：刪除index位置上的字符

public StringBuffer delete(int start,int end)：刪除start到end-1處的所有字符；

5.替換功能： public StringBuffer replace(int start,int end,String str)：將start到end處的所有字符替換為str;6.反轉功能： public StringBuffer reverse()：反轉內部字符串；

7.截取功能：

public String substring(int start)：截取從start到結尾，返回一個新字符串； public String substring(int start,int end)：截取從start到end-1處的所有字符；

二.StringBuffer類和StringBuilder類的區別：

1.StringBuffer是線程安全的； 2.StringBuilder是線程不安全的；

三.Arrays類：

1.對數組操作的類，沒有構造方法，內部包含了大量靜態的工具方法； 2.常用方法：

1).public static String toString(int[] a)：將int[]數組轉換為String的表示形式； 2).public static void sort(int[] a)：升序排序int[]數組；

3).public static int binarySearch(int[] a,int key)：二分查找int[]數組中的key值；

四.包裝類：

基本數據類型 byte short int long char float 包裝類型

Byte Short Integer

Long Character Float Double Boolean double boolean

第二篇：《Java程序設計》課程總結.

《Java程序設計》總評成績分析及課程總結

1、學期授課計劃是否符合教學大綱要求 符合。

2、教學內容及進度是否與學期授課計劃有出入,是何原因 無出入,完成規定的學習內容。

3、作業計劃、階段測試計劃、期末考試完成情況如何

順利完成預定的作業計劃及階段測試計劃。順利完成期末考試。

4、總評成績結果分析

因學生素質較高,在課堂表現、課程作品和答辯中整體表現良好,因此總評成績整體較高,85分以上人數占24%,無不及格學生。

5、對本課程教學及存在問題有何改進意見和設想

在今后的教學過程中應該加強“項目導向,任務驅動”的教學手段的運用,同時應采取各種方法加強與學生的互動。在本課程中,我采用了多媒體網絡教室、MindMapper、飛秋等軟件輔助教學,以學生為主體,以項目為主線,學生的參與性非常高,效果很好,在今后的課程中我會繼續加以實踐和總結。

總結人:xxx 2009-1-9

第三篇：JAVA課程總結（xiexiebang推薦）

Java課程總結

第1章 Java語言概述

1.字節碼是將Java源程序編譯后得到的中間代碼，它在某計算機平臺上由平臺相關的Java虛擬機解釋執行，從而實現Java程序的平臺無關性和可移植性。2．Java的特點

3.Java應用程序（2種），它們不同的結構特點及實現方式 第2-4章 1．

? 標識符：以英文字母、下劃線、$符號開始的字符序列，后面可以跟英文字母、下劃線、$符號或數字。可以標識類、接口、對象、方法、變量、數組等等。標識符不能和Java保留字同名。? 數據類型 a)簡單類型 i.ii.iii.iv.整數類型：byte(1字節)、short(2字節)、int(4字節)、long(8字節)浮點類型：float(4字節)、double(8字節)字符類型(2字節)布爾類型(1位)b)復合類型 i.ii.iii.類 接口 數組

2．運算符和表達式 3．控制語句

第5章 類、對象、消息的基本概念，面向對象的基本特征。※※第6章 Java語言中的面向對象特征 要求：熟練掌握本章的內容 1.類

源程序中由若干個類組成，類是源程序的基本單元

方法重載：多個方法使用同一個名稱，這些方法的返回類型必須相同，但是參數個數或類型不相同

構造方法：和類同名的、沒有返回類型(不是void)的方法，修飾符可以是public或private。構造方法的主要作用是在對象實例化過程中初始化成員變量。this變量

2.對象：對象的創建、使用、刪除。

包括對象間的賦值操作，對象的方法調用（不同的參數類型）。

3.包：

以package語句定義的類前綴，沒有定義包名的類屬于默認包。Package語句必須是源代碼文件的第一個有效語句。使用非默認包中的類一般都用import語句。

4.面向對象特性：封裝、繼承和多態性

Java訪問修飾符種類：public、private、protected 繼承：用于繼承父類的所有非private成員，語法上使用extends關鍵字 覆蓋(重寫)：在子類中重新定義父類的方法 5.其他：

①final關鍵字 ②static關鍵字

③java.lang.Object類

6.抽象類和接口

抽象類：以abstract修飾符修飾的類，這種類不能被直接實例化成對象，一般都包含0個或多個abstract方法。

接口：以interface定義的特殊抽象類，其所有成員變量都是abstract型方法，所有成員變量都是常量。第7章 數組和向量

數組的定義：不能直接指定元素個數，復合類型的數組變量必須逐元素初始化 當我們需要存儲不定長數據時，可以用向量（java.util.Vector類的對象）來代替數組。

第8章 字符串：構造方法、常用的成員方法

? 在Java語言中，字符串作為對象來處理，對應的類為java.lang包中的String和StringBuffer。

第10章 異常處理（大部分類在java.io包中）

重點掌握：幾種主要的異常類；異常處理機制

異常處理2種方式（try-catch-finally、在方法聲明后面使用throws子句拋棄異常）try-catch-finally語法格式為：

try{ 可能導致異常的代碼 } catch(異常類型 變量){ [異常的處理代碼] } [catch(異常類型 變量){ [異常的處理代碼] }] [finally{ 有無異常，都需要執行的代碼 }]

能看懂自定義異常、提交和處理異常的過程。

※第11章 輸入輸出處理（java.io包中）

? 常見字節流類：InputStream、OutputStream、FileInputStream、FileOutputStream

? 常見字符流：Reader、Writer、BufferedReader、BufferedWriter、InputStreamReader、OutputStreamWriter ※ ※第12章 圖形用戶界面設計

Java GUI的實現方式：AWT和Swing，要求：掌握界面元素添加、布局，事件處理，靈活運用java.awt包中的類，看懂例題并能熟練編寫程序。

組件、容器和布局管理器的使用

事件及事件處理（java.awt.event包）

第12章 線程

一般掌握

線程實現的兩種方式：繼承Thread類或實現Runnable接口

第13章 Applet技術基礎（java.applet包中）一般掌握

Java Applet程序的執行過程。

Java語言具有多媒體功能，支持圖像、動畫的顯示和聲音的播放。第15章 網絡編程（java.net包）一般掌握 Socket通信、URL 掌握基本的通信過程，理解建立套接字、通過獲得輸入、輸出流對象，進行通信的過程。URL：（統一資源定位地址)，是Internet中信息資源所在位置的一種表示方法 掌握，從網絡下載資源的基本操作語句。

第四篇：JAVA程序設計課程總結

JAVA程序設計課程總結

專業：計算機科學與技術 學號： 姓名：

JAVA程序設計課程總結

經過一學期的java學習，我在老師的上課講解以及自己的課下學習中對java編程有了一定的了解，我深深喜歡上了這種語言。培養了我正確應用面向對象的思維方法分析問題和解決問題的能力。

學習的內容主要分為以下幾個部分：（1）java程序的編輯，編譯，運行環境

（2）java語言程序設計中最基本的問題，即標識符，關鍵字，數據類型，常量，變量，表達式，聲明語句，賦值語句，數據的輸入與輸出等。（3）流程控制語句，即分支語句，循環語句，轉移語句。

（4）控制研究對象復雜性的原則，即分類，抽象，封裝和繼承，多態等。（5）數組的定義。（6）高級GUI組件的應用。

其中我對類與繼承了解較多。一．類

在Java中，類文件是以.java為后綴的代碼文件，在每個類文件中最多只許出現一個public類，當有public類的時候，類文件的名稱必須和public類的名稱相同，若不存在public，澤類文件的名稱可以為任意的名稱，但不能是數字開頭的名稱。在類內部對于成員變量，如果在定義的時候沒有進行顯示的賦值初始化，則java會保證類的每個成員變量都得到恰當的初始化：

1）對于char、short、byte、int、long、float、double等基本數據類型的變量來說會默認初始化為0，bolean變量默認會被初始化為false； 2）對于引用類型的變量，會默認初始化為null。

3）如果沒有顯示地定義構造器，則編譯器會自動創建一個無參構造器，注意：如果顯示地定義了構造器，編譯器就不會自動添加構造器，所有的構造器默認為static的。

初始化順序為：當程序執行時，需要生成某個類的對象，Java執行引擎會先檢查是否加載了這個類，如果沒有加載，則先執行類的加載再生成對象，如果已經加載，則直接生成對象。在類的加載過程中，類的static成員變量會被初始化，另外，如果類中有static語句塊，則會執行static語句塊。static成員變量和static語句塊的執行順序同代碼中的順序一致。在Java中，類是按需加載，只有當需要用到這個類的時候，才會加載這個類，并且只會加載一次。例如：

運行這段代碼就會發現“歐陽”只會被打印一次。在生成對象的過程中，會先初始化對象的成員變量，然后再執行構造器。也就是說類中的變量會在任何方法調用之前得到初始化，即使變量散步于方法定義之間。

二．繼承

在java中使用extends關鍵字來表示繼承關系，當創建一個類時，總是在繼承，如果沒有明確指出要繼承的類，就總是隱式的從根類Object進行繼承。例如：

類Number繼承于Student類，Student類稱為父類（基類），Number類稱為子類（導出類）。如果兩個類存在繼承關系，則子類會自動繼承父類的方法和變量，在子類中可以調用父類的方法和變量。在java中，只允許單繼承，也就是說 一個類最多只能顯示地繼承于一個父類。但是一個類卻可以被多個類繼承，也就是說一個類可以擁有多個子類。1.子類繼承父類的成員變量

當子類繼承了某個類之后，便可以使用父類中的成員變量，但是并不是完全繼承父類的所有成員變量。具體的原則如下： 1）能夠繼承父類的public和protected成員變量；不能夠繼承父類的private成員變量； 2）對于父類的包訪問權限成員變量，如果子類和父類在同一個包下，則子類能夠繼承；否則，子類不能夠繼承； 3）對于子類可以繼承的父類成員變量，如果在子類中出現了同名稱的成員變量，則會發生隱藏現象，即子類的成員變量會屏蔽掉父類的同名成員變量。如果要在子類中訪問父類中同名成員變量，需要使用super關鍵字來進行引用。

2.子類繼承父類的方法

子類也并不是完全繼承父類的所有方法。1）能夠繼承父類的public和protected成員方法；不能夠繼承父類的private成員方法； 2）對于父類的包訪問權限成員方法，如果子類和父類在同一個包下，則子類能夠繼承；否則，子類不能夠繼承；

3）對于子類可以繼承的父類成員方法，如果在子類中出現了同名稱的成員方法，則稱為覆蓋，即子類的成員方法會覆蓋掉父類的同名成員方法。如果要在子類中訪問父類中同名成員方法，需要使用super關鍵字來進行引用。

注意：隱藏是針對成員變量和靜態方法的，而覆蓋是針對普通方法的。

3.構造器

子類是不能夠繼承父類的構造器，如果父類的構造器都是帶有參數的，則必須在子類的構造器中顯示地通過super關鍵字調用父類的構造器并配以適當的參數列表。如果父類有無參構造器，則在子類的構造器中用super關鍵字調用父類構造器不是必須的，如果沒有使用super關鍵字，系統會自動調用父類的無參構造器。例如：

這樣的代碼是沒有問題的，如果把父類的無參構造器去掉，則下面的代碼必然會出錯：

改成下面這樣就行了：

4.Super super主要有兩種用法： 1）2）super.成員變量/super.成員方法;super(parameter1,parameter2....)第一種用法主要用來在子類中調用父類的同名成員變量或者方法；第二種主要用在子類的構造器中顯示地調用父類的構造器，要注意的是，如果是用在子類構造器中，則必須是子類構造器的第一個語句。

以上就是我掌握較好的點，但是其中也有很多我沒有考慮到的地方。很感謝老師陪我度過了一個愉快的學期，老師的教學方法(即實例與理論結合）也是我所認可的，能接受的，相信我在以后的工作生活中會越來越好。

第五篇：Java邏輯課程總結10班

第一章

? 開發java程序的步驟：編寫源程序，編譯源程序，運行（用記事本編寫源程序，以.java為后綴名→javac，生成.class文件→java 輸出結果）

? 源文件：.java ? 生成后:.class ? 程序的入口為：main方法，一個程序只能有一個入口，但一個項目中可以添加多個入口

? C#的入口呢？

? 基本的輸出：System.out.println(“Hello world！”);

? 注意：n t 的用法

以及print 與 println的區別

前者沒有換行，后者有

相當于print(“n”);? Java技術平臺：JavaSe JavaEE ? 程序注釋

多行注釋/*注釋內容*/ 單行注釋

//注釋內容 文檔注釋： /** 注釋的內容 */(對應的C#注釋又是如何的呢？)? 代碼規范

改縮進的要縮進，改換行的要換行 public 命名的類名，必須和源文件名相同 第二章

? 變量的理解：

電腦是使用內存來記憶計算時所使用的數據 通過地址來找到對應數據的量，試想，每次申請的時候，地址都會發生變化，這樣對開發是不是很不方便。所以我們用變量名，來代替實際的內存地址

例如，我們去住酒店

內存就像酒店

那變量的數據類型就像酒店里的房間類型，變量的名稱 就相當于房間的名稱

變量的值，就相當于房間里面住的客人

那我們通過變量名，就可以直接找到它所對應的值，就相當于，我們找到對應的房間名稱，就可以找到該房間對應的客人 一樣。

? 變量命名規則：

首字母，以字母，’_’或者’$’開始，其余部分可以包含任意多的數字、字母、下劃線或者$，但不能包含其他特殊符號

當然變量名不能包含java關鍵字（如int，main 等）? 變量的數據類型：char 單個字符 如’男’

int 整數

如一天24小時

double 小數

1.3

String

字符串

“Hello World”

? 變量的聲明及使用

? 第一步：聲明變量，即“根據數據類型在內存申請空間” double money;? 第二步：賦值，即“將數據存儲至對應的內存空間” money=1000.0;? 第三步：使用變量，即“取出數據使用 ”

System.out.println(money);? 當然，第一步和第二步，可以一起，如double money=1000.0;? 聲明變量的同時，給其賦值 ? 例題 ?

?

?

?

? public class TestType { public static void main(String[ ] args){ double score = 98.5;

String name = “張三”;char sex = '男';

System.out.println(“本次考試成績最高分： ” + score);//+ 連接輸出信息 System.out.println(“最高分得主： ” + name);System.out.println(“性別： ” + sex);} } 賦值運算符（=）語法：

變量名 = 表達式;（a =(b + 3)+(b – 1);）? 意思是，將等號右邊的值給等號左邊的變量

? 如：學員王浩的Java成績是80分，學員張萌的Java成績與王浩的相同，輸出張萌的成績

? int wangScore = 80;

//王浩成績 ? int zhangScore;

//張萌成績 ? zhangScore = wangScore;

? System.out.println(“張萌成績是" +zhangScore);算術運算符(+-* / %)? /：對于int類型的，若結果帶有小數，則直接忽略小數點及后面的數 如 5/3=1（而不是1.。。）

? %:取模 就是取余數

如5%3=2 輸入 導入import java.util.Scanner;? Scanner input = new Scanner(System.in);//相當于，我們要接受鍵盤輸入之前，先把鍵盤給準備好，接著，接收鍵盤輸入 ? 如： int a = input.netxInt();i++;i=i+1;

? i+=3;i=i+3;? ++放在前面，是先執行++，后執行別相應的別的操作，++放后面相反

? 如int a = i++;等價與int a=I;i++;兩步 ? int a = ++I;則等價于 i=i+1;a=I;? 一定要會轉換

數據類型轉換 ：①自動類型轉換

②強制數據類型轉換 ? 對應的規則：如果一個操作數為double型，則整個表達式可提升為double型

如

3.2+3 它將自動提升到double類型；

? 滿足自動轉換的條件(兩種數據類型要兼容，目標類型大于原類

型)大杯子裝小杯子 ? double 裝int ? ② 強制類型轉換

（類型名）表達式

如int b =(int)9.8;? 精度將會丟失，b=9，而不會是四舍五入

第三章

? 掌握新數據類型 boolean 類型（true 或 false）? 關系運算符（>,>=,<,<=,==,!=）注意 ==與=的區別，用在if條件中的是== ? 邏輯運算符（&& ,||,!）

? 注意&&，||屬于短路判斷 假 條件 ? 基本if選擇結構

? 語法結構： 真 if(條件){

代碼塊 //代碼塊 } ? 注意點：如果沒有{}，則只有一條語句屬于if語句 ? 建議，即使只有一條語句，也不要省略{} ? 條件1 &&條件2 僅僅兩個條件同時為真時，結果才為真

? 條件1 || 條件2

只要兩個條件中一個為真，結果為真 ?!條件

條件為真時，結果為假

? 條件為假時，結果為真（即，反一反）

? 運算符優先級：優先級順序：！>算術運算符>比較運算符>&&>|| ? 注意，當分不清優先級時，用()是明智之舉

? if-else選擇結構 ? 語法結構： 假 條件 if(條件){

真 //代碼塊1

}else { 代碼塊2 代碼塊1 //代碼塊2

}

第四章

? 重if選擇結構

? 語法結構： if(條件 1){

//代碼塊1

} else if(條件2){

//代碼塊2

} else {

//代碼塊3

} 注意：當連續判斷時，條件的順序不能亂，必須從小到大或者從大到小 ? 嵌套if選擇結構 if（條件1){ if（條件2){ 代碼塊1 } else { 代碼塊2 } } else { 代碼塊3 }

? switch選擇結構 switch(表達式){

case 常量 1: 語句;break;

case 常量 2: 語句;break;…

default: 語句;} ? 注意點：區別于多重選擇結構，它只能用于不連續的選擇結構

? switch 后的表達式，一定得是int 或者char，其他類型不行 ? case 后，記得加上break ? 與c#有什么不同點呢？？

? hasNextInt()方法，可以判斷用戶從鍵盤輸入的字符是否是合法的數字