Java 对象多态性的使用【非常详细】

青旅半醒 2022-06-03 01:50 95阅读 0赞

### 1. java接口可以实例化吗？ ###

`接口不可以实例化。但是接口对象可以指向它的实现类对象。`

`接口可以看做特殊的抽象类，只是所有的方法都是抽象方法（没有实现的方法），接口的方法都是默认public abstract的，所以不能被实例化。`

**比如：**

List Set Map都是接口，使用时先实现

**List<String> list = new ArrayList<>();**

有点类似于指针的感觉了。Factory接口可以用来代表实现它的类。比如：

public interface thing;
    public class fruit implements thing;
    thing something = new fruit();
    这个something指的就是水果。

### 2. 接口编程是为了实现多继承 ###

什么是多态

1.  **面向对象的三大特性**：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。
2.  **多态的定义**：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
3.  **实现多态的技术称为**：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
4.  **多态的作用**：消除类型之间的耦合关系。
5.  **现实中，关于多态的例子不胜枚举**。比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。

> 1.多态的定义： 允许不同类的对象对同一消息做出响应，同一消息可以根据发送对象的不同而采用多种不同的行为方式。  
>   
> 2.实现多态的必要条件：继承、重写、向上转型。（向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法）。

**多态存在的三个必要条件**

> 一、要有继承；  
> 二、要有重写；  
> 三、父类引用指向子类对象。

**多态的好处**：

> 1.可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。  
> 2.可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。  
> 3.接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。  
> 4.灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。  
> 5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

**对象多态性在面向对象中是一个最重要的概念，在Java中主要有两种体现形式：**

> 1. 方法的重载和覆写
> 
> 2. 对象的多态性 对于方法的重载和覆写在之前的讲解中，下面将重点介绍对象的的多态性。 对象的多态性主要分为以下两种类型： （1） 向上转型：子类对象—》父类对象； （2） 向下转型：父类对象—》子类对象； 对于向上转型，程序会自动完成，而对于向下转型时，必须明确的指明要转型的子类类型

**格式如下：**

对象向上转型：父类 父类对象 = 子类实例；
    对象向下转型：子类 子类对象 = （子类）父类对象；

![这里写图片描述][SouthEast]

下面进行对象向上转型的操作：  
**【对象向上转型】**

程序运行结果：

B-->public void fun()1

以上程序就是一个对象向上转型的关系，从程序的运算结果中可以发现，此时虽然使用父类对象调用fun1()方法，但是实际上调用的方法是被子类覆写过的方法，也就是说，如果对象发生了向上转型关系后，所调用的方法一定是被子类覆写过的方法。但是在此时一定要注意，此时的对象a是无法调用B类中的fun3()方法的，因为此方法只在子类中定义而没有在父类中定义，如果要想调用子类中的自己定义的方法，则肯定要使用子类实例，所以此时可以将对象进行向下转型。  
**【对象向下转型】**

class A
    {
        public void fun1(){
            System.out.println("A-->public void fun1()");
        }
        public void fun2(){
            this.fun1();
        }
    }
    class B extends A
    {
        //覆写A中的方法
        public void fun1(){
            System.out.println("B-->public void fun()1");
        }
        //子类中自己定义的方法
        public void fun3(){
            System.out.println("B-->oublic void fun3()");
        }
    }
    public class PolDemo01
    {
        public static void main(String[] args){
            A a=new B();//发生了向上转型关系，子类--》父类
            B b=(B)a;//此时发生了向下转型关系
            b.fun1();//调用方法被覆写的方法
            b.fun2();//调用父类的方法
            b.fun3();//调用子类定义的方法
        }
    }

运行结果：

B-->public void fun()1
    B-->public void fun()1
    B-->oublic void fun3()

从以上程序中可以发现，如果要想调用子类自己的方法，则一定只能用子类的实例化对象，另外，在子类对象里调用从父类中继承过来的fun2()方法，fun2()方法要调用fun1()方法，由于此时fun1()方法已经被子类所覆写，所以此时调用的方法是被子类覆写过的方法。

**阶段性总结：**

> 1. 向上转型主要特征，子类为父类对象实例化，父类接受子类对象功能，调用的方法一定是子类所覆写过的方法；（**向上转型找共性**）
> 
> 2. 向下转型主要特征，子类扩充了某些功能，这些功能父类没有定义，则需要执行向下转 型，以调用子类特有的功能；（**向下转型找特性**）

**对象向下转型的要求：**   
在对象向下转型前，必须首先发生对象向上转型，否则将出现对象转化异常。  
了解了对象的多态性后，那么这个概念到底有什么用途哪？下面要求设计一个方法，要求此方法可以接收A类的任意子类对象，并调用方法，此时，如果不用对象的多态性，则肯定会使用以下形式的代码：  
**【不使用对象多态性实现功能】**

class A
    {
        public void fun1(){
            System.out.println("A-->public void fun1()");
        }
        public void fun2(){
            this.fun1();
        }
    }
    class B extends A
    {
        //覆写A中的方法
        public void fun1(){
            System.out.println("B-->public void fun1()");
        }
        //子类中自己定义的方法
        public void fun3(){
            System.out.println("B-->poublic 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 fun3()");
        }
    }
    public class PolDemo04
    {
        public static void main(String[] args){
            fun(new B());//传递B类实例
            fun(new C());//传递C类实例
        }
        public static void fun(B b){
       //接收B类实例
            b.fun1();
        } 
        public static void fun(C c){
       //接收C类实例
            c.fun1();
        }
    }

运行结果：

B-->public void fun1()
    C-->public void fun1()

以上程序虽然实现了基本的要求，但是应该可以发现：如果按照以上的方式完成程序，则当产生一个A类的子类对象时，fun()方法就要被重载一次，则每一次扩充子类都必须修改类本身，这样肯定不方便，那么如果使用对象多态性完成可以很好地解决。  
**【使用对象的多态性】**

class A
    {
        public void fun1(){
            System.out.println("A-->public void fun1()");
        }
        public void fun2(){
            this.fun1();
        }
    }
    class B extends A
    {
        //覆写A中的方法
        public void fun1(){
            System.out.println("B-->public void fun1()");
        }
        //子类中自己定义的方法
        public void fun3(){
            System.out.println("B-->poublic 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 fun3()");
        }
    }
    public class PolDemo04
    {
        public static void main(String[] args){
            fun(new B());//传递B类实例，产生向上转型
            fun(new C());//传递C类实例，产生向上转型
        }
        public static void fun(A a){
       //接收父类对象
            a.fun1();
        }
    }

运行结果：

B-->public void fun1()
    C-->public void fun1()

从上程序运行的结果发现，此时由于在fun()方法中使用了对象的多态性，所以可以接收任何的子类对象，这样无论子类如何增加，fun()方法都不用做任何的改变，因为一旦发生对象的向上转型关系之后，调用的方法一定是被子类覆写过的方法。

### 三、instanceof关键字 ###

通过上面的分析发现，向下转型实际上比向上转型危险，因为有可能会造成错误，所以在Java中专门提供了一个instanceof的关键字，利用次关键字就可以判断出某一个对象是否是某一个类的实例

语法：

**对象 instanceof 类 ——>返回boolean型数据**

范例6：观察instanceof的使用

![Center][]

![Center 1][]

最规范的写法：

![Center 2][]

### 四、相互转型的意义 ###

解释此类问题，假设Person类下有学生、工人、教师三个子类；人一定说话，那么每个身份的人说的话一定不同。要求定义一个方法，此方法可以接受Person类对象的所有引用（实现接受person类的所有子类对象）；

![Center 3][]

![Center 4][]

![Center 5][]

![Center 6][]

**实现方式一：利用方法的重载完成**

实例7：

![Center 7][]

上面的参数各写各的，没有统一

![Center 8][]

如果person类产生了100个子类，而且还有可能随时增加更多子类，最终要的是参数没有得到有效的统一，优化如下：

**实现方式二：利用对象的向上转型操作完成**

明确：对象在进行向上转型时可以自动完成父类接收子类对象的功能，同时转型之后所调用的的方法一定随实例化子类的不同，同一个方法一定执行不同的功能；

现在结果和之前完全一样，如果随意扩充子类的话，fun（）方法不需要做任何修改可以满足所有功能；

![Center 9][]

### 五、总结上述问题 ###

**（一、）关于继承性和多态性总结**

> 1. **这两个特性一定是相辅相成，缺一不可的**
> 
> 2. **继承性解决的是一个类功能扩充的问题，而多态性解决的是参数统一的问题，有了多态性之后才应该发觉，父类的设计是相当重要的，而且子类不要轻易的扩充父类里没有的方法，要按照父类已有的方法规格覆写方法；**

（二、**）关于对象转型问题**

> 1. **向上转型（90%），自动完成，子类对象自动的转换为父类对象，而后调用的是子类所覆写过的方法；利用对象的向上转型可以解决参数参数统一问题；**
> 
> 2. **向下转型（1%），强制完成，不建议出现，当需要调用子类自己扩充的方法时使用**
> 
> 3. **不转型（9%），很多时候一些类是不进行转型操作的，例如String；**

### 六、多态性主要特征 ###

**1. 方法的多态性**

> 1）重载：同一个方法名称，根据参数的类型或个数不同可执行不同的方法体；
> 
> 2）覆写：同一个方法根据子类的不同，可以达到不同的功能

**2 对象的多态性**

> 1）向上转型：达到参数统一；
> 
> 2）向下转型：调用子类的特殊功能
> 
> 3. 利用instanceof关键字可以判断某一个对象是否是某一个类的实例

**对于多态，可以总结以下几点：**

> 一、使用父类类型的引用指向子类的对象；
> 
> 二、该引用只能调用父类中定义的方法和变量；
> 
> 三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）;
> 
> 四、变量不能被重写（覆盖），"重写"的概念只针对方法，如果在子类中"重写"了父类中的变量，那么在编译时会报错。

### 关注我们，更多技术干货： ###

**[2000多G的计算机各行业电子资源分享（持续更新）][2000_G]**

**[2020年微信小程序全栈项目之喵喵交友【附课件和源码】][2020]**

**[Spring Boot开发小而美的个人博客【附课件和源码】][Spring Boot]**

**[Java微服务实战296集大型视频-谷粒商城【附代码和课件】][Java_296_-]**

**[Java开发微服务畅购商城实战【全357集大项目】-附代码和课件][Java_357_-]**

**[最全最详细数据结构与算法视频-【附课件和源码】][-]**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70_pic_center]

<table> 
 <tbody> 
 <tr> 
 <td> 2021年JAVA 精心整理的常见面试题-附详细答案 </td> 
 <td><a href="https://mikejun.blog.csdn.net/article/details/114488339" rel="nofollow">https://mikejun.blog.csdn.net/article/details/114488339</a></td> 
 </tr> 
 <tr> 
 <td> 2021年- 精心整理的 SpringMVC 常见面试题-【附详细答案】 </td> 
 <td><a href="https://mikejun.blog.csdn.net/article/details/114992529" rel="nofollow">https://mikejun.blog.csdn.net/article/details/114992529</a></td> 
 </tr> 
 <tr> 
 <td> 2021年JAVA 面试题之--数据结构篇【附详细答案】 </td> 
 <td><a href="https://mikejun.blog.csdn.net/article/details/114647742" rel="nofollow">https://mikejun.blog.csdn.net/article/details/114647742</a></td> 
 </tr> 
 <tr> 
 <td> 精心整理的计算机各类别的电子书籍【超全】 </td> 
 <td><a href="https://mikejun.blog.csdn.net/article/details/115442555" rel="nofollow">https://mikejun.blog.csdn.net/article/details/115442555</a></td> 
 </tr> 
 <tr> 
 <td> 三天刷完《剑指OFFER编程题》--Java版本实现（第一天） </td> 
 <td><a href="https://mikejun.blog.csdn.net/article/details/106996017" rel="nofollow">https://mikejun.blog.csdn.net/article/details/106996017</a></td> 
 </tr> 
 <tr> 
 <td> 三天刷完《剑指OFFER编程题》--Java版本实现（第二天） </td> 
 <td><a href="https://mikejun.blog.csdn.net/article/details/108098502" rel="nofollow">https://mikejun.blog.csdn.net/article/details/108098502</a></td> 
 </tr> 
 <tr> 
 <td> 三天刷完《剑指OFFER编程题》--Java版本实现（第三天） </td> 
 <td><a href="https://mikejun.blog.csdn.net/article/details/108253489" rel="nofollow">https://mikejun.blog.csdn.net/article/details/108253489</a></td> 
 </tr> 
 </tbody> 
</table>

[SouthEast]: /images/20220603/40491ec1a16841479e0e1f3d9bd97039.png
[Center]: /images/20220603/3f1a24f9427e48d4b382e8ceee68679d.png
[Center 1]: /images/20220603/a7551b1bf81a4772baaa275f41fd8600.png
[Center 2]: /images/20220603/4f25c9147ecc481aa1369f876d71e557.png
[Center 3]: /images/20220603/2faecd3c00f44a15b72609ea003e2a73.png
[Center 4]: /images/20220603/d88edd64df694f92b0b855d13bcb3180.png
[Center 5]: /images/20220603/daf86454e1784989a71e0ffc7a240e04.png
[Center 6]: /images/20220603/2b028261e6d44d4aa1d4e33b031fd25b.png
[Center 7]: /images/20220603/aba3c21246d24e1a9943a1946c58e05a.png
[Center 8]: /images/20220603/321be920ce034b3c8acdade4d0a93941.png
[Center 9]: /images/20220603/2f3f582e7e2f44f798d4e0d48956400e.png
[2000_G]: https://mp.weixin.qq.com/s/sP4JgGWkCzpgwKr9sAV2_Q
[2020]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487704&idx=1&sn=5f4b2127c4d49fd07ae072a0721424a2&chksm=e8036fc2df74e6d489c4aa9b06f917ef7cee6027f13e150fca53cf79d5d188d4ccc1af49e098&scene=21#wechat_redirect
[Spring Boot]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487798&idx=2&sn=ac0293b996521b872a9dba5fbb3e65e6&chksm=e8036e2cdf74e73aba104a9a994a5b2e31483e8dcbe0f1d9936f6d5173b887e1560f59d2819c&scene=21#wechat_redirect
[Java_296_-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487674&idx=1&sn=7aff0bdf2bb727303f3d3618995aef21&chksm=e8036fa0df74e6b6d872c7e6ece179c524ed463a4a6b74c96875475c9a3d5ddb903427dd993b&scene=21#wechat_redirect
[Java_357_-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247486376&idx=1&sn=d1fef270c463ea8ac663f6fbfedd70a0&chksm=e80374b2df74fda4d3bafba878a106a19e18c5fcda266008f4f37975847a21bc612ffcd5ff39&scene=21#wechat_redirect
[-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487750&idx=1&sn=747bccbb5f5ea6b58915198de40da777&chksm=e8036e1cdf74e70ae97a5e8e265b49d7236d904d291203309159d07ba1724033062c0e370843&scene=21#wechat_redirect
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70_pic_center]: /images/20220603/6a070b61f2d441adbafdf05facf3fe3a.png