Java入門基礎(chǔ)之抽象類與接口
一.抽象類
1.什么是抽象類
首先我們來回顧一下上一篇文章提到的一個(gè)例子：打印圖形
class Shape {
public void draw() {
// 啥都不用干
}
}
class Cycle extends Shape {
@Override
public void draw() {
System.out.println("○");
}
}
class Rect extends Shape {
@Override
public void draw() {
System.out.println("□");
}
}
class Flower extends Shape {
@Override
public void draw() {
System.out.println("?");
}
}
/我是分割線//
public class Test {
public static void main(String[] args) {
Shape shape1 = new Flower();
Shape shape2 = new Cycle();
Shape shape3 = new Rect();
drawMap(shape1);
drawMap(shape2);
drawMap(shape3);
}
// 打印單個(gè)圖形
public static void drawShape(Shape shape) {
shape.draw();
}
}
我們發(fā)現(xiàn)， 父類 Shape 中的 draw 方法好像并沒有什么實(shí)際工作，主要的繪制圖形都是由 Shape 的各種子類的 draw 方法來完成的。
像這種沒有實(shí)際工作的方法， 我們可以把它設(shè)計(jì)成一個(gè) 抽象方法(abstractmethod)，包含抽象方法的類我們稱為 抽象類(abstract class)
2.語法規(guī)則
那么，抽象類到底怎么寫呢？請(qǐng)看代碼：
abstract class Shape {
abstract public void draw();
}
在 draw 方法前加上 abstract 關(guān)鍵字， 表示這是一個(gè)抽象方法。 同時(shí)抽象方法沒有方法體(沒有 { },不能執(zhí)行具體代碼)
對(duì)于包含抽象方法的類, 必須加上 abstract 關(guān)鍵字表示這是一個(gè)抽象類
注意事項(xiàng)：
抽象類不能直接實(shí)例化：
Shape shape = new Shape(); // 編譯出錯(cuò) Error:(30, 23) java: Shape是抽象的; 無法實(shí)例化
抽象方法不能是 private 的：
abstract class Shape {
abstract private void draw();
}
// 編譯出錯(cuò)
Error:(4, 27) java: 非法的修飾符組合: abstract和private
抽象類中可以包含其他的非抽象方法，也可以包含字段。這個(gè)非抽象方法和普通方法的規(guī)則都是一樣的，可以被重寫，也可以被子類直接調(diào)用：
abstract class Shape {
abstract public void draw();
void func() {
System.out.println("func");
}
}
class Rect extends Shape {
}
public class Test {
public static void main(String[] args) {
Shape shape = new Rect();
shape.func();
}
}
// 執(zhí)行結(jié)果
func
3.抽象類的作用
抽象類存在的最大意義就是為了被繼承
抽象類本身不能被實(shí)例化，要想使用，只能創(chuàng)建該抽象類的子類，然后讓子類重寫抽象類中的抽象方法。
那大家可能有一個(gè)疑問，普通的類也可以被繼承， 普通的方法也可以被重寫呀，為啥非得用抽象類和抽象方法呢?
確實(shí)如此，但是使用抽象類相當(dāng)于多了一重編譯器的校驗(yàn)：
使用抽象類的場(chǎng)景就如上面的代碼， 實(shí)際工作不應(yīng)該由父類完成， 而應(yīng)由子類完成。
那么此時(shí)如果不小心誤用成父類了，使用普通類編譯器是不會(huì)報(bào)錯(cuò)的。 但是父類是抽象類就會(huì)在實(shí)例化的時(shí)候提示錯(cuò)誤，讓我們盡早發(fā)現(xiàn)問題。
很多語法存在的意義都是為了 “預(yù)防出錯(cuò)”，例如我們?cè)?jīng)用過的 final 也是類似。 創(chuàng)建的變量用戶不去修改， 不就相當(dāng)于常量嘛? 但是加上 final 能夠在不小心誤修改的時(shí)候，讓編譯器及時(shí)提醒我們。
充分利用編譯器的校驗(yàn), 在實(shí)際開發(fā)中是非常有意義的。
二.接口
1.什么是接口
接口是抽象類的更進(jìn)一步。抽象類中還可以包含 非抽象方法 和字段。而接口中包含的方法都是抽象方法, 字段只能包含靜態(tài)常量
2.語法規(guī)則
在剛才的打印圖形的示例中，我們的父類 Shape 并沒有包含別的非抽象方法，也可以設(shè)計(jì)成一個(gè)接口：
interface IShape {
void draw();
}
class Cycle implements IShape {
@Override
public void draw() {
System.out.println("○");
}
}
public class Test {
public static void main(String[] args) {
IShape shape = new Rect();
shape.draw();
}
}
- 使用 interface 定義一個(gè)接口
- 接口中的方法一定是抽象方法，因此可以省略 abstract
- 接口中的方法一定是 public ，因此可以省略 public
- Cycle 使用 implements 繼承接口。此時(shí)表達(dá)的含義不再是 “擴(kuò)展”， 而是 “實(shí)現(xiàn)”
- 在調(diào)用的時(shí)候同樣可以創(chuàng)建一個(gè)接口的引用，對(duì)應(yīng)到一個(gè)子類的實(shí)例
- 接口不能單獨(dú)被實(shí)例化
- 從jdk1.8開始，接口中的普通方法可以有具體實(shí)現(xiàn)，但這個(gè)方法必須是default修飾的。
擴(kuò)展(extends) vs 實(shí)現(xiàn)(implements)：
- 擴(kuò)展指的是當(dāng)前已經(jīng)有一定的功能了，進(jìn)一步擴(kuò)充功能
- 實(shí)現(xiàn)指的是當(dāng)前啥都沒有，需要從頭構(gòu)造出來
注意事項(xiàng)：
接口中只能包含抽象方法。 對(duì)于字段來說， 接口中只能包含靜態(tài)常量(final static)：
interface IShape {
void draw();
public static final int num = 10;
}
其中的 public, static, final 的關(guān)鍵字都可以省略.省略后的 num 仍然表示 public 的靜態(tài)常量
總結(jié)：
- 我們創(chuàng)建接口的時(shí)候， 接口的命名一般以大寫字母 I 開頭
- 接口的命名一般使用 “形容詞” 詞性的單詞
- 阿里編碼規(guī)范中約定，接口中的方法和屬性不要加任何修飾符號(hào)，保持代碼的簡(jiǎn)潔性
一段易錯(cuò)的代碼：
interface IShape {
abstract void draw() ; // 即便不寫public，也是public
}
class Rect implements IShape {
void draw() {
System.out.println("□") ; //權(quán)限更加嚴(yán)格了，所以無法重寫
}
}
3.實(shí)現(xiàn)多個(gè)接口
有的時(shí)候我們需要讓一個(gè)類同時(shí)繼承多個(gè)父類。這件事情在有些編程語言通過 多繼承 的方式來實(shí)現(xiàn)的。
然而 Java 中只支持單繼承， 一個(gè)類只能 extends 一個(gè)父類。但是可以同時(shí)實(shí)現(xiàn)多個(gè)接口 ，也能達(dá)到多繼承類似的效果。
現(xiàn)在我們通過類來表示一組動(dòng)物:
class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}
另外我們?cè)偬峁┮唤M接口，分別表示 “會(huì)飛的” “會(huì)跑的” “會(huì)游泳的” :
interface IFlying {
void fly();
}
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
接下來我們創(chuàng)建幾個(gè)具體的動(dòng)物
貓，是會(huì)跑的 :
class Cat extends Animal implements IRunning {
public Cat(String name) {
super(name);
}
@Override
public void run() {
System.out.println(this.name + "正在用四條腿跑");
}
}
魚，是會(huì)游的 :
class Fish extends Animal implements ISwimming {
public Fish(String name) {
super(name);
}
@Override
public void swim() {
System.out.println(this.name + "正在用尾巴游泳");
}
}
青蛙，既能跑，又能游 :
class Frog extends Animal implements IRunning, ISwimming {
public Frog(String name) {
super(name);
}
@Override
public void run() {
System.out.println(this.name + "正在往前跳");
}
@Override
public void swim() {
System.out.println(this.name + "正在蹬腿游泳");
}
}
PS : IDEA 中使用 ctrl + i 快速實(shí)現(xiàn)接口
還有一種神奇的動(dòng)物，水陸空三棲，叫做 “鴨子” :
class Duck extends Animal implements IRunning, ISwimming, IFlying {
public Duck(String name) {
super(name);
}
@Override
public void fly() {
System.out.println(this.name + "正在用翅膀飛");
}
@Override
public void run() {
System.out.println(this.name + "正在用兩條腿跑");
}
@Override
public void swim() {
System.out.println(this.name + "正在漂在水上");
}
}
上面的代碼展示了 Java 面向?qū)ο缶幊讨凶畛Ｒ姷挠梅?: 一個(gè)類繼承一個(gè)父類，同時(shí)實(shí)現(xiàn)多種接口
繼承表達(dá)的含義是 is - a 語義，而接口表達(dá)的含義是 具有 xxx 特性
貓是一種動(dòng)物，具有會(huì)跑的特性
青蛙也是一種動(dòng)物，既能跑，也能游泳
鴨子也是一種動(dòng)物， 既能跑， 也能游，還能飛
這樣設(shè)計(jì)有什么好處呢?
時(shí)刻牢記多態(tài)的好處，讓我們忘記類型.有了接口之后，類的使用者就不必關(guān)注具體類型， 而只關(guān)注某個(gè)類是否具備某種能力
例如, 現(xiàn)在實(shí)現(xiàn)一個(gè)方法, 叫 “散步”:
public static void walk(IRunning running) {
System.out.println("我?guī)е锇槿ド⒉?);
running.run();
}
在這個(gè) walk 方法內(nèi)部，我們并不關(guān)注到底是哪種動(dòng)物，只要參數(shù)是會(huì)跑的， 就行:
Cat cat = new Cat("小貓");
walk(cat);
Frog frog = new Frog("小青蛙");
walk(frog);
// 執(zhí)行結(jié)果
我?guī)е锇槿ド⒉?
小貓正在用四條腿跑
我?guī)е锇槿ド⒉?
小青蛙正在往前跳
甚至參數(shù)可以不是 “動(dòng)物”，只要會(huì)跑!
class Robot implements IRunning {
private String name;
public Robot(String name) {
this.name = name;
}
@Override
public void run() {
System.out.println(this.name + "正在用輪子跑");
}
}
Robot robot = new Robot("機(jī)器人");
walk(robot);
// 執(zhí)行結(jié)果
機(jī)器人正在用輪子跑
4.接口之間的繼承
接口可以繼承一個(gè)接口，達(dá)到復(fù)用的效果.使用 extends 關(guān)鍵字:
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
// 兩棲的動(dòng)物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
}
通過接口繼承創(chuàng)建一個(gè)新的接口 IAmphibious 表示 “兩棲的”
此時(shí)實(shí)現(xiàn)接口創(chuàng)建的 Frog 類， 就繼續(xù)要實(shí)現(xiàn) run 方法，也需要實(shí)現(xiàn) swim 方法，接口間的繼承相當(dāng)于把多個(gè)接口合并在一起
三.接口的使用實(shí)例
1. Comparable 接口
剛才的例子比較抽象, 我們?cè)賮硪粋€(gè)更能實(shí)際的例子,給對(duì)象數(shù)組排序 :
給定一個(gè)學(xué)生類
class Student {
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "[" + this.name + ":" + this.score + "]";
}
}
再給定一個(gè)學(xué)生對(duì)象數(shù)組, 對(duì)這個(gè)對(duì)象數(shù)組中的元素進(jìn)行排序(按分?jǐn)?shù)降序):
Student[] students = new Student[] {
new Student("張三", 95),
new Student("李四", 96),
new Student("王五", 97),
new Student("趙六", 92),
};
按照我們之前的理解, 數(shù)組我們有一個(gè)現(xiàn)成的 sort 方法,我們來試試能否直接用sort方法進(jìn)行排序:
仔細(xì)思考, 不難發(fā)現(xiàn)學(xué)生和普通的整數(shù)不一樣, 兩個(gè)整數(shù)是可以直接比較的, 大小關(guān)系明確. 而兩個(gè)學(xué)生對(duì)象的大小關(guān)系怎么確定? 需要我們額外指定
讓我們的 Student 類實(shí)現(xiàn) Comparable 接口, 并實(shí)現(xiàn)其中的 compareTo 方法:
class Student implements Comparable {
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "[" + this.name + ":" + this.score + "]";
}
@Override
public int compareTo(Object o) {
Student s = (Student)o;
if (this.score > s.score) {
return -1;
} else if (this.score < s.score) {
return 1;
} else {
return 0;
}
}
}
在 sort 方法中會(huì)自動(dòng)調(diào)用 compareTo 方法. compareTo 的參數(shù)是 Object , 其實(shí)傳入的就是 Student 類型的對(duì)象
然后比較當(dāng)前對(duì)象和參數(shù)對(duì)象的大小關(guān)系(按分?jǐn)?shù)來算):
- 如果當(dāng)前對(duì)象應(yīng)排在參數(shù)對(duì)象之前, 返回小于 0 的數(shù)字
- 如果當(dāng)前對(duì)象應(yīng)排在參數(shù)對(duì)象之后, 返回大于 0 的數(shù)字
- 如果當(dāng)前對(duì)象和參數(shù)對(duì)象不分先后, 返回 0
我們?cè)俅螆?zhí)行一下:
這時(shí)候結(jié)果就符合我們預(yù)期了(￣▽￣)*
compareTo其實(shí)就是一個(gè)比較規(guī)則 , 如果我們想自定義比較類型的話 , 一定要實(shí)現(xiàn)可以比較的接口 . 但是 , Comparable接口有個(gè)很大的缺點(diǎn) , 那就是對(duì)類的侵入性很強(qiáng) , 所以我們一般不輕易改動(dòng)
2.Comparator接口
剛才我們提到了Comparable接口對(duì)類的侵入性很強(qiáng) , 那么有沒有一個(gè)比較靈活的接口供我們使用呢? 答案是肯定的 , 那就是Comparator接口
我們先來寫一個(gè)用年齡進(jìn)行比較的比較器:
class AgeComparator implements Comparator<Student>{
@Override
public int compare(Student o1,Student o2) {
return o1.age - o2.age;
}
}
再來寫一個(gè)用姓名進(jìn)行比較的比較器:
class NameComparator implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
return o1.name.compareTo(o2.name);
}
}
這時(shí)候,我們實(shí)例化這兩個(gè)比較器,并且在sort方法中傳入要排列的數(shù)組和我們寫的比較器對(duì)象 :
class Student implements Comparable<Student>{
public int age;
public String name;
public Student(int age, String name, double score) {
this.age = age;
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
public class Test {
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] = new Student(12,"af");
students[1] = new Student(6,"be");
students[2] = new Student(18,"zhangsan");
System.out.println("按年齡排序：");
AgeComparator ageComparator = new AgeComparator();
Arrays.sort(students,ageComparator);
System.out.println(Arrays.toString(students));
System.out.println("---------------------------");
System.out.println("按姓名排序：");
NameComparator nameComparator = new NameComparator();
Arrays.sort(students,nameComparator);
System.out.println(Arrays.toString(students));
}
}
運(yùn)行結(jié)果:
所以 Comparator接口 只需要根據(jù)自己的需求重新寫比較器就 ok 了, 靈活很多, 而不是像Comparable接口直接就寫死了
3.Clonable接口
Java 中內(nèi)置了一些很有用的接口 , Clonable 就是其中之一
Object 類中存在一個(gè) clone 方法, 調(diào)用這個(gè)方法可以創(chuàng)建一個(gè)對(duì)象的 “拷貝”. 但是要想合法調(diào)用 clone 方法, 必須要先實(shí)現(xiàn) Clonable 接口, 否則就會(huì)拋出 CloneNotSupportedException 異常
實(shí)現(xiàn)Clonable接口
別忘了要拋出異常
重寫Object的clone方法
我們來看一個(gè)例子 :
class Person implements Cloneable{
public int age;
@Override
public String toString() {
return "Person{" +
"age=" + age +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class TestDemo {
public static void main(String[] args) throws CloneNotSupportedException{
Person person = new Person();
person.age = 99;
Person person2 = (Person) person.clone();
System.out.println(person2);
}
}
運(yùn)行結(jié)果:
此時(shí)內(nèi)存如下:
這時(shí)候,我們?cè)賮砑右粋€(gè)Money類,并且在Person類中實(shí)例化它:
class Money implements Cloneable{
public double m = 12.5;
}
}
class Person implements Cloneable{
public int age;
public Money money = new Money();
@Override
public String toString() {
return "Person{" +
"age=" + age +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
我們?cè)趐erson2中拷貝一份money的值,這時(shí)候修改person2中的money,那么person1的money是否改變呢?
public class TestDemo {
public static void main(String[] args) throws CloneNotSupportedException{
Person person = new Person();
Person person2 = (Person) person.clone();
System.out.println(person.money.m);
System.out.println(person2.money.m);
System.out.println("-------------------------");
person2.money.m = 13.5;
System.out.println(person.money.m);
System.out.println(person2.money.m);
}
}
答案是不會(huì)改變!
那么是否說明Clonable接口就是只能實(shí)現(xiàn)淺拷貝呢?
答案也是否 , 決定深淺拷貝的并不是 方法的用途 , 而是代碼的實(shí)現(xiàn) !
我們來看看此時(shí)的內(nèi)存分布圖:
要想實(shí)現(xiàn)深拷貝,我們拷貝person的時(shí)候就要把person對(duì)象里的money也拷貝一份,讓person2的money指向 新拷貝出來的money ,這時(shí)候咱們就實(shí)現(xiàn)了深拷貝
具體的操作實(shí)現(xiàn)只需要將Money類重寫clone方法(方便克隆),然后將Person中的clone方法進(jìn)行修改 ,將money也進(jìn)行拷貝即可
具體代碼如下 :
class Money implements Cloneable{
public double m = 12.5;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Person implements Cloneable{
public int age;
public Money money = new Money();
@Override
public String toString() {
return "Person{" +
"age=" + age +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
Person tmp = (Person) super.clone();
tmp.money = (Money) this.money.clone();
return tmp;
// return super.clone();
}
}
我們來測(cè)試一下 :
public class TestDemo {
public static void main(String[] args) throws CloneNotSupportedException{
Person person = new Person();
Person person2 = (Person) person.clone();
System.out.println(person.money.m);
System.out.println(person2.money.m);
System.out.println("-------------------------");
person2.money.m = 13.5;
System.out.println(person.money.m);
System.out.println(person2.money.m);
}
這樣就成功實(shí)現(xiàn)了深拷貝 !
四.總結(jié)
抽象類和接口都是 Java 中多態(tài)的常見使用方式
抽象類中可以包含普通方法和普通字段, 這樣的普通方法和字段可以被子類直接使用(不必重寫), 而接口中不能包含普通方法, 子類必須重寫所有的抽象方法
到此這篇關(guān)于Java入門基礎(chǔ)之抽象類與接口的文章就介紹到這了,更多相關(guān)Java抽象類與接口內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
這篇文章主要介紹了java如何判斷時(shí)間段是否交叉重疊問題,具有很好的參考價(jià)值,希望對(duì)大家有所幫助,如有錯(cuò)誤或未考慮完全的地方,望不吝賜教2023-12-12
Spring框架 引入@Resource注解報(bào)空指針的解決
這篇文章主要介紹了Spring框架 引入@Resource注解報(bào)空指針的解決，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教2021-11-11
這篇文章主要介紹了詳解租約機(jī)制以及在hbase中的應(yīng)用的相關(guān)資料,需要的朋友可以參考下2017-02-02
這篇文章主要介紹了Java數(shù)組基礎(chǔ)詳解，具有一定參考價(jià)值，需要的朋友可以了解下。2017-11-11
這篇文章主要介紹了java的繼承原理與實(shí)現(xiàn)方法,結(jié)合實(shí)例形式詳細(xì)分析了Java繼承的概念、原理、用法及相關(guān)操作注意事項(xiàng),需要的朋友可以參考下2019-05-05
SpringBoot中的multipartResolver上傳文件配置
這篇文章主要介紹了SpringBoot中的multipartResolver上傳文件配置，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教2021-10-10
在本篇文章里小編給大家分享的是關(guān)于java多態(tài)機(jī)制原理特點(diǎn)詳解，有需要的朋友們可以跟著學(xué)習(xí)下。2020-02-02
java 教你如何給你的頭像添加一個(gè)好看的國(guó)旗
這篇文章主要介紹了java 教你如何給你的頭像添加一個(gè)好看的國(guó)旗,文中通過示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2019-09-09
Spring需要三個(gè)級(jí)別緩存解決循環(huán)依賴原理解析
這篇文章主要為大家介紹了Spring需要三個(gè)級(jí)別緩存解決循環(huán)依賴原理解析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2023-02-02
Java如何使用spire進(jìn)行word文檔的替換詳解
創(chuàng)作一份文案經(jīng)常會(huì)高頻率地使用某些詞匯,如地名、人名、人物職位等,若表述有誤,就需要整體撤換,下面這篇文章主要給大家介紹了關(guān)于Java如何使用spire進(jìn)行word文檔的替換的相關(guān)資料,需要的朋友可以參考下2023-01-01