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

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。

相关文章

requests处理token鉴权接口和jsonpath使用方式

requests处理token鉴权接口和jsonpath使用方式

《requests处理token鉴权接口和jsonpath使用方式》文章介绍了如何使用requests库进行token鉴权接口的处理,包括登录提取token并保存,还详述了如何使用jsonpath表达... 目录requests处理token鉴权接口和jsonpath使用json数据提取工具总结reques
阅读更多...
C++ 多态性实战之何时使用 virtual 和 override的问题解析

C++ 多态性实战之何时使用 virtual 和 override的问题解析

《C++多态性实战之何时使用virtual和override的问题解析》在面向对象编程中,多态是一个核心概念,很多开发者在遇到override编译错误时,不清楚是否需要将基类函数声明为virt... 目录C++ 多态性实战：何时使用 virtual 和 override？引言问题场景判断是否需要多态的三个关
阅读更多...
python调用dubbo接口的实现步骤

python调用dubbo接口的实现步骤

《python调用dubbo接口的实现步骤》本文主要介绍了python调用dubbo接口的实现步骤,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编... 目录 ​​其他实现方式与注意事项​​ ​​高级技巧与集成​​用 python 提供 Dubbo 接口
阅读更多...
Java中接口和抽象类的异同以及具体的使用场景

Java中接口和抽象类的异同以及具体的使用场景

《Java中接口和抽象类的异同以及具体的使用场景》文章主要介绍了Java中接口（Interface）和抽象类（AbstractClass）的区别和联系,包括相同点和不同点,以及它们在实际开发中的具体使... 目录一、接口和抽象类的 “相同点”二、接口和抽象类的 “核心区别”关键区别详解（避免踩坑）三、具体使
阅读更多...
sqlserver、mysql、oracle、pgsql、sqlite五大关系数据库的对象名称和转义字符

sqlserver、mysql、oracle、pgsql、sqlite五大关系数据库的对象名称和转义字符

《sqlserver、mysql、oracle、pgsql、sqlite五大关系数据库的对象名称和转义字符》：本文主要介绍sqlserver、mysql、oracle、pgsql、sqlite五大... 目录一、转义符1.1 oracle1.2 sqlserver1.3 PostgreSQL1.4 SQLi
阅读更多...
从基础到高级详解Go语言中错误处理的实践指南

从基础到高级详解Go语言中错误处理的实践指南

《从基础到高级详解Go语言中错误处理的实践指南》Go语言采用了一种独特而明确的错误处理哲学,与其他主流编程语言形成鲜明对比,本文将为大家详细介绍Go语言中错误处理详细方法,希望对大家有所帮助... 目录1 Go 错误处理哲学与核心机制1.1 错误接口设计1.2 错误与异常的区别2 错误创建与检查2.1 基础
阅读更多...
JavaScript对象转数组的三种方法实现

JavaScript对象转数组的三种方法实现

《JavaScript对象转数组的三种方法实现》本文介绍了在JavaScript中将对象转换为数组的三种实用方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友... 目录方法1：使用Object.keys()和Array.map()方法2：使用Object.entr
阅读更多...
MySQL中C接口的实现

MySQL中C接口的实现

《MySQL中C接口的实现》本节内容介绍使用C/C++访问数据库,包括对数据库的增删查改操作,主要是学习一些接口的调用,具有一定的参考价值,感兴趣的可以了解一下... 目录准备mysql库使用mysql库编译文件官方API文档对象的创建和关闭链接数据库下达sql指令select语句前言：本节内容介绍使用C/
阅读更多...
使用MapStruct实现Java对象映射的示例代码

使用MapStruct实现Java对象映射的示例代码

《使用MapStruct实现Java对象映射的示例代码》本文主要介绍了使用MapStruct实现Java对象映射的示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,... 目录一、什么是 MapStruct？二、实战演练：三步集成 MapStruct第一步：添加 Mave
阅读更多...
Java中实现对象的拷贝案例讲解

Java中实现对象的拷贝案例讲解

《Java中实现对象的拷贝案例讲解》Java对象拷贝分为浅拷贝（复制值及引用地址）和深拷贝（递归复制所有引用对象）,常用方法包括Object.clone()、序列化及JSON转换,需处理循环引用问题,... 目录对象的拷贝简介浅拷贝和深拷贝浅拷贝深拷贝深拷贝和循环引用总结对象的拷贝简介对象的拷贝，把一个
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2