java-面向对象3-继承性、多态性和super关键字

---

前言

本文主要介绍：面向对象的特征：继承性和多态性、方法的重写、关键字：super的使用

1. 面向对象之继承性

继承性(inheritance)：
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中， 那么多个类无需再定义这些属性和行为，只要继承那个类即可。
继承性的好处：

• ① 继承的出现减少了代码冗余，提高了代码的复用性；
• ② 继承的出现，更有利于功能的扩展；
• ③ 继承的出现让类与类之间产生了关系，提供了多态的前提；

类继承语法规则：
class A extends B{ }

• A:子类、派生类、subclass
• B:父类、超类、基类、superclass
  

说明：

• 子类继承了父类，就继承了父类的方法和属性。
• 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
• 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”

关于继承的规则：

• 子类不能直接访问父类中私有的(private)的成员变量和方法
  ①父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构，只有因为封装性的影响，使得子类不能直接调用父类的结构而已
• 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。
• Java只支持单继承和多层继承，不允许多重继承
  ① 一个子类只能有一个父类
  ② 一个父类可以派生出多个子类
• 子父类是相对的概念
• 子类直接继承的父类，称为：直接父类。
• 子类间接继承的父类称为：间接父类。
• 子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法。
  
  

注意：

• 如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
• 所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类
• 所有的java类具有java.lang.Object类声明的功能。

2. 方法的重写(override/overwrite)

定义:
在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

应用： 重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。

要求：

• 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
• 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
  • 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void。
  • 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类。
  • 父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)。
• 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
  • 子类不能重写父类中声明为private权限的方法
• 子类方法抛出的异常不能大于父类被重写方法的异常

注意：
子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法

3. 关键字：super

在Java类中使用super来调用父类中的指定操作：

• super可用于访问父类中定义的属性
• super可用于调用父类中定义的成员方法
• super可用于在子类构造器中调用父类的构造器

注意：

• 尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
• super的追溯不仅限于直接父类
• super和this的用法相像，this代表本类对象的引用，super代表父类的内存 空间的标识

调用父类的构造器

• 可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
• 子类中所有的构造器默认都会访问父类中空参数的构造器
• 当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器。同时，只能”二选一”，且必须放在构造器的首行
• 如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错
• 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器

public class Circle {
	private double radius;//半径

	public Circle() {
		radius = 1.0;
	}
	public Circle(double radius) {
		super();
		this.radius = radius;
	}
	/**
	 * 求圆的面积
	 * @return
	 */
	public double findArea() {
		return Math.PI*Math.pow(radius, radius);
	}
	public double getRadius() {
		return radius;
	}
	public void setRadius(double radius) {
		this.radius = radius;
	}
	
}

public class Cylinder extends Circle {
	private double length;//高
	public Cylinder() {
		super();
	}
	public Cylinder(double length) {
		super();
		this.length = length;
	}	
	public double getLength() {
		return length;
	}
	/**
	 * 圆的表面积
	 * @return
	 */
	@Override
	public double findArea() {
		// TODO Auto-generated method stub
		return super.findArea()*2+2*Math.PI*getRadius()*length;
	}
	/**
	 * 圆的体积
	 * @param length
	 */
	public double findVolume(){
		return super.findArea()*length;
	}
	public void setLength(double length) {
		this.length = length;
	}		
}

this和super的区别：

子类对象的实例化过程：

注意： 虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。

class Creature {
	public Creature() {
		System.out.println("Creature无参数的构造器");
	}
}

class Animal extends Creature {
	public Animal(String name) {
		System.out.println("Animal带一个参数的构造器，该动物的name为" + name);
	}

	public Animal(String name, int age) {
		this(name);
		System.out.println("Animal带两个参数的构造器，其age为" + age);
	}
}

public class Wolf extends Animal {
	public Wolf() {
		super("灰太狼", 3);
		System.out.println("Wolf无参数的构造器");
	}

	public static void main(String[] args) {
		new Wolf();
	}
}

Creature无参数的构造器
Animal带一个参数的构造器，该动物的name为灰太狼
Animal带两个参数的构造器，其age为3
Wolf无参数的构造器

4. 面向对象特征： 多态性

多态性：
是面向对象中最重要的概念，在Java中的体现：对象的多态性：父类的引用指向子类的对象。

• 可以直接应用在抽象类和接口上。

Java引用变量有两个类型：
编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。

• 若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
• 多态情况下：
  • “看左边”：看的是父类的引用（父类中不具备子类特有的方法）
  • “看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）

对象的多态： 在Java中,子类的对象可以替代父类的对象使用

• 对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
• 一个变量只能有一种确定的数据类型
• 一个引用类型变量可能指向(引用)多种不同类型的对象

Person p = new Student();
Object o = new Person();//Object类型的变量o，指向Person类型的对象
o = new Student(); //Object类型的变量o，指向Student类型的对象

• 子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。
• 一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。

//属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。
Student m = new Student(); m.school = “pku”; //合法,Student类有school成员变量
Person e = new Student(); e.school = “pku”; //非法,Person类没有school成员变量

• 方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法

public class Test {
	public void method(Person e) {
		// ……
		e.getInfo();
	}
	public static void main(Stirng args[]) {
		Test t = new Test();
		Student m = new Student();
		t.method(m); // 子类的对象m传送给父类类型的参数e
	}
}

虚拟方法调用(Virtual Method Invocation)：

• 正常的方法调用

Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();

• 虚拟方法调用(多态情况下)：子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

Person e = new Student();
e.getInfo(); //调用Student类的getInfo()方法

• 编译时类型和运行时类型：编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类 的getInfo()方法。——动态绑定

instanceof 操作符：
因为对象的多态性，父类对象接收子类示例，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
如果要强制使用子类特有的属性和方法，必须向下转型(使用强制类型转换符),但是使用强转时，可能出现ClassCastException的异常，为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。

instanceof关键字的使用：
x instanceof A：检验x是否为类A的对象，返回值为boolean型

• 要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
• 如果x属于类A的子类B，x instanceof A值也为true。
  

对象类型转换 (Casting ):

• 基本数据类型的Casting：
  • 自动类型转换：小的数据类型可以自动转换成大的数据类型如long g=20; double d=12.0f
  • 强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型 如 float f=(float)12.0; int a=(int)1200L
• 对Java对象的强制类型转换称为造型
  • 从子类到父类的类型转换可以自动进行
  • 从父类到子类的类型转换必须通过造型(强制类型转换)实现
  • 无继承关系的引用类型间的转换是非法的
  • 在造型前可以使用instanceof操作符测试一个对象的类型
    

/*
 * 1.若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，
 * 系统将不可能把父类里的方法转移到子类中：编译看左边，运行看右边 
 * 2.对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，
 * 这个实例变量依然不可能覆盖父类中定义的实例变量：编译运行都看左边
 */
class Base {
	int count = 10;

	public void display() {
		System.out.println(this.count);
	}
}

class Sub extends Base {
	int count = 20;

	public void display() {
		System.out.println(this.count);
	}
}

public class FieldMethodTest {
	public static void main(String[] args) {
		Sub s = new Sub();
		System.out.println(s.count);//20
		s.display();//20
		
		Base b = s;//多态性
		System.out.println(b == s);//true
		System.out.println(b.count);//10
		b.display();//20
	}
}