java學習筆記1

時間 2019-11-30

標籤 java 學習筆記欄目 Java 简体版

原文原文鏈接

Lusir Shahtml

Core Javajava

引言：程序員

1、why:算法

Core Java是整個Java體系的基礎和核心，其餘Java技術均是構建在Core Java基礎之上的。sql

2、What：數據庫

java語法基礎：字符集，條件語句，循環語句express

java面向對象編程：特徵，高級特性，面向對象編程思想編程

java IO流（輸入輸出）和文件操做小程序

多線程編程設計模式

圖形用戶界面（GUI）編程

Java 網絡編程：Socket編程

3、How：

Thinking+Coding+Testing；

ch01 java入門

1、Java起源與發展

java起源於SUN公司的Green項目----》Oak

SUN公司在推出java語言的同時，也推出了一系列開發工具，如：JDK（java Development Kit）java開發工具包

時間版本類庫數量描述

1996 JDK1.0 250 Applet

1997 JDK1.1 500 圖形用戶界面編程

1998 JDK1.2(java2.0) 2300 全面支持企業及開發

2000 JDK1.3(java2.0)

2002 JDK1.4(java2.0)

2004 JDK1.5(java5.0) 3500 對語言自己作了重大改變，更穩定、更高效、更安全；---Tiger

2005 JDK1.6(java6.0)

補充內容：

java的應用版本：

JavaSE：java標準版本，基礎和核心，主要用來作java小程序，桌面程序；

JavaME：java微型版本，主要用來作移動開發，遊戲開發；

JavaEE：java企業版本，主要用來作企業級開發；

JDK（java Development Kit）包括：

java虛擬機JVM：編譯、運行java程序，JVM能夠運行在任何平臺上；

java API（java/JDK類庫）：別人開發好的能夠直接使用的類。提供一些最基礎和實用的java類，例如java.lang，java.util，java.sql包中的類都處於java API中；

開發工具：這些開發工具都是可執行文件

javac.exe 編譯java源程序

java.exe 運行java程序

javadoc.exe 生成java說明文檔

jar.exe 打包工具

2、設置java開發環境

1）獲取J2SDK

2）安裝J2SDK

JDK安裝目錄下的文件夾簡介：

bin:表示java的可執行命令/文件

demo:java的一些基本例子

include:一些c程序,主要是和其它語言集成

jre:java的運行環境,jdk必須有jre,java程序才能被處理

lib:放置庫函數,也稱之爲第三方文件

sample:java的實例程序

src.zip:java類庫源代碼

3）設置環境變量

JAVA_HOME:設置爲java安裝目錄，設置目的是簡化其餘環境變量的設置；該變量可設可不設；

path：設置java命令（工具）的路徑範圍，保證在操做系統的任何位置調用java命令；該變量必須設置；%JAVA_HOME%\bin;

classpath：設置java源文件的二進制文件的存儲位置，通常設定爲當前路徑，默認爲當前路徑。該變量可設可不設；

3、java是什麼？

java是編程語言、開發環境、應用環境、部署環境。

制訂了規則並予以實現（JDK）；

4、java的特色

1）簡單功能強大的：語法相似於C、C++；廢棄了指針操做，自動內存管理；Java提供了大量類庫；

2）安全的：無指針操做；嚴格的代碼校驗（校驗器能夠發現操做數棧的溢出，非法類型轉化等錯誤）；

3）健壯的：致力檢查編譯和運行時錯誤；強類型語言；自動垃圾內存回收；

4）純面向對象的

面向對象是java語言最重要的特徵，具備封裝、繼承、多態等特徵；java語言只支持面向對象編程，不支持相似於C那樣的面向過程編程；C++既支持面向對象編程，也支持面向過程編程；

5）解釋的：java源程序先編譯成結構中立的字節碼文件，而後解釋執行；C和C++是編譯執行的，先編譯成本地機器碼文件，而後執行；

6）跨平臺的（可移植的）：即「一次編譯，到處執行」，經過JVM虛擬機實現的，其原理是爲不一樣的OS提供不一樣JVM，但其編譯生成字節碼文件的規格相同；

java做爲一門網絡編程語言，編譯生成結構中立的字節碼文件，該文件能夠運行在任意一個具備java運行環境的機器上。

注意：java語言的跨平臺是經過JVM實現的，可是JVM自己並不跨平臺；

7）多線程的：java是一個從語言級支持多線程程序設計的編程語言，也就是能夠直接經過java編程實現多線程。

多線程編程的簡單性是Java成爲流行的服務器端開發語言的主要緣由之一

8）自動垃圾內存回收

垃圾：無用對象佔用的內存

垃圾回收：無用對象佔用的內存的回收過程

C和C++要經過編程者自身經過編程實現內存的分配和回收，若是內存分配和回收不平衡時，將形成系統資源耗盡或者內存溢出而致使程序異常終止，從而發生錯誤；

java中垃圾內存是由垃圾回收器線程在適當的時候自動回收。

當系統內存緊張時，回收；不然不回收；

編程者也能夠手動回收垃圾內存：java.lang.System.gc()/java.lang.Runtime.gc()；

5、JVM（java virtual machine）java虛擬機：利用軟件來模擬一個虛擬的環境；

6、垃圾回收

7、java代碼安全

8、第一個java程序

1）源文件：包含java代碼（符合java語言規則編寫的內容）的文件；

特徵：以.java爲後綴名；能夠包含多個類或者接口；文件名與類名或者接口（只包含一個類或者接口）或者與public修飾的類或者接口（包含多個類或者接口）同名；

結構：

包聲明：無關緊要，若是有隻能有一行而且必須處於第一行（註釋除外）；

import語句：無關緊要，可有多行，緊跟包聲明語句；

類的聲明語句；

2）類：java代碼的組織單位，java代碼就是由一個個類組織的，java編程就是編寫一個個的java類；

3）方法、main方法

4）剖析類

package：

將類放入某一特定的包中，便於類的組織、權限訪問和區分名字相同的類；

能夠定義多級包，中間用「.」分開，包名.包名....

引入包名後，類的名字爲：包名+類名；

java中包層次和文件系統中的目錄/文件夾結構相似；

import:

導入一個或者多個與本類不在同一包層次下的類文件；

import java.io.File;

import java.io.*;導入java.io包下的全部類，可是不包括其中子包下的類；

java.lang包下的類默認導入；

9、經常使用的包：

java.lang：包含一些Java語言的基本類與核心類，如String、Math、Integer、System和Runtime，提供經常使用的功能，這個包中的全部類是被隱式導入的；

java.awt/javax.swing/java.awt.event：包含編寫與平臺無關的圖形界面(GUI)應用程序的類；

java.io：包含一些用做輸入輸出(I/O)處理的類，主要包括流的類；

java.net：包含用於創建網絡鏈接的類，與java.io同時使用完成與網絡有關的讀寫；

java.util：包含一些實用工具類和數據結構類。像集合類、日期類等。

10、Java API：Java Application Programming Interface，java開發者預先定義好的供編程者直接使用的類庫；

ch02 java語法基礎

1、程序註釋

爲了加強程序代碼的可讀性，在java源文件中的任意位置都可以加入程序註釋。

程序中加入註釋語句，在java程序編譯時會被編譯器忽略，不管在程序註釋中添加任何東西，編譯後程序不受任何影響。

單行註釋：//註釋內容；

利用單行註釋，從符號//開始至換行之間的內容會被認爲是註釋內容編譯時編譯器會忽略；

例如：int age;//age表示年齡

多行註釋：/*.........*/,「/*」,「*/」之間爲註釋內容，必須成對出現，註釋內容能夠換行；

例如：/*註釋內容*/

或者

註釋內容

爲了美觀能夠寫成：

*註釋內容

文檔註釋：和多行註釋類似，任何聲明以前都可加入文檔註釋，註釋內容可被JavaDoc工具讀取做爲JavaDoc文檔內容，文檔是對代碼結構和功能的描述；

/**

*註釋內容

2、java代碼編寫基本規則

java語句以英文分號結束，爲了程序代碼的可讀性最好佔一行；

java代碼塊放在一對大括號之間；java容許一組語句放在一塊兒用大括號括起來造成代碼；例如：循環體，語句塊，類體，方法體；語句塊可嵌套；

程序忽略空格、製表符、空行、續行符；

3、標識符

java中用來爲類、方法、變量等所起的名字叫標識符；

規則：標識符以字母、「_」、「$」開頭，後可跟字母、「_」、「$」或者數字，無長度限制，大小寫敏感，不能使用java的關鍵字、預留關鍵字以及有特殊用途的符號做爲標識符；

有效：abc $qw $$$ q1 _$ $_

無效：1q #qw class true

注意：goto和const雖然目前不是java的關鍵字，可是被做爲預留關鍵字保留；

true，false，null具備特殊用途，不能用作標識符；

Volatile修飾的成員變量在每次被線程訪問時，都強迫從共享內存中重讀該成員變量的值。

命名規範：類和接口的名字首字母要大寫；方法名和變量名第一個單詞字首字母要小寫，其餘首字母要大寫；包名要小寫；常量名要大寫；全部的命名最好不要用中文以及英文以外的其餘語言；

4、數據類型：一組性質相同的值的集合以及定義在該值集合上一組操做的總稱；

程序的基本功能就是處理數據，程序中用變量來表示數據，變量必定要先定義在使用；

經常使用的數據類型：整型，浮點型，字符型，字符串型，邏輯型

java中的數據類型分爲基本數據類型和引用類型；

引用類型：類類型，數組類型，接口類型等；

基本數據類型：

數值型：整型（字節型byte，short短整型，int整型，long長整型），浮點型（float單精度型，雙精度型double）

邏輯型boolean：只能表明兩種狀態邏輯真或者假，用於判斷現實中條件的成立與否，經常使用來進行邏輯運算和程序的流程控制；

在java中boolean型只能取true或者false，不能像C語言中那樣用0和非0的整數來表明true或者false；

字符型char：2個字節，16位，無符號，用「'」括起來；

char a='a';

char a='\u0061';

char a=ox0061;

char a=97;

轉義字符：以反斜槓開頭

\n 換行符，將光標定位當下一行的開頭；

\t 垂直製表符，將光標定位到下一個製表符位置；

\r 回車，將光標定位到當前行開始處，並不移到下一行；

\\ 反斜槓

\' 單引號

5、變量：

變量是用來記錄值能夠發生改變的數據的標識符，一樣那麼常量就是用來記錄值不能夠發生改變的數據的標識符；

在計算機技術中，變量包括變量名和變量值，變量名標示一段特定的存儲空間，變量值就是存放在該空間中的二進制數據，能夠被修改和訪問；

變量的分類：

按照存儲數據的數據類型分：基本數據類型和引用類型；

按照聲明的位置分：局部變量和成員變量（又稱爲實例變量）；

局部變量：聲明在方法

內部或者代碼塊內；

成員變量：聲明在類的內部，方法的外部；

在java中變量在聲明和初始化後才能使用

成員變量定義在類的內部，在使用類建立對象時同時建立成員變量，進行系統默認初始化和顯示初始化；

方法形參局部變量，在調用方式進行隱式初始化；

變量的做用域和生命週期：

成員變量的做用和其所屬對象相同，生命週期隨着對象的建立而建立，隨着對象的銷燬而銷燬；

局部變量的做用域爲其所在的方法內部或者代碼塊內部，生命週期就是方法或者代碼塊的一次執行期間；

6、內存的邏輯分區

棧內存：特定程序專用，先進後出的分配原則，存儲空間分配連續，存儲容量小速度快。一般存放局部變量；

堆內存：所用應用程序公用，存儲空間分配不連續，存儲容量大速度慢。一般存放成員變量、對象；

代碼區：專門存放方法、代碼塊；

靜態、常量存儲區：存放靜態變量、常量；

7、理解對象

面向對象的開發方法把軟件系統當作各類對象的集合，對象就是最小的子系統，一組相關的對象可以組合成更復雜的子系統。面向對象的開發方法將軟件系統當作各類對象的集合，接近人的天然思惟方式。

對象是對問題領域中實體、事件的抽象。對象具備如下特性：

1) 萬物皆爲對象。問題領域中的實體和概念均可以抽象爲對象。例如學生，成績單、教師、課和教室。

2) 每一個對象都是唯一的。正如世界上不存在如出一轍的葉子。

3) 對象具備屬性和行爲。

例如小張，性別女，年齡22，身高1.6m, 體重40kg, 可以學習，唱歌。小張的屬性包括姓名、性別、年齡、身高和體重，行爲包括學習、唱歌。

例如一部手機，牌子是諾基亞、價格是2000元，銀白色，可以拍照、打電話和收發短信等。這部手機的屬性包括品牌類型type、價格price和顏色color，行爲包括拍照takePhoto()，打電話call()，收發短信receiveMessage()和發短信sendMessage().

4) 對象具備狀態。狀態是指某個瞬間對象的各個屬性的取值。對象的某些行爲會改變對象自身的狀態，即屬性的取值。

例如小張原本體重爲40kg，經爲減肥後，體重減到45kg.

肥胖狀態: 40kg

| 減肥行爲

肥胖狀態: 35kg

5) 每一個對象都是某個類的實例。小張和小王都屬於學生類、中國和美國都屬於國家類、中文和英文都屬於語言類。類是具備相同屬性和行爲的對象的集合。

同一個類的全部實例都有相同屬性，但屬性取值不必定相同，也就是它們的狀態不必定相同。例如小張和小王都屬於學生類，都有姓名、性別、年齡、身高和體重這些屬性，可是他們的屬性取值不一樣。

同一個類的全部實例都有相同行爲，意味着它們具備一些相同的功能。

8、類

類建立對象的模板，建立類語法爲：

[<modifiers>] class <class_name>[extends superclass][implements interface a,....]{

[<attribute_declarations>]

[<constructor_declarations>]

[<method_declarations>]

}

修飾符 + 返回類型 +methodName(參數列表){

方法體；

}

void

9、實例化對象

new + 構造方法

引用變量名.屬性名或者方法名；

類建立好以後，經過new關鍵字建立具體對象。它有如下做用：

. 爲對象分配內存空間，將對象的實例變量自動初始化爲其變量類型的默認值；（Java對象的默認初始化規則：數值型：0或者0.0；字符型："\u0000"；邏輯型：false；引用類型：null；）

. 如實例變量顯示初始化，將初始化值賦給實例變量；

. 調用構造方法；

. 返回對象的引用；

注：結合實例，並畫內存分配圖講解。

10. 基本類型和引用類型的區別

1) 基本類型表明簡單的數據類型，好比整數和字符。

引用類型表明複雜數據類型，引用類型所引用的實例包括操縱這種數據類型的行爲。經過"."運算符，就能訪問引用變量所引用的實例的方法.

2) 基本類型Java虛擬機會爲其分配數據類型實際佔用的內存空間；

引用類型僅是一個指向堆區中某個實例的指針。

例：public class Counter {

int count = 13;

}

Counter counter = new Counter();

counter引用變量-------------> Counter實例

count變量(佔4個字節,值爲13)

counter引用變量的取值爲Counter實例的內存地址。

counter引用變量自己也佔必定的內存空間，到底佔用多少內存空間取決於Java虛擬機的實現，這對Java程序是透明的。

注：counter引用變量到底位於Java虛擬機的運行時數據區的哪一個區？取決於counter變量的做用域，若是是局部變量，則位於Java棧區；靜態成員變量，則位於方法區；實例成員變量，則位於堆區；

要求:

寫一個Teacher類,屬性:name,age,gender,salary

對於屬性賦值和取值並打印本對象信息

對老師的salary作操做--->寫方法,給每一個老師加薪,減薪

寫一個測試類測試所寫的方法

ch03 表達式、運算符、流程控制

1、運算符

算術運算符：+ - * / % ++ --；

自增自減符號：能夠放在變量的前面也能夠放在後面，放在後面表示先取變量值再自增或者自減1，放在變量前面先自增或者自減1再取變量值；

比較運算符：> >= < <= == != instanceof

引用名 instanceof 類型名；

判斷引用是否指向某一類型或者其子類型的實例；

邏輯運算符： && || ! & | ^

語法：進行邏輯運算的邏輯值或者邏輯表達式

短路與：&&

A && B：只有當A的值爲true纔會考慮B，A，B都爲true時返回true，不然false；

短路或：||

A || B 只有當A爲false時才考慮B，A，B都爲false時返回false，不然返回true；

位運算符：& | ^ ~

移位運算符：<< >> >>>

對整數的二進制數進行移位處理；

a<<b 左移：將二進制形式的a左移b位，最高位b爲拋棄，低位（右側）空出的b位補0；

a>>b 帶符號右移：將二進制形式的a右移b位，最右側的b爲拋棄，最高位空出的b位補原來的符號位；

a>>>b 無符號右移：將二進制形式的a右移b位，最右側的b爲拋棄，最高位空出的b位補0；

int a=5;

00000000 00000000 00000000 00000101

a<<2 00 00000000 00000000 00000000 00010100

a>>2 00000000 00000000 00000000 00000001 01

a>>>2 00000000 00000000 00000000 00000001 01

int a=-5

10000000 00000000 00000000 00000101

11111111 11111111 11111111 11111010

11111111 11111111 11111111 11111011

a<<2 11 11111111 11111111 11111111 11101100

a>>2 11111111 11111111 11111111 11111110 11

a>>>2 00111111 11111111 11111111 11111110 11

賦值運算符：=

賦值運算符的左邊必須是已經聲明過的變量，不能是常量或者複合表達式；

運算符左右兩邊必須是相同的數據類型，能夠進行類型自動轉換的除外；

a E=b;

a=a E b;

條件運算符： ? :

(條件表達式)?(值1):(值2);

字符串鏈接符：+

2、表達式：符合必定語法規則的運算符和操做數組成的序列；

3、類型轉換

基本數據類型轉換和引用類型轉換

基本數據類型轉換：

隱式轉換（自動轉換）：從窄精度類型向寬精度類型轉換；int b=3;long d=b;

顯示轉換（強制類型轉換）：從寬精度類型向窄精度類型轉換；

long d=234;int a=(int)d;

byte-->short-->int-->long-->float-->double

char-->int

引用類型轉換：

隱式轉換（自動轉換）：讓父類型的引用指向子類型實例（對象）；

Object object=new String("abc");

顯示轉換（強制類型轉換）：讓子類型引用轉換爲父類型；

String str=(String)object;

4、流程控制語句

順序結構：最簡單的基本結構，按照語句順序執行；

選擇（分支）結構：按照給定條件判斷，條件爲true執行一個分支，爲false執行另外一個分支；

包括if選擇結構和switch分支結構：

if選擇結構：

b表明一個邏輯表達式

if(b){

statement or block;

}

if(b){

statement or block;

}else{

statement or block;

}

if(b){

statement or block;

}else if(b){

statement or block;

}else if(b){

statement or block;

}

.....

[else{

statement or block;

}]

if選擇結構能夠嵌套；

switch選擇結構：

switch(expression){

case(常量1):{

statement or block;

break;

}

case(常量2):{

statement or block;

break;

}

......

[dafault:{

statement or block;

break;

}]

}

expression值的類型只能是int，byte，short，char，枚舉，類類型之一；

break使得執行完一個分支後跳出switch語句，從語法上來說能夠沒有break，可是不合語

意；

default語句能夠放在switch結構的任何位置；

循環結構：按照須要使得重複執行一行或者多行代碼；

for循環：用於循環次數已知的狀況；

while循環：又稱爲當型循環或者前測試循環，該循環有可能一次都不執行；

do...while循環：又稱爲直到型循環或者後測試循環，該循環至少執行一次；

for each循環：

***

*****

*******

*********

***********

i爲行標

每行*的個數爲2i-1個；

每行要打印n-i個空格；

break語句：用於終止所在的switch語句或者循環語句；用於終止循環時終止的是所在單層循環；

continue語句：用於結束所在循環的本次執行，即跳過剩餘循環語句，開始下一次循環；

ch04 數組

1、概念：一組相同數據類型的數據組成的有序集合；

數組是引用類型，數組型數據是一個對象，數組中元素至關於數組的屬性；

數組中存放的元素能夠是任意類型，基本數據類型和引用類型；

2、一維數組的聲明，初始化，使用

聲明：

int[] a;//規範，推薦使用

int a[];

Person[] ps;

Person ps[];

注意：數組在聲明時不能指定長度（即元素個數）；

例如：int[5] a;//不合法

建立數組

new int[3];

new Person[3];

數組是引用類型，數組的元素至關於對象的成員變量，在數組建立時各元素像對象的成員變量同樣將根據元素類型進行默認（隱式）初始化；

數組初始化：

動態初始化：數組的聲明、建立和初始化分開進行；

int[] a;

a=new int[3];

a[0]=2;

a[1]=3;

a[2]=9;

Person[] ps;

ps=new Person[3];

ps[0]=new Person("zhangsan",32);

.....

靜態初始化：在聲明數組的同時給數組分配內存空間並賦值；

int[] a={2,4,6};

Person[] ps={new Person("zhangsan",34),new Person("lisi",87)};

數組的訪問：

數組名[元素下標]

數組元素下標：0--n-1;n爲元素個數（數組長度）；

數組的元素個數能夠經過數組的屬性length得到；

數組的長度一旦肯定將不可改變；

多維數組：

若干個低維數組組成的數組；

特性：多維數組的聲明、初始化要從高維到低維進行；

java中的多維數組能夠不是規則的矩形；

int[][] a=new int[3][];

int[][] b=new int[3][4];

int[][] c=new int[][4];//非法

int[][] a=new int[3][];

a[0]=new int[3];

a[1]=new int[2];

......

多維數組的初始化：

動態初始化：

int[][] a=new int[3][];

a[0]=new int[3];

a[1]=new int[2];

......

a[0][0]=3;

a[0][1]=4;

.....

靜態初始化：

int[][] a={{1,2},{3,4},{5,6,7}};

int[3][2] a={{1,2},{3,4},{5,6}};//非法

數組的拷貝：java.lang.System.arraycopy(源數組，源數組索引位置，目標數組，目標數組索引位置，長度)；

數組的排序：java.util.Arrays.sort(數組類型參數);

ch05 對象和類

1、java編程語言是面向對象的，利用java語言進行編程稱爲面向對象編程（oop:Object-Oriented Programming）。

java編程的基本單位是類，對象要經過類進行實例化，及建立對象。

2、理解對象：

對象的概念和特徵（回顧ch02講過的內容）引出類；

3、類是一種抽象數據類型：引用類型；

類是元數據，元數據就是表示數據的數據，數據在面向對象程序設計中以對象的形式存在，類是對對象共有屬性和行爲的抽象描述。

成員方法：

包括實例方法（無static修飾）和靜態方法（類方法，有static修飾）

參數傳遞

值傳遞：對應參數的值拷貝過程，不能影響傳入參數的值；

引用傳遞：不能改變引用變量自己的值，只可能改變傳入引用所指向對象的值；

成員變量：

包括實例變量（無static修飾）和靜態變量（類變量，有static修飾）

4、this變量：表明當前對象的引用

兩種用法：

this.varName(實例變量)：用來區分實例變量和局部變量

簡化本類構造方法的調用：this(參數列表)，在本類構造方法中調用其餘構造方法必須放在第一行；

5、封裝：封裝就是包裝，java編程的基本單位是類，也就是說java是以類爲基礎的，全部的數據和操做都封裝到類中，封裝是OOP的基本特徵之一；

數據隱藏：

提供統一接口；

隱藏實現細節；

提升可維護性；

6、方法的重載 Overloading

條件：

1)方法名必須相同（在同一類中）；

2)參數列表必須不一樣（參數個數不一樣，參數類型不一樣，參數順序不一樣）；

3)返回類型可有可無（相同不相同都可）；

在編譯的過程當中根據方法參數肯定尋找相應的方法，稱爲編譯時多態；

編譯以後的方法名加上其參數類型稱爲惟一的名字；

7、建立和初始化對象

new的做用；

8、構造方法

構造方法是一個特殊的方法，方法名和類名相同，無返回類型；

構造方法在建立所屬類型的對象時使用，做用就是建立一個對象，構造方法中的代碼通常作一些初始化工做；

每一個類都有一個構造方法，若是類中沒有定義構造方法，那麼系統將自動爲其提供一個缺省的無參構造方法；

當一個類中定義了一個或者多個構造方法，那麼系統將再也不提供缺省的無參構造方法；

通常狀況下一個類都要保證具備一個無參構造方法，不然影響操做；

java Web中的JavaBean在使用時，系統將默認調用其無參參構造方法，若是沒有定義將出錯；

使用：

在本類的其餘構造方法中利用this變量來調用；

在當前類的子類中利用super變量來調用；

在程序中建立對象時經過new來調用；

9、繼承

概念：在已有類型的基礎上進行改進和擴充而獲得新的類型，也就是在定義一個類時能夠繼承一個已有的類，目的是爲了簡化代碼，實現代碼的複用；

條件：「is a」的關係

子類，父類--超類，派生；

關鍵字：extends

特色：

1）Object類是全部java類的父類；

2）單繼承

java類只能有一個直接父類，但能夠派生出多個子類；

3）子類不能繼承父類的構造方法；

4）子類能夠繼承父類中非private的方法和屬性；

5）若是子類聲明瞭一個與父類同名的成員變量，此時咱們稱子類的成員變量隱藏了父類的成員變量；

5）若是子類聲明瞭一個與父類同名的成員方法，則此時子類不能繼承父類的成員方法，此時咱們稱子類的成員方法覆蓋（重寫）了父類的成員方法

10、super變量

做用

用來調用父類中被子類隱藏的變量和被覆蓋的方法；

用來在子類的構造方法中調用父類的構造方法

1）super只能用在構造方法或者實例方法中，不能用在靜態方法或者靜態代碼塊中；

2）子類構造方法必定直接或者間接地調用父類的構造方法；

3）若是子類構造方法沒有顯示調用父類的構造方法，也沒有經過this來調用本類中其餘的重載構造方法，那麼將默認調用父類無參構造方法（若父類中沒有則出錯）；

11、方法覆蓋：

覆蓋（重寫）overriding：子類根據須要對從父類繼承來的方法進行重寫實現；

條件：

1）重寫發生在子父類之間，同一類中的方法不能被重寫只能被重載。

2）重寫方法和被重寫方法要保證具備相同的方法名字、參數列表、返回類型；

3）重寫方法不能具備比被重寫方法更嚴格的訪問權限；

4）重寫方法不能拋出比被重寫方法範圍更大的異常；

5）靜態方法的重寫：父類的靜態方法能夠被子類同名的靜態方法重寫，此時隱藏了父類的方法；父類的靜態方法不能被子類非靜態的方法重寫（編譯錯誤）；父類非靜態的方法不能被子類重寫爲靜態方法；

12、多態

多態是發生在繼承的基礎上的；

父類 FatherClass 類 Son1Class Son2Class...

FatherClass fc=new Son1Class()或者new Son2Class();

父類的一個引用能夠指向多種不一樣的子類對象；也就是引用能夠有不少類型(能夠是類型自己也能夠強轉爲所指向對象的類型)；

可是一個對象只有一個類型；

多態就是因爲一個父類引用指向不一樣的子類對象所引起的現象。當一個父類引用指向不一樣的子類對象調用相同的方法時，表現出不一樣的行爲；

多態不像方法重載那樣發生在編譯時刻，而是發生在運行時刻。

13、instanceof

用法：引用變量 instanceof 類型名

判斷引用變量是否指向指定類型的對象或者指定類型的子類型對象，若是是返回true，不然返回false；

引用類型之間的轉換：

顯式轉換：父類型--》子類型（先用instanceof進行類型判斷，結果爲true纔可進行強轉）

隱式轉換：子類型--》父類型

轉化原則：被轉化的實際對象類型必須是轉化後類型自己或者子類型；

Animal a=new Animal();

Bird b=(Bird)a;

Animal a=new Bird();

Bird b=(Bird)a;

Animal a=new Bird();

Animal aa=(Bird)a;

14、Object類，「==」和equals方法

Object類是全部java的根類；

「==」符號對於基本數據類型就是比較值是否相等，

例如a=2,b=3;a == b返回false；

若是「==」比較兩個引用變量也是比較兩個引用變量的值是否相等；也就是說看兩個引用變量是否指向內存中同一個對象，若是指向同一個對象返回true，不然則返回false；

equals方法：比較兩個對象是否相等

，即同一類型的兩個對象的各屬性值是否相等，若是相等返回true不然返回false；

Object類中實現的equals方法實際和「==」功能相同，因此定義類時一般重寫equals方法實現對象相等的比較；

equals和toString方法重寫

String類

finalize方法使用

ch06 高級特性

1、static修飾符

static修飾符能夠修飾成員變量、成員方法、代碼塊和內部類。

用static修飾的成員變量，稱爲成員變量或者類變量，能夠經過類名.靜態變量名來訪問；

用static修飾的成員方法，稱爲靜態方法或者類方法，能夠經過類名.靜態方法名來訪問；

用static修飾的程序代碼塊，稱爲靜態代碼塊，在類加載時由java虛擬機執行；

用static修飾的成員變量和成員方法屬於整個類公有，不依賴於類的某個實例，爲類的全部實例共享；

靜態變量：

成員變量分爲靜態變量和實例變量：

區別：

靜態變量屬於某個類，在內存中靜態變量只存一份，爲該類全部實例共享；實例變量對於該類的每個實例在內存都存一份，互不影響；

java虛擬機在加載類時就爲靜態變量分配內存，實例變量是在利用類建立對象時分配內存；

靜態變量存放在內存中靜態變量常量區，實例變量存放在堆區；

靜態變量經過類名.變量名訪問（固然靜態變量也能夠經過實例名.變量名來訪問，可是將出現警告信息），實例變量經過實例名.變量名訪問；

實例一：說明內存分配；實例二：統計一個類建立實例的個數；

靜態方法：

1）靜態方法不能直接訪問類的非靜態成員（實例變量和實例方法），能夠直接訪問類的靜態成員；

2）靜態方法中不能使用this和super關鍵字；

3）子類中能夠定義與父類同名的靜態方法，這成爲子類隱藏了父類的靜態方法，此時也要知足覆蓋條件；可是要注意：靜態方法和類綁定，執行靜態方法時要看該引用的實際類型，實例方法和實例綁定，執行實例方法要看引用指向對象實際類型；

4）父類中的靜態方法不能被覆蓋爲非靜態方法，反之也成立；

靜態代碼塊：

定義在類的內部，方法外部由static修飾的代碼塊稱爲靜態初始化代碼塊，類加載時自動執行，而且只執行一次；

非靜態代碼塊：實例化塊

非靜態代碼塊在建立對象時自動執行；

靜態代碼塊，非靜態代碼塊，構造方法的執行順序？？？

static應用：單例模式

設計模式：不一樣於語法，高於語法，是一種設計思想，是被人反覆使用、多人知曉的、前人代碼設計經驗的總結；例如單例模式、門面模式、MVC設計模式等

單例模式--》編寫一個類實現該類只能產生惟一一個實例（對象）；

1）提供一個私有的構造方法；

2）提供一個本類類型的私有的static的成員變量，並使用構造方法進行初始化；

3）提供一個public的方法得到成員變量即惟一實例；

2、final修飾符

final具備最終的，不可改變的意思，final能夠修飾類、變量、方法；

final修飾的類不能被繼承；

final修飾的方法不能被覆蓋；

final修飾的變量即常量，不能被改變只能被賦值一次；常量只能在聲明的同時賦值或者在構造方法中顯式賦值，賦值後才能使用；

final不能修飾構造方法，抽象類和抽象方法；

3、abstract修飾符

abstract能夠用來修飾類、成員方法，稱爲抽象類和抽象方法；

抽象方法：

只有方法聲明，沒有方法實現；

public abstract void setName(String name);//抽象方法

抽象方法必須用abstract修飾；

public void setName(String name){

}//不是抽象方法，是普通方法或者說是具體方法，只是實現爲空實現；

抽象類：

用abstract修飾的類稱爲抽象類

語法規則：

1）抽象類不能實例化對象，能夠聲明引用；

public abstract class A{

.........

}

A a;//合法

new A();//非法

2）包含抽象方法的類必須聲明爲抽象類；但抽象類能夠不包含抽象方法；//？？想想若是能夠實例化對象，來調用其中的抽象方法將執行什麼？？？

3）定義抽象類主要用來定義新類時去繼承它，子類繼承抽象類要實現其中的全部抽象方法，不然必須也聲明爲抽象類；

抽象類主要做用是：規劃和重用代碼；由子類繼承抽象類去發揮做用；

4）abstract修飾的方法、類不能有final來修飾；

4、接口interface

概念：接口本質是特殊的抽象類，比抽象類更抽象，是常量和抽象方法的集合，接口中只能包含常量和方法的定義，不能定義變量和方法的實現。

public interface Runner{

public static final int id=0;

public abstract void start();

public abstract void run();

public abstract void stop();

}

接口中的定義的屬性默認就是public static final修飾的，方法默認是public abstract修飾的，所能夠省略；

public interface Runner{

int id=0;

void start();

void run();

void stop();

}

接口和抽象類同樣不能實例化對象，只能聲明引用；

和繼承類似，java類能夠實現一個或者多個接口，類實現接口就必須實現所要實現接口中的全部抽象方法；

和子父類同樣，接口與實現類之間也存在多態；

數據庫--》任何語言數據庫編程訪問數據庫--》導入驅動（SQL Server-微軟，Oracle-oracle）

sun共制定統一接口數據庫廠商實現接口（驅動包）

接口能夠繼承，而且支持多繼承；即定義一個接口能夠繼承一個或者多個已經存在的接口；

類能夠在繼承一個類的同時實現一個或者多個接口；

5、訪問修飾符

類的修飾符

成員修飾符

6、內部類：在一個類內部再定義的一個類；

例如：

public class A{

private class B{

....

}

static class C{

....

}

接口名或抽象類引用=new 接口名或抽象類(){

.......

};

public void test(){

class D{

...

}

if(...){

class E{

...

}

接口名或抽象類引用=new 接口名或抽象類(){

.......

};

}

在程序中，凡是使用內部類的地方均可以使用普通類（頂層類）來替代，使用內部類可以使程序更有條理性，代碼更加簡潔，便於劃分類的層次結構和命名規範。

根據變量劃分原則來劃份內部類：

做用

域劃分：

成員內部類：實例內部類靜態內部類

局部內部類：

另外還有一種特殊的局部內部類沒有名字，稱爲匿名內部類；

頂層類：public default

內部類的訪問修飾符：private default protected public

靜態內部類：最簡單一種；

用static修飾的成員內部類(定義在外部類的內部，方法的外部)；

1）不能用private修飾；

2）只能訪問外部類的靜態成員，不能訪問非靜態成員；

3）建立靜態內部類實例不依附於外部類的實例，能夠直接經過外部類名.內部類名來建立；

new OuterClass.InnerClass();

實例內部類：沒有static修飾的成員內部類；

能夠訪問外部類的一切成員；

建立內部類的實例要依附於外部類的實例；

例如(new Outer()).new Inner();

局部內部類：定義在方法體內或者代碼塊內；

1）局部內部類和局部變量同樣不能使用public，private，protected，static修飾符；

2）局部內部類能夠訪問外部類的一切成員，只能使用方法體內或者代碼塊內final修飾的局部變量（常量）；

3）局部內部類只能在所定義的方法體內或者代碼塊內使用；

匿名內部類：既能夠定義在方法體或者代碼塊內，也能夠定義在方法體或者代碼塊外，沒有名字，只能在所在之處使用一次；

匿名內部類必定在new關鍵字的後面使用，隱含着繼承一個父類或者實現一個接口，沒有名字，根據多態，使用其父類名或者所實現接口名字；

父類名引用=new 父類名{....};

接口名引用=new 接口名{....};

應用：a.當類與接口（或者是接口與接口）發生方法命名衝突的時候，此時必須使用內部類來實現。

b.用接口不能徹底地實現多繼承，用接口配合內部類才能實現真正的多繼承。

7、封裝類：java API爲每一個基本數據類型提供了一個包裝類；

int --- Integer：對int類型數據進行包裝成爲一個對象；

byte-----Byte

short----Short

char---Char

boolean----Boolean

float----Float

double----Double

long ----Long

封裝類處於：java.lang包下

做用：1）用引用類型表示數值，例如表示一個缺考學生的成績；

2）有些場合必須使用引用類型，例如：集合中只能存放引用類型；

3）用於基本數據類型間以及與字符串間的轉換；

以Integer爲例講解：查閱API文檔

8、集合：

引入集合：數組的缺點

集合的概念：用來存放多個對象的對象，而且只能存放對象（引用類型），這個對象能夠用來維護和管理一組相同和類似的對象；

集合三要素：接口，接口的實現類，算法

集合相關的要素由java API提供，處於java.util包下

主要掌握用法；

集合框架接口層次圖：

Collection：集合的根接口，

集合分爲三類：

Set：不容許存放重複的元素，其中存放的元素是無序的；

List：按照必定的順序存放元素（不是排序），能夠存放重複的元素；

Map：存放鍵值對，不容許存放鍵重複的鍵值對，一個鍵只能對應一個值；

briup---02111111111

SortedSet:和Set相似，其中的元素按升序排列；

SortedMap:和Map相似，其中的鍵值對按鍵升序排列；

接口實現類：

Collection--》無直接實現類，提供了訪問集合的通用方法；

List---》ArrayList，Vector，LinkedList

Set --》HashSet，LinkedHashSet

SortedSet--》TreeSet

Map---》HashMap

SortedMap---》TreeMap

ArrayList類：實現了List接口，用於表示長度可變的數組列表；在構造對象時能夠指定列表長度(所能容納元素個數)，默認長度爲10，不指定長度但添加對象數目超過10時，系統將自動增長列表長度；

查閱ArrayList類的API；

Vector類：與ArrayList同樣也實現了List接口，表示一個可變的對象數組；

與ArrayList的差異：Vector是同步（線程安全）的，佔用的資源多一些，運行效率要低一些，主要用在多線程環境下，ArrayList是不一樣步的，適合在單線程環境下使用；

Iterator（迭代器）：Iterator描述的是使用統一方式對各類集合元素進行遍歷/迭代的工具，也稱爲迭代器；

主要方法：

public interface Iterator{

boolean hasNext();

Object next();

void remove();

}

HashSet類：實現了Set接口，HashSet不能存放重複的元素，其中的元素是無序的；HashSet中能夠存放null

HashSet在存儲對象元素時，會根據對象的哈希碼來計算對象的存儲位置，對象的哈希碼是經過Object類提供的hashCode()方法來得到，hashCode()方法返回的值是根據對象的內存地址獲得哈希碼，這兩個對象經過new來構造的其地址不同，那麼獲得的哈希碼就不同，因此HashSet認爲二者是不一樣的對象；

hashCode返回相同值的同時必須保證對象的equals方法爲真這樣HashSet才認爲二者爲相同的對象；

結論：如將自定義類對象用hashSet來添加時，必定要覆蓋hashcode()和equals()這兩個方法，覆蓋的原則是保證當兩個對象相同時hashcode返回相同的整數，並且equals()返回的值爲True。

TreeSet類：實現了Set接口，實現了排序功能的集合；

在將對象元素添加到TreeSet中時會按照必定排序規則將元素插入到有序的對象序列中，保證TreeSet中的元素組成的對象序列時刻按照「升序」排列；

向TreeSet添加的對象元素的類型必須實現Comparable接口，不然程序編譯時出現java.lang.ClassCastException異常，API中String類、封裝類都已實現該接口；

HashMap類：實現了Map接口，用於存放「key-value」對信息,不能存放鍵值重複的「鍵-值」對；

主要方法：

TreeMap類：使用和HashMap相似；向TreeMap添加的"鍵--值"對元素的鍵類型必須實現Comparable接口，不然程序編譯時出現java.lang.ClassCastException異常，API中String類、封裝類都已實現該接口，這一點和TreeSet徹底一致。

反射：

1、概念

java程序在運行時能夠動態加載、解析和使用編譯時並不肯定的類型，這種機制稱爲反射或者說是內省；也就是說反射機制在運行狀態中，對於任意一個類能夠知道它具備的屬性和方法，若是是一個對象，能夠調用它的任意一個方法；指的是動態地獲取類型信息和動態執行對象方法的功能；

2、功能

動態加載編譯時不肯定的類型；

解析類型結構，獲取內部信息；

操做類型及其實例，具體包括訪問屬性信息、執行對象方法、建立實例；

3、反射相關API

java.lang.Class：類類型，用來描述java類的抽象類型，和普通的java類同樣。(類是用來描述對象的抽象類型，類的實例是一個特定的對象)

Class的實例表示運行時的java類型，例如：類、接口、註釋、數組、枚舉、java基本數據類型和void。

在類加載時，java虛擬機將自動建立一個相應的Class對象來描述所加載類的類型信息，即java類的成分信息（屬性，構造方法，方法，所實現的接口，所繼承的父類，所在包等等信息）。

java.lang.Class

java.lang.reflect.Field

java.lang.reflect.Method

java.lang.reflect.Constructor

java.lang.reflect.Modifier

4、反射編程的基本步驟：

1）得到Class實例

引用類型獲取方式：

a:利用Class提供的靜態方法forName：

Class c=Class.forName("類名");// 這裏的類名指的是類的全名：包名+類名；

b:利用Object類提供的getClass方法：

Person p=new Person();

Class c=p.getClass();

c:利用.class表達式

Class c=類名.class;//這裏的類名指的是類的全名：包名+類名；

Class c=String.class；

Class c=com.briup.Person.class;

基本數據類型和void的獲取方式：

a:利用.class表達式

Class c=int.class;

Class c=void.class;

b:利用包裝類的TYPE

Class c=Integer.TYPE;//表示的是int不是Integer（Integer.class）；

Class c=void.TYPE;

2）利用Class對象的方法來得到類型的相關信息；

查閱java.lang.Class API；

3）訪問/操做類型成員

java.lang.reflect.Field

java.lang.reflect.Method

java.lang.reflect.Constructor

java.lang.reflect.Modifier

public static final

public static void setName(int a,int b,String str){

};

ch07 異常

1、異常的基本概念：

1)異常產生的條件

或者稱爲異常狀況。在Java代碼中哪些是異常狀況呢？例如：

a. 整數相除運算中，分母爲0;

b. 經過一個沒有指向任何具體對象的引用去訪問對象的方法；

c. 使用數組長度做爲下標訪問數組元素；

d. 將一個引用強制轉化成不相干的對象；

..........

2)異常會改變正常程序流程;異常產生後，正常的程序流程被打破了，要麼程序停止，要麼程序被轉向異常處理的語句；

3)當一個異常的事件發生後，該異常被虛擬機封裝造成異常對象拋出。

4)用來負責處理異常的代碼被稱爲異常處理器

5)經過異常處理器來捕獲異常

6)異常分爲錯誤（Error）和違例（Exception）兩種：

錯誤Error是指像JVM錯誤，內存資源耗盡等嚴重狀況。程序一旦發生錯誤是不可恢復的，只能終止程序；

違例Exception是指因爲編程錯誤或者偶然的外在因素引起的事件致使的通常性問題，如網絡鏈接中斷、試圖打開/讀取不存在的文件、數組越界、空指針訪問、對負數開平方等。程序發生違例Exception，能夠經過適當的手段方式使得程序得以繼續運行。

7）在Java中異常是特殊的運行錯誤對象。是面向對象規範的一部分，是異常類的對象，Java聲明瞭不少異常類，每一個異常類都表明了一種運行「錯誤」。每當Java程序運行過程當中發生一個可識別的運行「錯誤」時，即該「錯誤」有一個異常類與之相對應時，系統都會產生一個相應的該異常類的對象，即產生一個異常。

2、java異常類層次：

Throwable

Error Exception

.....................

1）Error類：表示僅靠程序自己沒法恢復的嚴重錯誤，好比內存空間不足，或者Java虛擬機的方法調用棧溢出。在大多數狀況下，遇到這樣的錯誤時，建議讓程序終止。

2）Exception類：表示程序自己能夠處理的異常。Exception還能夠分爲兩種：運行時異常和受檢查異常。

RuntimeException：運行時異常或者稱爲未檢查異常，編譯器不要求捕獲、處理；

java.lang.ArithmeticException 算術異常，如除數爲0

java.lang.ArrayIndexOutOfBoundsException 數組越界異常，如一個數組由3個元素，訪問第4個元素；

java.lang.NullPointerException 空指針異常，沒有初始化引用變量就使用

java.lang.NumberFormatException 數據格式轉換異常，如Integer.parseInt("a");

java.lang.SecurityException 安全異常，通常碰不到

java.lang.NegativeArraySizeException 數組長度負數異常；

上述異常爲unchecked異常，編譯器不要求必須捕獲，也就是說在程序中不進行異常處理編譯時也不會報錯，這個時候做爲程序員必須考慮到這些狀況，確保異常不要發生。如在作除法運算時必須確保除數不爲0，經過引用變量訪問對象時確保對象不爲空等。

運行時異常表示沒法讓程序恢復運行的異常，致使這種異常的緣由一般是因爲執行了錯誤操做。一旦出現了錯誤操做，建議終止程序，所以Java編譯器不檢查這種異常。運行時異常應該儘可能避免。在程序調試階段，遇到這種異常時，正確的作法是改進程序的設計和實現方式，修改程序中的錯誤，從而避免這種異常。捕獲它而且使程序恢復運行並非明智的辦法。

受檢查異常：除了RuntimeException及其子類之外，其餘的Exception類及其子類都屬於受檢查異常(Checked Exception)。這種異常的特色是Java編譯器會檢查它，也就是說，當程序中可能出現這類異常時，要麼用try...catch語句捕獲它，要麼用throws子句聲明拋出它，不然編譯不會經過。

例如java.io.IOException，java.lang.ClassNotFoundException，java.io.FileNotFoundException;

3、異常處理

checked異常必須處理，處理有兩種方式：就地處理（try-catch塊，捕獲）和向上拋出；向上拋出異常使用throws關鍵字，聲明將異常拋出給方法的調用者；

異常處理宗旨

1）使得程序返回到一個安全、已知的狀態；

2）可以讓用戶執行其餘命令；

3）若是可能保存全部的工做；

4）若是有必要能夠退出，以免進一步危害；

異常處理機制

1）java程序在執行過程當中若是出現異常，系統監測到並自動生成對應的異常類對象，而後將它交給運行時系統；

2）運行時系統會尋找相對應的代碼來處理這一異常，若是運行時系統找不到對應的異常處理代碼，則運行時系統將終止，相應的java程序也將不得不退出；

3）程序員對錯誤Error無能爲力，能夠對違例Exception進行處理。

try{

....//可能產生異常的代碼

}catch(ExceptionName1 e1){

....//異常處理代碼

}catch(ExceptionName2 e2){

....//異常處理代碼

}[finally{

....//無條件執行的語句，通常用於資源的釋放

}]

在try/catch塊語句中能夠有多個catch語句，可是其捕獲異常類對象應從特殊到通常（從窄到寬）

若是父類中的方法拋出多個異常，則子類中的覆蓋方法要麼拋出相同的異常，要麼拋出異常的子類，但不能拋出新的異常（注：構造方法除外）；

import java.io.*;

class B{

public void b() throws Exception{

}

class C extends B{

public void b() throws FileNotFoundException,IOException{//合法

}

class C1 extends B{

public void b() throws IOException{//合法

}

異常調用棧：異常處理時所通過的一系列方法調用過程被稱爲異常調用棧。

1. 異常的傳播：哪一個調用，哪一個處理；

a. 異常狀況發生後，發生異常所在的方法能夠處理；

b. 異常所在的方法內部沒有處理，該異常將被拋給該方法調用者，調用者能夠處理；

　　　　　　　 c. 如調用者沒有處理，異常將被繼續拋出；如一直沒有對異常處理，異常將被拋至虛擬機；

2. 若是異常沒有被捕獲，那麼異常將使你的程序將被中止。

異常產生後，若是一直沒有進行捕獲處理，該異常被拋給虛擬機。程序將被終止。

3. 常常會使用的異常API

getCause()：返回類型是Throwable，該方法得到Throwable的異常緣由或者null。

getMessage()：得到具體的異常出錯信息，可能爲null。

printStackTrace()：打印異常在傳播過程當中所通過的一系列方法的信息，簡稱異常處理方法調用棧信息；在程序調試階段，此方法可用於跟蹤錯誤。

異常對象能夠人爲製造：

java異常對象除了當程序運行出錯時有系統自動生成並拋出外，還能夠人工建立異常對象並拋出；使用關鍵字throw

IOException e=new IOException();

throw e;

或者

throw New Exception();

在人工拋出異常時，必須是Throwable及其子類的對象，不然編譯時將產生語法錯誤；

throw new String("aaa");//非法

throw語句後面不容許緊跟其它語句，由於這些語句永遠不會被執行。

4、自定義異常

能夠定義本身的異常類，繼承Exception，必須人工拋出；

5、斷言

JDK1.4引入，在java程序中加入檢查語句，主要用於程序調試；

斷言機制:

在程序中定義的boolean表達式（假定條件）不成立時（即返回false），系統將產生一個Error對象，類型爲AssertionError類型；

在約定條件不成立的狀況下須要終止程序操做時使用斷言；

斷言做爲Error的一種，斷言失敗沒必要進行鋪獲處理或者聲明拋出，一旦出現終止程序，沒必要進行補救和恢復。

使用斷言

assert boolean表達式[:表達式]

斷言用於程序調試，java運行時環境默認關閉斷言功能；

開啓斷言功能：

java -ea classname

或者

java -enableassertions classname

關閉斷言功能：

java -da classname

或者

java -disableassertions classname

ch08 GUI

1、基本概念

GUI:Graphics User Interface 圖形用戶界面，與用戶交互的窗口；

咱們之前講的內容也能夠說程序都是經過命令行窗口或者說是控制檯和用戶進行交互，能夠經過鍵盤輸入數據給應用程序，程序經過命令行窗口或者控制檯返回程序運行後的結果數據給用戶，GUI是經過圖形化的方式和用戶進行交互；圖形用戶界面更友好，和用戶交互很方便；典型是Windows界面，PPT等；

AWT：Abstract Window ToolKit抽象窗口工具集

AWT是JDK的一部分，能夠說是Java API的子集，其中包括組件、容器和佈局管理器等要素；AWT支持Java GUI事件處理；使用AWT能夠進行Java GUI的開發；

AWT構建圖形用戶界面的機制包括：

提供了一些容器組件(如Frame和Panel), 用來容納其餘的組件(如按鈕Button、複選框Checkbox和文本框TextField)。

用佈局管理器來管理組件在容器上的佈局；

利用監聽器來響應各類事件，實現用戶與程序的交互。一個組件若是註冊了某種事件的監聽器，由這個組件觸發的特定事件就會被監聽器接收和響應；

相關軟件包：

java.awt.*：GUI基本組件包；

java.awt.event.*:java GUI事件處理包（用於實現與用戶交互）；

javax.swing.*:圖形界面升級包；

2、組件：Component

組件是圖形用戶界面的基本組成元素；凡是可以顯示在屏幕上而且可以和用戶交互的對象稱爲組件，例如：菜單、按鈕、標籤、文本框和滾動條等；

組件不能單獨的顯示出來，必須放在必定的容器中才能顯示出來；

在java.awt.*包中定義了不少組件類：Button、Menu、Lable、TextField；

在java.awt.*包中有一個抽象類java.awt.Component，該類是除了Menu類以外全部組件類的功能父類，其中定義了GUI組件的基本特徵，例如：尺寸、位置、顏色等；還實現了做爲GUI組件應該具有的基本功能；

3、容器：Container

容器自己也是一個組件，具備組件具備的全部性質，只是容器組件能夠容納其餘組件或者容器；因此Container是Component的子類；

容器具備add()方法用於添加其餘組件到容器中；

容器分類：

1）java.awt.Window

能夠自由停泊的頂級窗口；例如：PPT

2）java.awt.Panel

能夠做爲容器容納其餘組件，可是不能獨立存在，必須添加到其餘容器；例如：添加到Frame中；

Frame

Frame的類層次結構：java API

java.lang.Object

java.awt.Component

java.awt.Container

java.awt.Window

java.awt.Frame

1、Frame對象的顯示效果是一個能夠自由停泊的「頂級」窗體；帶有標題和尺寸重置角標；

2、Frame默認是不可見的，能夠調用Frame的setVisible(true)方法設置爲可見；

3、做爲容器Frame可使用add()方法添加組件；

Panel

提供容納組件的空間，不能獨立存在，必須添加到其餘容器中；

能夠採用與所在容器不一樣的佈局管理器；

組件定位：

java組件在容器中的定位由佈局管理器決定；

若是人工控制組件的定位，可取消佈局管理器，而後使用Component的方法：

setLocation(),setSize，setBounds()

void setBounds(int x, int y, int width, int height)

void setSize(int width, int height)

void setLocation(int x, int y)

GUI的座標系：

4、佈局管理器：LayoutManager

用來控制組件在容器中的排列風格；包括組件的位置和大小的設定；

爲了使java GUI程序具備良好的平臺無關性，java提供了LayoutManager來管理容器的佈局，不建議直接設置組件在容器中的尺寸和位置；

每一個容器都有一個默認的佈局管理器，當容器須要對某一組件進行定位或者判斷其大小尺寸時，就會調用對應的佈局管理器；

GUI程序的開發步驟：

1、肯定容器；

2、設置佈局管理器

3、向容器添加組件

4、添加事件處理器

一個容器只能有一種排列風格；

例如：BorderLayout、FlowLayout、GridLayout、CardLayout、GridBagLayout等；

Window及其子類（Frame、Dialog）默認佈局管理器爲BorderLayout；

Panel及其子類（Applet）默認佈局管理器爲FlowLayout；

BorderLayout

BorderLayout佈局管理器是Frame默認的佈局管理器；

佈局效果：

BorderLayout將容器劃分爲東西南北中五個區域，組件只能被添加到指定的區域；

添加組件時若是沒有指定添加區域，默認添加到Center區域；

一個區域只能放一個組件，若是在一個區域添加多個組件，則先前添加的組件將做廢；

組件大小被強行控制，大小與指定區域大小相同；

BorderLayout容器的縮放原則；

FlowLayout

FlowLayout是Panel容器的默認佈局管理器

佈局效果：

組件在容器中逐行加入，行內自左向右，排滿一行後換行；

不改變組件大小，按原始大小加入；

組件在容器中默認居中對齊，也能夠經過構造方法設置對齊方式，行間距，組件間距；

GridLayout

GridLayout佈局效果：

將容器劃分爲規則的矩形網格，按照組件的加入順序自左向右逐行加入，行間自上而下，將組件放入單元格；

組件大小被強行控制，和單元格大小相同，隨着容器的大小變化，組件大小自動調整，但相對位置不變；

CardLayout

將多個組件放在容器的同一區域內交替顯示，就像落在一塊兒的撲克牌只顯示最上面的一張；

CardLayout能夠按照名稱顯示某一張卡片，或者按照順序依次顯示每一張卡片，也能夠直接定位到第一張、下一張、上一張或者最後一張；

GridBagLayout

GridBagLayout是創建在GridLayout佈局管理器基礎上的一種極爲複雜和靈活的佈局管理方式。

容器嵌套

容器嵌套可使得本來只能顯示一個組件的區域能夠顯示多個組件；

5、GUI事件處理

引言：

圖形用戶界面設計並非咱們Java GUI程序設計的所有，甚至不是主要的部分，前面所講的GUI界面不能用戶交互，是靜止的，這不是咱們想要的。GUI程序應該可以和用戶很好的交互，也就是說經過圖形界面可以接收來自用戶的輸入，而且可以按照用戶操做作出相應的響應。

Java GUI事件處理機制：

GUI事件處理機制和異常處理機制相似，JDK爲GUI組件的各類可能操做預先定義了事件類，若是用戶觸發了組件的某一操做，組件將產生對應事件類的事件對象，此時將根據事件對象執行註冊在該組件上的監聽器與事件對象相對應的方法（固然前提是對於咱們關心的組件事件，已經在組件上註冊了對應的監聽器並實現了事件處理方法）。

當用戶與GUI交互，好比移動鼠標、按下鼠標鍵、單擊Button按鈕、在文本框內輸入文本、選擇菜單項或者關閉窗口時, GUI會接收到相應的事件，即各類可能的操做。

GUI事件處理的基本概念：

1、事件對象：事件就是描述發生了什麼事，也能夠說是對組件進行了什麼操做，在Java中，用事件對象來描述事件，事件一旦被觸發組件就產生對應的事件對象，事件對象對應的類通常均是Java API直接提供，自已不多構建事件對象類；例如：用戶對按鈕進行了單擊操做，被單擊的按鈕組件將產生ActionEvent事件對象；

2、事件源：可以接收用戶事件（用戶操做）併產生事件對象的GUI組件都被當作事件源，事件源產生事件對象；如按鈕、文本框等；

3、事件監聽器：對事件進行處理的對象；該對象定義了可以接收、解析和處理事件的方法，該方法實現與用戶交互；

每一種事件都對應專門的監聽器中的某一方法。監聽器中的方法負責接收和處理這種事件。一個事件源能夠觸發多種事件，若是它註冊了某種事件的監聽器，那麼這種事件就會被接收和處理。

稱爲事件處理模型的三要素。

案例總結：GUI事件處理

1、定義監聽器類，該類實現特定的接口中的對應抽象方法即編寫本身的程序處理邏輯；

2、在相應組件上添加該監聽器對象；

3、今後監聽器將對該組件發生的某一操做進行監聽，若發生對應事件將執行對應監聽器的事件處理方法；

ActionEvent

當菜單或者按鈕觸發ActionEvent事件時，使用actionCommand屬性來記錄事件的相關指令信息；

從所講案例中能夠看出，GUI程序的運行結果做爲開發者並不能控制，和用戶操做有關，咱們稱之爲事件驅動程序；

GUI事件類型層次

java.util.EventObject

ActionEvent（點擊時觸發） ContainerEvent

java.awt.AWTEvent AdjustmentEvent FocusEvent KeyEvent

ComponentEvent InputEvent MouseEvent

ItemEvent WindowEvent

TextEvent

ActionEvent：指鼠標在菜單、按鈕進行點擊等

AdjustmentEvent：組件或者容器的大小發生變化或者重置

ItemEvent：組件條目發生變化時觸發，例如當列表框中條目發生變化或者被選中；

TextEvent：當文本框或者文本域中內容發生變化時觸發事件；

ContainerEvent：當向容器加入組件或者從容器移除組件時觸發；

FocusEvent：焦點事件，例如組件得到或者失去焦點時觸發的事件；

InputEvent：是父類，當用鼠標、鍵盤進行輸入時觸發；

KeyEvent：是InputEvent的子類，當用鍵盤進行輸入時觸發；

MouseEvent：是InputEvent的子類，當用鼠標進行輸入時觸發；

WindowEvent：當窗口初始化、最大化、最小化、關閉或者銷燬都會觸發這種事件；

事件及相應的監聽器接口

1)windowActivated(WindowEvent e) //激活窗口

2)windowClosed(WindowEvent e) //調用dispose方法關閉窗口後

3)windowClosing(WindowEvent e) //試圖利用窗口關閉框關閉窗口

4)windowDeactivated(WindowEvent e) //本窗口成爲非活動窗口

5)windowDeiconified(WindowEvent e) //窗口從最小化恢復爲普通窗口

6)windowIconified(WindowEvent e) //窗口變爲最小化圖標

7)windowOpened(WindowEvent e) //當窗口第一次打開成爲可見時

1)keyPressed(KeyEvent e) //鍵已被按下時調用

2)keyReleased(KeyEvent e) //鍵已被釋放時調用

3)keyTyped(KeyEvent e) //鍵已被按下並釋放時調用

1) componentHidden(ComponentEvent e) //組件隱藏

2) componentMoved(ComponentEvent e) //組件移動

3) componentResized(ComponentEvent e) ///組件改變大小

4) componentShown(ComponentEvent e) ///組件變爲可見

1)componentAdded(ContainerEvent e) ///容器內加入組件

2)componentRemoved(ContainerEvent e) //從容器中移走組件

6、Swing組件

處於java.swing.*;

Swing與AWT的關係：

Swing是創建在java AWT的基礎上的加強型組件集或者說工具集，使用輕量級組件來替代AWT中絕大多數重量級組件；

JFC：Java Foundation Classes，java基礎類庫和想象的不同，JFC專指用於建立java 圖形用戶界面的API，具體包括Swing、AWT、Java 2D等；

重量級組件：調用操做系統底層組件完成功能，開銷大效率低而且具備嚴重的平臺相關性；

輕量級組件：經過java繪圖技術實現，開銷小效率高具備平臺無關性；

Swing組件較AWT功能更強大，更復雜；Swing組件的根類JComponent繼承自java.awt.Container;

使用JFrame和JTextField；

7、多重監聽器:

一般狀況下，事件源能夠產生不一樣的事件對象，於是能夠註冊（觸發）多種不一樣類型的監聽器；

1、同一事件源能夠註冊多個監聽器；

2、同一事件源的同一種事件能夠註冊多個監聽器；

3、一個監聽器能夠被多個事件源註冊。

8、適配器類：Adapter

Adapter是針對大部分的事件監聽器接口所定義的對應的實現類，適配器類實現了相應的監聽器接口中的全部方法，只不過全部的方法都是空實現即什麼事情都不作。

例如：MouseMotionAdapter類的定義爲：

package java.awt.event;

public abstract class MouseMotionAdapter implements MouseMotionListener{

public void mouseDragged(MouseEvent e) { }

public void mouseMoved(MouseEvent e) { }

}

爲何要有適配器類？

經過前述實例能夠看出，若是要實現GUI的事件處理，要在定義監聽器類時實現監聽器接口，既然是實現接口必須實現其中全部的方法，在實現的方法中可能有些在程序中根本用不到，固然用不到的方法也只是空實現，儘管是這樣這也是程序員十分討厭的事情。因此出現了Adapter。

主要適配器類介紹：

適配器類實現的接口

MouseAdapter MouseListener

MouseMotionAdapter MouseMotionListener

FocusAdapter FocusListener

WindowAdapter WindowListener

KeyAdapter KeyListener

ComponentAdapter ComponentListener

ContainerAdapter ContainerListener

兩點說明：

1、在JDK中定義的適配器類都是abstract的，其實這不是必須的，只是怕程序員誤用。

2、適配器類不能徹底替代監聽器接口。

假如一個監聽器既要監聽鼠標事件對象，又要監聽單擊事件對象應該怎麼辦？？

9、監聽器類常用內部類實現；

監聽器類中方法所實現的功能：重用價值不大。

1、學會經常使用組件的使用；

2、習慣於查閱API文檔；

軟件工程：

計算器：

需求分析、設計、實現

利用GUI編程實現一個記事本。

ch10 線程

1、基本概念

程序：

程序是計算機指令的集合或者說一組指令序列，它以文件的形式存儲在磁盤上。

進程：

進程是一個程序在其自身的地址空間中的一次執行活動，也能夠說進程是運行中的程序；

進程是資源申請、調度和獨立運行的單位，所以，它使用系統中的運行資源；而程序不能申請系統資源，不能被系統調度，也不能做爲獨立運行的單位，所以，它不佔用系統的運行資源。

程序和進程是不一樣的概念，一個程序對應多個進程；

計算機是支持多進程的；

線程

線程是進程中的一個單一的執行流程。

進程是程序的一次執行，程序執行過程當中可能有不少個執行流程，因此說：一個進程能夠擁有多個線程。

在進程地址空間中，真正完成任務的是線程。

線程又稱爲輕量級進程，它和進程同樣擁有獨立的執行控制，由操做系統負責調度，區別在於線程沒有獨立的存儲空間，而是和所屬進程中的其它線程共享一個存儲空間，這使得線程間的通訊遠較進程簡單。

因此說線程依附於進程，也就是說一個線程必有一個父進程。

計算機支持多線程；

爲何設計多線程？

是否可使用多進程程序替代多線程程序？

Java語言是第一個語言級支持多線程的語言。

2、java中線程的概念模型（三要素）：

虛擬的CPU：由java.lang.Thread封裝和模擬；

Code：CPU要處理的代碼，傳遞給Thread對象；

Data：CPU要處理的數據，傳遞給Thread對象；

3、線程的建立：

1）直接繼承java.lang.Thread

查看java API瞭解Thread中的方法；

Thread-n

2）實現Runnable接口

run方法：線程體，線程所實現的業務功能代碼；

start方法：啓動一個線程，執行線程的run方法；

比較兩種建立線程方式：

實現Runnable接口：推薦使用

1）實現接口的同時繼承一個其餘的java類；

2）將CPU、代碼和數據分開；

繼承Thread類：

1）編寫簡單

2）繼承Thread的同時不能繼承其餘類；

區分幾種線程：

1）用戶線程User Thread：用戶建立的線程；

2）main線程：程序的入口方法，程序的主線索；

3）後臺線程Daemon Thread：也叫精靈線程，在後臺運行，禮讓其餘線程執行，在系統空閒時運行；例如：JVM中的垃圾回收線程就是一個後臺線程；

4）子線程Sub Thread：定義在其餘線程中的線程；

3、線程的生命週期：

1）線程的實現有兩種方式，一是繼承Thread類，二是實現Runnable接口，不管哪一種方式，當建立了（new+構造方法）線程對象後，線程就進入了初始狀態;

2）當該對象調用了start()方法，就進入可運行狀態;

3）進入可運行狀態後，當該對象被操做系統選中，得到CPU時間片就會進入運行狀態;

4）進入運行狀態後狀況就比較複雜了

4.1、run()方法或main()方法結束後，線程就進入終止狀態;

4.2、當線程調用了自身的sleep()方法或其餘線程的join()方法或者發出了IO請求，就會進入阻塞狀態(該狀態既中止當前線程，但並不釋放所佔有的資源)。當sleep()結束或join()結束後或者IO操做結束或者調用線程的interupt方法，該線程進入可運行狀態，繼續等待OS分配時間;

4.3、線程調用了yield()方法或者時間片用完，意思是放棄當前得到的CPU時間片者時間片用完線程還沒結束，回到可運行狀態，這時與其餘進程處於同等競爭狀態，OS有可能會接着又讓這個進程進入運行狀態;

4.4、當線程剛進入可運行狀態(注意，還沒運行即將運行)，發現將要調用的資源被synchronize(同步)，獲取不到鎖標記，將會當即進入鎖池狀態，等待獲取鎖標記(這時的鎖池裏也許已經有了其餘線程在等待獲取鎖標記，這時它們處於隊列狀態，既先到先得)，一旦線程得到鎖標記後，就轉入可運行狀態，等待OS分配CPU時間片;

4.5、當線程調用wait()方法後會進入等待隊列(進入這個狀態會釋放所佔有的全部資源，與阻塞狀態不一樣)，進入這個狀態後，是不能自動喚醒的，必須依靠其餘線程調用notify()或notifyAll()方法才能被喚醒(因爲notify()只是喚醒一個線程，但咱們由不能肯定具體喚醒的是哪個線程，也許咱們須要喚醒的線程不可以被喚醒，所以在實際使用時，通常都用notifyAll()方法，喚醒全部線程)，線程被喚醒後會進入鎖池，等待獲取鎖標記。

線程的優先級：

1、線程的優先級用一個整數表示1-10（從高到低）；

2、線程的默認優先級爲5；

java沒有規定優先級低的線程就必定要讓優先級高的線程先運行且直到線程結束，因此開發時不能利用優先級來控制線程的執行；

相關方法：setPriority和getPriority

屬性：MIN_PRIORITY,MAX_PRIORITY,NORM_PRIORITY;

線程的串行化（join方法）：

實際應用普遍，多用無參方法；

join();

A B--->B.join();

利用sleep方法實現數字時鐘；

yield方法使用，線程讓步給其餘線程進行執行，使用該方法後線程並不進入阻塞狀態而直接進入就緒狀態；

t.yield();

主要用於在一個線程在釋放已經用完的所佔資源時調用，以便其餘線程得到使用資源的機會；

實現線程終止，stop方法因存在不安全因素被廢棄，必須尋求替代方法；

4、線程同步：

棧的操做實例

class Stack{

int index=0;//元素個數

char[] data=new char[6];

public void push(char c){

data[index]=c;

index++;

}

public char pop(){

index--;

return data[index];

}

同一時刻只容許一個線程訪問的資源，稱爲臨界資源；處理臨界資源的代碼稱爲臨界區。

互斥鎖：

在java中爲了保證共享數據操做的完整性，引入了互斥鎖的概念；

java中每個對象都有惟一一個互斥鎖，一旦加上鎖以後，保證了同一時刻只能有一個線程訪問該對象及其所保護的臨界區；

也能夠理解爲線程若是要訪問一個對象及其所保護的臨界區，首先應得到該對象的鎖，得到對象鎖後即得到了訪問該對象及其所保護臨界區的權力，在該線程沒有釋放對象鎖以前即沒有訪問完該對象及其所保護臨界區以前，其餘線程就該對象沒法訪問該對象及其所保護臨界區；

線程---》對象---》代碼（臨界）

使用關鍵字synchronied實現給對象加鎖；

synchronized能夠修飾方法也能夠修飾代碼塊，用synchronized修飾的方法稱爲同步方法，用synchronized修飾的代碼塊稱爲同步代碼塊；

同步代碼塊是對this對象加鎖；

5、線程死鎖：

併發運行的多個線程彼此等待對方佔有的資源，都沒法運行的狀態稱爲死鎖；

A:x,y x

B:x,y y

String StringBuffer

String str="a"+"b"+"c";

"ab"-->"abc"

StringBuffer str="a"+"b"+"c";

"abc"

6、線程同步通訊：

爲了在多線程併發運行時避免死鎖，在線程阻塞時應該儘量的釋放所佔有的資源，使得其餘線程得到運行的機會；

使用的方法wait(),notify();notifyAll();

wait():是線程自己中止執行等待，同時釋放所佔有資源；直到有其餘線程調用notify或者notifyAll方法纔有可能從新執行，不然永遠不會執行；

notify：喚醒調用了wait方法而等待的線程中的某一個線程，至因而哪個不肯定；

notifyAll:喚醒調用了wait方法而等待的全部線程；

生產者消費者問題：

題意分析：做爲生產者來生產產品而消費者來消費產品，當生產者生產出產品後將其放在一個倉庫，而後通知消費者來拿產品並等待，等消費者拿走產品後生產者再往倉庫放產品（消費者拿走產品後通知生產者繼續放產品）；消費者從倉庫拿走產品後，通知生產者繼續往倉庫放產品並等待，等生產者放完產品後再來取產品（生產者放完產品後通知消費者來取產品）。

用多線程來解決這個問題：經過剛纔上述對這個問題的分析，看該問題中有幾個對象：生產者，消費者另外還有就是放置產品的倉庫也是一個對象。倉庫是用來存放產品的，以面向對象程序設計的思想，編寫倉庫這個類，將產品數據和操做產品的方法組織在一塊兒，也就是說倉庫類要提供放置產品和得到產品的方法。

生產者和消費者用線程來表示。

類和對象的叫法很差區分；

語境

注意：1、wait方法、notify方法放在同步塊或者同步方法中，因爲這是使用的是同步方法，因此咱們同步的對象是this；2、調用wait方法此時將線程放入this對象的等待隊列中，notify方法喚醒的也是this對象的等待隊列的線程；這裏咱們必定要注意wait方法和notify方法必定要處於鎖定同一對象的同步代碼塊中或者同步方法中，不然將會產一些問題。

ch11 I/O流

1、基本概念：

I/O：Input/Output，跨越了JVM邊界，和外界進行數據交換；

數據源：數據的來源，一切能夠提供數據的地方，例如：磁盤上的文件、鍵盤、網絡鏈接等；

數據宿：數據目的地，一切能夠接收數據的地方，例如：磁盤上的文件、顯示器、打印機；

目前不少人將二者都稱爲數據源。

在java中把不一樣的數據源和程序間的數據傳輸抽象的描述成「流」（Stream），計算機中處理的數據形式爲「0」或者「1」這樣的二進制位，稱爲數據流；

java.io包中定義了不少流類來實現數據I/O功能。

2、I/O流的分類：

1、按照數據的流向（或者操做類型）分：輸入流InputStream和輸出流OutputStream；

對於輸入流只能從中讀數據，不能向其寫數據；對於輸出流只能向其寫數據，不能從中讀數據；

區分輸入流和輸出流的最有效辦法：

以當前程序做參照，若是是讀數據就用輸入流，寫數據用輸出流；

I/O流類java.io.RandomAccessFile類是個特例，該類便是輸入流又是輸出流；

2、按照流的功能分：節點流和功能流（或者過濾流、處理流）；

節點流只能鏈接數據源；功能流是對已經存在的節點流進行鏈接和封裝，經過封裝來加強流的讀寫功能，功能流不能數據源直接鏈接；

3、按照操做的數據單位分：字節流和字符流；

字節流以字節爲單位進行傳輸（讀寫），字符流以字符爲單位進行傳輸（讀寫）；

java I/O流命名慣例：以InputStream或者OutputStream結尾的流爲字節流，以Reader或者Writer結尾的流爲字符流；

3、流類的體系結構

4個頂層流類：

這四個均爲抽象類，其中InputStream和OutputStram是字節流，Reader和Writer是字符流，InputStream和Reader是輸入流，Writer和OutputStram是輸出流，均爲相應流的父類。

查閱以上流類的API文檔熟悉相關方法：

4、經常使用I/O類：

1、FileInputStream和FileOutputStream：

FileInputStream以字節爲單位讀取本地文件的數據；FileOutputStream以字節爲單位將數據寫入到文件；

2、BufferedInputStream/BufferedOutputStream

二者是爲字節輸入流和輸出流增長功能(緩衝)；

3、DataInputStream/DataOutputStream

分別實現了DataInput/DataOutput接口；

DataInputStream:容許應用程序以與機器無關方式從底層輸入流中讀取基本 Java 數據類型和String類型數據；

DataOutputStream:容許應用程序以適當方式將基本 Java 數據類型或者字符串形式寫入輸出流中；

數據存儲格式與JVM中內存中的數據存儲格式相同

4、FileReader和FileWriter

FileReader以字符爲單位讀取本地文件的數據，FileWriter以字符爲單位將數據寫入文件；

5、BufferedReader/BufferedWriter

二者是爲字符輸入流和輸出流增長功能；

6、InputStreamReader/OutputStreamWriter

InputStreamReader實現字節流向字符流的轉換，OutputStreamWriter實現字符流轉換爲字節流；

流操做的基本步驟：

1）建立節點流實例，和數據源相連；

2）建立功能流實例對第一步建立的節點進行封裝，以加強其功能，例如：緩衝功能，操做功能等；

3）操做流，從輸入流中讀數據，從輸出流中寫數據；

4）對於具備緩衝功能的流進行刷新操做；

5）關閉流，釋放流對象自己佔用的資源以及其中使用的其餘資源。

PrintStream、PrintWriter

System.in System.out

7、RandomAccessFile類

RandomAccessFile類同時實現了DataInput和DataOutput接口，提供了對文件隨機存取的功能，利用這個類能夠在文件的任何位置讀取或寫入數據；

RandomAccessFile類提供了一個文件指針，用來標誌要進行讀寫操做的下一數據的位置。

8、ObjectOutputStream/ObjectInputStream

對象的序列化

1、將對象轉換爲字節流保存起來，並在往後還原這個對象，該機制稱爲對象序列化和反序列化；

2、將一個對象保存到永久存儲設備上稱爲持久化；

3、一個對象要想可以實現序列化，必須實現Serializable接口或Externalizable接口；

4、對象的序列化可利用ObjectOutputStream中的writeObject()方法；對象的反序列化可利用ObjectInputStream中的readObject()方法；

5、當一個對象被序列化時，只保存對象的沒有transient修飾的非靜態成員變量，不能保存任何的成員方法和靜態的成員變量；

6、若是一個對象的成員變量是一個對象，那麼這個對象的數據成員也會被保存。

7、當咱們利用對象的反序列化從新構建對象的時候，它並不會調用這個對象當中的任何構造器，它僅僅是根據咱們先前保存對象的狀態信息在內存中從新還原這個對象；

8、若是一個可序列化的對象包含對某個不可序列化的對象的引用，那麼整個序列化操做將會失敗，而且會拋出一個NotSerializableException。咱們能夠將這個引用標記爲transient，那麼對象仍然能夠序列化。

9、PipedInputStream/PipedOutputStream

使用管道流進行線程間的數據傳輸；

10、Properties類的使用：

5、文件操做：

java.io.File類：

1）一個File類的對象，表示了磁盤上的文件或目錄；通常狀況下，File只表示文件，但在Java中它不只表示文件並且還表示目錄；

2）File類提供了與平臺無關的方法來對磁盤上的文件或目錄進行操做。

查閱Java API文檔，熟悉File類的相關方法。

//window下路徑中分隔符爲「\」,Unix下爲"/";/ch04/a.txt

//File.separator在window下指的是「\」,Unix下爲"/"

ch12 網絡編程

基本概念：

1、計算機網絡

計算機網絡是相互鏈接的獨立自主的計算機的集合，最簡單的網絡形式由兩臺計算機組成。

2、網絡通訊

IP地址：

1）IP網絡中每臺主機都必須有一個唯一的IP地址；

2）IP地址是一個邏輯地址；

3）因特網上的IP地址具備全球惟一性；

4）32位，4個字節，經常使用點分十進制的格式表示，例如：192.168.0.16。

協議：

1）爲進行網絡中的數據交換（通訊）而創建的規則、標準或約定；(=語義+語法+規則) ；

2）不一樣層具備各自不一樣的協議。

端口號：

端口使用一個16位的數字來表示，它的範圍是0--65535，1024如下的端口號保留給預約義的服務。例如：http使用80端口。

3、OSI(Open System Interconnection)參考模型

物理層：二進制傳輸，肯定如何在通訊信道上傳遞比特流；

數據鏈路層：增強物理層的傳輸功能，創建一條無差錯的傳輸線路；

網絡層：在網絡中數據到達目的地有不少線路，網絡層就是負責找出最佳的傳輸線路；

傳輸層：傳輸層爲源端計算機到目的端計算機提供可靠的數據傳輸服務，隔離網絡的上下層協議，使得上層網絡應用的協議與下層無關；

會話層：在兩個相互通訊的應用進程之間創建、組織和協調其相互之間的通訊；

表示層：處理被傳送數據的表示問題，也就是信息的語法和語義，若有必要將使用一種通用的格式在多種格式中進行轉換；

應用層：爲用戶的應用程序提供網絡通訊服務；

OSI(Open System Interconnection)參考模型並非物理實體上存在這七層，這只是功能的劃分，是一個抽象的參考模型。進行網絡通訊時，每層提供本層對應的功能；

1）通訊實體的對等層之間不容許直接通訊，它們之間是虛擬通訊，實際通訊在最底層完成；

2）各層之間是嚴格單向依賴；

3）上層使用下層提供的服務 — Service user；

4）下層向上層提供服務 — Service provider。

5）對等層實體之間虛擬通訊；

6）下層向上層提供服務，實際通訊在最底層完成。

6、OSI各層所使用的協議

1）應用層：遠程登陸協議Telnet、文件傳輸協議FTP（網上下載一個軟件或者資料的時候就會使用該協議）、超文本傳輸協議HTTP（使用較多，經過IE瀏覽一個網頁的時候就使用該協議）、域名服務DNS（使用較多，經過網絡訪問一個計算機通常不使用該主機的IP地址，而是經過該主機的域名訪問）、簡單郵件傳輸協議SMTP（經過Formail發送郵件）、郵局協議POP3等（經過Formail收郵件）；