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

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。

相关文章

java中VO PO DTO POJO BO DO对象的应用场景及使用方式

java中VO PO DTO POJO BO DO对象的应用场景及使用方式

《java中VOPODTOPOJOBODO对象的应用场景及使用方式》文章介绍了Java开发中常用的几种对象类型及其应用场景,包括VO、PO、DTO、POJO、BO和DO等,并通过示例说明了它... 目录Java中VO PO DTO POJO BO DO对象的应用VO (View Object) - 视图对象
阅读更多...
Python中列表的高级索引技巧分享

Python中列表的高级索引技巧分享

《Python中列表的高级索引技巧分享》列表是Python中最常用的数据结构之一,它允许你存储多个元素,并且可以通过索引来访问这些元素,本文将带你深入了解Python列表的高级索引技巧,希望对... 目录1.基本索引2.切片3.负数索引切片4.步长5.多维列表6.列表解析7.切片赋值8.删除元素9.反转列表
阅读更多...
正则表达式高级应用与性能优化记录

正则表达式高级应用与性能优化记录

《正则表达式高级应用与性能优化记录》本文介绍了正则表达式的高级应用和性能优化技巧,包括文本拆分、合并、XML/HTML解析、数据分析、以及性能优化方法,通过这些技巧,可以更高效地利用正则表达式进行复杂... 目录第6章：正则表达式的高级应用6.1 模式匹配与文本处理6.1.1 文本拆分6.1.2 文本合并6
阅读更多...
vue如何监听对象或者数组某个属性的变化详解

vue如何监听对象或者数组某个属性的变化详解

《vue如何监听对象或者数组某个属性的变化详解》这篇文章主要给大家介绍了关于vue如何监听对象或者数组某个属性的变化,在Vue.js中可以通过watch监听属性变化并动态修改其他属性的值,watch通... 目录前言用watch监听深度监听使用计算属性watch和计算属性的区别在vue 3中使用watchE
阅读更多...
Java将时间戳转换为Date对象的方法小结

Java将时间戳转换为Date对象的方法小结

《Java将时间戳转换为Date对象的方法小结》在Java编程中,处理日期和时间是一个常见需求,特别是在处理网络通信或者数据库操作时,本文主要为大家整理了Java中将时间戳转换为Date对象的方法... 目录1. 理解时间戳2. Date 类的构造函数3. 转换示例4. 处理可能的异常5. 考虑时区问题6.
阅读更多...
【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

引言 高斯过程（Gaussian Process，简称GP）是一种概率模型，用于描述一组随机变量的联合概率分布，其中任何一个有限维度的子集都具有高斯分布 文章目录 引言一、高斯过程1.1 基本定义1.1.1 随机过程1.1.2 高斯分布 1.2 高斯过程的特性1.2.1 联合高斯性1.2.2 均值函数1.2.3 协方差函数（或核函数） 1.3 核函数1.4 高斯过程回归（Gauss
阅读更多...
系统架构师考试学习笔记第三篇——架构设计高级知识（20）通信系统架构设计理论与实践

系统架构师考试学习笔记第三篇——架构设计高级知识（20）通信系统架构设计理论与实践

本章知识考点：         第20课时主要学习通信系统架构设计的理论和工作中的实践。根据新版考试大纲,本课时知识点会涉及案例分析题(25分),而在历年考试中,案例题对该部分内容的考查并不多,虽在综合知识选择题目中经常考查,但分值也不高。本课时内容侧重于对知识点的记忆和理解,按照以往的出题规律,通信系统架构设计基础知识点多来源于教材内的基础网络设备、网络架构和教材外最新时事热点技术。本课时知识
阅读更多...
Java 后端接口入参 - 联合前端VUE 使用AES完成入参出参加密解密

Java 后端接口入参 - 联合前端VUE 使用AES完成入参出参加密解密

加密效果： 解密后的数据就是正常数据： 后端：使用的是spring-cloud框架，在gateway模块进行操作 <dependency><groupId>com.google.guava</groupId><artifactId>guava</artifactId><version>30.0-jre</version></dependency> 编写一个AES加密
阅读更多...
Java第二阶段---09类和对象---第三节 构造方法

Java第二阶段---09类和对象---第三节 构造方法

第三节 构造方法 1.概念 构造方法是一种特殊的方法，主要用于创建对象以及完成对象的属性初始化操作。构造方法不能被对象调用。 2.语法 //[]中内容可有可无 访问修饰符 类名([参数列表]){ } 3.示例 public class Car {     //车特征(属性）     public String name;//车名   可以直接拿来用 说明它有初始值     pu
阅读更多...
【机器学习】高斯网络的基本概念和应用领域

【机器学习】高斯网络的基本概念和应用领域

引言 高斯网络（Gaussian Network）通常指的是一个概率图模型，其中所有的随机变量（或节点）都遵循高斯分布 文章目录 引言一、高斯网络（Gaussian Network）1.1 高斯过程（Gaussian Process）1.2 高斯混合模型（Gaussian Mixture Model）1.3 应用1.4 总结 二、高斯网络的应用2.1 机器学习2.2 统计学2.3
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2