關於Java中的物件、類、抽象類、介面、繼承之間的聯絡

xbhog發表於2021-02-23

Java物件抽象繼承

關於Java中的物件、類、抽象類、介面、繼承之間的聯絡：

導讀：

寒假學習JavaSE基礎，其中的概念屬實比較多，關聯性也比較大，再次將相關的知識點複習一些，並理順其中的關係。

正文：

舉個例子：如果現在要想定義一個動物，那麼動物肯定是一個公共的標準，而這個公共標準就可以通過介面來完成。

在動物中又分為兩類：哺乳動物、卵生動物，而這個標準屬於對動物的標準進一步細化，應該稱為子標準，所以此種關係可以使用介面的繼承來表示。

而不如動物i可以繼續劃分為人、狗、貓等不同的型別，由於這些型別不表示具體的事物標準，所以可以使用抽象類進行表示。

如果要表示處工人或者學生這樣的概念，則肯定是一個具體的定義，則使用類的方式。

然後每個學生或者每個工人都是具體的，那麼就通過物件來表示；

由下面的圖可知，所有的設計中，介面應該是最先被設計出來的，被子類所繼承。

程式碼例項化：

package Java從入門到專案實戰.抽象類與介面;
//動物
interface  animal{
    public abstract String breathe();
}
//哺乳動物---介面繼承extend
//類實現的話--implements
interface mammals extends animal {
//    全域性方法
//    抽象方法
}
//卵生動物
interface Egg_laying_animals extends animal {
//    全域性方法
//    抽象方法
}
//定義人類抽象類（屬於哺乳動物）
abstract class peopel implements mammals{
}
//定義非人類抽象類(輸入哺乳動物)
abstract  class small_animal implements mammals{

}
//學生 屬於人類中
class student extends peopel{
    @Override
    public String breathe() {
        return null;
    }
}
public class 介面綜合 {
    public static void main(String[] args) {
//        物件：類的例項化
        student std = new student();
        System.out.println(std.breathe());
    }
}

介面：

介面的基本定義：

package Java從入門到專案實戰.抽象類與介面;
interface IMessageF{
    //在介面可以定義全域性變數、抽象方法（public許可權）、default方法以及static方法；
    //如果介面中有抽象方法，那麼介面必須需要子類進行例項化
    public static final String INFO = "xbhog";  //全域性變數
    public abstract String getInfo();   //抽象方法
}
class MessageIpml implements IMessageF{
    @Override
    public String getInfo(){    //方法覆寫
        return "hello xbhog!";  //獲取訊息
    }
}

public class 介面的基本使用 {
    public static void main(String[] args) {
        //介面的呼叫  例項化
        IMessageF msg = new MessageIpml();   //子類例項化父類介面
        System.out.println(msg.getInfo());
    }
}

子類實現多個父介面與例項轉換

package Java從入門到專案實戰.抽象類與介面;
interface Imessage1{
    public static final String INFO = "xbhog";
    public abstract String getInfo();
}

interface IChannel{
    public abstract boolean connect();
}
//實現多個介面，繼承了兩個，所以在子類中需要進行覆寫父類中的抽象方法
class MessageImpl1 implements Imessage1,IChannel{
    @Override
    public String getInfo(){
        if(this.connect()){
            return  "部落格地址：www.cnblogs.com/xbhog/";
        }
        return "【預設訊息】"+ Imessage1.INFO;
    }
    @Override
    public boolean connect(){
        return true;
    }
}
public class 子類實現多個父介面 {
    public static void main(String[] args) {
        Imessage1 msg = new MessageImpl1();
        System.out.println(msg.getInfo());
        //--------觀察介面例項轉換-------------
        Imessage1 msg1 = new MessageImpl1();
        Object obj = msg1; //向上轉型
        IChannel channel = (IChannel) obj; //物件強制轉換成IChannel介面例項
        System.out.println(channel.connect());
    }
}

子類繼承抽象類同時實現介面

package Java從入門到專案實戰.抽象類與介面;
//訊息介面
interface IMessage1{
    public static final String INFO = "xbhog";
    public abstract String getInfo();
}
//通道介面
interface IChannel1{
    public abstract boolean connect();
}
//定義一個抽象類
abstract class DatabaseAbstract{
    public abstract boolean getDatabaseConnection();
}
//繼承於抽象類，同時實現介面
class MessageImpl2 extends  DatabaseAbstract implements IMessage1,IChannel1{
    @Override
    public String getInfo() {
        if (this.connect()){
            if(this.getDatabaseConnection()){
                return  "【資料庫訊息】部落格地址：https://www.cnblogs.com/xbhog/";
            }else {
                return "資料庫訊息無法訪問！";
            }
        }
        return "【預設訊息】："+IMessage1.INFO;
    }

    @Override
    public boolean connect() {
        return true;
    }

    @Override
    public boolean getDatabaseConnection() {
        return true;
    }
}

public class 子類繼承抽象類並實現介面 {
    public static void main(String[] args) {
        IMessage1 msg = new MessageImpl2();
        System.out.println(msg.getInfo());
    }
}

extends繼承多個父介面

關於介面的簡化：在定義介面時，對於全域性常量和抽象方法可以省略static final與 abstract關鍵字;

package Java從入門到專案實戰.抽象類與介面;
interface Imessage3{
    public static final String INFO = "xbhog";
    public abstract String getInfo();
}
interface IChannel3{
    public boolean connect();  //抽象方法，省略了abstract;
}

interface IService extends Imessage3,IChannel3{
    public String service();   //抽象方法，省略了abstract;
}
class MessageService implements  IService{
    @Override
    public String getInfo() {
        return Imessage3.INFO;
    }

    @Override
    public boolean connect() {
        return false;
    }

    @Override
    public String service() {
        return "【資料庫訊息服務】：https://www.cnblogs.com/xbhog/";
    }
}
public class 使用extends繼承多個父介面 {
    public static void main(String[] args) {

    }
}

介面的加強

為什麼需要加強介面：首先需要明白，在介面下的子類需要覆寫父類的方法，如果該介面下有1000多個子類，不巧的是介面需要增加方法，那麼每個子類都要覆寫一遍新添的方法，想想都很恐怖；在此基礎上增加了彌補的方法

增加default定義普通方法：便於擴充介面同時簡化設計結構

package Java從入門到專案實戰.抽象類與介面;
interface IMessage{

//    必須覆寫
    public String message();  //抽象類
    public default String messageSmple(){
        return "null";
    };
//    定義介面普通方法，增加了介面的靈活性
//    當子類過多是，增加一個新的方法，那麼需要每個子類都需要覆寫一邊
//    default的普通方法解決了該問題，當子類需要的時候覆寫，不需要時放置
    public default boolean connect(){
        System.out.println("建立關注xbhog的通道....");
        return true;
    }
}

class MessageImpl implements IMessage{
    public String message(){
        return "xbhog";
    }
}

public class 介面定義加強使用default定義普通方法 {
    public static void main(String[] args) {
        IMessage msg = new MessageImpl();
        if(msg.connect()){
            System.out.println(msg.message());
        }
    }
}

default缺點：必須通過介面例項化物件才能呼叫，為了避免例項化物件的依賴，可以使用static方法，隱藏介面呼叫的細節

package Java從入門到專案實戰.抽象類與介面;
interface ImessageS{
    public String message();
//    定義公共方法，被所有子類繼承
    public default boolean connect(){
        System.out.println("建立訂閱xbhog部落格的通道.....");
        return true;
    }
//    建立static靜態方法，可以通過介面名稱直接呼叫
    public static ImessageS getInstance(){
//        獲得子類物件
        return new MessageImple();
    }
}
class MessageImple implements ImessageS{
    public String message(){
        if(this.connect()){
            return "www.cnblogs.com/xbhog";
        }
        return "null";
    }
}

public class 在介面中定義static方法 {
    public static void main(String[] args) {
//        例項化子類介面物件
        ImessageS msg = ImessageS.getInstance();
        System.out.println(msg.message());
    }
}

抽象類：

抽象類的特點：

含有抽象方法的類一定是抽象類
抽象類不一定還有抽象方法
抽象類中既可以有抽象方法也可以有非抽象放方法
如果子類繼承了抽象方法，要麼重寫抽象類中的抽象方法，要麼子類就宣告為抽象類
不能建立物件，因為方法沒有具體實現，建立物件沒有作用，抽象類是用來繼承的

基本定義

abstract class Message{
    private String type;
    public abstract String getConnectInfo();	//抽象方法
    public void setType(String type){   //普通方法
        this.type = type;
    }
}

抽象類的構造方法

package Java從入門到專案實戰.抽象類與介面;
//構造抽象方法
abstract class abMessage{
    private String type;
 	//此時抽象類中沒有提供無參構造方法，所以在子類必須明確呼叫單參構造方法   
    public abMessage(String type){
        this.type = type;
    }
    public abstract String getContentInfo();
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}
class Database extends abMessage{
    //子類構造
    public Database(String type) {
        //呼叫父類單參構造方法
        super(type);
    }
	//覆寫抽象類方法
    @Override
    public String getContentInfo() {
        return "【"+super.getType()+"】資料庫連線資訊";
    }
}
public class 構造方法 {
    public static void main(String[] args) {
        abMessage demo = new Database("xbhog");
        System.out.println(demo.getContentInfo());
    }
}

抽象類中定義static 方法：該類方法不受到抽象類例項化物件的限制

package Java從入門到專案實戰.抽象類與介面;
abstract class message{
    public  abstract String getInfo();
    public static message getInstance(){
        return new datamessage();
    }
}
class datamessage extends message{
    @Override
    public String getInfo() {
        return "xbhog資料庫連線";
    }
}

public class 抽象類定義static {
    public static void main(String[] args) {
        //因為該方法被static修飾，全域性使用message.getInstance相當於new datamessage();
        message mes =  message.getInstance();
        System.out.println(mes.getInfo());
    }
}

模板設計模式

package Java從入門到專案實戰.抽象類與介面;
//抽象三個公共行為
abstract class Action{
    static final int EAT = 1; //吃飯指令
    static final int SLEEP = 5; //睡覺指令
    static final int WORK = 10; //工作指令

    public abstract void eat();
    public abstract void sleep();
    public abstract void work();

    public void command(int code){
        switch (code){
            case EAT:{
                this.eat();
                break;
            }
            case SLEEP:{
                this.sleep();
                break;
            }
            case WORK:{
                this.work();
                break;
            }
            case EAT+SLEEP+WORK:{
                this.eat();
                this.sleep();
                this.work();
                break;
            }
        }
    }
}

//具象化 機器人
class Rebot extends Action{
    @Override
    public void eat() {
        System.out.println("機器人需要接通電源充電");
    }

    @Override
    public void sleep() { } //機器人不需要睡覺

    @Override
    public void work() {
        System.out.println("機器人按照固定的設定進行工作");
    }
}

//具象化 人
class Person extends Action{
    @Override
    public void eat() {
        System.out.println("人需要吃五穀雜糧來維持生命力");
    }

    @Override
    public void sleep() {
        System.out.println("不睡覺會死的");
    }

    @Override
    public void work() {
        System.out.println("每天工作996");
    }
}
//具象化 豬
class pig extends Action{
    @Override
    public void eat() {
        System.out.println("使勁吃，養肥了賣錢");
    }

    @Override
    public void sleep() {
        System.out.println("不睡覺，養不肥");
    }

    @Override
    public void work() {

    }
}

public class 模板設計模式 {
    public static void main(String[] args) {
        Action rebotAction = new Rebot();
        Action personAction = new Person();
        Action pigAction = new pig();
        System.out.println("機器人行為---------");
        rebotAction.command(Action.SLEEP);
        rebotAction.command(Action.WORK);
        System.out.println("人類行為----------");
        personAction.command(Action.WORK+Action.SLEEP+Action.EAT);
        System.out.println("豬的行為-------");
        pigAction.command(Action.SLEEP);

    }
}

綜合案例練習：

實現相關程式碼：

package Java從入門到專案實戰.抽象類與介面;
//定義人這個類
abstract class people{
    private String name;
    private  String age;
    public people() {}
    public people(String name,String age){
        this.name = name;
        this.age= age;
    }

    public abstract void eats();  //定義抽象方法
    public void setName(String name) {
        this.name = name;
    }

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

    public String getName() {
        return name;
    }

    public String getAge() {
        return age;
    }

}
//定義運動員抽象類
abstract class athletes extends people{
    public  athletes(){}
    public athletes(String name, String age){
        super(name,age);
    }
//    抽象方法
    public abstract void  study();
}
interface speakEnglish{
    public abstract void speak();
}

//定義教練的抽象類
abstract class coach extends people{
    public coach(){}
    public coach(String name,String age){
        super(name,age);
    }
    public abstract void teach();
}
//籃球運動員
class Basketball_player extends athletes{
    public Basketball_player(String name, String age){
        super(name,age);
    }
    @Override
    public void eats() {
        System.out.println("籃球運動員正在吃飯....");
    }

    @Override
    public void study() {
        System.out.println("籃球運動員正在學習......");
    }
}
//乒乓球遠動員
class pingpang extends athletes implements speakEnglish{
    public pingpang(String name, String age){
        super(name,age);
    }
    @Override
    public void eats() {
        System.out.println("乒乓球運動員正在吃飯....");
    }

    @Override
    public void study() {
        System.out.println("乒乓球運動員正在學習......");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球運動員練習英語口語......");
    }
}
//乒乓球教練
class pingpangCoach extends coach implements  speakEnglish{
    public pingpangCoach(String name, String age){
        super(name,age);
    }
    @Override
    public void eats() {
        System.out.println("乒乓球教練正在吃飯.....");
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教練正在授課....");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球教練練習英語口語.....");
    }
}
//籃球教練
class BasketballCoach extends coach{
    public BasketballCoach(String name, String age){
        super(name, age);
    }
    @Override
    public void eats() {
        System.out.println("籃球教練正在吃飯");
    }

    @Override
    public void teach() {
        System.out.println("籃球教練正在授課......");
    }
}
public class 綜合案例實現 {
    public static void main(String[] args) {

    }
}

結束：

整理最近學習Java的相關概念，理清思路。

如果有錯誤歡迎指正，感謝各位看到最後！

Java之繼承和抽象類
2021-03-25
Java繼承抽象
物件導向 -- 三大特性之繼承補充抽象類介面類
2019-03-28
物件繼承抽象
【JAVA】筆記（5）--- final；抽象方法；抽象類；介面；解析繼承，關聯，與實現；
2021-11-13
Java筆記抽象繼承
PHP 抽象類繼承抽象類時的注意點PHP 抽象類繼承抽象類時的注意點
2021-09-09
PHP抽象繼承
介面、抽象類、普通類之間的關係
2021-01-02
抽象
java-介面和抽象類的聯絡和區別。
2019-01-08
Java抽象
JAVA類的頂層Type抽象和繼承關係
2020-10-07
Java抽象繼承
Java基礎10 介面的繼承與抽象類
2019-11-15
Java繼承抽象
介面是否可繼承(extends)介面? 抽象類是否可實現 (implements)介面? 抽象類是否可繼承具體類(concrete class)?
2020-11-06
繼承抽象
Java抽象類、繼承及多型和介面卡的實現
2021-06-14
Java抽象繼承多型
java關於繼承父類,需要實現父類中的構造方法
2024-04-18
Java繼承構造方法
java中的抽象類與介面
2020-11-13
Java抽象
Java集合為什麼設計為：實現類繼承了抽象類，同時實現抽象類實現的介面
2022-01-08
Java繼承抽象
Java的抽象類 & 介面
2023-05-10
Java抽象
類的繼承_子類繼承父類
2019-05-13
繼承
類的繼承，介面的使用
2024-06-06
繼承
JAVA學習線路：day01物件導向（繼承、抽象類）
2020-10-10
Java物件繼承抽象
聊聊TypeScript中類、介面之間相互繼承與實現的那些事兒
2019-01-11
TypeScript繼承
java中抽象類和介面
2020-04-04
Java抽象
TypeScript 介面繼承類
2019-03-05
TypeScript繼承
6-2 抽象類的繼承 (5分)
2020-10-23
抽象繼承
Java中的類繼承與多型
2024-07-15
Java繼承多型
Java 的抽象類, 介面以及內部類
2023-03-02
Java抽象
Java中的介面與抽象類詳解
2024-07-15
Java抽象
第二十八節：Java基礎-進階繼承，抽象類，介面
2021-09-09
Java繼承抽象
C#介面、抽象類、普通類和繼承（子類與父類）都有其特定的用途和場景
2024-04-30
C#抽象繼承
Java的抽象類與介面理解
2020-12-03
Java抽象
類的繼承
2018-07-30
繼承
關於Java中的類和物件筆記
2024-09-11
Java物件筆記
物件、原型鏈、類、繼承【上】
2019-10-10
物件原型繼承
【java】類之間的關係
2020-11-30
Java
關於抽象類和介面的初步理解
2019-02-16
抽象
Java中的介面與抽象類設計原則
2024-07-22
Java抽象
如何講清楚 Java 物件導向的問題與知識？（類與物件，封裝，繼承，多型，介面，內部類...）
2021-01-28
Java物件封裝繼承多型
Golang物件導向程式設計之繼承&虛基類【組合&介面】
2018-08-10
Golang物件程式設計繼承
Python類的繼承
2019-03-10
Python繼承
20200109 - 類的繼承
2020-01-09
繼承
JAVA物件導向--抽象類
2024-03-11
Java物件抽象

關於Java中的物件、類、抽象類、介面、繼承之間的聯絡

關於Java中的物件、類、抽象類、介面、繼承之間的聯絡：

導讀：

正文：

介面：

抽象類：

綜合案例練習：

結束：

相關文章