面向对象高级——接口的基本概念和对象的多态性

2024-08-28 16:08
文章标签 接口 对象 基本概念 高级 面向对象 多态性

本文主要是介绍面向对象高级——接口的基本概念和对象的多态性，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

接口

 需要掌握接口的定义格式及使用
掌握接口与抽象类的关系
具体内容：
接口是Java中最重要的概念，接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。
如果一个类中完全是由全局常量（static final声明）和抽象方法组成，就可以将其定义成一个接口。
接口的定义格式：
interface 接口名称{
   全局常量；
   抽象方法；
}
  
interface A{		// 定义接口Apublic static final String AUTHOR = "刘勋" ;	// 全局常量public abstract void print() ;	// 抽象方法public abstract String getInfo() ;	// 抽象方法
}
对于接口来讲，因为在其定义的时候已经定义了其组成就是全局常量和抽象方法，所以，在开发中往往可以简化其定义 
interface A{		// 定义接口AString AUTHOR = "刘勋" ;	// 全局常量void print() ;	// 抽象方法String getInfo() ;	// 抽象方法
}
以上两种定义方式是完全一样的，没有任何的区别。

实现接口
与抽象类一样，接口的使用也必须通过子类，子类通过implements关键字实现接口。
实现格式：
class 子类 implements 接口A，接口B{

}
 接口的使用中也必须有子类，子类必须覆写全部的抽象方法，implements关键字实现，一个子类可以实现多个接口。如果子类不是抽象类的话，肯定要覆写接口中的全部抽象方法。 
interface A{		// 定义接口Apublic String AUTHOR = "刘勋" ;	// 全局常量public void print() ;	// 抽象方法public String getInfo() ;	// 抽象方法
}
interface B{	// 定义接口Bpublic void say() ;	// 定义抽象方法
}
class X implements A,B{	// X类同时实现A和B两个接口public void say(){System.out.println("Hello World!!!") ;}public String getInfo(){return "HELLO" ;}public void print(){System.out.println("作者：" + AUTHOR) ;}
};
public class InterfaceDemo03{public static void main(String args[]){X x = new X() ;	// 实例化子类对象x.say() ;x.print() ;}
};
接口的实现
以上程序中，一个子类同时实现了两个接口，这样在子类中就必须同时覆写完两个接口中的全部抽象方法。

继承抽象类实现接口：
一个子类可以同时继承抽象类和实现接口。格式如下：
class 子类 extends 抽象类  implements 接口A，接口B，...{} 

interface A{		// 定义接口Apublic String AUTHOR = "刘勋" ;	// 全局常量public void print() ;	// 抽象方法public String getInfo() ;	// 抽象方法
}
abstract class B{	// 定义抽象类Bpublic abstract void say() ;	// 定义抽象方法
}
class X extends B implements A{	// X类线继承B类，再实现A接口public void say(){System.out.println("Hello World!!!") ;}public String getInfo(){return "HELLO" ;}public void print(){System.out.println("作者：" + AUTHOR) ;}
};
public class InterfaceDemo04{public static void main(String args[]){X x = new X() ;	// 实例化子类对象x.say() ;x.print() ;}
};
在使用中，一个抽象类可以实现一个接口，那么对于抽象类的子类则就必须同时覆写接口和抽象类中定义的所有抽象方法。 
interface A{		// 定义接口Apublic String AUTHOR = "李兴华" ;	// 全局常量public void print() ;	// 抽象方法public String getInfo() ;	// 抽象方法
}
abstract class B implements A{	// 定义抽象类B，实现接口Apublic abstract void say() ;	// 定义抽象方法
}
class X extends B{	// X类线继承B类public void say(){System.out.println("Hello World!!!") ;}public String getInfo(){return "HELLO" ;}public void print(){System.out.println("作者：" + AUTHOR) ;}
};
public class InterfaceDemo05{public static void main(String args[]){X x = new X() ;	// 实例化子类对象x.say() ;x.print() ;}
};
接口的继承
一个接口不能继承一个抽象类，但是却可以通过extends关键字同时继承多个接口，实现接口的多继承。
格式：
interface 子接口 extends 父接口A,  父接口B, ...{} 

interface A{		// 定义接口Apublic String AUTHOR = "刘勋" ;	// 全局常量public void printA() ;	// 抽象方法
}
interface B{public void printB() ;
}
interface C extends A,B{public void printC() ;
}
class X implements C{	// X类线继承B类public void printA(){System.out.println("A、Hello World!!!") ;}public void printB(){System.out.println("B、Hello JAVA") ;}public void printC(){System.out.println("C、Hello LX") ;}
};
public class InterfaceDemo06{public static void main(String args[]){X x = new X() ;	// 实例化子类对象x.printA() ;x.printB() ;x.printC() ;}
};

接口的总结：
1、只是阐述了接口的基本概念，而实际的应用并没有阐述。
2、接口是一个特殊的类，只包含全局常量和抽象方法。
    接口中的抽象方法可以不加入abstract而抽象类中的抽象方法必须有abstract关键字声明。
3、一个类只能继承一个父类，但是可以同时实现多个接口。
4、一个接口可以同时继承多个接口，以实现接口的多继承。
5、接口和抽象类一样，都必须依靠子类。
6、一个抽象类可以实现多个接口，但是一个接口；不能继承一个抽象类。

 对象的多态性

多态性：多态性在面向对象中是一个重要的概念，在JAVA中面向对象主要有以下两种主要体现：
方法的重载和覆盖。
对象的多态性。
对象多态性主要应用在抽象类和接口上。
对象的多态性主要分为以下两种类型：
向上转型：子类对象——>父类对象。对于向上转型，程序会自动完成，格式：
              对象向上转型：父类  父类对象 = 子类实例;
向下转型：父类对象——>子类对象。对于向下转型，必须明确的指明要转型的子类类型，格式：
             对象向下转型：子类  子类对象 = (子类)父类实例 
class A{					// 定义类Apublic void fun1(){		// 定义fun1()方法System.out.println("A --> public void fun1(){}") ;}public void fun2(){this.fun1() ;		// 调用fun1()方法}
};
class B extends A{public void fun1(){		// 此方法被子类覆写了System.out.println("B --> public void fun1(){}") ;}public void fun3(){System.out.println("B --> public void fun3(){}") ;}
};
public class PolDemo01{public static void main(String asrgs[]){B b = new B() ;		// 实例化子类对象A a = b ;			// 向上转型关系a.fun1() ;			// 此方法被子类覆写过
//		a.fun3() ;        //错误：子类向上转型后，是无法调用子类拓展的方法或属性的}
};


对于以上的程序，是通过其子类进行父类对象的实例化操作的，则如果调用的方法被子类覆写过，则肯定调用被覆写的方法。
注意点：转型之后，因为操作的是父类对象，所以是无法找到在子类中定义的新方法。
将父类对象变为子类对象成为向下转型，向下转型需要采用强制的手段。 
class A{					// 定义类Apublic void fun1(){		// 定义fun1()方法System.out.println("A --> public void fun1(){}") ;}public void fun2(){this.fun1() ;		// 调用fun1()方法}
};
class B extends A{public void fun1(){		// 此方法被子类覆写了System.out.println("B --> public void fun1(){}") ;}public void fun3(){System.out.println("B --> public void fun3(){}") ;}
};
public class PolDemo02{public static void main(String asrgs[]){A a = new B() ;			// 向上转型关系B b = (B)a ;		// 发生了向下转型关系b.fun1() ;b.fun2() ;b.fun3() ;}
};

在类B中存在三个方法，所以全部可以进行调用。
但是，在进行对象向下转型操作时必须注意一点： 
class A{					// 定义类Apublic void fun1(){		// 定义fun1()方法System.out.println("A --> public void fun1(){}") ;}public void fun2(){this.fun1() ;		// 调用fun1()方法}
};
class B extends A{public void fun1(){		// 此方法被子类覆写了System.out.println("B --> public void fun1(){}") ;}public void fun3(){System.out.println("B --> public void fun3(){}") ;}
};
public class PolDemo03{public static void main(String asrgs[]){A a = new A() ;			// 实例化了一个父类对象B b = (B)a ;		// 发生了向下转型关系b.fun1() ;b.fun2() ;b.fun3() ;}
};

以上异常是第二大出现的异常，此异常出现是在对象转型的时候经常发生的，如果两个没有关系的对象发生了转换关系，则肯定会出现此异常。
 也就是说，如果要想产生对象的向下转型，则肯定必须先产生一个向上的转型关系。A a = new B(); 建立关系。
对象多态性的应用：
要求：设计一个方法，此方法可以接收A类的任意子类对象，并调用方法。
实现一：不使用对象的多态性完成。使用重载完成。 
class A{					// 定义类Apublic void fun1(){		// 定义fun1()方法System.out.println("A --> public void fun1(){}") ;}public void fun2(){this.fun1() ;		// 调用fun1()方法}
};
class B extends A{public void fun1(){		// 此方法被子类覆写了System.out.println("B --> public void fun1(){}") ;}public void fun3(){System.out.println("B --> public void fun3(){}") ;}
};
class C extends A{public void fun1(){		// 此方法被子类覆写了System.out.println("C --> public void fun1(){}") ;}public void fun5(){System.out.println("C --> public void fun5(){}") ;}
};
public class PolDemo04{public static void main(String asrgs[]){fun(new B()) ;	// 传递B的实例fun(new C()) ;	// 传递B的实例}public static void fun(B b){b.fun1() ;		// 调用覆写父类中的fun1()方法}public static void fun(C c){c.fun1() ;		// 调用覆写父类中的fun1()方法}
};

如果按照以上思路，每增加一个子类，则fun方法就必须重载一次，当子类非常多时  就会无比繁琐。
此时，为了解决这个问题，就可以使用对象的多态性完成操作。 
class A{					// 定义类Apublic void fun1(){		// 定义fun1()方法System.out.println("A --> public void fun1(){}") ;}public void fun2(){this.fun1() ;		// 调用fun1()方法}
};
class B extends A{public void fun1(){		// 此方法被子类覆写了System.out.println("B --> public void fun1(){}") ;}public void fun3(){System.out.println("B --> public void fun3(){}") ;}
};
class C extends A{public void fun1(){		// 此方法被子类覆写了System.out.println("C --> public void fun1(){}") ;}public void fun5(){System.out.println("C --> public void fun5(){}") ;}
};
public class PolDemo05{public static void main(String asrgs[]){fun(new B()) ;	// 传递B的实例fun(new C()) ;	// 传递B的实例}public static void fun(A a){a.fun1() ;		// 调用覆写父类中的fun1()方法}
};

如果采用以上的方式，不管有多少子类，代码都可以轻易的完成。

多态性总结：
1、对象多态性的概念
     向上转型：自动完成。
    向下转型：强制。发生向下转型关系之前必须先发生向上转型的关系。
2、对象多态性可以解决方法接收参数的问题。

这篇关于面向对象高级——接口的基本概念和对象的多态性的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1115237。

相关文章

JavaScript中的高级调试方法全攻略指南

JavaScript中的高级调试方法全攻略指南

《JavaScript中的高级调试方法全攻略指南》什么是高级JavaScript调试技巧,它比console.log有何优势,如何使用断点调试定位问题,通过本文,我们将深入解答这些问题,带您从理论到实... 目录观点与案例结合观点1观点2观点3观点4观点5高级调试技巧详解实战案例断点调试：定位变量错误性能分
阅读更多...
SpringBoot实现不同接口指定上传文件大小的具体步骤

SpringBoot实现不同接口指定上传文件大小的具体步骤

《SpringBoot实现不同接口指定上传文件大小的具体步骤》：本文主要介绍在SpringBoot中通过自定义注解、AOP拦截和配置文件实现不同接口上传文件大小限制的方法,强调需设置全局阈值远大于... 目录一  springboot实现不同接口指定文件大小1.1 思路说明1.2 工程启动说明二 具体实施2
阅读更多...
从基础到高级详解Python数值格式化输出的完全指南

从基础到高级详解Python数值格式化输出的完全指南

《从基础到高级详解Python数值格式化输出的完全指南》在数据分析、金融计算和科学报告领域,数值格式化是提升可读性和专业性的关键技术,本文将深入解析Python中数值格式化输出的相关方法,感兴趣的小伙... 目录引言：数值格式化的核心价值一、基础格式化方法1.1 三种核心格式化方式对比1.2 基础格式化示例
阅读更多...
Android协程高级用法大全

Android协程高级用法大全

《Android协程高级用法大全》这篇文章给大家介绍Android协程高级用法大全,本文结合实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友跟随小编一起学习吧... 目录1️⃣ 协程作用域（CoroutineScope）与生命周期绑定Activity/Fragment 中手
阅读更多...
使用Java读取本地文件并转换为MultipartFile对象的方法

使用Java读取本地文件并转换为MultipartFile对象的方法

《使用Java读取本地文件并转换为MultipartFile对象的方法》在许多JavaWeb应用中,我们经常会遇到将本地文件上传至服务器或其他系统的需求,在这种场景下,MultipartFile对象非... 目录1. 基本需求2. 自定义 MultipartFile 类3. 实现代码4. 代码解析5. 自定
阅读更多...
AOP编程的基本概念与idea编辑器的配合体验过程

AOP编程的基本概念与idea编辑器的配合体验过程

《AOP编程的基本概念与idea编辑器的配合体验过程》文章简要介绍了AOP基础概念,包括Before/Around通知、PointCut切入点、Advice通知体、JoinPoint连接点等,说明它们... 目录BeforeAroundAdvise — 通知PointCut — 切入点Acpect — 切面
阅读更多...
深度解析Python yfinance的核心功能和高级用法

深度解析Python yfinance的核心功能和高级用法

《深度解析Pythonyfinance的核心功能和高级用法》yfinance是一个功能强大且易于使用的Python库,用于从YahooFinance获取金融数据,本教程将深入探讨yfinance的核... 目录yfinance 深度解析教程 (python)1. 简介与安装1.1 什么是 yfinance?
阅读更多...
MySQL数据类型与表操作全指南( 从基础到高级实践)

MySQL数据类型与表操作全指南( 从基础到高级实践)

《MySQL数据类型与表操作全指南(从基础到高级实践)》本文详解MySQL数据类型分类（数值、日期/时间、字符串）及表操作（创建、修改、维护）,涵盖优化技巧如数据类型选择、备份、分区,强调规范设计与... 目录mysql数据类型详解数值类型日期时间类型字符串类型表操作全解析创建表修改表结构添加列修改列删除列
阅读更多...
Python 函数详解:从基础语法到高级使用技巧

Python 函数详解:从基础语法到高级使用技巧

《Python函数详解:从基础语法到高级使用技巧》本文基于实例代码,全面讲解Python函数的定义、参数传递、变量作用域及类型标注等知识点,帮助初学者快速掌握函数的使用技巧,感兴趣的朋友跟随小编一起... 目录一、函数的基本概念与作用二、函数的定义与调用1. 无参函数2. 带参函数3. 带返回值的函数4.
阅读更多...
基于Redisson实现分布式系统下的接口限流

基于Redisson实现分布式系统下的接口限流

《基于Redisson实现分布式系统下的接口限流》在高并发场景下,接口限流是保障系统稳定性的重要手段,本文将介绍利用Redisson结合Redis实现分布式环境下的接口限流,具有一定的参考价值,感兴趣... 目录分布式限流的核心挑战基于 Redisson 的分布式限流设计思路实现步骤引入依赖定义限流注解实现
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2