Java超詳細(xì)分析抽象類(lèi)和接口的使用

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

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

什么是抽象類(lèi)

什么是抽象類(lèi)呢？抽象類(lèi)顧名思義就是很抽象，就是當(dāng)我們沒(méi)有足夠的信息去描述這個(gè)類(lèi)的時(shí)候我們就可以先不用描述，這樣的類(lèi)就是抽象類(lèi)。

用代碼舉個(gè)例子：

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

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

我們可以發(fā)現(xiàn)我只用了這兩個(gè)子類(lèi)來(lái)畫(huà)圖形分別是圓形和矩形，我并沒(méi)有調(diào)用父類(lèi)來(lái)實(shí)現(xiàn)這個(gè)方法，為啥呢？？？就是因?yàn)檫@個(gè)父類(lèi)并不能畫(huà)出圖形，那這個(gè)父類(lèi)的draw方法的實(shí)現(xiàn)豈不是沒(méi)有用，我只需要它父類(lèi)要有這方法，通過(guò)子類(lèi)重寫(xiě)就可以了，不需要父類(lèi)的方法有具體的實(shí)現(xiàn)。

沒(méi)錯(cuò)，這就引入到我們今天的主題抽象類(lèi)

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

抽象類(lèi)語(yǔ)法

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

public abstract void draw();

但是這樣為啥會(huì)報(bào)錯(cuò)呢？？

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

但是相反，抽象類(lèi)里面一定有抽象方法么？？？

編譯器并不會(huì)報(bào)錯(cuò)，所以答案是不一定，抽象類(lèi)里面可以有抽象方法也可以沒(méi)有抽象方法。

抽象類(lèi)能否被實(shí)例化呢？？？

所以，抽象類(lèi)是不能實(shí)例化的。

抽象類(lèi)能否像普通類(lèi)一樣定義成員變量和方法，構(gòu)造方法呢？？？

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

既然抽象類(lèi)不能實(shí)例化，那他存在的意義是什么呢？？？

老鐵思考的有道理，其實(shí)抽象類(lèi)最大的意義就是被繼承，因?yàn)槌橄箢?lèi)不能實(shí)例化對(duì)象，只能依靠子類(lèi)來(lái)重寫(xiě)父類(lèi)(就是抽象類(lèi))的方法來(lái)完成業(yè)務(wù)需求。

怎么繼承抽象類(lèi)呢？？？有哪些注意的點(diǎn)呢？？？

這樣繼承為啥會(huì)出錯(cuò)呢？？原因是在子類(lèi)繼承抽象類(lèi)的時(shí)候，子類(lèi)需要重寫(xiě)父類(lèi)的所有方法或者子類(lèi)需要用abstract修飾(抽象類(lèi)被抽象類(lèi)繼承或者子類(lèi)重寫(xiě)抽象類(lèi)(父類(lèi))的所有方法)。

這樣就正確了。

這里還要注意當(dāng)我們沒(méi)有重寫(xiě)父類(lèi)的方法時(shí)而是用abstract來(lái)修飾，這時(shí)當(dāng)你在次繼承這個(gè)子類(lèi)的時(shí)候也就是這個(gè)子類(lèi)變成了父類(lèi)，下一個(gè)子類(lèi)還是要繼續(xù)重寫(xiě)這個(gè)父類(lèi)的方法和這個(gè)父類(lèi)的父類(lèi)的方法。

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

抽象方法不能被static 和final 修飾，因?yàn)樽宇?lèi)要重寫(xiě)父類(lèi)的方法，同時(shí)可以省略訪問(wèn)修飾限定符，默認(rèn)是public。

總結(jié)抽象類(lèi)：

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

接口

說(shuō)到接口我們會(huì)想到什么呢？？？我一開(kāi)始想到的就是充電接口插排等等，比如充電接口，只要符合那個(gè)插口的標(biāo)準(zhǔn)，我們都可以使用那個(gè)接口來(lái)進(jìn)行充電。這就是把標(biāo)準(zhǔn)進(jìn)行統(tǒng)一起來(lái)，然后大家就可以根據(jù)不同的標(biāo)準(zhǔn)來(lái)使用不同的接口，比如蘋(píng)果手機(jī)與安卓手機(jī)的手機(jī)接口就是不一樣的，他們就是兩種不同的標(biāo)準(zhǔn)，安卓手機(jī)用安卓的接口，蘋(píng)果用蘋(píng)果的接口這就將標(biāo)準(zhǔn)統(tǒng)一起來(lái)。

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

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

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

這里我定義了一個(gè)動(dòng)物類(lèi)，這個(gè)動(dòng)物有名字，年齡，還有吃飯的行為。

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 {
}

接著我又定義了一個(gè)魚(yú)類(lèi)(子類(lèi))繼承這個(gè)動(dòng)物類(lèi)(父類(lèi))，我想讓這個(gè)魚(yú)有這個(gè)游泳的行為，但是這就會(huì)有一個(gè)問(wèn)題，在父類(lèi)定義了一個(gè)swim方法，接著我還要定義很多類(lèi)，難道所有的類(lèi)都要有這個(gè)游泳的行為么？？？答案是不可以的。所以我們就不能把這個(gè)swim方法定義在父類(lèi)里面，那我們就可以把這個(gè)方法定義在子類(lèi)(魚(yú)類(lèi))里面，這樣就符合了，但是如果我還要定義1000個(gè)動(dòng)物都會(huì)游泳難道都要在自己類(lèi)中寫(xiě)這個(gè)游泳的方法么？？這樣做顯然是不可行的。那我們?cè)撛趺醋瞿兀浚?/p>

我們可以就提供一個(gè)公共的接口，這也是一種標(biāo)準(zhǔn)，只要符合這一標(biāo)準(zhǔn)都可以使用這個(gè)接口或者可以說(shuō)可以實(shí)現(xiàn)這一功能。

看了上面的引例我們應(yīng)該接口是干什么的了，接下來(lái)我們來(lái)學(xué)一下接口的語(yǔ)法。

怎么定義接口

定義接口要使用interface關(guān)鍵字：

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

接口中的成員變量：

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

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

接口中的成員方法：

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

接口能否實(shí)例化？？？

接口是不能被實(shí)例化的。

怎么使用接口？？？

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

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

//創(chuàng)建一個(gè)Ant類(lèi) 
//利用implements關(guān)鍵字來(lái)實(shí)現(xiàn)接口
//一個(gè)類(lèi)可以實(shí)現(xiàn)多個(gè)接口，接口之間利用逗號(hào)連接
//實(shí)現(xiàn)了接口必須要在接口中重寫(xiě)接口中的方法
//重寫(xiě)方法快捷鍵：鼠標(biāo)移動(dòng)到implements關(guān)鍵字上然后 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+"爬山");
    }
}

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

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

接口間的繼承

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

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

這里來(lái)講一下接口與接口之間的繼承

我們利用extends關(guān)鍵字將兩個(gè)接口連接起來(lái)，這樣就實(shí)現(xiàn)了接口之間的繼承。

例如：

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

類(lèi)IRunning拓展了IFlying的功能
接口與接口之間繼承后IRunning拓展了IFlying功能
有了IRunning的功能的類(lèi)也要重寫(xiě)IFlying這個(gè)方法

幾個(gè)重要的接口

接口comparable

我們這里舉一個(gè)例子：

比如我們要進(jìn)行給一個(gè)學(xué)生進(jìn)行排序，我們之前學(xué)過(guò)Arrays的sort方法，好我們來(lái)嘗試一下這個(gè)方法對(duì)學(xué)生進(jìn)排序。

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ù)字大小的，而我們這里比較學(xué)生這個(gè)對(duì)象并沒(méi)有指定,我們究竟依靠什么來(lái)比較這個(gè)學(xué)生對(duì)象，目前這個(gè)學(xué)生有名字，分?jǐn)?shù)，年齡，我們到底依靠什么比較是根據(jù)我們的需求來(lái)定，那我們要具體的比較學(xué)生對(duì)象的某一個(gè)學(xué)生怎么比較呢·？？？看報(bào)錯(cuò)信息也就是這個(gè)異常，我們需要提供這個(gè)comparable這個(gè)接口然后重寫(xiě)這個(gè)comparable方法。

怎樣提供接口？？？？

我們根據(jù)類(lèi)要實(shí)現(xiàn)一個(gè)接口是利用關(guān)鍵字implements來(lái)連接的。

然后使用comparable這個(gè)接口,尖括號(hào)里面寫(xiě)上你要排序的類(lèi)。

好這樣我們就實(shí)現(xiàn)了這個(gè)接口，當(dāng)然看前面那個(gè)紅線就知道會(huì)有報(bào)錯(cuò)，這也就是當(dāng)我們實(shí)現(xiàn)一個(gè)接口我們必須重寫(xiě)這個(gè)接口中的方法，然后Alt+enter重寫(xiě)這個(gè)接口中的方法。

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

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

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

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

同樣的我們還可以根據(jù)分?jǐn)?shù)來(lái)排序這個(gè)學(xué)生對(duì)象。

comparator接口-比較器

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

對(duì)學(xué)生年齡排序：

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

對(duì)學(xué)生分?jǐn)?shù)排序：

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

對(duì)學(xué)生名字排序：

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

我們還是利用Arrays.sort方法里面再加一個(gè)比較器的這個(gè)參數(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ù)什么排序，實(shí)例化對(duì)應(yīng)的對(duì)象，通過(guò)對(duì)象調(diào)用重寫(xiě)comparator的方法就可以進(jìn)行比較，不需要擔(dān)心類(lèi)中被修改。

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

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

今天我們學(xué)的cloneable接口可以將一個(gè)對(duì)象的屬性拷貝到另外一個(gè)對(duì)象里面去。

怎么使用cloneable接口

我們創(chuàng)建一個(gè)人這個(gè)類(lèi)，人這個(gè)類(lèi)中有兩個(gè)屬性，一個(gè)是分?jǐn)?shù)，一個(gè)是smartphone這個(gè)對(duì)象(引用類(lèi)型)。

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)在要將這個(gè)person這個(gè)類(lèi)實(shí)現(xiàn)cloneable接口，利用implements連接，同樣的我們要重寫(xiě)這個(gè)cloneable這個(gè)接口中的方法。

這里我們要注意·重寫(xiě)cloneable這個(gè)方法，它的返回類(lèi)型是object，object是Java中所有類(lèi)的父類(lèi)。

好，完成了接口的操作，我們接下來(lái)完成克隆的工作，我們?cè)趺词褂胏lone這個(gè)方法來(lái)進(jìn)行克隆呢？？？

淺拷貝：

//淺拷貝
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);
    }
}

原因是什么呢？？畫(huà)一下圖理解一下

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

為淺拷貝。只要將money值進(jìn)行修改兩個(gè)對(duì)象的money的值都改變，沒(méi)有徹底的拷貝。

深拷貝

//深拷貝
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);
    }
}