Java的態和抽象類是什么

這篇文章主要為大家展示了“Java的態和抽象類是什么”，內容簡而易懂，條理清晰，希望能夠幫助大家解決疑惑，下面讓小編帶領大家一起研究并學習一下“Java的態和抽象類是什么”這篇文章吧。

多態：

我們知道Java的三大特性：封裝、繼承、多態。前兩個之前在Java入門（六）已經講到，現在來講多態這個特性。

什么是多態？

多態顧名思義即為多種形態的意思

Java中多態的含義：

1.發送消息給某個對象，讓這個對象自行決定采用哪種行為響應這個消息

2.子類對象的引用賦值給父類引用變量來實現動態的方法調用

Java中形成多態的前提：

1.繼承

2.父類方法的重寫

3.向上轉型

我對多態的解釋：

比如我們，是人，也是學生，也是年輕人，我可以用人的身份去做事情，也可以用學生的身份去買學生票，也可以用年輕人的身份做公益，這樣我們可以通過不同的形態去做不同的事情。這樣是不是更好理解一點？

注意：

多態前提條件：必須有子父類關系。

在使用多態后的父類引用變量調用方法時，會調用子類重寫后的方法。

多態的定義與使用格式：

父類類型 變量名=new 子類類型();

多態中成員的特點：

• 多態成員變量：編譯運行看左邊

• 多態成員方法：編譯看左邊，運行看右邊

多態的轉型：

• 多態的轉型分為向上轉型和向下轉型兩種

• 向上轉型：多態本身就是向上轉型過的過程

使用格式：父類類型 變量名=new 子類類型();

適用場景：當不需要面對子類類型時，通過提高擴展性，或者使用父類的功能就能完成相應的操作。

• 向下轉型：一個已經向上轉型的子類對象可以使用強制類型轉換的格式，將父類引用類型轉為子類引用各類型

• 使用格式：子類類型 變量名=（子類類型） 父類類型的變量；

適用場景：當要使用子類特有功能時。

代碼解釋：

public class Person {     //人類，作為父類使用
    public void speak(){
        System.out.println("我們都是一個人");
    }
}
public class Student extends Person{    //繼承父類，相當于我們是學生，有人的方法
    @Override
    public void speak(){
        System.out.println("我是人類中的學生");
    }
}
public class Child extends Person{   //繼承父類，相當于我們是孩子，有孩子的行為
    @Override
    public void speak(){
        System.out.println("我是人類中的孩子");
    }
}

//測試類
public class TestMain {
    public static void main(String[] args) {
		//父類類型 變量名=new 子類類型();
        Person p = new Student();   //子類對象的引用賦值給父類 
        p.speak(); //多態 相當于這里使用的是Student的方法。輸出我是人類中的學生
        //我作為人，我用學生的身份，說出：我是人類中的學生
		Person p = new Child(); 
		p.speak();  //輸出：我是人類中的孩子
		//我作為人，用孩子的身份，說出我是人類中的孩子
    }
}
//這段代碼，我們用到了 繼承，重寫，向上轉型，因為多態本來就是向上轉型的過程

多態的作用：介紹完多態，講講多態有什么用呢？為什么多態可以作為Java的三大特性。肯定是有原因的：

• 提高代碼的可重用性

• 降低模塊之間的耦合度

這里給大家介紹一下什么是多態機制？Java語言是如何實現多態的？（可能有點難以理解，本人對于該內容也沒用理解充分，但這也是面試會考的題）

所謂多態就是指程序中定義的引用變量所指向的具體類型和通過該引用變量發出的方法調用在編程時并不確定，而是在程序運行期間才確定，即一個引用變量倒 底會指向哪個類的實例對象，該引用變量發出的方法調用到底是哪個類中實現的 方法，必須在由程序運行期間才能決定。因為在程序運行時才確定具體的類，這樣，不用修改源程序代碼，就可以讓引用變量綁定到各種不同的類實現上，從而 導致該引用調用的具體方法隨之改變，即不修改程序代碼就可以改變程序運行時 所綁定的具體代碼，讓程序可以選擇多個運行狀態，這就是多態性。 多態分為編譯時多態和運行時多態。其中編輯時多態是靜態的，主要是指方法的 重載，它是根據參數列表的不同來區分不同的函數，通過編輯之后會變成兩個不 同的函數，在運行時談不上多態。而運行時多態是動態的，它是通過動態綁定來 實現的，也就是我們所說的多態性。

對于多態的理解，還可以參考一段代碼：

class People{     //父類
    public void eat(){
        System.out.println("我們會吃飯");
    }
}

class Student extends People{  //繼承父類
    @Override
    public void eat(){
        System.out.println("我會吃肉");
    }
    public void study(){
        System.out.println("我們要好好學習");
    }
}

class Teacher extends People{     //繼承父類
    @Override
    public void eat(){
        System.out.println("老師會吃蔬菜");
    }
    public void teach(){
        System.out.println("老師要認真上課");
    }
}
//測試類：
public class TestMain {
    public static void main(String[] args) {
        People p=new Stu();      //子類對象的引用賦值給父類 
        p.eat();       //輸出： 我會吃肉
    }
}

抽象類：

什么是抽象類？

普通類是一個完善的功能類，可以直接產生實例化對象，并且在普通類中可以包含有構造方法、普通方法、static方法、常量和變量等內容。而抽象類是指在普通類的結構里面增加抽象方法的組成部分。

抽象方法：

在所有的普通方法上面都會有一個“{}”，這個表示方法體，有方法體的方法一定可以被對象直接使用。而抽象方法，是指沒有方法體的方法，同時抽象方法還必須使用關鍵字abstract做修飾。也就是說，抽象類里面的抽象方法，可以不寫，在被繼承后，再重寫。

抽象類聲明關鍵字： abstracat

定義一個抽象類：

public abstract class studnet{//定義一個抽象類
	public void study(){                         //普通方法
		System.out.println("我會學習");
	}
	public abstract void eat();         //抽象方法，沒有方法體，有abstract關鍵字做修飾
}
//注意： 有抽象方法，這個類必須是抽象的！！！

舉例解釋：形狀類Shape需要提供用于計算面積和周長的方法，但是形狀本身沒有被確定，那么計算周長和面積的方法就無法確定，此時我們就需要使用抽象類和抽象方法。

由于Shape類計算周長和面積的方法無法確定，那么就可以將這樣的方法聲明為抽象的，以便在具體的子類中進行實現。

//定義一個shape類，但是沒有具體的形狀，所以我們定義成抽象類
public abstract class Shape {
    private int a;
    public abstract void area(){}     //求面積的方法
    public abstract void perimeter();   //求周長的方法
    public Shape() {    //無參構造
    }
    public Shape(int a) {
        this.a = a;
    }
}

//計算圓形面積的子類
public  abstract class shape {    //有抽象方法的類，則一定是抽象類，需要關鍵字abstract修飾
        private int a;
        public abstract void area();     //求面積的方法，沒有方法體的方法，需要關鍵字abstract修飾
        public abstract void perimeter();   //求周長的方法
}

//創建計算圓面積和周長的子類，并繼承抽象類shape,并重寫shape內的方法
public class Circle extends shape{
    public static double pi = 3.14;
    private double r;  //半徑

    @Override
    public void area() {
        System.out.println("圓的面積："+Circle.pi*this.r*this.r);
    }
    @Override
    public void perimeter() {
        System.out.println("圓的周長為："+2*Circle.pi*this.r);
    }
    public Circle() {
    }
    public Circle(double r) {  //
        this.r = r;
    }
}

//測試類：
public class TestMain {
    public static void main(String[] args) {
        Circle c = new Circle(5);        //傳入半徑為：5
        c.area();
        c.perimeter();
    }
}
//輸出結果： 圓的面積：78.5
//			圓的周長為：31.400000000000002

抽象方法和抽象類的注意事項：

• 抽象類中是可以有構造函數的，并且構造函數的寫法和其它類沒有區別，只不過它真正跑起來是因為子類構造函數的super調用，畢竟我們沒辦法new一個抽象類對象出來，只能把抽象類的構造函數交給子類的構造函數去使用。

• 抽象類中不一定包含抽象方法，但是有抽象方法的類一定是抽象類。

• 抽象類的子類，必須重寫父類中所有的抽象方法，如果有一個抽象方法沒有重寫，都會出現編譯錯誤不給過，這時也可以把子類也聲明為抽象類，報錯就會消失。

簡潔總結：

• 抽象方法：沒有方法體的方法，需要關鍵字abstract修飾

• 有抽象方法的類，則一定是抽象類，需要關鍵字abstract修飾

• 抽象方法不能使用private和static修飾

• 抽象類,不一定有抽象方法的類

• 抽象類,不一定有抽象方法的類

• 抽象類可以有構造函數

普通類和抽象類有哪些區別？

• 普通類不能包含抽象方法，抽象類可以包含抽象方法

• 抽象類不能直接實例化，普通類可以直接實例化。

以上是“Java的態和抽象類是什么”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！