Java中的對象、類、抽象類、接口、繼承之間的聯(lián)系

更新時間：2021年02月25日 16:25:49 作者：Xbhog

這篇文章主要介紹了Java中的對象、類、抽象類、接口、繼承之間的聯(lián)系，文章講解的很清晰，有不太懂的同學(xué)可以多研究下

正文：

舉個例子：如果現(xiàn)在要想定義一個動物，那么動物肯定是一個公共的標(biāo)準(zhǔn)，而這個公共標(biāo)準(zhǔn)就可以通過接口來完成。

在動物中又分為兩類：哺乳動物、卵生動物，而這個標(biāo)準(zhǔn)屬于對動物的標(biāo)準(zhǔn)進(jìn)一步細(xì)化，應(yīng)該稱為子標(biāo)準(zhǔn)，所以此種關(guān)系可以使用接口的繼承來表示。

而哺乳動物可以繼續(xù)劃分為人、狗、貓等不同的類型，由于這些類型不表示具體的事物標(biāo)準(zhǔn)，所以可以使用抽象類進(jìn)行表示。

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

然后每個學(xué)生或者每個工人都是具體的，那么就通過對象來表示；

由下面的圖可知，所有的設(shè)計(jì)中，接口應(yīng)該是最先被設(shè)計(jì)出來的，被子類所繼承。

代碼實(shí)例化：

package Java從入門到項(xiàng)目實(shí)戰(zhàn).抽象類與接口;
//動物
interface animal{
 public abstract String breathe();
}
//哺乳動物---接口繼承extend
//類實(shí)現(xiàn)的話--implements
interface mammals extends animal {
// 全局方法
// 抽象方法
}
//卵生動物
interface Egg_laying_animals extends animal {
// 全局方法
// 抽象方法
}
//定義人類抽象類（屬于哺乳動物）
abstract class peopel implements mammals{
}
//定義非人類抽象類(輸入哺乳動物)
abstract class small_animal implements mammals{

}
//學(xué)生 屬于人類中
class student extends peopel{
 @Override
 public String breathe() {
  return null;
 }
}
public class 接口綜合 {
 public static void main(String[] args) {
//  對象：類的實(shí)例化
  student std = new student();
  System.out.println(std.breathe());
 }
}

接口：

1.接口的基本定義：

package Java從入門到項(xiàng)目實(shí)戰(zhàn).抽象類與接口;
interface IMessageF{
 //在接口可以定義全局變量、抽象方法（public權(quán)限）、default方法以及static方法；
 //如果接口中有抽象方法，那么接口必須需要子類進(jìn)行實(shí)例化
 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) {
  //接口的調(diào)用 實(shí)例化
  IMessageF msg = new MessageIpml(); //子類實(shí)例化父類接口
  System.out.println(msg.getInfo());
 }
}

2.子類實(shí)現(xiàn)多個父接口與實(shí)例轉(zhuǎn)換

package Java從入門到項(xiàng)目實(shí)戰(zhàn).抽象類與接口;
interface Imessage1{
 public static final String INFO = "xbhog";
 public abstract String getInfo();
}

interface IChannel{
 public abstract boolean connect();
}
//實(shí)現(xiàn)多個接口，繼承了兩個，所以在子類中需要進(jìn)行覆寫父類中的抽象方法
class MessageImpl1 implements Imessage1,IChannel{
 @Override
 public String getInfo(){
  if(this.connect()){
   return "博客地址：www.cnblogs.com/xbhog/";
  }
  return "【默認(rèn)消息】"+ Imessage1.INFO;
 }
 @Override
 public boolean connect(){
  return true;
 }
}
public class 子類實(shí)現(xiàn)多個父接口 {
 public static void main(String[] args) {
  Imessage1 msg = new MessageImpl1();
  System.out.println(msg.getInfo());
  //--------觀察接口實(shí)例轉(zhuǎn)換-------------
  Imessage1 msg1 = new MessageImpl1();
  Object obj = msg1; //向上轉(zhuǎn)型
  IChannel channel = (IChannel) obj; //對象強(qiáng)制轉(zhuǎn)換成IChannel接口實(shí)例
  System.out.println(channel.connect());
 }
}

3.子類繼承抽象類同時實(shí)現(xiàn)接口

package Java從入門到項(xiàng)目實(shí)戰(zhàn).抽象類與接口;
//消息接口
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();
}
//繼承于抽象類，同時實(shí)現(xiàn)接口
class MessageImpl2 extends DatabaseAbstract implements IMessage1,IChannel1{
 @Override
 public String getInfo() {
  if (this.connect()){
   if(this.getDatabaseConnection()){
    return "【數(shù)據(jù)庫消息】博客地址：https://www.cnblogs.com/xbhog/";
   }else {
    return "數(shù)據(jù)庫消息無法訪問！";
   }
  }
  return "【默認(rèn)消息】："+IMessage1.INFO;
 }

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

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

public class 子類繼承抽象類并實(shí)現(xiàn)接口 {
 public static void main(String[] args) {
  IMessage1 msg = new MessageImpl2();
  System.out.println(msg.getInfo());
 }
}

4.extends繼承多個父接口

關(guān)于接口的簡化：在定義接口時，對于全局常量和抽象方法可以省略static final與 abstract關(guān)鍵字;

package Java從入門到項(xiàng)目實(shí)戰(zhàn).抽象類與接口;
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 "【數(shù)據(jù)庫消息服務(wù)】：https://www.cnblogs.com/xbhog/";
 }
}
public class 使用extends繼承多個父接口 {
 public static void main(String[] args) {

 }
}

5.接口的加強(qiáng)

為什么需要加強(qiáng)接口：首先需要明白，在接口下的子類需要覆寫父類的方法，如果該接口下有1000多個子類，不巧的是接口需要增加方法，那么每個子類都要覆寫一遍新添的方法，想想都很恐怖；在此基礎(chǔ)上增加了彌補(bǔ)的方法

5.1 增加default定義普通方法：便于擴(kuò)充接口同時簡化設(shè)計(jì)結(jié)構(gòu)

package Java從入門到項(xiàng)目實(shí)戰(zhàn).抽象類與接口;
interface IMessage{

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

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

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

5.2 default缺點(diǎn)：必須通過接口實(shí)例化對象才能調(diào)用，為了避免實(shí)例化對象的依賴，可以使用static方法，隱藏接口調(diào)用的細(xì)節(jié)

package Java從入門到項(xiàng)目實(shí)戰(zhàn).抽象類與接口;
interface ImessageS{
 public String message();
// 定義公共方法，被所有子類繼承
 public default boolean connect(){
  System.out.println("建立訂閱xbhog博客的通道.....");
  return true;
 }
// 建立static靜態(tài)方法，可以通過接口名稱直接調(diào)用
 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) {
//  實(shí)例化子類接口對象
  ImessageS msg = ImessageS.getInstance();
  System.out.println(msg.message());
 }
}

抽象類：

抽象類的特點(diǎn)：

含有抽象方法的類一定是抽象類
抽象類不一定還有抽象方法
抽象類中既可以有抽象方法也可以有非抽象放方法
如果子類繼承了抽象方法，要么重寫抽象類中的抽象方法，要么子類就聲明為抽象類
不能創(chuàng)建對象，因?yàn)榉椒]有具體實(shí)現(xiàn)，創(chuàng)建對象沒有作用，抽象類是用來繼承的
基本定義

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

7.抽象類的構(gòu)造方法

package Java從入門到項(xiàng)目實(shí)戰(zhàn).抽象類與接口;
//構(gòu)造抽象方法
abstract class abMessage{
 private String type;
 	//此時抽象類中沒有提供無參構(gòu)造方法，所以在子類必須明確調(diào)用單參構(gòu)造方法 
 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{
 //子類構(gòu)造
 public Database(String type) {
  //調(diào)用父類單參構(gòu)造方法
  super(type);
 }
	//覆寫抽象類方法
 @Override
 public String getContentInfo() {
  return "【"+super.getType()+"】數(shù)據(jù)庫連接信息";
 }
}
public class 構(gòu)造方法 {
 public static void main(String[] args) {
  abMessage demo = new Database("xbhog");
  System.out.println(demo.getContentInfo());
 }
}

8.抽象類中定義static 方法：該類方法不受到抽象類實(shí)例化對象的限制

package Java從入門到項(xiàng)目實(shí)戰(zhàn).抽象類與接口;
abstract class message{
 public abstract String getInfo();
 public static message getInstance(){
  return new datamessage();
 }
}
class datamessage extends message{
 @Override
 public String getInfo() {
  return "xbhog數(shù)據(jù)庫連接";
 }
}

public class 抽象類定義static {
 public static void main(String[] args) {
  //因?yàn)樵摲椒ū籹tatic修飾，全局使用message.getInstance相當(dāng)于new datamessage();
  message mes = message.getInstance();
  System.out.println(mes.getInfo());
 }
}

9.模板設(shè)計(jì)模式

package Java從入門到項(xiàng)目實(shí)戰(zhàn).抽象類與接口;
//抽象三個公共行為
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;
   }
  }
 }
}

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

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

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

//具象化 人
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("使勁吃，養(yǎng)肥了賣錢");
 }

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

 @Override
 public void work() {

 }
}

public class 模板設(shè)計(jì)模式 {
 public static void main(String[] args) {
  Action rebotAction = new Rebot();
  Action personAction = new Person();
  Action pigAction = new pig();
  System.out.println("機(jī)器人行為---------");
  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);

 }
}

綜合案例練習(xí)：

實(shí)現(xiàn)相關(guān)代碼：

package Java從入門到項(xiàng)目實(shí)戰(zhàn).抽象類與接口;
//定義人這個類
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;
 }

}
//定義運(yùn)動員抽象類
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();
}
//籃球運(yùn)動員
class Basketball_player extends athletes{
 public Basketball_player(String name, String age){
  super(name,age);
 }
 @Override
 public void eats() {
  System.out.println("籃球運(yùn)動員正在吃飯....");
 }

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

 @Override
 public void study() {
  System.out.println("乒乓球運(yùn)動員正在學(xué)習(xí)......");
 }

 @Override
 public void speak() {
  System.out.println("乒乓球運(yùn)動員練習(xí)英語口語......");
 }
}
//乒乓球教練
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("乒乓球教練練習(xí)英語口語.....");
 }
}
//籃球教練
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 綜合案例實(shí)現(xiàn) {
 public static void main(String[] args) {

 }
}

到此這篇關(guān)于Java中的對象、類、抽象類、接口、繼承之間的聯(lián)系的文章就介紹到這了,更多相關(guān)Java中的對象、類、抽象類、接口、繼承之間的聯(lián)系內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: