java中的继承和多态以及重载和重写
2016-06-02 10:19
525 查看
继承(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
public class MethoDemo{
public static void main(String args[]){
int one = add(10,20) ; // 调用整型的加法操作
float two = add(10.3f,13.3f) ; // 调用浮点数的加法操作
int three = add(10,20,30) ; // 调用有三个参数的加法操作
System.out.println("add(int x,int y)的计算结果:" + one) ;
System.out.println("add(float x,float y)的计算结果:" + two) ;
System.out.println("add(int x,int y,int z)的计算结果:" + three) ;
}
// 定义方法,完成两个数字的相加操作,方法返回一个int型数据
public static int add(int x,int y){
int temp = 0 ; // 方法中的参数,是局部变量
temp = x + y ; // 执行加法计算
return temp ; // 返回计算结果
}
public static int add(int x,int y,int z){
int temp = 0 ; // 方法中的参数,是局部变量
temp = x + y + z ; // 执行加法计算
return temp ; // 返回计算结果
}
// 定义方法,完成两个数字的相加操作,方法的返回值是一个float型数据
public static float add(float x,float y){
float temp = 0 ; // 方法中的参数,是局部变量
temp = x + y ; // 执行加法操作
return temp ; // 返回计算结果
}
};
输出结果:
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
class Person{ // 定义父类
void print(){ // 默认的访问权限
System.out.println("Person --> void print()。") ;
}
};
class Student extends Person{ // 定义继承关系
public void print(){
System.out.println("Student --> void print()。") ;
}
};
public class OverrideDemo{
public static void main(String args[]){
Student s = new Student() ;
s.print() ;
}
};
输出结果:
Student --> void print()。
小结:
java的三大特性:封装,继承,多态.而方法的重载和覆写正是多态的体现.
相关文章推荐
- PostgreSQL教程(三):表的继承和分区表详解
- C#与.net高级编程 C#的多态介绍
- C#中面向对象编程机制之多态学习笔记
- Lua面向对象之类和继承浅析
- 浅析Ruby中继承和消息的相关知识
- C#中的多态深入理解
- C#中多态、重载、重写区别分析
- 设计引导--一个鸭子游戏引发的设计理念(多态,继承,抽象,接口,策略者模式)
- C++实现不能被继承的类实例分析
- C# 面向对象三大特性:封装、继承、多态
- PHP类的封装与继承详解
- js继承 Base类的源码解析
- Javascript 面向对象 继承
- JavaScript 继承使用分析
- Javascript面向对象编程(二) 构造函数的继承
- Javascript中的几种继承方式对比分析
- javascript面向对象之Javascript 继承
- JavaScript 对象、函数和继承
- 封装与继承
- Java总结(九)——(线程模块 一(线程的创建(方法一)与启动,线程状态与生命周期,进程与线程))