程式師世界 >> 編程語言 >> JAVA編程 >> JAVA綜合教程 >> java基礎知識總結2

java基礎知識總結2

編輯：JAVA綜合教程

java基礎知識總結2

十一、包裝類(Integer)

a) 常用方法:
i. Integer.MAX_VALUE（）;//獲取int的最大值
ii. Integer.MIN_VALUE（）;//獲取int的最小值
iii. toBinaryString（）//轉二進制
iv. toHexStrng()//轉十六進制

十二、抽象類

a) 抽象類的特點：
i. 抽象方法一定在抽象類中；
ii. 抽象方法和抽象類都必須被abstract關鍵字修飾；
iii. 抽象類不可以用new創建對象，因為調用抽象方法沒意義；
iv. 抽象類中的方法要被使用，必須由子類復寫起所有的抽象方法後，建立子類對象調用；
v. 如果子類只覆蓋了部分抽象方法，那麼子類還是一個抽象類
b) 格式：【訪問控制符】class 類名{
屬性；
訪問控制符返回類型方法名（形參列表）{
//方法體；【return 返回值】
}
訪問控制符 abstract 返回類型方法名（形參列表）；
}
例：package b;
public class AbstractDemo{
public static void main(String[] args){Chinese c = new Chinese();}
}
abstract class Chinese{
public abstract void show();
}
abstract class D{
public void show(){System.out.println(“213”);}
}

十三、接口（interface）——–不能實例對象，也就是不能new接口

a) 定義：當抽象類中的方法都是抽象的，那麼該類可以通過接口的形式來表示
b) 格式：
1、接口中常見定義：常量、抽象方法
2、接口中的成員都有固定修飾符
常量：public static final
方法：public abstract
接口中的成員都是public的
c) 接口不可以建立對象，需要被子類實現時，子類對接口中的抽象方法都覆蓋後，才可以實例化，否則子類就是一個抽象類
接口支持多實現implements，但接口不能實現接口，可以繼承（多繼承）接口
d) 例子
public class InterfaceDemo{
public static void main(String[] args){SubInter si = new SubInter();System.out.println(si.NUM);System.out.println(SubInter.NUM);System.out.println(Inter.NUM);}
}
interface Inter{
public static final int NUM = 3;public abstract void show();
}
class SubInter implements Inter{//實現接口
public void show(){}
}

十四、單例設計模式

a) 定義：是對同一種問題的固定解決方式，單例就是只創建一個對象
b) 想要保證對象唯一：1、為了避免其他程序過多建立該類對象，先控制其他程序建立該類對象；2、為了讓其他程序可以訪問，在本類中自定義該對象；3、為方便訪問，提供訪問方式
c) 使用場景：僅需要創建一個對象時
d) 定義步驟：
1、private 的構造方法
2、private static 的實例對象
3、public static外界訪問方法
i. 代碼實現：
1. 第一種：餓漢式—–先初始化
private int a;
private A(){};
private static A a = new A();
public static get(){
Return a;
}
2. 第二種：懶漢式—-調用時初始化—延時加載
private int a;
private A(){};
private static A a = new A();
public static get(){
if(a==null){a == new A();
}
return a;
}
e) 好處：
i. 控制資源的使用
ii. 控制實例的產生數量
iii. 讓多個不相關的兩個線程或進程之間實現通信

十五、 package

a) 定義：就是把字段和方法包裹起來，並用一定的修飾符加以修飾從而達到對外信息隱藏，並暴露可以暴露的方法
b) Java.lang.*;——–基礎包，默認導入
c) 要求：1、必須放在非注釋的第一行；2、包名通常是域名的倒置，包名必須小寫，不含關鍵字，不能以java、javax開頭
d) 作用：1、便於管理；封裝的需要；防止類名沖突
e) 包的導入用import關鍵字；
f) 常用包有; java.lang.annotation\java.net\java.nio\java.sql\java.util\javax.sql\
javax.xml\javax.swing

十六、繼承（extends）—–類與類之間是屬於關系—–關聯關系

a) 實現方式：繼承（inheritance）和組合（composition）
i. 繼承的實現方式有：實現繼承、可視繼承———-類與類之間是繼承（泛化）關系
1. 實現繼承是指使用基類的屬性和方法而無需額外編碼的能力；
2. 可視繼承是指子窗口（類）使用基窗口（類）的外觀和實現代碼的能力；
ii. 組合（聚合關系）：接口繼承和純虛類繼承
1. 接口繼承是指僅使用屬性和方法的名稱、但是子類必須提供實現的能力。
b) 初始化順序：先父類靜態初始化塊–》子類靜態初始化塊—》父類的對象初始化塊—》父類的構造方法–》子類的對象初始化塊—》子類的構造方法，如：
package a;
public class B extends A{
static{System.out.println(“————-4————”);}{System.out.println(“————-5————”);}public B(){System.out.println(“————-6————”);}public static void main(String[] args){B b = new B();new B();}
}
class A{
static{System.out.println(“————-1————”);}{System.out.println(“————-2————”);}public A(){System.out.println(“————-3————”);}
}

十七、多態（向上轉型）

a) 多態的壞處
i. 向上轉型後，會丟掉子類的新方法
ii. 向上轉型是安全的，但向下轉型卻是不安全的
iii. 例：
package a;
//向上轉型————打印的類型看右邊
//缺點：損失掉了子類新增的方法、屬性
public class A extends Super{
public void f(Super s){System.out.println(s);}public static void main(String[] args) {//Super a = new A();//a.A@82764b—–打印出A型變量//System.out.println(a);/A a = new A();a.f(a);//a.A@82764b——-向上轉型///Super[] s = new Super[](new A(),new Super());//System.out.println(a.length);Super[] s = new Super[]{new A(),new Super()};System.out.println(s.length);Object o = new int[3];int[] b = (int[])o;System.out.println(b.length);//編譯出錯，損失掉了子類新增的方法、屬性}
}
class Super{}
b) 後期綁定
i. 將一個方法調用同一個方法主體關聯起來被稱為綁定。若在程序執行前綁定，叫前期綁定，java中除了static和final方法，其他所有的方法都是後期
ii. Overload—–前期綁定——–靜態綁定——編譯階段
Override—–後期綁定——–動態綁定——運行階段
例：Super a = new subclass();//向上轉型——-overload看左邊，override看右邊
c) 實現多態的方式
i. 重寫override：指子類重新定義父類的方法的做法
ii. 重載（overload）：是指允許存在多個同名函數，而這些函數的參數表不同（或許參數個數不同，或許參數類型不同，順序或許兩者都不同）
iii. 協變重寫：子類方法可以比父類方法的返回類型更具體（子類的返回類型是父類方法返回類型的子類）
d) 只有普通方法具有多態，final、static、private方法不具備多態性
Field（域成員==字段）不具備多態性—–它們都是前期綁定—-同變量的聲明類型綁定
c) 設計原則：
1、開閉原則—對擴展開放，對修改封閉，實現關鍵在於抽象化
2、裡氏代換原則—面向基類原則—任何基類可以出現的地方，子類一定可以出現

十八、 String（聲明，創建，初始化，操作（比較equals/==，轉換，查找，截取，分割，拆分，替換，連接））

a) 在java中使用的是unicode碼；字符串的內存空間大小跟它的屬性有關，String創建初始化時在JVM中數據流動，
b) 聲明創建初始化
i. 格式：String 變量名 = 初始值；
ii. String 變量名 = new String（初始值）；
c) 操作：
i. 比較（equals與==）
1. equals比的是內容，==比的是地址,equalsIgnoreCase()—忽略大小寫
2. 例1：String d = “123”;
String d1 = new String(“123”);
System.out.println(d.equals(d1)); //true
System.out.println(d==d1);//false
ii. charAt(int index)——返回指定索引處的char值
iii. length()——–返回字符串的長度
iv. 轉換
1. toString()——返回本身
2. toLowerCase()—將所有字符串轉換為小寫
3. toUpperCase()—將所有字符串轉換為大寫
v. 查找
1. indexOf(String key)——從前查找返回的第一個key的索引
2. indexOf(String key,int formindex)—-返回從指定位置開始查找到的第一個key的索引
3. lastIndexOf（）———從後查找返回最後一個key的索引
vi. 截取
1. substring(int bindex,int eindex)—-截取源字符串（begin,end）並返回一個新String
vii. 拆分
1. split(String regex)—–根據regex將源字符串進行分割成若干個新字符串
viii. 替換
1. replace（char oldchar,char newchar);
ix. 連接
1. + 或concat連接—在源字符串尾部連接新字符串，返回新字符串
2. “a“+”b”;
x. 創建對象
1. String str1 = “abc”;
System.out.println(str1 == “abc”);
步驟：
1) 棧中開辟一塊空間存放引用str1，
2) String池中開辟一塊空間，存放String常量”abc”，
3) 引用str1指向池中String常量”abc”，
4) str1所指代的地址即常量”abc”所在地址，輸出為true
2. String str2 = new String(“abc”);
System.out.println(str2 == “abc”);
步驟：
1) 棧中開辟一塊空間存放引用str2，
2) 堆中開辟一塊空間存放一個新建的String對象”abc”，
3) 引用str2指向堆中的新建的String對象”abc”，
4) str2所指代的對象地址為堆中地址，而常量”abc”地址在池中，輸出為false
3. String str3 = new String（”abc”);
System.out.println(str3 == str2);
步驟：
1) 棧中開辟一塊空間存放引用str3，
2) 堆中開辟一塊新空間存放另外一個(不同於str2所指)新建的String對象，
3) 引用str3指向另外新建的那個String對象
4) str3和str2指向堆中不同的String對象，地址也不相同，輸出為false
4. String str4 = “a” + “b”;
System.out.println(str4 == “ab”);
步驟：
1) 棧中開辟一塊空間存放引用str4，
2) 根據編譯器合並已知量的優化功能，池中開辟一塊空間，存放合並後的String常量”ab”，
3) 引用str4指向池中常量”ab”，
4) str4所指即池中常量”ab”，輸出為true
5. final String s = “a”;
String str5 = s + “b”;
System.out.println(str5 == “ab”);
步驟：
同4
6. String s1 = “a”;
String s2 = “b”;
String str6 = s1 + s2;
System.out.println(str6 == “ab”);
步驟：
1) 棧中開辟一塊中間存放引用s1，s1指向池中String常量”a”，
2) 棧中開辟一塊中間存放引用s2，s2指向池中String常量”b”，
3) 棧中開辟一塊中間存放引用str5，
4) s1 + s2通過StringBuilder的最後一步toString()方法還原一個新的String對象”ab”，因此堆中開辟一塊空間存放此對象，
5) 引用str6指向堆中(s1 + s2)所還原的新String對象，
6) str6指向的對象在堆中，而常量”ab”在池中，輸出為false
7. String str7 = “abc”.substring(0, 2);

步驟：
1) 棧中開辟一塊空間存放引用str7，
2) substring()方法還原一個新的String對象”ab”（不同於str6所指），堆中開辟一塊空間存放此對象，
3) 引用str7指向堆中的新String對象，
8. String str8 = “abc”.toUpperCase();
步驟：
1) 棧中開辟一塊空間存放引用str6，
2) toUpperCase()方法還原一個新的String對象”ABC”，池中並未開辟新的空間存放String常量”ABC”，
3) 引用str8指向堆中的新String對象

十九、 this

a) this是只指向當前對象的指針；
b) 使用：
i. 如果用在構造方法中，表示當前構造方法正在初始化的對象，如：
1. Person p = new Person();
2. public Person（int id）{
this.id = id;//相當於是p.id = id;
3. }
ii. 如果用在方法中，表示當前正在調用該方法的對象，如：
1. public show（int id）{
this.id = id;//相當於是p.id = id;
2. }
————p.show（）；

二十、 Static——數據共享

a) Static修飾符可以用於修飾類的成員變量和方法—–只在類加載時加載一次
i. 修飾成員變量時，該變量成為類變量或靜態變量，隸屬於類，類的所有對象共享同一個靜態變量（生命周期長，類加載時確立，保存在方法區中）
ii. 修飾方法時，該方法成為類方法或靜態方法，可以直接用類名.方法名（）調用，也可以使用創建對象後通過對象引用名.方法（）調用
iii. 靜態方法不能訪問非靜態方法：
1. 靜態方法也稱類方法，它在調用時直接使用類名.方法來調用；非靜態方法在調用時必須先創建對象，在對象上調用，格式為：對象名.方法名（）；
2. 在靜態方法被調用時可能沒有實例對象，也就無法調用非靜態方法

二十一、區別與聯系：

a) break與continue與return
i. continue和break都可以結束本輪循環，但continue結束本輪後繼續下一輪循環，break則直接跳出循環
ii. break可以用在多重循環中用來跳出離它最近的循環，也可以用在多分支語句swtich中用來跳出循環
iii. continue只能用在循環語句中，用於結束本輪循環，執行下一次循環；
iv. continue與break之後的語句都不執行
v. return是終止方法並返回數據，在方法體內return後的語句都不執行
b) 類變量（static）、實例變量、局部變量
i. 定義：類變量和實例變量定義在類中方法外，局部變量定義在方法內、形參、代碼塊中
ii. 修飾符：類變量必須要用static修飾，實例變量不用static修飾，類變量和實例變量可以不賦值，局部變量必須要先初始化
iii. 使用：類變量調用格式為：類名.變量名；實例變量調用時必須要先創建實例對象，在該對象上調用（對象.變量名）；局部變量可以直接使用
iv. 加載：類變量（棧中）在類加載時加載，類結束時結束；實例變量（堆中）在對象調用時加載，調用結束時結束；局部變量(棧中)在方法開始調用時開始，方法結束時結束
c) this與super
i. 操作屬性——–this.屬性：表示調用本類中的屬性，如果本類中的屬性不存在，則從父類開始查找；super.屬性：表示調用父類中的屬性
ii. 操作方法——–this.方法（）：表示調用本類中的方法，如果本類中的方法不存在，則從父類開始查找；super.方法（）：表示調用父類中的方法；
iii. 調用構造方法—-this（）;調用本類中的其他構造方法，super():表示調用父類的構造方法
iv. 查找范圍———this先從子類查找，如果沒有從父類查找，super不查子類直接查父類；
v. 特殊：this可以表示當前對象
d) String與StringBuffer、StringBuilder
i. String是不可變的對象，每次對String類型進行改變都相當於產生了一個新的對象，StringBuffer是可變長度的字符序列，修改後不會產生新對象
ii. StringBuffer的實質是它有容量這個屬性，默認容量為16，當初始化長度大於16時，其容量為初始化長度的2倍。
iii. String操作字符的方法有”+”、concat;StringBuffer操作字符的方法有insert、append、delete（開始int，endint）
iv. 初始化格式：
1. String st = “234”; String s = new String();
2. StringBuffer sb = new StringBuffer();
v. StringBuffer與StringBuilder都是可變長度的字符序列，在多線程中，前者是安全的，後者是不安全的
e) equals與==
i. 如果是基本類型比較，那麼只能用==來比較，不能用equals；
ii. 對於基本類型的包裝類型，比如Boolean、Character、Byte、Short、Integer、Long、Float、Double等的引用變量，==是比較地址的，而equals是比較內容的；
iii. 在String或重寫equals方法的類中：equals是比內容，==是比地址
iv. 在其他類中沒有重寫equals方法時，equals與==用法相同，都是比地址
f) 重載與重寫
i. 重載與重寫都是類的多態表現形式，重載是一個類的多態表現形式，重寫是子類繼承父類的多態表現形式，重載與重寫都是針對方法；
ii. 重載要求同名不同參數列表（類型、個數、順序），與返回類型無關，重寫要求同名同參數列表（類型、個數、順序），同返回類型（協同—-引用數據類型，是其子類或相同，基本數據類型是相同），訪問修飾符大於或等於父類，拋出異常要小於或等於父類(當拋出的異常是RuntimeException時，則都可以編譯通過)
iii. 重載可以用在構造方法和普通方法中，重寫只能用在普通方法中
g) Integer與int
i. 類型：int是基本數據類型，Integer是引用數據類型；
ii. Integer是對int的包裝，屬於包裝類；
iii. 默認值：int的默認值是0，Integer的默認值是null.
h) 類、抽象類、interface
1、抽象類需要有abstract修飾，類則不需要
2、抽象類中可以有普通方法和抽象方法，但普通類中只能有普通方法
3、抽象類和普通類都可以繼承，但抽象類的子類必須重寫其父類的所有抽象方法，而普通類則不要求
4、抽象類不能被實例化，普通類可以被實例化
5、接口是抽象類的抽象，接口中只能有抽象方法和常量，接口支持多繼承，不含有構造方法和初始化塊
i) final、finally與finalize
i. final用於聲明屬性方法和類，分別表示：屬性不可變，方法不可覆蓋，類不可繼承
ii. finally是異常處理語句的一部分，表示總是執行
iii. finalize是Object的一個方法，在垃圾收集器執行的時候會調用被回收對象的此方法。