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中的继承和多态

1、  什么是继承,继承的特点?子类继承父类的特征和行为,使得子类具有父类的各种属性和方法。或子类从父类继承方法,使得子类具有父类相同的行为。特点:在继承关系中,父类更通用、子类更具体。父类具有更一般...

【Java】Java的继承和多态详解

原文链接——码农网 什么是继承? 多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。 多个类可以称为子类,单独这...

我是如何成为一名python大咖的?

人生苦短,都说必须python,那么我分享下我是如何从小白成为Python资深开发者的吧。2014年我大学刚毕业..

Java方法继承、方法重载、方法覆盖小总结

1、方法继承:利用extends关键字一个方法继承另一个方法,而且只能直接继承一个类。当Sub类和Base类在同一个包时Sub类继承Base类中的public/protected/默认级别的变量个方法...

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

Java之封装、继承、多态

面向对象设计原则 - 学习笔记

设计模式 刘伟 http://blog.csdn.net/lovelion 在线书籍 https://gof.quanke.name/ 对于面向对象软件系统的设计而言,在支持可维护...

设计模式概述-学习笔记

设计模式 刘伟 http://blog.csdn.net/lovelion 在线书籍 https://gof.quanke.name/ 模式是在特定环境下人们解决某类重复出现问题的一套成功...

Java多态特性:重载和覆写的比较

Java重载: 在同一个类中方法具有相同的名字,相同或不同的返回值,但参数不同的多个方法(参数个数或参数类型) public class MethoDemo{ public static vo...
  • pengkv
  • pengkv
  • 2014-07-09 10:07
  • 1175

java静态方法不能多态也不能够重写

文章转载自http://blog.sina.com.cn/s/blog_7da2c9030101dhh7.html java静态方法不能多态也不能够重写   JAVA静态方法形式...

JAVA构造器+继承+重载与重写+自动转型与多态

一、构造器:构造器主要用于构造类的对象并初始化对象的属性,与C++中的构造函数的作用一样        格式:public   类名(参数表)  {}    ...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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