首页 > 代码库 > Java 多态——与C++的比较

Java 多态——与C++的比较

2024-08-22 07:47:45   221人阅读

学习了Java和C++之后，由于长期不使用C++，而java的基础知识掌握不牢，现在已经搞不清java多态了。现在先来谈谈java多态，稍后有时间再更新C++的多态，并进行比较~

一. Java的多态

首先什么是Java的多态？

多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作。

 

  • 实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
  • 多态的作用：消除类型之间的耦合关系。

Java中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载。

1. 方法的重载

方法的重载是指在一个类中，出现多个方法名相同，但参数个数或参数类型不同的方法，则称为方法的重载。Java在执行具有重载关系的方法时，将根据调用参数的个数和类型区分具体执行的是哪个方法。

【例1】 定义一个名称为Calculate的类，在该类中定义两个名称为getArea()的方法（参数个数不同）和两个名称为draw()的方法（参数类型不同）。

技术分享 
 1 package test;
 2 
 3 public class Calculate {
 4     final float PI = 3.14159f;
 5     public float getArea(float r){
 6         float area = PI * r *r;
 7         return area;
 8     }
 9     public float getArea(float l,float w){
10         float area = 1 * w;
11         return area;
12     }
13     public void draw(int num){
14         System.out.println("画"+num+"个任意形状的图形");
15         
16     }
17     public void draw(String  shape){
18         System.out.println("画一个"+shape);
19         
20     }
21      public static void main(String[] args){
22          Calculate calculate = new Calculate();
23          float l = 20;
24          float w = 30;
25          float areaRectangle = calculate.getArea(l,w);
26          System.out.println("求长为"+l+"宽为"+w+"的矩形的面积是："+areaRectangle);
27          float r = 7;
28          float areaCirc = calculate.getArea(r);
29          System.out.println("求半径为"+r+"的圆的面积是："+areaCirc);
30          int num = 7;
31          calculate.draw(num);
32          calculate.draw("三角形");
33      
34      }
35 }
View Code

执行结果如下图所示：

技术分享

重载的方法之间并不一定必须有联系，但是为了提高程序的可读性，一般只重载功能相似的方法。

注意：在方法重载时，方法的返回值类型不能作为区分方法重载的标志。

2.方法的覆盖（重写）

当子类继承父类中所有可能被子类访问的成员方法时，如果子类的方法名与父类的方法名相同，那么子类就不能继承父类的方法，此时，称子类的方法覆盖了父类的方法。覆盖体现了子类补充或者改变父类方法的能力，通过覆盖，可以使一个方法在不同子类中表现出不同的行为。

【例2】定义动物类Animal及它们的子类，然后在Zoo类中分别创建各个子类对象，并调用子类覆盖父类的cry()方法。

(1)创建一个名称为Animal的类，在该类中声明一个成员方法cry():

技术分享 
 1 package example_2;
 2 
 3 public class Animal {
 4 
 5     public Animal() {
 6         
 7     }
 8     public void cry(){
 9         System.out.println("动物发出叫声！");
10     }
11 
12 }
View Code

(2)创建一个Animal类的子类Dog类，在该类中覆盖父类的成员方法cry():

技术分享 
 1 package example_2;
 2 
 3 public class Dog extends Animal {
 4 
 5     public Dog() {
 6     }
 7 
 8     public void cry(){
 9         System.out.println("狗发出“汪汪.....”声！");
10     }
11 
12 }
View Code

(3)再创建一个Animal类的子类Cat类，在该类中覆盖了父类的成员方法cry():

技术分享 
 1 package example_2;
 2 
 3 public class Cat extends Animal{
 4 
 5     public Cat() {
 6     }
 7     public void cry(){
 8         System.out.println("猫发出“喵喵....”声！");
 9     }
10 
11 }
View Code

(4)再创建一个Animal类的子类Cattle类，在该类中不定义任何方法：

技术分享 
1 package example_2;
2 
3 public class Cattle extends Animal {
4 
5 }
View Code

（5）创建Zoo类，在该类的main()方法中分别创建子类Dog，Cat和Cattle的对象并调用它们的cry()成员方法：

技术分享 
 1 package example_2;
 2 
 3 public class Zoo {
 4 
 5     /**
 6      * @param args
 7      */
 8     public static void main(String[] args) {
 9         // TODO Auto-generated method stub
10         Dog dog = new Dog();
11         System.out.println("执行dog.cry();语句时的输出结果：");
12         dog.cry();
13         Cat cat = new Cat();
14         System.out.println("执行cat.cry();语句时的输出结果：");
15         cat.cry();
16         Cattle cattle = new Cattle();
17         System.out.println("执行cattle.cry();语句时的输出结果：");
18         cattle.cry();
19 
20     }
21 
22 }
View Code

运行结果如下图所示：

技术分享

从上面的运行结果中可以看出，由于Dog类和Cat类都重写了父类的方法cry()，所以执行的是子类中的cry（）方法，但是Cattle类没有重写父类的方法，所以执行的是父类中的cry()方法。事实上，在Zoo类中，如下写法更能体现多态性：

技术分享 
 1 package example_2;
 2 
 3 public class Zoo {
 4 
 5     /**
 6      * @param args
 7      */
 8     public static void main(String[] args) {
 9         // TODO Auto-generated method stub
10         Animal animal;
11         animal = new Dog();
12         System.out.println("执行animal.cry();语句时的输出结果：");
13         animal.cry();
14         animal = new Cat();
15         System.out.println("执行animal.cry();语句时的输出结果：");
16         animal.cry();
17         animal = new Cattle();
18         System.out.println("执行animal.cry();语句时的输出结果：");
19         animal.cry();
20 
21     }
22 
23 }
View Code

在进行方法覆盖时，需要注意一下几点：

  • 子类不能覆盖父类中声明为final或者static的方法。
  • 子类必须覆盖父类中声明为abstract的方法，或者子类也将该方法声明为abstract。
  • 子类覆盖父类中的同名方法时，子类中方法的声明也必须和父类中被覆盖的方法的声明一样。

3.接口实现

 

Java 多态——与C++的比较


联系
我们