Java-String類

阿新 • • 發佈：2020-08-09

一、封裝性

1.封裝與隱藏

　　當建立了類的物件以後，如果直接跳過“物件.屬性”的方式對相應的物件屬性賦值的話，可能會出現不滿足實際情況的意外，我們考慮不讓物件來直接作用屬性，而是通過“物件.方法”的形式，來控制物件對屬性的訪問。實際情況中，對屬性的要求就可以通過方法來實現。
private修飾的屬性，只能在本類中被呼叫，出了此類，就不能被呼叫了。
解決方法:
【1】（封裝性的思想）將類的屬性私有化；
【2】提供公共的方法來呼叫，setter設定,getter獲取
舉例：

public class TestArgsTransfer{
    public static void main(String[] args) {
    Animal a1 = new Animal();
    // a1.name = "芙芙";
    // a1.legs = 2;
    }
}

class Animal{
    //private修飾的屬性，只能在本類中被呼叫，出了此類，就不能被呼叫了。
    private String name;//動物的名字
    private int legs;//腿的個數

    public void eat(){
        System.out.println("動物進食");
}

    public void sleep(){
        System.out.println("動物睡覺");
    }

public void info(){
    System.out.println("name:"+name+"legs:"+legs);
}

//獲取類的屬性
public int getLegs() {
    return legs;
}

public String getName() {
    return name;
}

//設定類的屬性
public void setLegs(int l) {
    if(l > 0 && l % 2 == 0){
        legs = l;
    }else{
        System.out.println("您輸入的資料有誤");
    }
}

public void setName(String n) {
    //...
    name = n;
    }
}

許可權修飾符：public private 預設 protect
4個都可以用來修飾屬性、方法；
注：
（1）許可權從大到小排列，public > protected > 預設 > privated
（2）修飾類的許可權有：public、default(預設)

2.this

this的使用方法：

this可以用來修飾屬性、方法、構造器
this理解為當前物件或當前正在建立的物件。比如：this.name，this.show()
可以在構造器中通過“this(形參)”的方式顯示本類中其他過載的指定的構造器，要求：
在構造器內部必須宣告在首行；

this的使用場景：

當形參與成員變數重名時候，如果在方法內部需要使用成員變數，必須新增this來表明該變數是類成員；
在任意方法內，如果使用當前類的成員變數或成員方法，可以在其前面新增this，增強程式的閱讀性。
在構造器中使用“this(形參列表)”顯示的呼叫本類中過載的其他的構造器
要求“this(形參列表)”要宣告在構造器的首行！
若一個類中有n個構造器，那麼最多有n-1個構造器中使用了this(形參)。

舉例：

public class TestPerson{
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(10);
        p.info();
        p.setName("牛");
        p.info();
        System.out.println();

        Person p1 = new Person("韓梅梅",23);
        p1.info();

        Person p2 = new Person(23);
        p2.info();
    }
}

class Person{
    //屬性
    private String name;
    private int age;

    //構造器
    public Person(String name){
        this.name = name;
    }

public Person(){
    age = 12;
}

public Person(int age){
    this.age = age;
}

public Person(String name, int age){
    this(name);
    this.age= age;
}

//this.name表示當前正在建立的物件
//name是形參
public Person(String name,int age){
    //this.name = name;
    this(name);//可以用來顯示的呼叫當前類的過載的指定的構造器
    System.out.println("這裡是person類中形參為name和age的構造器");
    this.age = age;
}
//this.name表示當前物件的屬性
//name是形參
public void setName(String name){
    this.name = name;
}

public void setAge(int age) {
    this.age = age;
}

public String getName() {
    return name;
}

public int getAge() {
    return age;
}

public void eat(){
    System.out.println("人吃飯");
}

public void sleep(){
    System.out.println("人睡覺");
}

public void info(){
    System.out.println("name:"+this.name+"age:"+this.age);
    this.show();
}

public void show(){
    System.out.println("show方法:"+this.name);
    }
}

結果：

name:nullage:10
show方法:null
name:牛age:10
show方法:牛

這裡是person類中形參為name和age的構造器
name:韓梅梅age:23
show方法:韓梅梅
name:nullage:23
show方法:null

3.JavaBean

JavaBean是一種Java語言寫成的可重用元件。

所謂JavaBean，是指符合如下標準的Java類：

類是公共的；
有一個無參的公共的構造器；
有屬性，且有對應的get、set方法。

4.package

宣告原始檔所在的包，寫在程式的第一行。
每“.”一次，表示一層檔案目錄。

5.import

顯示匯入指定包下的類或介面；
寫在包的宣告和原始檔之間；
如果需要引入多個類或介面，那麼就並列寫出；
如果匯入的類是java.lang包下的，如：System String Math等，就不需要顯示的宣告。
理解.*的概念，比如java.util.*；
如何處理同名類的匯入，如：在util包和sql包下同時存在Date類；
import static 表示匯入指定類的static的屬性或方法。
匯入java.lang.*只能匯入lang包下的所有類或介面，不能匯入lang的子包下的類或介面。

二、繼承性

1.繼承

1.1 子類繼承父類以後，父類中宣告的屬性、方法，子類可以獲取到。

明確：當父類中有私有的屬性或方法時，子類同樣可以獲取得到，只是由於封裝性的設計，使得子類不可以直接呼叫罷了。

子類除了通過繼承，獲取父類的結構之外，還可以定義自己的特有的成分。

extends：子類是對父類功能的“擴充套件”，明確子類不是父類的子集。

1.2 java中的繼承性只支援單繼承，一個類只能繼承一個父類。反之，一個父類可以有多高子類。

1.3 子父類是相對的概念。

2.方法的重寫（override）

2.1 前提：有子類繼承父類

2.2 子類繼承父類以後，若父類的方法對子類不適用那麼子類可以對父類的方法重寫（override或overwrite）。

2.3 重寫的規則

要求子類方法的“返回值型別方法名（引數列表）”與父類的方法一樣；
子類方法的修飾符不能小於父類方法的修飾符；
若父類方法拋異常，那麼子類方法拋的異常型別不能大於父類的。
子父類的方法必須同為static或同為非static的。

2.4 方法的過載和重寫的區別？

過載：
1. “兩同一不同”，同一個類中，同一個方法名，不同的引數列表。注：方法的過載與方法的返回值無關。
2. 構造器是可以過載的
重寫：前提是在繼承的基礎之上，子類在獲取了父類的結構之後，可以對父類中同名的方法進行“重構”
1. 方法的返回值、方法名、形參列表相同；
2. 許可權修飾符不小於父類的同名方法；
3. 子類方法的異常型別不大於父類的；
4. 兩個方法要同為static或同為非static。

3.四種訪問許可權修飾符

Java許可權修飾符public、protected、private置於類的成員定義前，用來限定物件對該類物件成員的訪問許可權。

修飾符	類內部	同一個包	子類	任何地方
private	√
default	√	√
protected	√	√	√
public	√	√	√	√

對於class的許可權修飾只可以用public和default

public類可以在任意地方被訪問；
default類只可以被同一個包內部的類訪問。

4.關鍵字super

super：可以用來修飾屬性、方法、構造器。

super的追溯不限於直接父類。

super和this的用法很像，this代表本類物件的引用，super代表父類的記憶體空間的標識。

4.1 屬性

　　當子類與父類中有同名的屬性時，可以通過“super.此屬性”顯式的呼叫父類中宣告的屬性。若想呼叫子類的同名的屬性"this.此屬性"。

4.2 方法

　　當子類重寫父類的方法以後，在子類中若想再顯式的呼叫父類的被重寫的方法，就需要使用“super.方法”

4.3 構造器

super修飾構造器，通過在子類中使用“super(形參列表)”來顯示的呼叫父類中指定的構造器。

在構造器內部，“super（形參列表）”必須要宣告在首行！！！
在構造器內部：“this（形參列表）”或“super（形參列表）”只能出現一個！！！
在構造器中，不顯示的呼叫“this（形參列表）”或“super（形參列表）”其中任何一個，預設呼叫的是父類空參的構造器！！！

建議：設計一個類時，儘量要提供一個空參的構造器！！！

5.子類物件例項化過程

三、多型性

若編譯時型別和執行時型別不一致，就出現多型（Polymorphism）。

1.多型性是什麼

多型性，可以理解為一個事物的多種表現形態。

方法的過載與重寫；
子類物件的多型性---直接應用在抽象類和介面上。

2.子類物件的多型性使用前提

要有類的繼承；
要有子類對父類方法的重寫。

3.程式執行分為編譯狀態和執行狀態

對於多型性來說：

編譯時，“看左邊”，將此引用變數理解為父類的型別；
執行時，“看右邊”，關注於真正物件的實體，子類的物件。那麼執行的方法就是子類重寫的。

格式：物件a instanceof 類A，判斷物件a是否是類A的一個例項，是的話返回true，否則返回false。

若a是A類的例項，那麼a也一定是A類的父類的例項。

多型的好處：

4.類的屬性無多型性

子類物件的多型性，並不適用於屬性。