Java特性之——多态

我不是女神ヾ 2021-06-24 15:57 441阅读 0赞

先来回答一个问题，java的三大特性是什么？

没错，是**封装、继承、多态。**

在这儿，简单记录一下多态是什么意思，然后举一个比较实用的例子。

**一、什么是多态。**

> 我个人理解，多态就是：**父类的引用指向子类的对象。**
> 
> 比如：
> 
> Parent是父类，Girl是继承了Parent类的一个子类，那么：

> > Parent  p= new Girl();

> 这就多态。
> 
>   
>

**二、实现多态的条件。**

> 继承、实现为实现多态提供了基础，但是还需要：重写。**(注意不是重载)。**
> 
>   
>

**三、多态的原理。**

> 多态的实现，其实就是java提供父子类指尖的自动向上转型功能。

四、优点与弊端。

> 先说优点：

> > 如果我们定义了一个**指向子类对象(  new Girl()  )**的**父类引用(Parent  p中的p ****)**，那么它除了能够调用父类的方法外，还能调用在子类中对父类方法重写(Override)的方法：(其实还是相当于父类的引用调用了父类中的方法，只不过该方法在指向子类的对象中被重写了，所以最后输出的是被重写的行为)
> 
> 再说弊端：

> > 多态是可以调用所有父类中的方法，也可以调用指向子类对象中的方法，但是如果**该方法是子类特有的方法**，或者是对父类中的方法进行了重载(Overloading)，那么是无法调用的(你可以在子类中写一个不同于父类方法名的方法，当你使用父类引用打点调用方法的时候，你会发现，根本就找不到这个方法)。
> > 
> >   
> >

五、举例说明。

> 假使有个父类Parent。
> 
> //父类 public class Parent \{ public String wife; public void sys()\{ System.out.println("-------parent.sys-------"); \} public void unique()\{ System.out.println("------parent.unique-----"); \} \}  
> 
> 
>   
> 
> 
> 有一个继承了Parent类的子类Girl。
> 
> public class Girl extends Parent \{ public String brother; //对父类中的方法进行了重写 public void sys()\{ System.out.println("--------girl.sys--------"); \} //自己特有的方法 public void habit()\{ System.out.println("--------girl.habit-------"); \} \}  
> 
> 
>   
> 
> 
> 现在需要一个入口测试。
> 
>  public static void main(String\[\] args) \{ //多态：父类的引用 指向 子类的对象 Parent p = new Girl(); p.sys();//子类对父类中的该方法进行了重写,可以调用 p.unique();//父类自己的方法,可以调用 //p.habit();//子类自己的方法，无法调用 \}  
>

>   
> 
> 
> 输出结果：

> > \--------girl.sys--------          父类的引用p调用了sys方法，但是最后输出的是指向子类对象girl中对该方法重写的行为。  
> > \------parent.unique-----     父类的引用p调用了unique方法，指向的子类对象没有对该方法进行重写，所以输出的是父类中该方法的行为。  
> > 
> > 
> >   
> >

六、网上经典案例。

> //父类 class A ...\{ //父类的方法 public String show(D obj)...\{ return ("A and D"); \} public String show(A obj)...\{ return ("A and A"); \} \} //继承了父类的子类 class B extends A...\{ //重载(参数形式不同) public String show(B obj)...\{ return ("B and B"); \} //对父类方法进行了重写 public String show(A obj)...\{ return ("B and A"); \} \}  
>

问，如下形式，会输出什么

> A  a  =  new  B（）；
> 
> B  b  = new  B（）；
> 
>   
> 
> 
> system.out.println（a.show(b)）；

结果：

> B and A
> 
>   
>

解释：

> 父类的引用a指向了子类B的对象，因为子类中Show （B obj）子类的是**重载，并不存在于父类中，**所以a.show无法调用子类中这个重载的方法，所以最后输出的结果肯定不会是“B and B”。
> 
>   
> 
> 
> 因为A是B的父类，所以父类引用a其实调用的是父类中a.show（A obj）这个方法，又因为子类B对该方法做了重写，所以最后输出的是子类中该方法的行为："B and B".
> 
>   
>

在这儿，留下一个多态的优先级，能看懂当然最好，看不懂的先有个疑问，以后肯定会恍然大悟的：

> this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。  
> 
> 
> 简单提示一下，this表示父类引用指向的子类，super表示父类

>   
>

七、最后留一个遇到过的例子吧。

> 在第五步中中，有一个父类Parent，有一个子类Girl，现在再添一个子类Son：
> 
> public class Son extends Parent \{ public void sys()\{ System.out.println("-------son.sys------"); \} \}  
> 
> 
>   
> 
> 
> 下面有一个main方法，大家可以仔细看一下，想一下。
> 
>  public static void main(String\[\] args) \{ //以父类为泛型的list容器 List<parent> list = new ArrayList<parent>(); //两个子类 Girl g = new Girl(); Son s = new Son(); //加入容器 list.add(g); list.add(s); for(int i = 0;i < list.size();i++)\{ //采用多态，不必纠结从容器中取出的是Girl还是Son Parent p = list.get(i); //如果是Girl，就输出Girl类中的sys方法 //如果是Son，就输出Son类中的sys方法 //----当然，子类中，这个sys方法对父类中该方法进行了重写 p.sys(); \} \} </parent></parent>  
> 
> 
>   
>

输出结果如下：

> \--------girl.sys--------  
> \-------son.sys------  
> 
> 
>   
> 
> 
>   
>

什么？你说不知道什么时候有用？

其实我也不知道什么时候该用，反正到时候肯定就知道了。

如果有不懂，或是不理解的同学，可以私信我，或者是下方留言，我看到后会及时回复的。

虽然，，，我也是一个小白。