Java超詳細分析抽象類和接口的使用

更新時間：2022年04月25日 15:30:20 作者：厚積薄發(fā)?

在類中沒有包含足夠的信息來描繪一個具體的對象，這樣的類稱為抽象類，接口是Java中最重要的概念之一，它可以被理解為一種特殊的類，不同的是接口的成員沒有執(zhí)行體，是由全局常量和公共的抽象方法所組成，本文給大家介紹Java抽象類和接口，感興趣的朋友一起看看吧

什么是抽象類

什么是抽象類呢？抽象類顧名思義就是很抽象，就是當我們沒有足夠的信息去描述這個類的時候我們就可以先不用描述，這樣的類就是抽象類。

用代碼舉個例子：

class Shape {
    public void draw() {
        System.out.println("我要畫圖形?。?);
    }
}
class circle extends Shape {
    @Override
    public void draw() {
        System.out.println("我要畫圓形?。?！");
    }
}
class rect extends Shape {
    @Override
    public void draw() {
        System.out.println("我要畫矩形！??！");
    }
}
public class TestDemo3 {
    public static void drawShape(Shape shape) {
        shape.draw();
    }
    public static void main(String[] args) {
        drawShape(new circle());
        drawShape(new rect());
    }
}

正好也通過這個小小的案例來復習一下多態(tài)，我們創(chuàng)建一個Shape父類，然后又創(chuàng)建兩個子類分別為 rect類和circle類然后利用這兩個類使用同一個方法，產(chǎn)生的形態(tài)是不一樣的這就是多態(tài)，但是

我們可以發(fā)現(xiàn)我只用了這兩個子類來畫圖形分別是圓形和矩形，我并沒有調(diào)用父類來實現(xiàn)這個方法，為啥呢？？？就是因為這個父類并不能畫出圖形，那這個父類的draw方法的實現(xiàn)豈不是沒有用，我只需要它父類要有這方法，通過子類重寫就可以了，不需要父類的方法有具體的實現(xiàn)。

沒錯，這就引入到我們今天的主題抽象類

上面父類的draw方法由于它的具體實現(xiàn)根本沒有用處，所以我們就可以不寫，這也正符合抽象類的定義，當不能有足夠的信息去描述它，那我們就把它叫做抽象類。

抽象類語法

上面父類的draw方法沒有具體的實現(xiàn)我們就可以把它叫做抽象方法。利用abstract來修飾

public abstract void draw();

但是這樣為啥會報錯呢？？

原因是被abstract修飾的方法叫做抽象方法，如果一個類里面有抽象方法，那這個類一定是抽象類，所以類也要被abstract來修飾。

但是相反，抽象類里面一定有抽象方法么？？？

編譯器并不會報錯，所以答案是不一定，抽象類里面可以有抽象方法也可以沒有抽象方法。

抽象類能否被實例化呢？？？

所以，抽象類是不能實例化的。

抽象類能否像普通類一樣定義成員變量和方法，構造方法呢？？？

抽象類與普通類的區(qū)別就是在與抽象類不能實例化，其他定義成員變量，成員方法，構造方法等等都是一樣的。

既然抽象類不能實例化，那他存在的意義是什么呢？？？

老鐵思考的有道理，其實抽象類最大的意義就是被繼承，因為抽象類不能實例化對象，只能依靠子類來重寫父類(就是抽象類)的方法來完成業(yè)務需求。

怎么繼承抽象類呢？？？有哪些注意的點呢？？？

這樣繼承為啥會出錯呢？？原因是在子類繼承抽象類的時候，子類需要重寫父類的所有方法或者子類需要用abstract修飾(抽象類被抽象類繼承或者子類重寫抽象類(父類)的所有方法)。

這樣就正確了。

這里還要注意當我們沒有重寫父類的方法時而是用abstract來修飾，這時當你在次繼承這個子類的時候也就是這個子類變成了父類，下一個子類還是要繼續(xù)重寫這個父類的方法和這個父類的父類的方法。

抽象方法能否別static和final修飾呢？？？

抽象方法不能被static 和final 修飾，因為子類要重寫父類的方法，同時可以省略訪問修飾限定符，默認是public。

總結抽象類：

我們把不能足夠描述清楚一個對象的類叫做抽象類。
被abstract修飾的方法稱為抽象方法，被abstract修飾的類稱為抽象類
抽象方法必須在抽象類里面，也就是說，只要有抽象方法，類名也必須利用abstract來修飾，相反，抽象類里面可以沒有抽象方法，也可以有抽象方法。
抽象類不能實例化，除了不能實例化之外其他與普通類一樣可以定義成員變量，成員方法，構造方法等。同時構造方法和類方法(被static修飾的方法)不能被abstract來修飾
抽象方法的訪問修飾限定符不能是private，如果省略默認是public，同時抽象方法不能被final修飾。
子類繼承抽象類的時候，子類必須重寫抽象類的所有方法并且要有方法的具體實現(xiàn)，如果重寫那子類還是抽象類，必須用abstract來修飾。
抽象類中的方法沒有具體實現(xiàn)，要通過子類重寫在子類中實現(xiàn)。
一個類只能繼承一個抽象類

接口

說到接口我們會想到什么呢？？？我一開始想到的就是充電接口插排等等，比如充電接口，只要符合那個插口的標準，我們都可以使用那個接口來進行充電。這就是把標準進行統(tǒng)一起來，然后大家就可以根據(jù)不同的標準來使用不同的接口，比如蘋果手機與安卓手機的手機接口就是不一樣的，他們就是兩種不同的標準，安卓手機用安卓的接口，蘋果用蘋果的接口這就將標準統(tǒng)一起來。

而在Java中也是一樣的，我們把這個標準或者可以說是一種公共的規(guī)范叫做接口，只要符合這一接口的標準我們就可以使用它。

聽著這抽象的概念你可能現(xiàn)在還是不太明白這到底是什么，我在來拿代碼舉個例子：

class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println(this.name+"吃飯***！");
    }
}

這里我定義了一個動物類，這個動物有名字，年齡，還有吃飯的行為。

class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println(this.name+"吃飯***！");
    }
    public void swim() {
        System.out.println("我要游泳~~~~");
    }
}
class Fish extends Animal {
}

接著我又定義了一個魚類(子類)繼承這個動物類(父類)，我想讓這個魚有這個游泳的行為，但是這就會有一個問題，在父類定義了一個swim方法，接著我還要定義很多類，難道所有的類都要有這個游泳的行為么？？？答案是不可以的。所以我們就不能把這個swim方法定義在父類里面，那我們就可以把這個方法定義在子類(魚類)里面，這樣就符合了，但是如果我還要定義1000個動物都會游泳難道都要在自己類中寫這個游泳的方法么？？這樣做顯然是不可行的。那我們該怎么做呢？？

我們可以就提供一個公共的接口，這也是一種標準，只要符合這一標準都可以使用這個接口或者可以說可以實現(xiàn)這一功能。

看了上面的引例我們應該接口是干什么的了，接下來我們來學一下接口的語法。

怎么定義接口

定義接口要使用interface關鍵字：

//創(chuàng)建一個接口
//創(chuàng)建接口要是用interface關鍵字  接口的命名最好是形容詞其他的也可以
interface IFlying{
    //這就是一個flying接口
}

接口中的成員變量：

這樣會報錯，接口中的成員變量都是常量，所以必須初始化，接口中的成員變量會被隱式指定為public static final 修飾的。

interface IFlying{
    //接口中的成員變量默認都是被public static final修飾的常量
    //這里的成員變量不可改變
   public static final int a =10;
}

接口中的成員方法：

interface IFlying{
    //接口中的成員方法都是抽象方法，默認是public abstract 
    //其中public abstract 可以被省略
    //接口中的成員方法不能有具體的實現(xiàn)
    public abstract void eat();
    //一般就寫成：
    //void eat();
    default void sleep(){
        //接口中的方法想要具體實現(xiàn)，要加上default修飾
    }
    //接口中可以有靜態(tài)方法的具體實現(xiàn)
    public static void method() {
        System.out.println("我是靜態(tài)的方法!!");
    }
}

接口能否實例化？？？

接口是不能被實例化的。

怎么使用接口？？？

實現(xiàn)的接口如下：

interface IFlying{
    void eat();
}
interface IRunning{
    void run();
}
interface ISwimming{
    void swim();
}
interface IClimbing{
    void climb();
}

//創(chuàng)建一個Ant類 
//利用implements關鍵字來實現(xiàn)接口
//一個類可以實現(xiàn)多個接口，接口之間利用逗號連接
//實現(xiàn)了接口必須要在接口中重寫接口中的方法
//重寫方法快捷鍵：鼠標移動到implements關鍵字上然后 alt+enter
class Ant implements IClimbing,IRunning{
    public String name;
    @Override
    public void run() {
        System.out.println(this.name+"要跑步");
    }
    @Override
    public void climb() {
        System.out.println(this.name+"爬山");
    }
}

接口的使用時利用implements關鍵字與類連接，類與接口之間使用implements連接的。
一個類可以實現(xiàn)多個接口，多個接口之間利用逗號連接。
class Ant implements IClimbing,IRunning.的意思是類Ant可以實現(xiàn)兩個功能，既可以爬又可以跑。
類實現(xiàn)接口時，必須要重寫接口中的方法。如果不重寫該類還是抽象類，要用abstract來修飾。
接口能否有靜態(tài)方法和代碼塊呢？？？

接口中是不能有靜態(tài)代碼塊和構造方法的。

接口間的繼承

我們這里總結一下類與接口之間的聯(lián)系

類與類之間是繼承關系利用extends來連接代表子類繼承了父類
類與接口之間是利用implements來連接，代表類能實現(xiàn)某個功能
接口與接口之間也可以進行聯(lián)系，利用extends 接口A和接口B interface A enxtends B 代表接口A拓展了接口B的功能。

這里來講一下接口與接口之間的繼承

我們利用extends關鍵字將兩個接口連接起來，這樣就實現(xiàn)了接口之間的繼承。

例如：

interface IRunning extends IFlying{
    //類IRunning拓展了IFlying的功能
    void run();
    //接口與接口之間繼承后IRunning拓展了IFlying功能
    //有了IRunning的功能的類也要重寫IFlying這個方法
}

類IRunning拓展了IFlying的功能
接口與接口之間繼承后IRunning拓展了IFlying功能
有了IRunning的功能的類也要重寫IFlying這個方法

幾個重要的接口

接口comparable

我們這里舉一個例子：

比如我們要進行給一個學生進行排序，我們之前學過Arrays的sort方法，好我們來嘗試一下這個方法對學生進排序。

class Student{
    public String name;
    public int age;
    public double score;
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student[] student = new Student[4];
        student[0] = new Student("張三",18,88);
        student[1] = new Student("李四",98,98);
        student[2] = new Student("王二麻子",8,18);
        student[3] = new Student("趙老八",58,38);
        System.out.println(Arrays.toString(student));
        Arrays.sort(student);
        System.out.println(Arrays.toString(student));
    }
}

從這里發(fā)現(xiàn)Arrays.sort方法是比較具體的數(shù)字大小的，而我們這里比較學生這個對象并沒有指定,我們究竟依靠什么來比較這個學生對象，目前這個學生有名字，分數(shù)，年齡，我們到底依靠什么比較是根據(jù)我們的需求來定，那我們要具體的比較學生對象的某一個學生怎么比較呢·？？？看報錯信息也就是這個異常，我們需要提供這個comparable這個接口然后重寫這個comparable方法。

怎樣提供接口？？？？

我們根據(jù)類要實現(xiàn)一個接口是利用關鍵字implements來連接的。

然后使用comparable這個接口,尖括號里面寫上你要排序的類。

好這樣我們就實現(xiàn)了這個接口，當然看前面那個紅線就知道會有報錯，這也就是當我們實現(xiàn)一個接口我們必須重寫這個接口中的方法，然后Alt+enter重寫這個接口中的方法。

好，我們就重寫了這樣的一個方法，比如我們要比較年齡按照升序排列：

然后調(diào)用Arrays.sort方法就可以進行排序了。

同樣我們還可以根據(jù)名字排序：

由于，名字是String類型也就是引用類型所以我們要調(diào)用compareTo方法來進行比較。

同樣的我們還可以根據(jù)分數(shù)來排序這個學生對象。

comparator接口-比較器

我們剛才使用comparable這個接口會有一個缺陷，就比如當我們已經(jīng)實現(xiàn)按照年齡排序好了，但是有個人突然把他改成了名字比較，如果是未來做項目開發(fā)的時候，那就會給程序猿造成很大的困擾，就怕有一天別人修改了那段代碼，所以我們就有了這個comparator這個比較器，我們還是把他封裝起來，不用在去學生這個類中去修改。

對學生年齡排序：

class AgeComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}

對學生分數(shù)排序：

class ScoreComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return (int)(o1.score - o2.score);
    }
}

對學生名字排序：

class NameComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}

我們還是利用Arrays.sort方法里面再加一個比較器的這個參數(shù)就可以比較了。

 public static void main(String[] args) {
        Student[] student = new Student[4];
        student[0] = new Student("張三",18,88);
        student[1] = new Student("李四",98,98);
        student[2] = new Student("王二麻子",8,18);
        student[3] = new Student("趙老八",58,38);
        System.out.println(Arrays.toString(student));
        AgeComparator ageComparator = new AgeComparator();
        Arrays.sort(student,ageComparator);
        System.out.println(Arrays.toString(student));
    }

這樣我們將根據(jù)什么排序，實例化對應的對象，通過對象調(diào)用重寫comparator的方法就可以進行比較，不需要擔心類中被修改。

cloneable接口深入理解深拷貝與淺拷貝

我們之前學過數(shù)組中的克隆方法，就是把一個數(shù)組中的內(nèi)容全部拷貝到另外一個數(shù)組中去。

今天我們學的cloneable接口可以將一個對象的屬性拷貝到另外一個對象里面去。

怎么使用cloneable接口

我們創(chuàng)建一個人這個類，人這個類中有兩個屬性，一個是分數(shù)，一個是smartphone這個對象(引用類型)。

class SmartPhone{
    public int money = 9999;
}
class Person{
    public int score = 96;
    SmartPhone smartPhone = new SmartPhone();
}
public class TestDemo {
    public static void main(String[] args){
        Person person1 = new Person();
    }
}

我們現(xiàn)在要將這個person這個類實現(xiàn)cloneable接口，利用implements連接，同樣的我們要重寫這個cloneable這個接口中的方法。

這里我們要注意·重寫cloneable這個方法，它的返回類型是object，object是Java中所有類的父類。

好，完成了接口的操作，我們接下來完成克隆的工作，我們怎么使用clone這個方法來進行克隆呢？？？

淺拷貝：

//淺拷貝
class SmartPhone{
    public int money = 9999;
}
class Person implements  Cloneable{
    public int score = 96;
    SmartPhone smartPhone = new SmartPhone();
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    @Override
    public String toString() {
        return "Person{" +
                "score=" + score +
                ", smartPhone=" + smartPhone +
                '}';
    }
}
public class TestDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person();
        Person person2 = (Person)person1.clone();
        System.out.println(person1.smartPhone.money);
        System.out.println(person2.smartPhone.money);
        person1.smartPhone.money=9;
        System.out.println("===============拷貝之后=================");
        System.out.println(person1.smartPhone.money);
        System.out.println(person2.smartPhone.money);
    }
}

原因是什么呢？？畫一下圖理解一下

這就是淺拷貝，對基本數(shù)據(jù)類型進行值傳遞，對引用數(shù)據(jù)類型進行引用傳遞般的拷貝，此

為淺拷貝。只要將money值進行修改兩個對象的money的值都改變，沒有徹底的拷貝。

深拷貝

//深拷貝
class SmartPhone implements  Cloneable{
    public int money = 9999;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    @Override
    public String toString() {
        return "SmartPhone{" +
                "money=" + money +
                '}';
    }
}
class Person implements  Cloneable{
    public int score = 96;
    SmartPhone smartPhone = new SmartPhone();
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person tmp = (Person)super.clone();
        tmp.smartPhone= (SmartPhone) this.smartPhone.clone();
        return tmp;
    }
    @Override
    public String toString() {
        return "Person{" +
                "score=" + score +
                ", smartPhone=" + smartPhone +
                '}';
    }
}
public class TestDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person();
        Person person2 = (Person)person1.clone();
        System.out.println(person1.smartPhone.money);
        System.out.println(person2.smartPhone.money);
        person1.smartPhone.money=9;
        System.out.println("===============拷貝之后=================");
        System.out.println(person1.smartPhone.money);
        System.out.println(person2.smartPhone.money);
    }
}

此時為深拷貝，進行了徹底的拷貝。對基本數(shù)據(jù)類型進行值傳遞，對引用數(shù)據(jù)類型，創(chuàng)建一個新的對象，并復制其內(nèi)容，此為深拷貝。

到此這篇關于Java超詳細分析抽象類和接口的使用的文章就介紹到這了,更多相關Java抽象類與接口內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章:

java中volatile不能保證線程安全(實例講解)
下面小編就為大家?guī)硪黄猨ava中volatile不能保證線程安全(實例講解)。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧
2017-09-09
SpringBoot中使用MQTT實現(xiàn)消息的訂閱和發(fā)布(示例代碼)
這篇文章主要介紹了SpringBoot中使用MQTT實現(xiàn)消息的訂閱和發(fā)布的相關知識,本文通過實例代碼給大家介紹的非常詳細,感興趣的朋友跟隨小編一起看看吧
2024-06-06
Java/Android引用類型及其使用全面分析
下面小編就為大家?guī)硪黄狫ava/Android引用類型及其使用全面分析。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧
2016-09-09
SpringBoot執(zhí)行定時任務@Scheduled的方法
這篇文章主要介紹了SpringBoot執(zhí)行定時任務@Scheduled的方法，本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下
2020-07-07
Java的線程池ThreadPoolExecutor及多種線程池實現(xiàn)詳解
這篇文章主要介紹了Java的線程池ThreadPoolExecutor及多種線程池實現(xiàn)詳解,ThreadPoolExecutor 使用 int 的高 3 位來表示線程池狀態(tài),低 29 位表示線程數(shù)量,之所以將信息存儲在一個變量中,是為了保證原子性,需要的朋友可以參考下
2024-01-01
基于@RequestParam注解之Spring MVC參數(shù)綁定的利器
這篇文章主要介紹了基于@RequestParam注解之Spring MVC參數(shù)綁定的利器,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教
2025-03-03
ElasticSearch如何設置某個字段不分詞淺析
最近在學習ElasticSearch官方文檔過程中發(fā)現(xiàn)的某個問題,記錄一下希望能幫助到后面的朋友,下面這篇文章主要給大家介紹了關于ElasticSearch如何設置某個字段不分詞的相關資料,需要的朋友可以參考下
2022-04-04
Java yield()線程讓步實現(xiàn)過程解析
這篇文章主要介紹了Java yield()線程讓步實現(xiàn)過程解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
2020-03-03
springboot整合token的實現(xiàn)代碼
這篇文章主要介紹了springboot整合token的實現(xiàn)代碼,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
2019-11-11
java中xml進行報文發(fā)送和解析操作
這篇文章主要介紹了java中xml進行報文發(fā)送和解析操作，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧
2020-10-10