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多個子類，不巧的是接口需要增加方法，那麼每個子類都要覆寫一遍新添的方法，想想都很恐怖；在此基礎上增加瞭彌補的方法
5.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());
}
}
}
5.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());
}
}
抽象類：
抽象類的特點：
- 含有抽象方法的類一定是抽象類
- 抽象類不一定還有抽象方法
- 抽象類中既可以有抽象方法也可以有非抽象放方法
- 如果子類繼承瞭抽象方法，要麼重寫抽象類中的抽象方法，要麼子類就聲明為抽象類
- 不能創建對象，因為方法沒有具體實現，創建對象沒有作用，抽象類是用來繼承的
- 基本定義
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);
}
}
綜合案例練習：
實現相關代碼：
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中的對象、類、抽象類、接口、繼承之間的聯系內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！