java中的继承和多态以及重载和重写

转载 2016年06月02日 10:19:05

继承(inheritance)

       简单的说,继承就是在一个现有类型的基础上,通过增加新的方法或者重定义已有方法(下面会讲到,这种方式叫重写)的方式,产生一个新的类型。继承是面向对象的三个基本特征--封装、继承、多态的其中之一,我们在使用JAVA时编写的每一个类都是在继承,因为在JAVA语言中,java.lang.Object类是所有类最根本的基类(或者叫父类、超类),如果我们新定义的一个类没有明确地指定继承自哪个基类,那么JAVA就会默认为它是继承自Object类的。

我们可以把JAVA中的类分为以下三种:

类:使用class定义且不含有抽象方法的类。
抽象类:使用abstract class定义的类,它可以含有,也可以不含有抽象方法。
接口:使用interface定义的类。

在这三种类型之间存在下面的继承规律:

类可以继承(extends)类,可以继承(extends)抽象类,可以继承(implements)接口。
抽象类可以继承(extends)类,可以继承(extends)抽象类,可以继承(implements)接口。
接口只能继承(extends)接口。

请注意上面三条规律中每种继承情况下使用的不同的关键字extends和implements,它们是不可以随意替换的。大家知道,一个普通类继承一个接口后,必须实现这个接口中定义的所有方法,否则就只能被定义为抽象类。我在这里之所以没有对implements关键字使用“实现”这种说法是因为从概念上来说它也是表示一种继承关系,而且对于抽象类implements接口的情况下,它并不是一定要实现这个接口定义的任何方法,因此使用继承的说法更为合理一些。

以上三条规律同时遵守下面这些约束:

类和抽象类都只能最多继承一个类,或者最多继承一个抽象类,并且这两种情况是互斥的,也就是说它们要么继承一个类,要么继承一个抽象类。
类、抽象类和接口在继承接口时,不受数量的约束,理论上可以继承无限多个接口。当然,对于类来说,它必须实现它所继承的所有接口中定义的全部方法。
抽象类继承抽象类,或者实现接口时,可以部分、全部或者完全不实现父类抽象类的抽象(abstract)方法,或者父类接口中定义的接口。
类继承抽象类,或者实现接口时,必须全部实现父类抽象类的全部抽象(abstract)方法,或者父类接口中定义的全部接口。

继承给我们的编程带来的好处就是对原有类的复用(重用)。就像模块的复用一样,类的复用可以提高我们的开发效率,实际上,模块的复用是大量类的复用叠加后的效果。除了继承之外,我们还可以使用组合的方式来复用类。所谓组合就是把原有类定义为新类的一个属性,通过在新类中调用原有类的方法来实现复用。如果新定义的类型与原有类型之间不存在被包含的关系,也就是说,从抽象概念上来讲,新定义类型所代表的事物并不是原有类型所代表事物的一种,比如黄种人是人类的一种,它们之间存在包含与被包含的关系,那么这时组合就是实现复用更好的选择。

多态(Polymorphism)

多态是又一个重要的基本概念,上面说到了,它是面向对象的三个基本特征之一。究竟什么是多态呢?我们先看看下面的例子,来帮助理解:

//汽车接口 
interface Car { 
  // 汽车名称 
  String getName(); 
  
  // 获得汽车售价 
  int getPrice(); 
} 
  
// 宝马 
class BMW implements Car { 
  public String getName() { 
    return "BMW"; 
  } 
  
  public int getPrice() { 
    return 300000; 
  } 
} 
  
// 奇瑞QQ 
class CheryQQ implements Car { 
  public String getName() { 
    return "CheryQQ"; 
  } 
  
  public int getPrice() { 
    return 20000; 
  } 
} 
  
// 汽车出售店 
public class CarShop { 
  // 售车收入 
  private int money = 0; 
  
  // 卖出一部车 
  public void sellCar(Car car) { 
    System.out.println("车型:" + car.getName() + " 单价:" + car.getPrice()); 
    // 增加卖出车售价的收入 
    money += car.getPrice(); 
  } 
  
  // 售车总收入 
  public int getMoney() { 
    return money; 
  } 
  
  public static void main(String[] args) { 
    CarShop aShop = new CarShop(); 
    // 卖出一辆宝马 
    aShop.sellCar(new BMW()); 
    // 卖出一辆奇瑞QQ 
    aShop.sellCar(new CheryQQ()); 
    System.out.println("总收入:" + aShop.getMoney()); 
  } 
} 
?

运行结果:

车型:BMW  单价:300000
车型:CheryQQ  单价:20000
总收入:320000

继承是多态得以实现的基础。从字面上理解,多态就是一种类型(都是Car类型)表现出多种状态(宝马汽车的名称是BMW,售价是300000;奇瑞汽车的名称是CheryQQ,售价是2000)。将一个方法调用同这个方法所属的主体(也就是对象或类)关联起来叫做绑定,分前期绑定和后期绑定两种。下面解释一下它们的定义:

前期绑定:在程序运行之前进行绑定,由编译器和连接程序实现,又叫做静态绑定。比如static方法和final方法,注意,这里也包括private方法,因为它是隐式final的。
后期绑定:在运行时根据对象的类型进行绑定,由方法调用机制实现,因此又叫做动态绑定,或者运行时绑定。除了前期绑定外的所有方法都属于后期绑定。

多态就是在后期绑定这种机制上实现的。多态给我们带来的好处是消除了类之间的耦合关系,使程序更容易扩展。比如在上例中,新增加一种类型汽车的销售,只需要让新定义的类继承Car类并实现它的所有方法,而无需对原有代码做任何修改,CarShop类的sellCar(Car car)方法就可以处理新的车型了。

Java多态特性———重载(overloading)和重写(overriding)

Java重载:

  • 在同一个类中
  • 方法具有相同的名字,相同或不同的返回值,但参数不同的多个方法(参数个数或参数类型)

[java] view plain copy
  1. public class MethoDemo{  
  2.     public static void main(String args[]){  
  3.         int one = add(10,20) ;      // 调用整型的加法操作  
  4.         float two = add(10.3f,13.3f) ;  // 调用浮点数的加法操作  
  5.         int three = add(10,20,30) ; // 调用有三个参数的加法操作  
  6.         System.out.println("add(int x,int y)的计算结果:" + one) ;  
  7.         System.out.println("add(float x,float y)的计算结果:" + two) ;  
  8.         System.out.println("add(int x,int y,int z)的计算结果:" + three) ;  
  9.     }  
  10.     // 定义方法,完成两个数字的相加操作,方法返回一个int型数据  
  11.     public static int add(int x,int y){  
  12.         int temp = 0 ;          // 方法中的参数,是局部变量  
  13.         temp = x + y ;          // 执行加法计算  
  14.         return temp ;           // 返回计算结果  
  15.     }  
  16.     public static int add(int x,int y,int z){  
  17.         int temp = 0 ;          // 方法中的参数,是局部变量  
  18.         temp = x + y + z ;          // 执行加法计算  
  19.         return temp ;           // 返回计算结果  
  20.     }  
  21.     // 定义方法,完成两个数字的相加操作,方法的返回值是一个float型数据  
  22.     public static float add(float x,float y){  
  23.         float temp = 0 ;        // 方法中的参数,是局部变量  
  24.         temp = x + y ;          // 执行加法操作  
  25.         return temp ;           // 返回计算结果  
  26.     }  
  27. };  
输出结果:

add(int x,int y)的计算结果:30

add(float x,float y)的计算结果:60

add(int x,int y,int z)的计算结果:23.6

Java覆写:

  • 子类覆写父类的方法,在不同的类
  • 重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型
  • 重写方法不能使用比被重写方法更严格的访问权限

[java] view plain copy
  1. class Person{       // 定义父类  
  2.     void print(){   // 默认的访问权限  
  3.         System.out.println("Person --> void print()。") ;  
  4.     }  
  5. };  
  6. class Student extends Person{   // 定义继承关系  
  7.     public void print(){  
  8.         System.out.println("Student --> void print()。") ;  
  9.     }  
  10. };  
  11. public class OverrideDemo{  
  12.     public static void main(String args[]){  
  13.         Student s = new Student() ;  
  14.         s.print() ;  
  15.     }  
  16. };  
输出结果:

Student --> void print()。


小结:

java的三大特性:封装,继承,多态.而方法的重载和覆写正是多态的体现.


相关文章推荐

Java之封装、继承、多态(重载、重写)

Java之封装、继承、多态
  • huixion
  • huixion
  • 2016年03月22日 20:37
  • 920

JAVA重载的规则与意义

首先看JAVA重载的规则: 1、必须具有不同的参数列表; 2、可以有不同的返回类型,只要参数列表不同就可以; 3、可以有不同的访问修饰符; 4、可以抛出不同的异常; 5、方法能够在一个类中或...
  • wantken
  • wantken
  • 2014年06月17日 14:47
  • 3731

JAVA方法重载的例子

      在JAVA中一个激动人心的功能就是方法的重载,只要同一个函数名有不同个数、不同类型的参数时,就是会调动那一个函数。下面是一个简单的方法重载的例子!代码如下:class OverloadDe...

Java是如何调用相应重载方法的

同一个类中有多个方法名相同但参数列表不同的方法,这种现象称为方法重载(overload)。其中参数列表不同包括以下情形: —参数的个数不同 —参数的类型不同 那么我们在调用其中一个被重载的方法时,J...

Java之重载和重写

重载(Overload)与重写(Overwrite/Override)都是针对方法来说的,那这两种机制有什么好处呢? 重载——同样的一个方法能够根据输入数据的不同,做出不同的处理。【有...

Java中方法的重载

方法的重载是针对同一个类中的方法而言,如果方法出现在不同类中,那么就不会有重载一说。对于同一个类,如果这个类里面有两个或者多个重名的方法,但是方法的参数个数、类型、顺序至少有一个不一样,这时候就会构成...

关于java重载(重载方法匹配优先级)

首先看一段代码 public class Overload { public static void sayHello(Object arg){ System.out.println("hel...

java重载-方法重载中的准确性原则

大家先猜猜看下边这段程序执行结果 public class StringUtil { /** * 判断输入的字符串是否是null或"" * * @param str * @re...
  • jackpk
  • jackpk
  • 2015年02月03日 18:47
  • 2220

Java之重载与覆盖

有的时候,类的同一种功能有多种实现方式,到底采用哪种实现方式,取决于调用者给定的参数。例如我们最常用的System.out.println()能够打印出任何数据类型的数据,它有多种实现方式。运行时,J...
  • fsz521
  • fsz521
  • 2013年03月30日 10:09
  • 9300

JAVA 重载“+”

这几天搞java,老是在System.out.println(“buf"+buf);,对中间的“+”很是迷惑!!! 按照println(string s),先要把参数转化为字符串,然后把字符串里面的...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java中的继承和多态以及重载和重写
举报原因:
原因补充:

(最多只允许输入30个字)