Java基礎學習筆記十二 類、抽象類、接口作為方法參數和返回值以及常用API

不同修飾符使用細節

常用來修飾類、方法、變量的修飾符

• public 權限修飾符，公共訪問, 類,方法,成員變量
• protected 權限修飾符，受保護訪問, 方法,成員變量
• 默認什么也不寫 也是一種權限修飾符，默認訪問, 類,方法,成員變量
• private 權限修飾符，私有訪問, 方法,成員變量
• static 靜態修飾符 方法,成員變量
• final 最終修飾符 類,方法,成員變量,局部變量
• abstract 抽象修飾符 類 ,方法

我們編寫程序時，權限修飾符一般放於所有修飾符之前，不同的權限修飾符不能同時使用；

• 同時，abstract與private不能同時使用；
• 同時，abstract與static不能同時使用；
• 同時，abstract與final不能同時使用。

修飾類能夠使用的修飾符

修飾類只能使用public、默認的、final、abstract關鍵字，使用最多的是 public關鍵字

public class Demo {} //最常用的方式
class Demo2{}
public final class Demo3{}
public abstract class Demo4{}

修飾成員變量能夠使用的修飾符

• public : 公共的
• protected : 受保護的
• : 默認的
• private ：私有的
• final : 最終的
• static : 靜態的

使用最多的是 private

public int count = 100;
protected int count2 = 100;
int count3 = 100;
private int count4 = 100; //最常用的方式
public final int count5 = 100;
public static int count6 = 100;

修飾構造方法能夠使用的修飾符

• public : 公共的
• protected : 受保護的
• : 默認的
• private ：私有的

使用最多的是 public

public Demo(){} //最常用的方式
protected Demo(){}
Demo(){}
private Demo(){}

修飾成員方法能夠使用的修飾符

• public : 公共的
• protected : 受保護的
• : 默認的
• private ：私有的
• final : 最終的
• static : 靜態的
• abstract : 抽象的

使用最多的是 public

public void method1(){}//最常用的方式
protected void method2(){}
void method3(){}
private void method4(){}
public final void method5(){}
public static void method6(){}//最常用的方式
public abstract void method7();//最常用的方式

類作為方法參數與返回值

類作為方法參數

在編寫程序中，會經常碰到調用的方法要接收的是一個類類型的情況，那么這時，要向方法中傳入該類的對象。如下代碼演示：

class Person{
    public void show(){
        System.out.println("show方法執行了");
    }
}
//測試類
public class Test {
    public static void main(String[] args) {
//創建Person對象
        Person p = new Person();
//調用method方法
        method(p);
    }
    //定義一個方法method，用來接收一個Person對象，在方法中調用Person對象的show方法

    public static void method(Person p){
        p.show();
    }
}

類作為方法返回值

寫程序調用方法時，我們以后會經常碰到返回一個類類型的返回值，那么這時，該方法要返回一個該類的對象。如下代碼演示：

class Person{
    public void show(){
        System.out.println("show方法執行了");
    }
}
//測試類
public class Test {
    public static void main(String[] args) {
//調用method方法，獲取返回的Person對象
        Person p = method();
//調用p對象中的show方法
        p.show();
    }

    //定義一個方法method，用來獲取一個Person對象，在方法中完成Person對象的創建
    public static Person method(){
        Person p = new Person();
        return p;
    }
}

抽象類作為方法參數與返回值

抽象類作為方法參數

開發中，抽象類作為方法參數的情況也很多見。當遇到方法參數為抽象類類型時，要傳入一個實現抽象類所有抽象方法的子類對象。如下代碼演示：

//抽象類
abstract class Person{
    public abstract void show();
}
class Student extends Person{
    @Override
    public void show() {
        System.out.println("重寫了show方法");
    }
}
//測試類
public class Test {
    public static void main(String[] args) {
//通過多態的方式，創建一個Person類型的變量，而這個對象實際是Student
        Person p = new Student();
//調用method方法
        method(p);
    }

    //定義一個方法method，用來接收一個Person類型對象，在方法中調用Person對象的show方法
    public static void method(Person p){//抽象類作為參數
//通過p變量調用show方法,這時實際調用的是Student對象中的show方法
        p.show();
    }
}

抽象類作為方法返回值

抽象類作為方法返回值的情況，也是有的，這時需要返回一個實現抽象類所有抽象方法的子類對象。如下代碼演示：

//抽象類
abstract class Person{
    public abstract void show();
}
class Student extends Person{
    @Override
    public void show() {
        System.out.println("重寫了show方法");
    }
}
//測試類
public class Test {
    public static void main(String[] args) {
//調用method方法，獲取返回的Person對象
        Person p = method();
//通過p變量調用show方法,這時實際調用的是Student對象中的show方法
        p.show();
    }

    //定義一個方法method，用來獲取一個Person對象，在方法中完成Person對象的創建
    public static Person method(){
        Person p = new Student();
        return p;
    }
}

接口作為方法參數與返回值

接口作為方法參數

接口作為方法參數的情況是很常見的，經常會碰到。當遇到方法參數為接口類型時，那么該方法要傳入一個接口實現類對象。如下代碼演示。

//接口
interface Smoke{
    public abstract void smoking();
}
class Student implements Smoke{
    @Override
    public void smoking() {
        System.out.println("課下吸口煙，賽過活神仙");
    }
}
//測試類
public class Test {
    public static void main(String[] args) {
    //通過多態的方式，創建一個Smoke類型的變量，而這個對象實際是Student
        Smoke s = new Student();
        //調用method方法
        method(s);
    }

    //定義一個方法method，用來接收一個Smoke類型對象，在方法中調用Smoke對象的show方法
    public static void method(Smoke sm){//接口作為參數
    //通過sm變量調用smoking方法，這時實際調用的是Student對象中的smoking方法
        sm.smoking();
    }
}

接口作為方法返回值

接口作為方法返回值的情況，在后面的學習中會碰到。當遇到方法返回值是接口類型時，那么該方法需要返回一個接口實現類對象。如下代碼演示。

//接口
interface Smoke{
    public abstract void smoking();
}
class Student implements Smoke{
    @Override
    public void smoking() {
        System.out.println("課下吸口煙，賽過活神仙");
    }
}
//測試類
public class Test {
    public static void main(String[] args) {
//調用method方法，獲取返回的會吸煙的對象
        Smoke s = method();
//通過s變量調用smoking方法,這時實際調用的是Student對象中的smoking方法
        s.smoking();
    }

 //定義一個方法method，用來獲取一個具備吸煙功能的對象，並在方法中完成吸煙者的創建
    public static Smoke method(){
        Smoke sm = new Student();
        return sm;
    }
}

歸納總結：

• 類作為方法參數時，說明要向方法中傳入該類的對象
• 類作為方法返回值時，說明該方法要返回一個該類的對象。
• 抽象類作為方法參數時，說明要傳入一個實現抽象類所有抽象方法的子類對象。
• 抽象類作為方法返回值時，說明需要返回一個實現抽象類所有抽象方法的子類對象。
• 接口作為方法參數時，說明該方法要傳入一個接口實現類對象。
• 接口作為方法返回值時，說明該方法需要返回一個接口實現類對象。

常用API

Java 的API（API: Application(應用) Programming(程序) Interface(接口)）就是JDK中提供給我們使用的類，這些類將底層的代碼實現封裝了起來，我們不需要關心這些類是如何實現的，只需要學習這些類如何使用即可。

在JDK安裝目錄下有個src.zip文件，這個文件解壓縮后里面的內容是所有Java類的源文件。可以在其中查看相對應的類的源碼。
我們在每次查看類中的方法時，都打開源代碼進行查看，這種方式過於麻煩。其實，我們可以通過查幫助文檔的方式，來了解Java提供的API如何使用。如下圖操作：查找Object類

 

通過幫助文檔中類與方法的介紹，我們就能夠使用這個類了。

Object類

Object類是Java語言中的根類，即所有類的父類。所有類在創建對象的時候，最終找的父類就是Object。

equals方法

equals方法，用於比較兩個對象是否相同，它其實就是使用兩個對象的內存地址在比較。Object類中的equals方法內部使用的就是==比較運算符。
在開發中要比較兩個對象是否相同，經常會根據對象中的屬性值進行比較，也就是在開發經常需要子類重寫equals方法根據對象的屬性值進行比較。如下代碼演示：

/*
描述人這個類，並定義功能根據年齡判斷是否是同齡人
由於要根據指定類的屬性進行比較，這時只要覆蓋Object中的equals方法
在方法體中根據類的屬性值進行比較
*/
class Person extends Object{
    int age ;
    //復寫父類的equals方法，實現自己的比較方式
    public boolean equals(Object obj) {
//判斷當前調用equals方法的對象和傳遞進來的對象是否是同一個
        if(this == obj){
            return true;
        }
//判斷傳遞進來的對象是否是Person類型
        if(!(obj instanceof Person)){
            return false;
        }
//將obj向下轉型為Perosn引用，訪問其屬性
        Person p = (Person)obj;
        return this.age == p.age;
    }
}

注意：在復寫Object中的equals方法時，一定要注意public boolean equals(Object obj)的參數是Object類型，在調用對象的屬性時，一定要進行類型轉換，在轉換之前必須進行類型判斷。

toString方法

toString方法返回該對象的字符串表示，其實該字符串內容就是對象的類型+@+內存地址值。
由於toString方法返回的結果是內存地址，而在開發中，經常需要按照對象的屬性得到相應的字符串表現形式，因此也需要重寫它。

class Person extends Object{
    int age ;
    //根據Person類的屬性重寫toString方法
    public String toString() {
        return "Person [age=" + age + "]";
    }
}

String類

查閱API中的String類的描述，發現String 類代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作為此類的實例實現。

//演示字符串
String str = "AAA";
str = "BBB";

字符串是常量；它們的值在創建之后不能更改。也就是說一旦這個字符串確定了，那么就會在內存區域中就生成了這個字符串。字符串本身不能改變，但str變量中記錄的地址值是可以改變的。

字符串有大量的重載的構造方法。通過String類的構造方法可以完成字符串對象的創建，那么，通過使用雙引號的方式創建對象與new的方式創建對象，有什么不同呢？

String s3 = "abc";
String s4 = new String("abc");
System.out.println(s3==s4);//false
System.out.println(s3.equals(s4));//true,
////因為String重寫了equals方法，建立了字符串自己的判斷相同的依據（通過字符串對象中的字符來判斷）

 s3和s4的創建方式有什么不同呢？

s3創建，在內存中只有一個對象。這個對象在字符串常量池中
s4創建，在內存中有兩個對象。一個new的對象在堆中，一個字符串本身對象，在字符串常量池中

String類構造方法

構造方法是用來完成String對象的創建，下圖中給出了一部分構造方法需要在API中找到，並能夠使用下列構造方法創建對象。

String s1 = new String(); //創建String對象，字符串中沒有內容

byte[] bys = new byte[]{97,98,99,100};
String s2 = new String(bys); // 創建String對象，把數組元素作為字符串的內容
String s3 = new String(bys, 1, 3); //創建String對象，把一部分數組元素作為字符串的內容，參數offset為數組元素的起始索引位置，參數length為要幾個元素

char[] chs = new char[]{’a’,’b’,’c’,’d’,’e’};
String s4 = new String(chs); //創建String對象，把數組元素作為字符串的內容
String s5 = new String(chs, 0, 3);//創建String對象，把一部分數組元素作為字符串的內容，參數offset為數組元素的起始索引位置，參數count為要幾個元素

String s6 = new String(“abc”); //創建String對象，字符串內容為abc

String類的方法查找

String類中有很多的常用的方法，我們在學習一個類的時候，不要盲目的把所有的方法嘗試去使用一遍，這時我們應該根據這個對象的特點分析這個對象應該具備那些功能，這樣大家應用起來更方便。
字符串是一個對象，那么它的方法必然是圍繞操作這個對象的數據而定義的。我們想想字符串中有哪些功能呢？
1、字符串中有多少個字符?

String str = "abcde";
int len = str.length();
System.out.println("len="+len);

2、獲取部分字符串

String str = "abcde";
String s1 = str.substring(1); //返回一個新字符串，內容為指定位置開始到字符串末尾的所有字符
String s2 = str.substring(2, 4);//返回一個新字符串，內容為指定位置開始到指定位置結束所有字符
System.out.println("str="+str);
System.out.println("s1="+s1);
System.out.println("s2="+s2);

3、字符串是否以指定字符串開頭。結尾同理

String str = "StringDemo.java";
boolean b1 = str.startsWith("Demo");//判斷是否以給定字符串開頭
boolean b2 = str.startsWith("String");
boolean b3 = str.endsWith("java");//判斷是否以給定字符串結尾

4、字符串中是否包含另一個字符串

String str = "abcde";
int index = str.indexOf(“bcd”); //判斷是否包含指定字符串，包含則返回第一次出現該字符串的索引，不包含則返回-1
boolean b2 = str.contains("bcd");//判斷是否包含指定字符串，包含返回true，不包含返回false

5、將字符串轉成一個字符數組。或者字節數組

String str = "abcde";
char[] chs = str.toCharArray();
byte[] bytes = str.getBytes();

6、判斷兩個字符串中的內容是否相同

String str = "abcde";
String str2 = "abcde";
String str3 = "hello";
boolean b1 = str.equals(str2);
boolean b2 = str.equals(str3);

7、獲取該字符串對象中的內容

String str = new String("hello");
System.out.println( str.toString() );
System.out.pintln( str );

直接打印引用類型變量時，默認調用該類型進行重寫后的toString方法

下面的需求所對應的方法，自己動手在API中查找，並進行方法使用。

• 判斷該字符串的內容是否為空的字符串
• 獲取給定的字符，在該字符串中第一次出現的位置
• 獲取該字符串中指定位置上的字符
• 把該字符串轉換成 小寫字符串
• 把該字符串轉換成 大寫字符串
• 在該字符串中，將給定的舊字符，用新字符替換
• 在該字符串中， 將給定的舊字符串，用新字符串替換
• 去除字符串兩端空格，中間的不會去除，返回一個新字符串

StringBuffer類

在學習String類時，API中說字符串緩沖區支持可變的字符串，什么是字符串緩沖區呢？接下來我們來研究下字符串緩沖區。
查閱StringBuffer的API，StringBuffer又稱為可變字符序列，它是一個類似於 String 的字符串緩沖區，通過某些方法調用可以改變該序列的長度和內容。
原來StringBuffer是個字符串的緩沖區，即就是它是一個容器，容器中可以裝很多字符串。並且能夠對其中的字符串進行各種操作。

StringBuffer的方法使用

代碼演示：
創建一個字符串緩沖區對象。用於存儲數據。

StringBuffer sb = new StringBuffer();
sb.append("haha"); //添加字符串
sb.insert(2, "it");//在指定位置插入
sb.delete(1, 4);//刪除
sb.replace(1, 4, "cast");//替換指定范圍內的內容
String str = sb.toString();

注意：append、delete、insert、replace、reverse方法調用后，返回值都是當前對象自己，所以說，StringBuffer它可以改變字符序列的長度和內容。

StringBuffer類方法查找練習
下面的需求所對應的方法，自己動手在API中查找，並進行方法使用。

• 從指定位置開始，到末尾結束，截取該字符串緩沖區，返回新字符串
• 在原有字符串緩沖區內容基礎上，刪除指定位置上的字符

對象的方法鏈式調用

在我們開發中，會遇到調用一個方法后，返回一個對象的情況。然后使用返回的對象繼續調用方法。這種時候，我們就可以把代碼現在一起，如append方法一樣，代碼如下：

//創建一個字符串緩沖區對象。用於存儲數據。
StringBuffer sb = new StringBuffer();
//添加數據。不斷的添加數據后，要對緩沖區的最后的數據進行操作，必須轉成字符串才可以。
String str = sb.append(true).append("hehe").toString();

無論多少數據，數據是什么類型都不重要，只要最終變成字符串就可以使用StringBuffer這個容器。

StringBuilder類

查閱API發現還有一個StringBuilder類，它也是字符串緩沖區，StringBuilder與它和StringBuffer的有什么不同呢？
我們閱讀StringBuilder的API說明發現，它也是一個可變的字符序列。此類提供一個與 StringBuffer 兼容的 API，但不保證同步。該類被設計用作 StringBuffer 的一個簡易替換，用在字符串緩沖區被單個線程使用的時候（這種情況很普遍）。如果可能，建議優先采用該類，因為在大多數實現中，它比 StringBuffer 要快。

總結

1、Object: 它是所有類的超類，祖宗類。java中所有的類都直接或間接的繼承這個類
方法：

• public String toString() 返回當前對象中的內容, 對於Object類默認操作來說，返回的對象的類型+@+內存地址值
• public boolean equals(Object obj) 比較兩個對象內容是否相同，對於Object類默認操作來說,比較的是地址值

2、String: 字符串類，字符串是常量；它們的值在創建之后不能更改
方法：

• boolean equals(Object obj) 判斷兩個字符串中的內容是否相同
• boolean equalsIgnoreCase(String str) 判斷兩個字符串中的內容是否相同, 忽略大小寫
• boolean contains(String str) 判斷該字符串中 是否包含給定的字符串
• boolean startsWith(String str) 判斷該字符串 是否以給定的字符串開頭
• boolean endsWith(String str) 判斷該字符串 是否以給定的字符串結尾
• boolean isEmpty() 判斷該字符串的內容是否為空的字符串 ""
• int length() 獲取該字符串的長度
• char charAt(int index) 獲取該字符串中指定位置上的字符
• String substring(int start) 從指定位置開始，到末尾結束，截取該字符串，返回新字符串
• String substring(int start,int end) 從指定位置開始，到指定位置結束，截取該字符串，返回新字符串
• int indexOf(int ch ) 獲取給定的字符，在該字符串中第一次出現的位置
• int indexOf(String str) 獲取給定的字符串，在該字符串中第一次出現的位置
• int indexOf(int ch,int fromIndex) 從指定位置開始，獲取給定的字符，在該字符
• byte[] getBytes() 把該字符串 轉換成 字節數組
• char[] toCharArray() 把該字符串 轉換成 字符數組
• String replace(char old,char new) 在該字符串中，將給定的舊字符，用新字符替換
• String replace(String old,String new) 在該字符串中， 將給定的舊字符串，用新字符串替換
• String trim() 去除字符串兩端空格，中間的不會去除，返回一個新字符串
• String toLowerCase() 把該字符串轉換成 小寫字符串
• String toUpperCase() 把該字符串轉換成 大寫字符串
• int indexOf(String str,int fromIndex) 從指定位置開始，獲取給定的字符串，在該字符串中第一次出現的位置

3、StringBuffer/StringBuilder:
方法：

• public StringBuffer append(String str) 在原有字符串緩沖區內容基礎上，在末尾追加新數據
• public StringBuffer insert(int offset,String str) 在原有字符串緩沖區內容基礎上，在指定位置插入新數據
• public StringBuffer deleteCharAt(int index) 在原有字符串緩沖區內容基礎上，刪除指定位置上的字符
• public StringBuffer delete(int start,int end) 在原有字符串緩沖區內容基礎上，刪除指定范圍內的多個字符
• public StringBuffer replace(int start,int end,String str)在原有字符串緩沖區內容基礎上，將指定范圍內的多個字符 用給定的字符串替換
• public StringBuffer reverse() 將字符串緩沖區的內容 反轉 "abc"----"cba"
• public String substring(int start) 從指定位置開始，到末尾結束，截取該字符串緩沖區，返回新字符串
• public String substring(int start,int end) 從指定位置開始，到指定位置結束，截取該字符串緩沖區，返回新字符串