5.3面向对象特性------继承
5.3.1 类的继承
子类在保留父类基本属性与行为的基础上，可以增加新的属性或行为，或者修改属性和行为。
子类继承父类，父类派生子类，子类还可以派生子类，这样就形成了类的层次结构。
JAVA中继承通过以下形式实现：
class 子类名 extends 父类名 【implements<接口名>】{
}java语言通过使用extends来实现类的继承，如果类定义时没有使用extends关键字，则默认该类的父类是java.lang.Object类。Object类是java预定义的所有类的父类，包含了所有java的公共属性，其中定义的属性和方法局可以被任何类使用、继承或修改。
为了避免二义性：java语言规定，一个子类只能有一个父类，即java不支持多继承，只是单继承。
子类继承父类时遵循普遍性原则 和 特殊性原则。普遍性原则是子类继承父类已有的成员变量和方法（构造方法不可继承，是调用，个人理解）；特殊性原则是指子类可增加父类中没有的变量和方法，或修改父类中已有的变量和方法。
【例 5 -12】继承应用举例。
Employee (雇主)为父类，Manager(经理)为子类，经理是一类特殊的雇员，具有雇员一般的性质和行为（方法）。
另外，经理在一般雇员的基础上，增加了工作的特殊性：享受特殊的津贴。
Ex5_12_Inheritance.java
package com.ch5;
public class Ex5_12_Inheritance {
public static void main(String[] args) {
Manager_ex mrZhang = new Manager_ex();
mrZhang.setName("张刚"); // 调用set方法为对象设置属性值
mrZhang.setDepartment("教务处");
mrZhang.setSalary(2500);
// 以上是public权限的属性 父类属性，子类继承
mrZhang.setSpecial("教务处处长");
mrZhang.setSubsidy(500);
// 以上是private权限的子类 属性 新增属性
System.out.println("*********************员工信息*********************");
System.out.println();
System.out.println(mrZhang.toString());
}
}
class Employee{
protected String name;
protected double salary;
protected String department;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
@Override
public String toString() {
return "Employee [name=" + name + ", salary=" + salary
+ ", department=" + department + "]";
}
}// class Employee end
class Manager_ex extends Employee{
// Manager_ex子类名字 ，因为本包中存在了一个名字为Manager的类，所以换了个名字
private String special;
private double subsidy;
public String getSpecial() {
return special;
}
public void setSpecial(String special) {
this.special = special;
}
public double getSubsidy() {
return subsidy;
}
public void setSubsidy(double subsidy) {
this.subsidy = subsidy;
}
@Override
public String toString() {
return "name=" + name + ", salary=" + salary
+ ", department=" + department + ",special=" + special + ", subsidy=" + subsidy;
}
/**
* 子类可以从父类继承成员变量和方法，但受访问权限的限制。
* 如果父类和子类分别定义在不同的包中，子类只能访问父类中 public,protected权限的变量；
* 如果父类和子类在同一个包中，子类能访问父类中的public,protected,默认权限的变量，
* 父类中的private权限的变量，对子类不可见。
*/
}结果：
***********员工信息***********
name=张刚, salary=2500.0, department=教务处,special=教务处处长, subsidy=500.0
5.3.2 super 的使用
子类在继承父类时，可能会出现变量隐藏，方法覆盖（Overriding）等现象。
变量隐藏：子类的成员变量和父类的成员变 同名时，此时，父类的成员变量被隐藏。
方法覆盖是指：是指子类的方法名 和父类的方法名相同，方法的返回值类型，入口参数的数目，类型，顺序均相同，只是方法实现的功能不同，此时父类的方法被覆盖。
如果子类服药调用父类被隐藏的变量或被覆盖的方法，可以使用super关键字实现。
package com.ch5;
public class Ex5_13_Super1 {
/**
* 用super关键字访问父类被隐藏的成员变量 或 被覆盖的方法
* @param args
*/
public static void main(String[] args) {
AClass aClass = new AClass();
System.out.println("aClass对象创建完毕");
BClass Bclass = new BClass();
System.out.println("bClass对象创建完毕");
aClass.p1();
System.out.println("aClass.p1();语句执行完毕");
Bclass.p1();
}
}
class AClass{
int a;
float a1;
public AClass(){
a = 50;
a1 = 99.99f;
System.out.println("public AClass()构造方法执行了");
}
public void p1(){
System.out.println("this is a method of A");
System.out.println("a = " + a);
}
} // AClass end
class BClass extends AClass{
int a; // 与父类成员变量名相同，属于变量隐藏现象
public BClass(){
a = 10;
a1 = 123.6f;
System.out.println("public BClass()构造方法执行了");
}
public void p1(){ // 与父类成员方法相同，属于方法覆盖新现象
System.out.println("this is a method of B");
System.out.println("a = " + a); // 此处的a是BClass的变量值 即啊= 10
super.p1(); // 通过super调用被覆盖的父类成员方法
System.out.println("super.a = " + super.a); // 调用 被隐藏的成员变量
}
}
/**
* 在本例中，BClass 继承了AClass时，出现了变量隐藏和方法覆盖的现象，
* BClass通过super关键字调用被隐藏的父类成员变量 a 和 被覆盖的父类成员方法p1().
*
* super除了调用父类被隐藏的变量和 被覆盖的方法外，还可以显示的调用父类的构造方法。
*
* 综上所述，java提供关键字super来访问父类的成员和方法，具体有以下三种情况
* （1）用来调用父类 中被覆盖的方法
* （2）用来调用父类中被隐藏的成员变量
* （3）用来调用父类的构造方法。
*/
5.3.3 子类对象的构造
当用子类构造方法创建一个子类对象时，子类的构造方法总会显示的或隐式地 先 调用父类的某个构造方法。
如果子类的构造方法没有明显地指明调用父类的哪个构造方法，java会默认地调用父类的无参构造方法；子类也可以通过super关键字，显示地调用父类的构造方法，具体调用哪个根据super()的参数类型决定。
【例5-14】使用super调用父类的构造方法。
package com.ch5;
public class Ex5_14_SuperUse {
public static void main(String[] args) {
// TODO Auto-generated method stub
SubClass sc1 = new SubClass(); // 因为父类有 有参构造方法，所以系统
System.out.println();
SubClass sc2 = new SubClass(400);
}
}
class SuperClass{
private int n;
SuperClass(){
System.out.println("SuperClass()构造方法执行完毕*********");
}
SuperClass(int n){
System.out.println("****标志1****");
System.out.println("SuperClass(" +n+ ")");
this.n = n;
}
}
class SubClass extends SuperClass{
private int n;
SubClass(){
super(300); // B行 显式地调用父类的特定构造方法 SuperClass(int n)
System.out.println("***标志2***");
System.out.println("SubClass()");
}
SubClass(int n){
// super(); // A行 显式的调用父类的构造方法 SuperClass()
System.out.println("SubClass(" +n+ ")");
this.n = n;
}
}
结果：
标志1
SuperClass(300)
标志2
SubClass()
SuperClass()构造方法执行完毕***
SubClass(400)
子类创建时，系统默认自动调用父类的无参构造方法（这里的无参构造方法是指手动创建的无参构造方法 或者 系统提供的默认无参构造方法）【需要注意的是：如果父类有了有参数的构造方法，系统将不在提供无参构造方法，此时子类一定要避免使用父类的无参构造函数（因为可能父类没有这个函数）】。
即使注释掉A行，结果还是不变。因为父类的无参构造函数时被调用的，不管有没有super();
创建sc1的时候，没有执行父类的无参构造函数，因为 B行那里显式调用了特定的构造函数，所有无参的父类构造函数没有执行。要注意“默认”的意思，这时候就不是默认的情况了。
【例5-15】子类错误调用父类无参构造方法的示例
Ex5_15_Convert.java
package com.ch5;
public class Ex5_15_Convert {
/**
* 子类错误的调用父类的无参构造函数
*/
public static void main(String[] args) {
Doctor d = new Doctor("wang",1,"wu");
}
}
class Doctor{
String name;
int ID;
String address;
public Doctor(String name1,int ID1,String address1){
name = name1;
ID = ID1;
address = address1;
System.out.println("名字 ：" + name);
System.out.println("编号 ：" + ID);
System.out.println("地址 ：" + address );
}
public Doctor(){
// 手写 无参构造方法 如果不定义该无参构造方法，将提示 A行错误
/**
* 假设没有这个无参构造方法，因为有了有参构造方法 public Doctor(String name1,int ID1,String address1)
* 所以系统也不会给 Doctor类提供默认的无参构造方法，但是A行要调用无参构造方法，因为父类没有这个方法被调用，所以出错
*
* 其实，只有有了构造方法，不管这个构造方法有没有参数，系统都不会提供无参的构造方法了
*/
}
}
class Specialist extends Doctor{
public Specialist(String name1,int ID1,String address1){
super(name1,ID1,address1);
}
public Specialist(){
super();// 显式 调用 无参构造方法 这里可以注释，因为父类有无参构造方法，子类会隐式调用
name = "dulu";
}
}
在本例中，Specialist 类是Doctor类的子类，而Doctor 类中定义了Doctor(String name1,int ID1,String address1)构造方法，所以系统不再默认提供无参的构造方法（这里自定义了一个，不是系统提供的）
因此Specialist 类如果显式地调用super，A行错误；不显式调用，也会出错，因为会默认调用。所以手动编写了一个无参构造方法，这样就不会出错了。
因此，调用构造方法要注意以下几个原则：
（1）创建对象时调用该父类的构造方法，只要在子类的构造方法中，将第一个语句写为super语句即可，显示调用。可以有参数，也可以没有参数。
（2）如果子类构造方法中第一条语句没有用super来调用父类的构造方法，则编译器也会用super()调用父类的无参构造方法。
（3）如果某个类的构造方法第一条语句是this()调用本类外的第一个构造方法，那么java系统就不会默认用这个构造方法（这个方法是：如果某个类的构造方法）去调用父类的无参构造方法。
（4）如果父类中定义了有参构造方法，则java系统不再提供默认的无参构造方法，因此在子类的构造方法中一定要提供super语句来显式地调用父类的无参构造方法。
（5） 如果父类没有无参构造方法，而子类也没有显示地调用父类的构造方法，编译出错。因为要默认 调用无参，但父类没有。
5.3.4 对象类型转换
如同基本数据类型之间的类型转换，对象在一定范围内也可以进行类型转化。由于子类 拥有父类的方法和属性，因此，java中子类可以向上转换为父类对象（也称为向上转换类型），允许将子类实例赋值给父类的引用，也允许一个父类的引用指向子类对象。
假设 SubClass(子)是SuperClass（父） 的子类，下面的语句是合法的：
SuperClass superClass = new SubClass();
// 父类引用指向子类对象但是反过来，一个父类对象的类型 未必可以转换为子类对象，因为子类具有的信息，父类未必包含，这种转化是不安全的。只有当父类引用实际上指向一个子类对象时，才可以进行转换。
下面是错误的：
SubClass subClass = new SuperClass();【例5-16】对象类型转换示例
Ec5_16_Convert .java
package com.ch5;
/**
* 对象类型转换示例
* @author Administrator
*
*/
public class Ec5_16_Convert {
public static void main(String[] args) {
C c = new D(); // 父类引用（c）指向子类对象 创建一个子类对象，再转换为父类
System.out.println("c.n = " + c.n);// n = 0;n的值是父类的值，而不是子类n的值
c.n = 3.1415926; // 修改的是父类引用的被隐藏的变量,子类中n 的值12 没有改变
System.out.println("c.n = " + c.n);
// c.w = 300; // A行 父类引用不能操作子类 新增的 成员变量
// c.cry(); // B行 父类引用不能操作子类 新增的 成员方法
c.m = 186;
c.f();
c.g();
// C行，c 是一个子类对象，因此实际调用的是子类的g()方法，输出的n和m的值，是子类中的值，因为g()方法是继承的，不是新增的
System.out.println();
System.out.println();
D d = (D) c; // 强制将父类对象c 转换为 子类对象 用d 保存这个对象
d.n = 55;
d.f();
d.g();
d.cry();
}
}
class C{
int m = 1;
double n;
void f(){
System.out.println("被子类继承的方法 f()");
}
void g(){
System.out.println("你好，n = " + n + " m = " + m);
}
}
class D extends C{
int n = 12; // 变量隐藏
int w;
void g(){ // 方法覆盖
System.out.println("父类中现在n = " + super.n);
System.out.println("父类中现在m = " + super.m);
System.out.println("super开始");
super.g();// 调用父类的g() 和上面2行功能相同
System.out.println("super结束");
System.out.println("子类重写方法g()n, = " + n + " m = " + m);
}
void cry(){
System.out.println("子类新增的方法 void cry()");
}
}结果：
例5-16中，如果注释掉A,B两行，将会出现语法错误。C行调用的是子类重写的方法。
结论：
（1）上转型 对象 不能操作子类 新增的 成员变量和成员方法。
（2）上转型 对象 可以代替子类对象调用子类重写的实例方法。
（3）上转型 对象 可以调用子类继承的成员变量 和 隐藏的成员变量。
对象转换不仅只发生在对象赋值的情况下，也会发生在方法调用的参数传递的情况下。如果一个方法的形式参数定义的是父类对象，那么调用这个方法时，也可以使用子类作为手机参数。
【例5-17】
Ex5_17_Convert .java
package com.ch5;
public class Ex5_17_Convert {
public static void main(String[] args) {
// TODO Auto-generated method stub
TaxRate taxRate = new TaxRate();
Manager2 manager = new Manager2();
taxRate.findTaxRate(manager); // 参数传递时，对象类型转换
}
}
class TaxRate{
void findTaxRate(Employee2 e){
System.out.println("这是一条输出语句");
}
}
class Employee2{
public Employee2(){
System.out.println("public Employee2()父类构造构造方法执行了");
}
}
class Manager2 extends Employee2{
public Manager2(){
System.out.println("public Manager2() 子类构造方法执行了");
}
}
本篇结束