java基础总结（小白向）
java入門基礎總結（小白向）
1.類和對象的理解
? 理解類和對象對應學習Java尤其重要，可以說類和對象貫穿整個Java語言。我們先給出類和對象比較官方的介紹。
? 類：具有相同屬性和方法的一組對象的集合。
? 對象：類的一個具體實例。
? --屬性：對象的靜態描述
? --方法：對象的動態描述（可以是主動也可以是被動的描述）
? 看似有一點高深，其實翻譯成比較容易理解的大白話，就是模板和個體。打個比方：你家里有3只貓，這3只加貓同屬一類，這一類叫家貓（或者說大一點類別:貓）。家貓是不是有一些固有的屬性，比如毛色，眼睛的顏色，體重等等。家貓又有以下動作（方法）抓老鼠，喵喵叫，被擼。這時候家貓這個模板就出來啦。
? 而對象是從對象中拷貝出來的實例個體，比如：這三只家貓分別叫Tom,mimi,kiki，并且其擁有自己獨特的毛色等等，這三只貓就是三個對象（實例）。
這里先給出一代碼框架出來先
class Cat{//屬性String name;String Coatcolor;int eyecolor; //這里用int類型代指眼睛顏色類型，1.綠 2.藍具體可根據實際情況float weight;//構造函數后面會具體說明Cat(String name,String Coatcolor,int eyecolor,float weight){//一些賦值操作}//-------------------------------------------------------------------//方法public void catch(){System.out.println(name+"抓到老鼠");}//其余方法······· }2.類的創建
? 這里介紹類的創建，也就是創建一個模板。如上述的代碼一樣，創建了一個模板。
? 類的創建用關鍵字class來修飾，class這個關鍵字是告訴計算機你要創建一個類。class后面跟類的名字，就如上面的class Cat我創建了一個類，名字叫Cat(建議:類的名字首字母為大寫)。具體創建格式如下。
[訪問權限修飾符]class 類名 [extends 父類] {//屬性;//方法; } //[]為可選項，后面具體介紹，這里并沒有寫全 //可以根據上面代碼進行對比? 類的方法是以函數的形式進行表達的，方法結構如下：
[訪問權限修飾符] [final] [static] [abstract] void 方法名([形式參數列表]) [throws異常類] { //方法體 } //[]可選項包含主方法的類稱為主類，主類是程序執行的入口點。主方法結構如下：
public class Dome{public static void main (String[] args){//主方法體} }屬性，方法體外的變量或常量。
class Cat{//定義屬性成員[訪問權限修飾符][static]類型 變量名······ }3.常量和變量
常量：數據在程序運行過程中值不發生改變，常量用final聲明。
變量:一個命名的內存塊,用于存儲Java程序中的信息。
java的數據類型如下：
數據類型分：基本數據類型，引用數據類型
基本數據類型分：數值型:(byte,short,int,long,float,double)，字符型(char)，布爾型(boolean)
引用數據類型分：類(class)，數組和字符串(String,char[])，接口(interface)
4.java選擇結構
其實java的很多語法地方和C很相似，會C那么Java的選擇結構基本是沒有問題了。
//二分支選擇 if (條件表達式){//當條件表達式為真時，執行改處語句塊 }else{//否則，執行改處語句塊 }//多分支選擇 if(條件表達式一){//條件表達式一為真時，執行改處語句塊，否則跳轉到下一條件表達式的語塊 }else if(條件表達式二){//條件表達式二為真時，執行改處語句塊，否則向下跳轉 }else if(條件表達式三){//同理 }else{//都不成立，執行改語句塊 }//開關語句（switch） switch(表達式){case 常量1：語句塊；break;case 常量2：語句塊；break;·······default:必定輸出語塊； } //default為可選5.java的循環結構
java的循環結構跟C類似，具體如下：
//for循環 for(表達式1;表達式2;表達式3){/*表達式1：初始化部分表達式2：循環條件表達式3：迭代部分*/ }//條件循環(while) while(條件表達式){//當條件表達式為真時，執行循環語句塊 }//條件循環(do-while) do{//與（while）相似，不過是先執行一次然后再判斷是否繼續執行 }while(條件表達式);說到循環結構就必須說一下跳轉語句,jave支持三種跳轉語句:
/*必須注意break和continue的不同,break是跳出整個循環體,而continue只是結束當前循環，如果條件允許，循環還會繼續進行。 */ break //結束循環，跳出循環體 continue //結束當前循環 return //函數出口，返回一個值，或者空6.類和對象的構造和創建
創建對象必須用new操作符，
new操作符的作用：
—為對象分配內存空間；
—調用類的構造方法；
—為對象返回一個引用(地址)。
? 回到前面的代碼中，會發現一個比較特殊的方法(函數)，這個特殊的方法就叫做構造方法，或者叫做構造函數。
? 每個類里面都有一個構造函數，構造函數主要完成對象創建時的初始化操作。構造方法的名稱與類名一致，沒有返回類型。
//這里就創建了一個對象mycat Cat mycat = new Cat（"tom","blue",2,10）； /*第一步在內存中聲明了一個存放對象地址的變量，該變量稱為對象名，此時值為null； 第二步用new調用構造函數并在內存中開辟一塊存儲空間，并把地址交給變量，此時對象名指向內存空間*/這里重新說明一下構造函數：
/*每個類都必須有一個構造函數，當創建一個類時，java會默認給類添加一個隱式無參的構造函數，當程序員沒寫構造函數時，java默認調用隱式構造函數。 */class Cat{//屬性（成員變量）String name;String Coatcolor;int eyecolor; float weight; //------------------------------------------------ //此處存在隱式構造函數。此函數給成員變量賦值null,或者0.//------------------------------------------------public void catch(){System.out.println(name+"抓到老鼠");} }class Cat{//屬性（成員變量）String name;String Coatcolor;int eyecolor; float weight; //------------------------------------------------ //當用戶編寫了構造函數，隱式構造函數將消失，不在被調用public Cat(String name,String Coatcolor,int eyecolor,float weight){this.name=name;this.Coatcolor=Coatcolor;this.eyecolor=eyecolor;this.weight=weight;}//------------------------------------------------public void catch(){System.out.println(name+"抓到老鼠");} }對象的銷毀
? Java提供了資源回收機制，可以自動銷毀無用的對象，收回其所占內存空間。
如果編程者需要主動釋放對象，要重載Object父類中的finalize方法來釋放資源，該方法一般在垃圾收集器刪除對象之前被自動調用。這種情況不經常使用。
7.靜態成員與實例成員
? 實例變量：對象擁有的變量，通過對象（實例）來訪問。
? 每個對象創建時都為實例成員分配對應的內存空間。實例變量是獨立的，每個對象都有屬于自己的實例變量，類的每個對象都有自己的實例屬性存儲空間。
? 靜態變量：所有類和對象共享，通過類訪問。靜態成員有靜態屬性和靜態成員方法，靜態屬性被所有對象共享。
? 用static修飾符聲明靜態屬性。一個靜態屬性只標記一個存儲位置，多個類對象共享這個存儲空間，即一個對象修改了值，另外一個對象取出的是修改后的值。
? 靜態方法：用static聲明，用 類名.方法名（實際參數列表）的形式訪問。靜態方法體中不能訪問類的實例成員。就是說類方法（對象共同擁有的方法）是無法訪問實例變量和調用實例方法（非靜態方法），并且不能使用this關鍵字。
下面通過代碼理解一下
public class ex1 {public static void main(String[] args) {System.out.println("靜態成員能通過類名直接調用A.A1："+A.A1);A.test();A test1 = new A(1);A test2 = new A(2);System.out.println("--------------------");test1.test();test1.test2();System.out.println("--------------------");test2.test();test2.test2();System.out.println("--------------------");test1.change(5);System.out.println("test1和test2對象的靜態變量更改成："+test2.A1);}}public class A {static int A1=10;int A2;public A(int A2) {this.A2=A2;}public static void test() {System.out.println("靜態方法只能訪問靜態變量A1："+A1); }public void test2() {System.out.println("非靜態方法能訪問靜態變量A1："+A1+"\t和非靜態變量A2："+this.A2); }public void change(int x) {A1=x;} }輸出結果如下：
靜態成員能通過類名直接調用A.A1：10 靜態方法只能訪問靜態變量A1：10 -------------------- 靜態方法只能訪問靜態變量A1：10 非靜態方法能訪問靜態變量A1：10 和非靜態變量A2：1 -------------------- 靜態方法只能訪問靜態變量A1：10 非靜態方法能訪問靜態變量A1：10 和非靜態變量A2：2 -------------------- test1和test2對象的靜態變量更改成：5關鍵字this的使用
在類的實例方法或構造方法中有一個名為this的引用，指向當前對象本身。
this可以引用屬性（成員變量） -----this.屬性
this也可以調用類中的其他成員方法 -----this.成員方法名(參數表)
this也可以調用本類的其他構造方法，不過必須位于構造方法中第一行。 -----this(參數)
this也可以作為return的返回值，返回對象本身。 -----return this;
8.方法的重載
? 成員方法的重載，一個類中可以擁有多個方法名相同，簽名不同的方法，稱為該方法被重載。方法的簽名：方法名、參數個數、參數類型。
? 打個比方：輸出函數中System.out對象中的println方法就有多個原型，實現了重載,可以實現對多種類型數據的輸出。也就是說，兩個名字相同的方法，只要其形參列表不同，那么者兩方法就能同時存在，具體調用時，看傳入參數來決定使用哪個方法。通過以下代碼幫助理解。
public class A {public void run(int x) {System.out.println("這是重構方法1");}public void run() {System.out.println("這是重構方法2");} }//demo public class test_main {public static void main(String[] args) {A a=new A();a.run(0);a.run();}}實驗結果如下：
這是重構方法1 這是重構方法29.類的封裝和訪問控制
? 封裝性為軟件提供了一種模塊化的設計機制。設計者提供類模塊，使用者用類模塊組裝更復雜的軟件系統。java是面向對象語言，模塊化的程序便于維護。而且java提供了訪問權限的控制，java根據封裝性要求，需要為類中的成員變量和成員方法提供不同的訪問權限。
訪問權限關鍵字，有public,protected,default(默認),private，訪問權限由大到小。
public —本類 —本包和其他包 —子類 —非子類
protected —本類 —本包 —子類
default —本類 —本包
private —本類
? public的權限范圍是最大的，是公開屬性，任何類都能調用public的方法，protected其次，除了其他包的非子類無法訪問以外，其余都能訪問。平時使用最多的是默認類，default可以不寫，不寫就是default。權限最小的是private，除了本類能訪問外，其余都無法訪問，若要訪問，那么就必須一些Get,Set的公共類方法。
類級別：public 默認
成員級別：public protected 默認 private
老樣子附代碼幫助理解：
/*A.java*/ package test6; public class A {public String a;protected String b;String c;private String d;public A() {System.out.println("創建public類A");a="public";b="protected";c="default";d="private";}public String getD() {return d;}public void setD(String d) {this.d = d;}}/*B.java*/ package test6; class B {public String a;protected String b;String c;private String d;public B(){System.out.println("創建默認類B");a="public";b="protected";c="default";d="private";}public String getD() {return d;}public void setD(String d) {this.d = d;} }//C.java package test7; public class C {public String a;protected String b;String c;private String d;public C(){System.out.println("創建public類C");a="public";b="protected";c="default";d="private";}public String getD() {return d;}public void setD(String d) {this.d = d;} }//D.java package test7; import test6.A; public class D extends A{public String a;protected String b;String c;private String d;public D(){System.out.println("創建public類D");a="public";b="protected";c="default";d="private";}public String getsuperA() {return super.a;}public String getsuperB() {return super.b;}public String getD() {return d;}public void setD(String d) {this.d = d;} }//test_demo.java package test6; import test7.*; public class test_demo{public static void main(String[] args) {A demo1=new A();System.out.println("本包下能直接訪問變量："+"\ndemo1.a="+demo1.a+"\tdemo1.b="+demo1.b+"\tdemo1.c="+demo1.c);System.out.println("若要訪問私有變量必須通過Get和Set方法，"+"demo1.getD="+demo1.getD());System.out.println("----------------------------------------------------------");B demo2=new B();System.out.println("本包下能直接訪問變量："+"\ndemo2.a="+demo2.a+"\tdemo2.b="+demo2.b+"\tdemo2.c="+demo2.c);System.out.println("若要訪問私有變量必須通過Get和Set方法，"+"demo2.getD="+demo2.getD());System.out.println("----------------------------------------------------------");C demo3=new C();System.out.println("其他包下能直接訪問變量："+"\ndemo3.a="+demo3.a);System.out.println("若要訪問私有變量必須通過Get和Set方法，"+"demo3.getD="+demo3.getD());System.out.println("----------------------------------------------------------");D demo4=new D();System.out.println("其他包下能直接訪問變量："+"\ndemo4.a="+demo4.a);System.out.println("若要訪問私有變量必須通過Get和Set方法，"+"demo4.getD="+demo4.getD());System.out.println("D能訪問父類C的變量："+"\nsuper.a="+demo4.getsuperA()+"\tsuper.b="+demo4.getsuperB());} }輸出結果：
創建public類A 本包下能直接訪問變量： demo1.a=public demo1.b=protected demo1.c=default 若要訪問私有變量必須通過Get和Set方法，demo1.getD=private ---------------------------------------------------------- 創建默認類B 本包下能直接訪問變量： demo2.a=public demo2.b=protected demo2.c=default 若要訪問私有變量必須通過Get和Set方法，demo2.getD=private ---------------------------------------------------------- 創建public類C 其他包下能直接訪問變量： demo3.a=public 若要訪問私有變量必須通過Get和Set方法，demo3.getD=private ---------------------------------------------------------- 創建public類A 創建public類D 其他包下能直接訪問變量： demo4.a=public 若要訪問私有變量必須通過Get和Set方法，demo4.getD=private D能訪問父類C的變量： super.a=public super.b=protected? 請繼續考慮test_demo與A，B，C，D的關系，和A和D類的關系。
? 因為test_demo和A,B同一包下所以能直接創建A，B類的實例，并且能直接訪問到A，B類的非私有成員屬性，而C,D類不是同意包下，所以必須是public類的情況下才能直接創建，并且只能直接訪問其public成員屬性。而A和D是父子關系但不是同一包下，所以D能訪問A的public和protected的成員。這里并沒有考慮全部權限的使用情況，若考慮上構造器的權限，權限的使用情況會更加得復雜。這里就不一一列出了。
10.類的繼承
? 繼承性是面向對象的核心特征之一，是從已有的類創建新類的一種機制。先創建具有共性的一般類，再從一般類派生出具有特殊性的新類，新類繼承一般類的屬性和方法，并定義了自己的新的屬性和方法，我們就把這種機制稱為繼承。Java通過繼承機制很好地實現了類的可重用性和擴展性。所以繼承是java的一個重要知識點。在第9部分我們就使用了一點點類的繼承。這里就給出貓類的繼承樹狀圖。
? 這里貓就是野貓和家貓的父類，而野貓和家貓是貓的子類，子類也可以派生出新的子類，而且Java只支持單繼承，也就是說一個父類可以有多個子類，但一個子類只能有一個父類。并且：
? 祖先類：位于類層次樹中較高層次的類。父類也稱為直接祖先類。
? 根類：Java提供了一個最頂層的根類Object（java.lang.Object），它是所有Java類的祖先類。
? 這也就是說這里貓類其實是繼承了java.lang.Object類，這個類一般不用寫入代碼中，因為java會隱式地添加上去，所以程序員不用可以刻意寫上去。
? 現在再說一下繼承的優點，繼承的優點包括：
1.提供了軟件的可維護性。
2.增強了軟件可擴充性。
3.提高程序代碼的重用性和降低軟件的復雜性并縮短軟件的開發周期。
? 因為繼承增加了程序的模塊化性，程序的模塊化能提升軟件的可維護性，并且因為繼承可以在原有的父類代碼下，添加一些新的元素從而派生出新的子類，可以很大地提高代碼的重用性，我們就可以不必在編寫某個模塊時又要重頭編寫，只有在原有的父類下，添加新的元素，覆蓋原有父類的屬性和方法，或者添加一些private類的屬性和方法，這樣也可以創造出于父類有不完全相同的子類。
子類的定義和使用格式如下，
[權限修飾符] [其他修飾符]class 子類名 extends 父類名{零到多個屬性；零到多個構造方法；零到多個成員方法；}[其他修飾符]包括一些abstract等 具體可以查看（9.類的封裝和訪問控制）中的代碼A類和D類? 查看（9.類的封裝和訪問控制）中的代碼A,D類和輸出結果，如果你是細心的人的話，你會發現在創建D類的對象test4時是不是多一個（創建public類A）這個輸出結果，其實這是在執行子類對象的構造函數里的語句前，會優先調用父類的構造函數，所以我們才會看到（創建public類A）這個輸出結果。所以，子類對象的初始化調用子類構造方法時，要先執行父類的構造函數。子類構造方法中可以使用super顯式調用父類構造方法，如果沒有顯式調用，則默認調用父類無參數構造方法。
通俗點說就是，要創建某個對象時，就必須在創建對象的爸爸的基礎上創建對象。
10.2子類的使用和覆蓋父類成員
Java中子類可以繼承父類除構造方法的所有成員，但訪問父類成員的權限如下：
（1）子類對父類的private成員（包括屬性與方法）沒有訪問權限。如果需要訪問父類的成員，可以通過父類中的非private成員方法來引用父類的成員。
（2）子類對父類的public或protected成員具有訪問權限。
（3）子類對父類的缺省權限成員的訪問分為兩種情況：
對同一包中父類的缺省權限成員具有訪問權限
對其他包中父類的缺省權限成員沒有訪問權限。
變量的覆蓋
? 再重新觀察（9.類的封裝和訪問控制）中A，D類的代碼，其中A有成員變量a,b,c,d，D也有成員變量a,b,c,d。這里D的成員變量隱藏了A中的成員變量，所以我們調用D類對象時我們是訪問D類的a,b,c,d變量的。當我們創建D的對象時，我們會先調用A中的構造函數，而再運行D的構造函數，這就把原來A類中的成員變量隱藏了，所以我們調用D類的對象時是訪問D的對象，而隱藏起來的父類成員可以在其子類中用super.變量名或者super.方法名來調用。
方法的覆蓋
? 方法的覆蓋其實和變量的覆蓋同理。含義：父類中的非私有成員方法被子類繼承，但如果繼承成員方法不能滿足子類功能，則子類重寫該方法。
要求：
（1）兩個方法要具有完全相同的返回類型、方法名、形參列表。
（2）方法體要根據子類的需要重寫，從而滿足子類功能的要求。
（3）若子類中需要調用被覆蓋的父類中的同名方法，通過super關鍵字來實現調用，即：super.方法名()
super的使用
super代指父類
訪問父類被隱藏的成員變量： super.variable
調用父類中被override的方法：super.method ([paramlist])
調用父類的構造方法：super ([paramlist])
當然這不能super.super.·····這樣子的連用
final關鍵字的使用
作用：
final成員變量：常量數據成員,不允許被修改。
final方法:阻止一個子類覆蓋自己類中的方法，該方法不能被覆蓋（重寫）。
final類：該類不能派生出任何子類。
就是說被final標明的變量，方法，類都不能被修改，覆蓋或者派生。并且，抽象類和方法不能聲明為final，因為它一定會在子類的某個地方被再定義。
11.多態
? 多態：是指一個程序中同名的不同方法共存的情況。指“一種定義，多種實現”。是面向對象的核心特征之一。其實上面說的方法重載，方法重寫（方法的覆蓋）和轉型，構成了java的多態性。
? 轉型又分向上轉型和向下轉型，一個聲明為父類的對象名，通過引用子類的實例來調用子類的方法稱為**向上轉型。即子類對象轉型成父類類型，一個聲明為父類類型的對象名，其值是子類對象的地址，可以調用子類中從父類繼承下來的方法和覆蓋的實例方法，但使用父類對象名引用子類對象，不能調用子類對象獨有的實例方法。父類類型聲明的對象轉型成子類類型是向下轉型**。即用父類類型聲明的子類對象使用強制類型轉換轉換成子類類型，可以賦值給子類類型對象名。但是使用父類類型聲明的父類對象向下轉型成子類對象會出現運行時錯誤，不建議使用。
注意：子類覆蓋（override）父類方法時，形參類型必須與父類保持一致，返回類型與父類的保持一致或是父類的方法的返回類型的子類型，此時該子類型稱為協變返回類型。
12.抽象類
? 抽象類是對抽象概念的描述，不能進行實例化。抽象類提供了方法聲明與方法實現分離的機制，使各子類表現出共同的行為模式。抽象類中包含抽象方法，抽象方法在不同的子類中表現出多態性。
**1.**抽象方法(abstract method)：
含義：沒有方法體的方法，稱為抽象方法。
抽象方法的聲明格式：[權限修飾符] abstract 方法返回值類型 方法名（參數列表）；
? 一個abstract方法不能聲明為private，因為private方法不能被繼承，因此不能在子類中進行重新定義。構造方法不能聲明為抽象的。
**2.**抽象類：
含義：用abstract聲明的不能實例化的類。
聲明格式：
[權限修飾符] abstract class 類名
{
類體
}
（1）在抽象類體中，可以包含抽象方法，也可以不包含抽象方法。但類體中包含抽象方法的類必需要聲明為抽象類。舉例：通過接口接入抽象方法，雖然類體里面沒有抽象方法，但是此類為抽象類。
（2）抽象類不能實例化，即使抽象類中沒有聲明抽象方法，也不能實例化。抽象類代表有還沒有方法體的方法，所以是無法實例化的。
（3）抽象類的子類只有給出每個抽象類方法的方法體，即覆蓋父類的所有抽象方法后，才能創建子類，如果有一個抽象方法未在子類中被覆蓋，該子類也必須被聲明為抽象類。就是說只有還有沒有被實現的方法，就無法實例化。
13.內部類與外部類
內部類：嵌套在一個類內部的類
外部類：包含嵌套類定義代碼的類
頂層類：類定義代碼不嵌套在其他類定義中的類。頂層類不能被其他類包含。
? 內部類可直接訪問其外部類的所有成員。外部類不能直接訪問內部類的成員，必須要創建內部類的實例，然后使用對象名作前綴來訪問內部類的所有成員。
? 前面我們學過了成員的覆蓋（重寫）值得注意的是內部類是允許繼承的，并且內部類可直接訪問其外部類的所有成員。那么當內部類的父類成員和外部類的成員重名時，是優先訪問那個類的成員呢。這里給段代碼方便自己到時翻看以前的筆記時方便理解：
public class SuperCls{string s="super"; }public class OuterCls {String s = "outer";class Inner extends SuperCls {//String s = "inner";void print(){System.out.println(s);}} }/*test函數代碼*/ OuterCls out=new OuterCls(); OuterCls.Inner inner=out.new Inner(); //創建內部類，必須依附在外部類對象上 inner.print();//這里是輸出 super所以訪問順序是內部類，父類，外部類。父類優先級是比外部類高的。
內部類的創建有一點必須值得注意的是，內部類的創建必須依附在外部類的對象上，也就是說若要創建內部類，就必須創建外部類類先，或者在外部類內部直接創建。
創建方式：
//在外部類外創建非靜態內部類 outer.inner in = new outer().new inner();//在外部類外創建靜態內部類 outer.inner in = new outer().inner();//在外部類內創建非靜態內部類 inner in = new inner();//在外部類內使用靜態內部類（無需創建） inner.方法名();內部類和外部類相互訪問變量的方法，如下：
public class Demo {public static void main(String[] args) {Outer o = new Outer("外部類的變量");o.outMethod();Outer.Inner i = o.new Inner();System.out.print("其他類訪問：");i.inMethod();}}public class Outer {private String outStr;Outer(String s) {outStr = s;}public void outMethod() { // 外部類中訪問內部類成員的方法Inner in = new Inner(); // 創建內部類實例System.out.println("outMethod訪問:" + in.inStr);in.inMethod();}class Inner {private String inStr = "內部類的變量";public void inMethod() {System.out.println("inMethod訪問:" + outStr);}}}//輸出結果 outMethod訪問:內部類的變量 inMethod訪問:外部類的變量 其他類訪問：inMethod訪問:外部類的變量14.包
? **1.**包是為了便于管理大型軟件系統中數目眾多的類，解決類命名沖突的問題。由.class文件組成的一個集合，在物理上包被轉換成一個文件夾，組織形式是一種層次結構，包中還可以再有包。功能相同或者相關的類組織在一個包中。
? 比較常見的包有：java.lang基礎包（Java類中的默認引入的包，包含公共基類Object，常用類System，String等），java.util工具包（Scanner類等），java.sql數據庫包，java.io輸入輸出流包（InputStreamReader，BufferedReader，IOException等），java.net網絡包等。
Java的核心包，包名以“java”開始，Java的擴展包，包名以“javax”開始。
語法格式是：package 包名1.包名2.包名3······
在package語句中，用“.”來指明包(目錄)的層次。
? 關于包的管理，許多IDE（集成開發工具）都有包的管理，包的管理的細節大部分工作已經交由IDE處理。
? **2.**包的引入
? 包的引入是通過import語句進行引入的，語法格式為import 包名1.包名2.·····.類名,其實import語句是以類為單位進行引入的，就如：
引入整個包里面的所有類 import 包名.*
引用某個包中的某個類 import 包名.類名
? 其實import語句某種意義下是屬于將某個類路徑更名，因為不使用導入語句，仍然使用某個類，例如：test.demo1.test_main A=new test.demo1.test();也可以通過這種寫類的全名來進行類的創建。這里就不詳細說了，這里給個鏈接，里面有import的作用詳解。
https://blog.csdn.net/qq_25665807/article/details/74747868.
（這個真的很不錯，說得十分詳細）。
15.接口
1.接口的基礎
? 接口（interface）在Java中應用非常廣泛，能很好地體現Java的面向對象編程思想。接口的目的在于對象的抽象處理，使設計和實現分離。
? 接口的另一個重要作用是彌補Java只支持單繼承的不足。一個類可以實現多個接口，這樣就實現了多重繼承的功能。
? 接口是一組相關常量和（或）抽象方法，在大多數情況下，接口只包含方法。作用是指定一組方法來表示一個特定的類接口，而這些方法能在很多不同的類中正確地實現。所有類都可以共享這個通用的接口，且可使用接口類型的變量來多態調用其中的方法。
? 這里給出幾個知識點：
1.可在抽象類中定義方法的默認行為，但是接口的方法不能擁有默認行為。
2.如沒有指定接口方法和屬性的訪問權限，Java將其隱式地聲明成public。
3.extends表示的是一種單繼承關系，而一個類卻可以實現多個接口，表示的是一種多繼承關系。
4.如要表示的兩類事物在本質上是相同的，則使用繼承；如果要表示的兩類事物在本質上是不同的，但有相同名字的屬性或方法，則使用接口。
5.接口中的屬性成員，默認為常量。
6.接口中的方法在默認狀態下總是public和abstract類型的。
7.接口中的常量在默認狀態下總是public、static、final類型的。
2.接口的繼承
接口的繼承：使用extends在一個接口基礎上定義另一個接口。
優點：擴展后的接口從其原始接口得到所有方法和常量。
多重繼承：接口有一點是要注意的，那就是接口是允許多繼承的，在Java語言中，類不支持多重繼承，而接口支持。
3.接口的定義
public interface Ianimal{//方法都默認為abstract類，abstract方法沒有方法體public void eat();public void sleep(); }4.嵌套接口
接口能定義在其他類和接口的內部，并且接口可以使用權限聲明有public,pricate,protected.
public class A { public interface B { // 嵌套接口void method();} }接口的引用用implement來進行引用
public class C implements A.B {public void method() {System.out.println("實現嵌套接口method()方法");} }接口內部也可以定義類，一個接口的內部類在默認情況下是static和public類型。
例如：
interface Port {class Info { //類體} }? 這里補個鏈接https://www.cnblogs.com/lesliefang/archive/2013/04/18/3029622.html鏈接里的文章有說Java內部靜態類，雖然Java的內部靜態類用得真的很少，不過作為知識點來補充也不錯。
16.Java異常處理機制
1.異常處理的概述
? 異常就是程序執行時出錯的情況。對出錯情況作出相應的處理叫做異常處理，通常異常處理有兩個方面：
一.由計算機系統本身檢驗錯誤并給出錯誤信息和終止程序的執行；
二.由程序員在程序中添加異常處理功能。
? Java語音異常處理時是可以將異常情況在方法調用中進行傳遞，直到將異常傳遞到可以處理的位置。java的異常是向上傳遞，也就是說當某段代碼出現異常，在當前函數下沒有進行異常處理，那么異常就會傳遞到調用此異常函數的上一層函數。
2.異常處理的語法
? 異常處理用關鍵詞try和catch，其中try為要執行的代碼段，catch為要捕捉的異常并對異常執行處理的代碼段。
try{//執行代碼塊 }catch(異常表達式一){//異常處理 }catch(異常表達式二){}finally{}//finally為非必須語句塊，finally無論try語句塊有沒有發生異常都會執行。一般用來收尾的。3.異常的類型
1.Throwable:java.lang包中專門用來處理異常的類。
Java程序拋出的異常對象必須是Throwable類及其后代類對象。
Throwable類有兩個直接子類：1.Error類 2.Exception類
2.Error類及其子類主要包括:虛擬機錯誤、裝載錯誤、動態連接錯誤，因為這類異常主要是和硬件和環境有關系，并且不是由程序本身拋出。所以Java程序不對這類異常進行處理。
3.Exception類，又分成兩大子類，第一大子類RuntimeException類及其子類，該類異常是程序運行時異常，也就是由程序自身的問題導致產生的異常，該類異常不要求程序必須處理。第二大子類，直接繼承Exception類。該類異常屬于程序外部的問題引起的異常，也就是由于程序運行時某些外部問題導致產生的異常，如文件不存在異常等。該類異常Java編譯器要求Java程序必須處理。
由Exception類派生的非RuntimeException類，編譯器將檢查是否進行了處理：1.是否在try{}catch{}語句中捕獲并處理了異常。2.是否聲明方法時注明拋出該異常。若兩項工作都未做，則無法編譯。
4.拋出異常
? Java允許主動拋出異常，使用關鍵詞throws來聲明拋出的異常類。為了說明方法可能拋出的異常，只需將關鍵字throws書寫在方法的形參表之后，加上可能拋出異常類的清單，這些異常類用逗號隔開。
根據異常的向上傳播效應，如果中間的調用方法沒有處理異常，異常最后會到達main方法交給系統處理。
? 如果需要在程序中自行拋出異常，則應使用 throw 語句，throw 語句可以單獨使用，throw 語句拋出的不是異常類，而是一個異常實例，而且每次只能拋出一個異常實例。
? 如果想深入了解throw的用法，這里給個鏈接https://blog.csdn.net/weixin_43819113/article/details/91468459后面大部分細節的都以鏈接方式給出，主要是細講的話篇幅會十分大。（主要是懶）
17.Java API
這里介紹一些Java比較經常使用的類包。這里給個JDK14開發文檔https://docs.oracle.com/en/java/javase/14/docs/api/index.html
1.java.lang包
1）String類：提供了字符串連接、比較、字符定位、字符串打印等處理方法。
2）StringBuffer類：提供字符串進一步的處理方法，包括子串處理、字符添加插入、字符替換等。
3）Math類：提供大量的數學計算方法。
4）System類：提供對標準輸入、輸出設備的讀寫方法，包括鍵盤、屏幕的in/out控制。常用的System.out.print()、System.out.println()都是該類的靜態屬性輸出流out所提供的方法。
5）Thread類：提供Java多線程處理方法，包括線程的懸掛、睡眠、終止和運行等。
6）Object類：這是Java類的祖先類，該類為所有Java類提供了調用Java垃圾回收對象方法以及基于對象線程安全的等待、喚醒方法等。
7）Throwable類：該類是Java錯誤、異常類的祖先類，為Java處理錯誤、異常提供了方法。
2.java.io包
提供數據流方式的系統輸入輸出控制、文件和對象的讀寫串行化處理
BufferedInputStream / BufferedOutputStream 字節型輸入輸出流
BufferedReader / BufferedWriter 字符型輸入輸出流
DataInputStream / DataOutputStream 字節型輸入輸出流
FileReader / FileWriter 字符型輸入輸出流
FileInputStream / FileOutputStream等。 字節型輸入輸出流
3.java.applet包
? 此包只有一個Applet類，用于開發或嵌入到網頁上的Applet小應用程序，使網頁具有更強的交互能力以及多媒體、網絡功能。Applet是用Java編程語言編寫的小應用程序，該程序可以包含在 HTML頁面中。
4.javax.swing包
? 提供Java編寫的圖形界面創建類，支持各種操作平臺的界面開發。swing包還提供了樹形控件、標簽頁控件、表格控件的類。javax.swing包很多類都繼承java.awt包的類。
5.java.net包
? 提供網絡開發的支持，包括封裝了Socket套接字功能的服務器ServerSocket類、客戶端Socket類以及訪問互聯網上的各種資源的URL類。
18.比較常用的類
String類
? Java自帶的標準final類，字符串了。有final字段說明是無法被繼承的了。String放在java.lang包中，lang包默認自帶引入。所以不需要用import語句引入。
? 既然String是類那么先說一下String類的構造函數
String() //初始化一個新的String對象，使其包含一個空字符串 String(char[ ] value ) //分配一個新的String對象，使它代表字符數組參數包含的字符序列 String(char[ ] value, int offset, int count) //分配一個新的String對象，使它包含來自字符數組參數中子數組的字符 String(String value ) //初始化一個新的String對象，使其包含和參數字符串相同的字符序列 String(StringBuffer buffer ) //初始化一個新的String對象，它包含字符串緩沖區參數中的字符序列創建String變量的方法：
利用構造方法創建：String s=new String(“new string”);
利用常量初始化：String s= “new string”;
兩者有本質上的區別，要理解區別首先要對java的內存管理有一點認識。
java內存管理
? Java程序用字符串池管理字符串，Java程序運行時JVM會在內存創建一個字符串緩沖池，字符串常量保存在字符串緩沖池中，相同的常量只允許保存一個。
? 棧（stack）用來保存基本類型（或者叫內置類型，主要有char、byte、short、int、long、float、double、boolean）和對象的引用（地址），數據可以共享，速度僅次于寄存器（register），快于堆。
? 堆（heap）是用于存儲對象的內存空間，字符串緩沖池在堆空間內，堆中可以存放隱式對象（如字符串常量），也可以存放顯式對象（如用new創建的對象）。
/*假設我現在創建3個字符串變量，其中s1和s2是利用常量初始化，而s3和s4是利用構造方法創建。 */String s1 = "new string"; String s2 = "new string"; String s3 = new String("new string"); String s4 = new String(s1);//這里畫了個圖所以如果你們使用==和equals方法對比字符
可以得出以下結果
/*==是引用對比equals在String中重寫了，所以是進行值的對比 */ s1 == s2 s1 != s3 s1 equals s3/*順便介紹一下字符串的intern()方法，調用該方法時，去查字符串緩沖池中是否有該字符串，若存在，則返回緩沖池中的字符串引用，若不存在，在緩沖池中添加該字符串，并返回引用。該方法確保字符串在字符串緩沖池中一定存在。*/s3=s3.intern();//結果 s1 == s3? String類變量是一個保存String類對象的引用（地址）的變量。當執行賦值語句時，原來的引用就被新字符串的引用所覆蓋，原來的字符串被丟棄。不用程序員去釋放原有對象的內存空間，因為Java有垃圾回收機制。會自動釋放無用的內存空間。
? String類字符串之所以不能被更改是因為，其實質上是通過一個private final char value[ ];的屬性變量來實現字符串的存儲的。因為被用final標記的變量是無法更改其值的，也就是說它是常量。所以在對String類字符串進行更改時都是新建一個字符串并返回引用來實現的。所以你會發現String類中對字符串進行修改的方法最終都會返回一個引用，因為那個引用就是新的字符串引用。
StringBuffer類
字符串可以分為兩類：
一，永久字符串：不可被更改的字符串，即存放字符串的內存的內容不可用被更改，如String對象。
二，可變字符串：可以被更改的字符串，即內存的大小可以擴展，里面的內容可以被更改。如：StringBuffer對象，StringBuilder對象。
? 其中StringBuffer對象：適用于多線程。StringBuilder對象：適用于單線程，操作要快于StringBuffer對象。
? 又因為StringBuffer對象是不支持字符串緩沖池的引用，所以StringBuffer的引用是不能像String對象那樣只使用字符串常量做初始值。
這里給個StringBuffer類構造函數的代碼
public StringBuffer() {super(16);}public StringBuffer(int capacity) {super(capacity);}public StringBuffer(String str) {super(str.length() + 16);append(str);}/*其中他們用使用了父類的構造函數來實現構造，他們的父類是AbstractStringBuilder類，就算不看父類代碼大概都能猜測出其構造函數的作用*/System類與Runtime類
System類該類是與系統相關的屬性和方法的集合，它的所有屬性和方法都是靜態的，用類名訪問即可。
? public static String getProperty(String key)，該方法根據參數key值獲得和系統相關的屬性值，DK中已經定義好的key值在JavaAPI文檔的System類的getProperties方法的文檔中可以查看。
? public static long currentTimeMillis()，該方法獲取當前系統時間距離UTC(協調世界時) 的1970年1月1日0點0時0分0秒的毫秒數。
? public static void gc()，該方法表示運行Java虛擬機的垃圾回收機制，盡最大可能回收垃圾，釋放內存。但是否立刻釋放，要看具體實現。
? public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)該方法實現數組的復制，把源數組從特定位置開始，復制到目標數組的特定位置，可以設置復制的元素個數。該方法是一個native方法（java調用非java代碼的接口），所以效率比for循環拷貝要高。所以數組的拷貝復制建議使用。
? public static void gc()，該方法表示運行Java虛擬機的垃圾回收機制，盡最大可能回收垃圾，釋放內存。但是否立刻釋放，要看具體實現。
Runtime類該類封裝了Java虛擬機運行時的環境。每個Java應用程序都有一個Runtime類實例，使該程序能夠和其運行的環境相連接。應用程序可以通過Runtime類的靜態方法getRuntime（）獲取Runtime的實例，從而獲取虛擬機的信息。
? public static Runtime getRuntime()獲取Runtime實例
? public int availableProcessors()獲取虛擬機處理器數目
? public long totalMemory()獲取虛擬機內存大小
? public long freeMemory()獲取虛擬機空閑內容大小
? public long maxMemory()獲取虛擬機試圖使用的最大內存量
? public Process exec(String command)執行參數所表示的外部命令，返回一個進程對象，來管理執行的這個進程
?
Math類與Random類
Math類:存在于java.lang包，可用于求一些數學運算。
Random類：存在于java.util包中，生成各種類型的隨機數。
所以Math類不需要引入。
Math類
Math類方法：
public static int ceil(double a) 返回大于或等于a的最小整數
public static int floor(double a) 返回小于或等于a的最大整數
public static int abs(int a) 返回a的絕對值
public static int max(int a，int b) 返回a和b的最大值
public static int min(int a，int b) 返回a和b的最小值
public static double random( ) 返回一個偽隨機數，其值介于0和1之間
其余方法請查看API文檔
Random類
Random包含在java.util包中。
Random有兩個構造方法：
Random( )(使用系統時間為種子數)
Random(long seed)
Random類的nextInt( )方法能生成一個偽隨機數;
Date類
表示特定的瞬間，精確到毫秒。
允許把日期解釋為年、月、日、小時、分鐘和秒值。它也允許格式化和解析日期字符串。
Date date = new Date(); System.out.println("當前日期為:" + date); /*這里的date是調用了toString函數方法，直接打印函數的引用Java會默認調用toString()函數。 */采用DateFormat類的方法格式化或過濾所需要的數據參數
Date date = new Date(); String str =DateFormat.getInstance().format(date); System.out.println("格式化日期："+str); /*這里DateFormat.getInstance()返回的是一個DateFormat對象,然后調用format方法 */采用SimpleDateFormat類的方法格式化或過濾所需要的數據參數
SimpleDateFormat time = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss"); System.out.println("日期時間為:"+ time.format(date));這里給個代碼
public static void main(String[] args) {Date date = new Date();System.out.println(date.toString());String strdate = DateFormat.getInstance().format(date);System.out.println(strdate);System.out.println(DateFormat.getDateInstance(DateFormat.FULL).format(date));DateFormat shortDateFormat = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT);DateFormat mediumDateFormat = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);DateFormat longDateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);DateFormat fullDateFormat = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL);System.out.println(shortDateFormat.format(date));System.out.println(mediumDateFormat.format(date));System.out.println(longDateFormat.format(date));System.out.println(fullDateFormat.format(date));}輸出結果
Fri Mar 27 17:04:51 CST 2020 2020/3/27 下午5:04 2020年3月27日星期五 2020/3/27 下午5:04 2020年3月27日 下午5:04:51 2020年3月27日 CST 下午5:04:51 2020年3月27日星期五 中國標準時間 下午5:04:5119.Java基本類型包裝器
? Java的基本類型是重C繼承而來的，并且Java提供了將基本數據類型進行了包裝，形成類。一個包裝器類的對象可以存儲對應基本數據,還可以提供相關的方法和屬性。
基本類型 包裝類 int Integer byte Byte short Short long Long float Float double Double char Character boolean BooleanInteger
//這里介紹變量，這是從API文檔找到的 Modifier and Type Field Description static int BYTES 以二進制補碼形式表示整型值的字節數。 static int MAX_VALUE 一個常數,int能存儲最大的值 static int MIN_VALUE 一個常數,int能存儲最小的值 static int SIZE int占用位數 static class<Integer> TYPE 數據類型//方法就不介紹了，具體請看API文檔? 你可以把基本類型包裝器理解成，在原數值的基礎上，添加一些屬性描述，和數據轉換的方法。其他的基本類型包裝器就不在這里說了，其實他們都差不多。這里再介紹一下裝包和拆包。
//裝包 //構造函數有兩個 Integer(int value) Integer(String s) Integer x = 5; //自動進行裝包;等價Integer x = new Integer(5);//拆包（其實就是返回原有值） int i = x.intValue(); int i = x; //自動進行拆包20.泛型
Java泛型實現了把類型作為參數。這怎么理解呢，給個代碼吧
//值得注意的是基本類型不能用在泛型上 class PointDemo<T> { //這里的泛型T可以當成一個參數，具體類型通過創建對象時給出private T x;private T y;public void setX(T x){this.x=x; }public void setY(T y){this.y=y; }public T getX(){return x; }public T getY(){return y; } }public class PointTest { public static void main(String[] args){//（2）生成泛型類的對象(確定T的類型) 注意不能傳基本類型，如intPointDemo<Integer> p1=new PointDemo<Integer>(); //把Integer賦值給TPointDemo<Float> p2=new PointDemo<Float>();PointDemo<String> p3=new PointDemo<String>();//設置整型類型的坐標值p1.setX(30); p1.setY(50);//設置浮點類型的坐標值p2.setX(30.2f); p2.setY(50.1f);//設置字符串類型的坐標值p3.setX("東經"); p3.setY("北緯");System.out.println("x1、y1的坐標值為："+p1.getX()+p1.getY());System.out.println("x2、y2的坐標值為："+p2.getX()+p2.getY());System.out.println("x3、y3的坐標值為："+p3.getX()+p3.getY()); } }21.集合類
? 在Java中集合類用來批量存放對象的，相當于一個容器，里面包含著一組對象，其中每個對象作為集合的一個元素出現。Java API提供的集合類位于java.util包內。
? Collection中可放不同類型數據，是Set接口和List接口的父接口。能放不同類型數據，意味著，集合類里面能放多種類型數據。其中Collection是作為List和Set父接口。
? 這里看一下Collection接口的方法。可以看到add函數中的形參是泛型，說明可以添加各種類型。
boolean add(E e); //添加元素e到collection 中。 其中E為泛型。 void clear(); //移除此 collection 中的所有元素（可選操作）。 int size(); //返回此 collection 中的元素數。 boolean remove(Object o); //從此 collection 中移除指定元素的單個實例，如果存在的話 //（可選操作）。Object表示任何類型。 /* 其余方法請自行查找*/? 順便說一下Collection的子接口。Set是無序的集合接口，元素存入順序和集合內存儲的順序不同，不允許元素重復，其實現類有HashSet（無序），TreeSet（有序）等。List是有序的集合，允許元素重復，List中的元素都對應著一個整數型的序號，記載其在容器中的位置，可以根據序號存取容器中的元素，主要實現類有ArrayList類及LinkedList類。
1.ArrayList類
? ArrayList類繼承于java.util.AbstractList,使用Collection和List等接口。
ArrayList有以下幾個特點：
? 1.線性順序存儲
? 2.可以存儲重復數據
? 3.ArrayList的大小可動態改變，可看成動態數組或Array的復雜版本
? 提供如下構造方法：
public ArrayList(); //默認的構造方法，以默認的大小(16) 初始化內部的數組。 public ArrayList(Collection c); //用一個Collection對象來構造，并將該集合的元素添加到ArrayList。 public ArrayList(int n); //用指定的大小來初始化內部的數組。? 常用方法：
public boolean add(E e); public boolean add(int index,E e); public Object remove(int index); public T[] toArray(T[] a); public E get(int index); public int indexOf(Object o); /*具體作用就不說了，請自行查找*/2.LinkdeList類
ArrayList由數組實現，隨機訪問效率高，隨機插入和刪除效率低。
LinkedList由雙向鏈表實現，隨機訪問效率低，隨機插入和刪除效率高。
LinkedList提供了以下構造方法：
public LinkedList(); public LinkedList(Collection c);常用方法：
public boolean add(Object e); public Object remove(int index); public Object get(int index); public void addFirst(E e); public void addLast(E e); public E remove(int index); public E remove(); public E removeFirst(); public E removeLast(); /*具體作用就不說了，請自行查找*/3.HashSet類
? HashSet繼承Set接口，不允許有重復元素。主要用哈希算法確定元素在集合中的位置。HashSet集合在用add()方法添加一個新對象時。實際是HashSet是使用一個HashMap對象存儲數據的，把元素以Map的Key值存儲。
22.迭代器
這里說一下迭代器：
Iterator：是Java迭代器最簡單的實現，用于對 collection 進行迭代的迭代器。
ListIterator：為List設計，具有更多功能，可從兩個方向遍歷List，也可從List中插入和刪除元素。
? 迭代器是一種設計模式，作用是在于對數據的遍歷與數據的內部表示進行分離。Collection對象可以調用iterator()，放回一個iterator對象。
這里介紹一下iterator常用方法：
next(); /*第一次調用next()方法時，它返回序列的第一個元素，以后再次調用時將獲得序列中的下一個元素。*/ hasNext(); //Iterator對象調用該方法檢查序列中是否還有元素。 remove(); //Iterator對象調用該方法刪除上次調用next方法獲取的元素。Iterator和ListIterator區別：
1.ListIterator有add()方法，可向List中添加對象，而Iterator不能。
2.ListIterator和Iterator都有hasNext()和next()方法，可以實現順序向后遍歷，但是ListIterator有hasPrevious()和previous()方法，可實現逆向（順序向前）遍歷，而iterator不可以。
3.ListIterator可以定位當前的索引位置，nextIndex()和previousIndex()可以實現。Iterator沒有此功能。
4.ListIterator和Iterator都可實現刪除對象，但是ListIterator可以實現對象的修改，可以利用set()方法實現對LinkedList等List數據結構的操作。Iterator僅能遍歷，不能修改。
下面用代碼對其進行簡單的介紹
//假如我們有一collection ArrayList<File> al = new ArrayList<File>(); //只能存File類的列表(這里使用了泛型確定的傳入的元素是File類型) Iterator iter =al.iterator(); //通過集合類的iterator()方法返回對應的迭代器 while(iter.hasNest())System.out.println(iter.next().toString()); //遍歷列表中的元素 //使用迭代器的好處是我們不用考慮集合中元素的個數，而且效率也高。//還有其他寫法，一般for循環寫法比如： ArrayList<File> al = new ArrayList<File>(); //只能存File類的列表 Iterator iter =al.iterator(); //通過集合類的iterator()方法返回對應的迭代器 for(File f=iter.next();iter.hasNest();)System.out.println(f.toString()); //遍歷列表中的元素//常用版效果等同于上面for循環 ArrayList<File> al = new ArrayList<File>(); //只能存File類的列表 for(File f:al)System.out.println(f.toString()); //遍歷列表中的元素23.流
? 流是輸入和輸出設備的一種抽象表示，這些設備是數據源或數據終點。可以把流想象為流入程序變量內存空間或從變量內存空間中流出的字節序列。引入流的好處：1.不必擔心各種設備的具體工作機制，對于它們的管理均在幕后進行。2.用戶的程序可以適用于各種輸入輸出設備，改變輸入輸出設備時不用改寫程序編碼。特點是：每個數據都必須等待排在它前面的數據讀入或送出之后才能被讀寫；每次讀寫操作處理的都是序列中剩余的未讀寫數據中的第一個，而不能隨意選擇輸入輸出的位置。
FileInputStream fis = new FileInputStream(path); //可以把fis看成字節序列（path為磁盤文件路徑）fis.read(); //從磁盤中讀取1字節到內存中（從字節序列中讀取1字節數據）或著說是從流中讀出一個字節的數據 //輸入輸出流是相當于內存來講了，讀入到內存的叫輸入流，從內存寫到其他設備叫輸出流。輸入流：從外設流入計算機內存的數據序列；文件，當從其中讀取數據時，使用輸入流和它關聯。鍵盤是標準輸入設備，和輸入流關聯。
輸出流：從計算機內存流向外設的數據序列,即把數據寫入流時，該流稱為輸出流。文件，當向其中寫數據時，使用輸出流和它關聯；屏幕是標準輸出設備，和輸出流關聯。
另外，根據流中數據單位的不同，可將流分為字節流和字符流。1.字節流 2.字符流，其中字節流中數據以8位的字節為單元進行讀寫，字符流數據以16位的字符為單位進行讀寫。
Java中流主要分為4大家族：InputStream,OutputStream,Reader,Writer.
1.字節流
? InputStream類和OutputStream類是字節流的兩個頂層父類。它們提供了輸入流類與輸出流類的通用API。InputStream類和OutputStream類都是抽象類。
InputStream類的子類有：AudioInputStream，SequenceInputStream，FileInputStream，ObjectInputStream，ByteArrayInputStream，PipedInputStream，FilterInputStream。
InputStream類主要方法如下：
int read(); //從流中讀出一個字節的數據，沒有返回-1. int read(byte b[]); //從流中讀取數據存放到字節數組b中。返回讀取字節數，沒有返回-1. int read(byte b[], int off, int len); /* 從流中讀取len個字節的數據存放到字節數組b下標off的起始位置中。*/ long skip(long n); //跳過流中若干字節數 int available(); //返回流中可用字節數 void mark(int readlimit) //在流中標記一個位置 void reset() //返回標記過的位置 boolean markSupport() //是否支持標記和復位操作 void close() //關閉流? FilterInputStream類有9個直接子類，它們提供對輸入流數據過濾或轉換的更多的特殊方式。
BufferedInputStream DataInputStream CheckedInputStream CipherInputStream DigestInputStream InflaterInputStream LineNumberInputStream ProgressMonitorInputStream PushbackInputStreamSystem.out.println(""); = PrintStream.println(""); //標準的輸出流（輸出到控制臺）
2.字符流
? 流根據讀取數據的方式可以分為：字節流和字符流，字節流是按照字節的方式讀取，字符流是按照字符的方式讀取，一次讀取兩字節。因為Java中一個字符占2字節。
字節流適合讀取：視頻，聲音，圖片等二進制文件，
字符流適合讀取：純文本文件。
//寫入文件 public class Filetest(){public static void main(String[] args) throws Exception{FileWriter fw = new FileWriter("a.txt",true); //追加fw.write("Hello");fw.flush();//刷新fw.close();//關閉流}}//讀入文件public Test2{public static void main(String args[]){char[] c= new char[512];//剛好1KBint tem=0;try{FileReader fr = new FileReader("a.txt"); //當前路徑下的txt文件while((tem=fr.read(c)) != -1){System.out.print(new String(c,0,tem))} }catch(Exception e){e.printStackTrace();}finally{try{if(fr!=null)fr.close();}catch(Exception e){e.printStackTrace();}}}}代碼給上，請自行體會。
代碼中每個文件操作都有異常處理操作是因為，這些異常不是RuntimeException類的異常，java必須捕獲這些異常，因為這些異常是由于外界的原因導致程序的中斷，所以必須捕獲。在上面的異常處理那章已經有說明，所以就不再進行重復。
24.總結
? 以為Java涉及的基礎知識比較廣，所以這里只是粗略的介紹了一下，其實就是自己粗略的記錄一下筆記。很多細節上的問題根本沒有進行記錄，如果想知道還是其各位購買相關的書籍和教程來進行學習。如有錯誤，請各位提出。
總結
以上是生活随笔為你收集整理的java基础总结（小白向）的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 牙齿丑怎么办
- 下一篇： BufferedReader和FileR