Java继承和多态
继承
定义
继承就是利用现有类创建新类的过程，现有的类称为 父类（基类），新类称为 子类（派生类）。比如现实中：儿子继承了父亲遗产一样。面向对象程序设计中的继承，就是代码重用。
Java中所有的类都继承自 Object 这个父类。
实现
在Java中实现继承需要使用到extends关键字；
[访问修饰符] class 派生类名 extends 基类名 {
成员列表
}
如：
class Student extends Person
{
……
}
访问修饰符 请参看之前章节的内容。
例子
例：
定义抽象类：Person。
public abstract class Person { // 抽象类
private String name; // 私有变量
public String getName() { // Getter方法
return name;
}
public void setName(String name) { //Setter方法
this.name = name;
}
public Person(String name) { // 构造函数，用于初始化name
super();
this.name = name;
}
public abstract String getDesc(); // 抽象类中的抽象方法。 只有声明，没有具体实现。
public String toString(){ // toString方法覆盖了Object类的toString方法
return name + getDesc();
}
}
public class Student extends Person { // 继承类
private String major; // 新增加的数据
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
public Student(String name,String major) { // 构造函数用于初始化
super(name); // 调用超类构造函数
this.major = major;
}
@Override
public String getDesc() { // 必须实现超类中的抽象方法
// TODO Auto-generated method stub
return " : a student, major is " + major;
}
继承的作用
- 当今软件设计的特征
软件规模越来越大
软件设计者越来越多
软件设计分工越来越细 - 引入继承，实现了代码重用；
- 引入继承，实现了递增式的程序设计。
- 继承是能自动传播代码和重用代码的有力工具；
- 继承能够在某些比较一般的类的基础上建造、建立和扩充新类；
- 能减少代码和数据的重复冗余度，并通过增强一致性来减少模块间的接口和界面，从而增强了程序的可维护性；
- 能清晰地体现出类与类之间的层次结构关系。
注意事项
- 继承是单方向的，即派生类可以继承和访问基类中的成员，但基类则无法访问派生类中的成员； 父类不能访问子类方法
- 在Java中只允许 单一继承 方式，即一个派生类只能继承于一个基类，而不能象C++中派生类继承于多个基类的多重继承方式。
继承中的构造方法
- 父类中的构造方法可以被重载，但不能被子类继承，即便它是public的；
- 父类的构造方法负责初始化属于它的成员变量，而子类的构造方法则只需考虑属于自己的成员变量，不必去关注父类的情况。
- 当实例化子类的对象时，必须先执行父类的构造方法，然后再执行子类的构造方法；
- 如果父类还有更上级的父类，就会先调用最高父类的构造方法，再逐个依次地将所有继承关系的父类构造方法全部执行；
- 如果父类的构造方法执行失败，那么子类的对象也将无法实例化。
如
class ParentClass { //定义父类
public ParentClass() { //构造方法
System.out.println("这是父类的构造方法。");
}
}
class ChildClass extends ParentClass { //子类继承于父类
public ChildClass() { //构造方法
System.out.println("这是子类的构造方法。");
}
}
public class ConstructorTest { //该类用于容纳main方法
public static void main(String[] args) {
ChildClass cc = new ChildClass(); //实例化子类对象
}
}
super
如果子类需要调用父类的方法或者属性怎么办？
- 在子类的构造方法中，super关键字可以显式地调用父类的构造方法，用于将参数传递给它；需要注意的是： 该语句必须是子类构造方法的第一条语句
如：
class Point //定义"点"类
{
protected float mX, mY; //x轴坐标和y轴坐标
public Point(float x, float y) //构造方法
{
mX = x;
mY = y;
}
……
}
class Circle extends Point //定义"圆"类继承于"点"类
{
protected float mRadius; //半径
public Circle(float x, float y, float r) //构造方法
{
super(x, y); //显式调用父类构造方法，必须是第一条语句
mRadius = r;
}
……
}
- 如果父类和子类中有同名成员，在子类中默认访问是属于自己的那一个成员；super关键字可以明确地指定要访问父类中的成员；但前提条件是：父类中的该成员不是private的
多态
方法覆盖
定义
- 在类的继承体系结构中，如果子类中出现了与父类中有同原型的方法，那么认为子类中的方法覆盖了父类中的方法（也称为方法重写）；
- 通过子类的实例调用被覆盖的方法时，将总是调用子类中的方法，而父类中的方法将被隐藏。
如：
/*如果不但名称相同，而且连方法原型也完全相同的话，则构成方法覆盖*/
class ParentClass { //定义父类
public void fun() {
System.out.println("这是父类中的方法。");
}
}
class ChildClass extends ParentClass {//子类继承于父类
public void fun() { //子类覆盖父类中的方法
System.out.println("这是子类中的方法。");
}
}
class OverriddenTest { //用于容纳main方法
public static void main(String[] args) {
ParentClass parObj = new ParentClass();
parObj.fun(); //父类的实例调用此方法
ChildClass chiObj = new ChildClass();
chiObj.fun(); //子类的实例调用此方法
}
}
方法覆盖的注意事项
- 子类中重写的方法，其访问权限不能比父类中被重写方法的访问权限更低
- 在子类中重写方法时要保持方法的签名与父类中方法的签名一致
引用转型
- 基类（父类）的引用可以指向派生类（子类）的对象。
如：
BaseClass obj = new DerivedClass();
- 如果存在方法覆盖，那么将会调用其派生类中的方法
如：
class Shapes { //基本形状类
public void draw() { //绘图的方法
System.out.println("绘制了一个基本形状。");
}
}
class Circle extends Shapes { //圆形类继承于基本形状类
public void draw() { //覆盖父类的绘图方法
System.out.println("绘制了一个圆形。");
}
}
class Square extends Shapes { //正方形类继承与基本形状类
public void draw() { //覆盖父类的绘图方法
System.out.println("绘制了一个正方形。");
}
}
public class polymorphismDemo {
public static void main(String[] args) {
Shapes obj = new Shapes(); //父类的引用指向父类的实例
obj.draw(); //调用绘图方法
obj = new Circle(); //父类的引用指向子类的实例
obj.draw(); //调用绘图方法
obj = new Square(); //父类的引用指向子类的实例
obj.draw(); //调用绘图方法
}
}
多态
在Java中，使用父类的引用，调用同一个方法，却可以得到不同的调用结果，这就是多态。即： 同一函数，多种形态。
实际上多态包括 动态多态 和 静态多态。
静态多态
- 静态多态也称为编译时多态，即在编译时决定调用哪个方法；
- 静态多态一般是指方法重载；
- 只要构成了方法重载，就可以认为形成了静态多态的条件；
- 静态多态与是否发生继承没有必然联系。
动态多态
动态多态也称为运行时多态，即在运行时才能确定调用哪个方法。
形成动态多态必须具体以下条件：
- 必须要有继承的情况存在；
- 在继承中必须要有方法覆盖；
- 必须由基类的引用指向派生类的实例，并且通过基类的引用调用被覆盖的方法；
由上述条件可以看出，继承是实现动态多态的首要前提。
抽象
抽象方法
基类无法（或者没有必要）提供被覆盖方法的具体实现，那么就可以将这个方法定义为 抽象方法。
[访问权限] abstract 返回值类型 方法名（参数列表）{
}
如：
public abstract void draw(){
}
抽象类
如果某个类包含抽象方法，那么这个类就必须定义成 抽象类。
[访问权限] abstract class 类名{
成员列表
}
如：
public abstract class Shapes{
public abstract void draw();
}
抽象类的注意事项
- 抽象类不可以直接实例化，只可以用来继承；
- 抽象类的派生子类应该提供对其所有抽象方法的具体实现；
- 如果抽象类的派生子类没有实现其中的所有抽象方法，那么该派生子类仍然是抽象类，只能用于继承，而不能实例化；
- 抽象类中也可以包含有非抽象的方法；
- 构造方法和静态方法不可以修饰为abstract。
如：
abstract class Shapes { //基本形状类，抽象类
public abstract void draw(); //绘图方法，抽象方法
}
class Circle extends Shapes { //圆形类继承于基本形状类
public void draw() { //实现抽象父类的抽象绘图方法
System.out.println("绘制了一个圆形。");
}
}
class Square extends Shapes { //正方形类继承与基本形状类
public void draw() { //实现抽象父类的抽象绘图方法
System.out.println("绘制了一个正方形。");
}
}
public class abstractDemo { //该类用于容纳main方法
public static void main(String[] args) {
Shapes obj;
obj = new Circle(); //父类的引用指向子类的实例
obj.draw(); //调用绘图方法
obj = new Square(); //父类的引用指向子类的实例
obj.draw(); //调用绘图方法
}
}
接口
接口定义
如果某个类中所有的方法都是 抽象方法，那么可以考虑将该类定义为接口。
[访问权限] interface 接口名{
成员列表
}
如：
public interface IMyInterface{
public void doIt();
}
实现接口
接口只能用于实现，不能实例化（new）。
[访问权限] class 类名 implements 接口名 {
成员列表
}
如：
public class MyClass implements IMyInterface {
public void doIt(){
}
}
接口的注意事项
- 接口中不能定义非抽象方法，也就是说接口中不能包含有函数实体。
接口中的所有方法都默认为抽象方法，无需在每个方法前加abstract关键字。 - 接口的实现类应该提供对接口中所有抽象方法的具体实现，否则将成为抽象类。
与抽象类和它的继承类相似，也可以使用接口的引用指向其实现类的对象，从而达到动态多态的效果。 - Java只支持单继承，而不能象C++那样可以多重继承，接口正是为了弥补这一点。
- Java中还允许一个接口继承于另一个接口，即由父接口派生出子接口。
如：
public interface 子接口名 extends 父接口名 {
成员列表
}
final关键字
final修饰变量
如果将某个变量修饰为final，那么该变量就成为 常量
如：
final double PI = 3.14159;
☆ 常量在声明时必须初始化。
final修饰方法
如果将某个成员方法修饰为final，则意味着该方法 不能被子类覆盖
如：
public final void fun() {
……
}
//如果在派生类中出现同原型的方法，将会报错。
final修饰类
如果将某个类修饰为final，则说明该类 无法被继承
如：
public final class MyClass {
……
}
//任何类想继承于MyClass类都将报错。
类和类之间的关系
有——>has
汽车有轮子。一般来说这种关系对应的是 属性。是——>is
圆形是个形状。一般来说这种关系对应的是 方法。
