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

xbhog 發表於 2021-02-23
Java

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

導讀:

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

正文:

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

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

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

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

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

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

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

程式碼例項化:

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());
    }
}

介面:

  1. 介面的基本定義:

    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());
        }
    }
    
  2. 子類實現多個父介面與例項轉換

    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());
        }
    }
    
  3. 子類繼承抽象類同時實現介面

    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());
        }
    }
    
  4. 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) {
    
        }
    }
    
  5. 介面的加強

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

    1. 增加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());
              }
          }
      }
      
    2. 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());
          }
      }
      

抽象類:

抽象類的特點:

  1. 含有抽象方法的類一定是抽象類

  2. 抽象類不一定還有抽象方法

  3. 抽象類中既可以有抽象方法也可以有非抽象放方法

  4. 如果子類繼承了抽象方法,要麼重寫抽象類中的抽象方法,要麼子類就宣告為抽象類

  5. 不能建立物件,因為方法沒有具體實現,建立物件沒有作用,抽象類是用來繼承的

  6. 基本定義

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

    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());
        }
    }
    
  8. 抽象類中定義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());
        }
    }
    
  9. 模板設計模式

    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);
    
        }
    }
    

綜合案例練習:

image-20210221215011157

實現相關程式碼:

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的相關概念,理清思路。

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