5.1 类超类和子类
Posted motivated_Dou
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了5.1 类超类和子类相关的知识，希望对你有一定的参考价值。
5.1 类、超类和子类
子类比超类拥有的功能更加丰富。
在本例中，Manager类比超类Employee封装了更多的数据，拥有更多的功能。
在Manager类中，增加了一个用于存储奖金信息的域，以及一个用于设置这个域的方法：
class Manager extends Employee
{
private double bonus;
...
public void setBouns(double b)
{
bonus = b;
}
}
如果有一个Manager对象，就可以使用setBonus方法。
Manager boss = ... ; boss.setBonus(5000);
由于setBonus方法不是在Employee类中的定义，所以属于Employee类的对象不能使用它。
从超类中还继承了name、salary和hireDay这3个域，所以现在就有了4个域（由于增加了bonus域）。
在通过扩展超类定义子类的时候，仅需要指出子类和超类的不同之处，因此，会将通用的方法放在超类中，而将具有特殊用途的方法放在子类中，这种将通用的功能放在超类的方法，在面向对象程序设计中十分普遍。
超类中的有些方法在子类Manager中不一定适用，比如说Manager中的getSalary方法应该返回薪水和奖金的总和，为此需要提供一个新的方法来覆盖（override）超类中的这个方法。
class Manager extends Employee
{
...
//这个方法是错误的
public double getSalary()
{
return salary + bonus;
}
...
}
由于Manager类的getSalary方法不能直接地访问超类的私有域。尽管每个Manager对象都拥有一个名为salary的域，但在Manager类的getSalary方法中并不能直接访问salary域。只有Employee类的方法才能够访问私有部分。如果Manager类的方法一定要访问私有域，就必须借助公共的接口，Employee类中的公有方法getSalary就是这个公共接口。
public double getSalary()
{
//通过子类的getSalary方法不能获得超类的salary域
//所以以下这种方式也是错误的
double baseSalary = getSalary();
return baseSalary + bonus;
}
为了获取salary域，就必须要调用超类Employee中的getSalary方法，而不是当前类的这个方法。
为了调用超类Employee中的getSalary方法，而不是当前类的getSalary，必须使用super关键字来解决这个问题：
public double getSalary()
{
double baseSalary = super.getSalary();
return baseSalary + bonus;
}
在子类中可以增加域、增加方法或覆盖超类的方法，然而绝对不能删除继承的任何域和方法。
public Manager(String n, double s, int year, int month, int day)
{
super(n, s, year, month, day);
bonus = 0;
}
这里的super语句super(n, s, year, month, day)是“调用超类Employee中含的n、s、year、month和day参数的构造器”的简写方式。
由于Manager类的构造器不能访问Employee类的私有域，所以必须利用Employee类的构造器对这部分私有域进行初始化，我们可以通过super实现对超类构造器的调用。使用super调用构造器的语句必须是子类构造器的第一条语句。
综上，super的作用：
1、调用超类的方法；
2、调用超类的构造器。（调用构造器的语句只能作为另一个构造器的第一个语句出现）
重新定义Manager对象的getSalary方法之后，奖金就会自动添加到经理的薪水中。
Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
boss.setBonus(50000);
接下来定义一个包含3个雇员的数组，将经理和雇员的信息都放在数组中：
Employee[] staff = new Employee[3];
staff[0] = boss;
staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
staff[2] = new Employee("Tony Tester", 40000, 1990, 3, 15);
for(Employee e:staff)
{
System.out,println(e.getName() + " " + e.getSalary());
}
这里staff[1]和staff[2]仅输出基本薪水，这是因为它们对应的是Employee对象，而staff[0]对应的是Manager对象，它的getSalary方法将奖金和基本薪水加在了一起。
在这里将e声明为Employee类型，但实际上它既可以引用Employee类型的对象，也可以引用Manager类型的对象。当e引用Employee对象的时候，e.getSalary()调用的是Manager类中getSalary方法，当e引用Manager对象的时候，e.getSalary()调用的是Manger类中的getSalary方法。
虚拟机知道e实际引用的对象类型，因此能够正确地调用相应的方法。
一个对象变量可以指示多种实际类型的现象被称为多态（polmorphism）。在运行时能够自动选择调用哪个方法的现象称为动态绑定（dynamic binding）。
Employee.java
package inheritance;
import java.util.Date;
import java.util.GregorianCalendar;
public class Employee {
private String name;
private double salary;
private Date hireDay;
public Employee(String n, double s, int year, int month, int day)
{
name = n;
salary = s;
GregorianCalendar calender = new GregorianCalendar(year, month - 1, day);
hireDay = calender.getTime();
}
public String getName()
{
return name;
}
public double getSalary()
{
return salary;
}
public Date getHireDay()
{
return hireDay;
}
public void raiseSalary(double byPercent)
{
double raise = salary * byPercent/10;
salary += raise;
}
}
Manager.java
package inheritance;
public class Manager extends Employee
{
private double bonus;
//其余的参数会从Employee继承来
public Manager(String n, double s, int year, int month, int day)
{
super(n, s, year, month, day);
bonus = 0;
}
public double getSalary()
{
double baseSalary = super.getSalary();
return baseSalary + bonus;
}
public void setBonus(double b)
{
bonus = b;
}
}
ManagerTest.java
package inheritance;
public class MangerTest {
public static void main(String args[])
{
Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
boss.setBonus(5000);
Employee[] staff = new Employee[3];
staff[0] = boss;
staff[1] = new Employee("Harry Cracker", 50000, 1989, 10, 1);
staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);
for(Employee e:staff)
{
System.out.println("name = " + e.getName() + ",salary = " + e.getSalary());
}
}
}
5.1.1 继承层次
Java是不允许“实现多继承”，简称不允许“多继承”。但是Java支持“声明多继承”——Java的接口的多继承——一个类可以实现多个接口（“继承”了多个接口上的方法声明），而一个接口可以继承多个接口（同样是“继承”了多个接口上的方法声明）。
5.1.2 多态
可以将一个子类的对象赋值给超类变量。
对象变量是多态的，一个Employee变量既可以引用一个Employee对象，也可以引用一个Employee类的任何一个子类的对象（例如Manager类）。
Manager boss = new Manager(...); Employee[] staff = new Employee[3]; staff[0] = boss;
在这个例子中，staff[0]和boss引用的是同一个对象，但编译器将staff[0]看成Employee对象。所以以下调用方式是正确的：
boss.setBonus(5000);
但下面这种调用方式是错误的：
staff[0].setBonus(5000);
这是因为staff[0]声明的类型是Employee，而setBonus方法是Manager类的方法，不是Employee类的方法。
可以将一个子类变量赋给一个超类变量，但不能将一个超类变量赋给一个子类变量。
5.1.3 动态绑定
调用方法的过程可以分解为：
（1）编译器查看对象的声明类型和方法名。假设调用x.f(param)，且隐式参数x声明为C类的对象。有可能存在多个名字为f，但参数不一样的方法。例如可能存在方法f(int)和f(Stirng)，编译器会一一列举所有C类中名为f的方法和其超类中访问属性为private且名为f的方法（超类的私有方法不可访问）。至此，编译器已获得所有可能被调用的候选方法。
（2）编译器查看调用方法时提供的参数类型。如果在所有名为f的方法中存在一个与提供的参数类型完全匹配，就选择这个方法这个过程被称为重载解析（overloading resolution）。例如，对于调用x.f("Hello")来说，编译器将会挑选f(String)，而不是f(int)。
方法签名：方法的名字和参数列表称为方法的签名。
（3）如果是private方法、static方法、final方法或者构造器，那么编译器将可以准确地知道应该调用哪个方法，我们讲这种方法称为静态绑定（static binding）。与此对应的是，调用的方法依赖于隐式参数的实际类型，并且在运行时实现动态绑定。
（4）程序运行而且采用动态绑定调用方法的时候，虚拟机一定调用与x所引用对象的实际类型最合适的那个类的方法。假设x的实际类型是D，它是C类的子类，如果D类定义了一个方法f(String)，就直接调用它，否则就在D类的超类中寻找f(String)方法，以此类推。
每次调用方法的时候都要进行搜索，时间开销很大，所以虚拟机预先为每个类创建了一个方法表（method table），其中列出了所有方法的签名和实际调用的方法，当需要调用方法的时候，虚拟机查找这个表就可以了。
对于之前的e.getSalary()，e声明为Employee类型，由于这个方法没有参数，所以不需要担心方法重载的问题。
方法重载（method overload）的具体规范 如果有两个方法的方法名相同，但参数不一致，那么可以说一个方法是另一个方法的重载。 一.方法名一定要相同。 二.方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。 1.如果参数个数不同，就不管它的参数类型了！ 2.如果参数个数相同，那么参数的类型或者参数的顺序必须不同。 三.方法的返回类型、修饰符可以相同，也可不同。 四.main方法也可以被重载 方法重载的作用：可以一个相同的方法传入不同的参数以达到想要的结果
所以，e.getSalary()执行的过程如下：
（1）虚拟机提取e的实际类型的方法表，即可能是Employee、Manager的方法表，也可能是Employee类的其他子类的方法表；
（2）虚拟机搜索定义getSalary签名的类，此时，虚拟机已经知道应该调用哪个方法；
（3）虚拟机调用方法。
动态绑定有一个非常重要的特征：无需对现存的代码进行修改，就可以对程序进行扩展。
假设现在增加了一个新类Excutive，并且e有可能引用这个类的对象，我们不需要对包含调用e.getSalary()的代码进行重新编译。如果e恰好引用一个Excutive类的对象，就会自动调用Excutive.getSalary()方法。
5.1.4 阻止继承 final类和方法
有时候，可能希望组织人们利用某个类定义子类，不允许扩张的类称为final类，如果在定义类的时候使用了final修饰符就表示这个类是final类。
将方法或类声明为final的主要目的是：确保它们不会在子类中改变语义。例如，Calender类中的getTime和setTime方法都声明为final。这表明Calender类的设计者负责实现Date类与日历状态之间的转换，而不允许子类处理这些问题。
5.1.5 强制类型转换
将一个类型强制转换成另外一个类型的过程被称为类型转换。
double x = 3.45; int nx = (int)x;
将表达式x的值转换为int类型，丢弃了小数部分。
有时候我们需要将某个类的对象引用转换为另外一个类的对象引用，对象引用的类型转换只需要用括号将目标类名称括起来，并放置在需要转换的对象引用之前就可以了。
Manager boss = (Manager) staff[0];
将一个值存入变量的时候，编译器将检查是否允许该操作。一个子类的引用赋给一个超类变量，编译器是允许的，但是将一个超类变量的引用赋给一个子类变量，必须进行类型转换，这样才能够通过运行时的检查。
运行上述程序的时候，java运行系统会报告错误，并差生一个ClassCaseException异常，如果没有捕获这个异常，程序就会终止。所以在进行类型转换的时候，先查看一下是否成功进行地转换，这个过程只需要使用instanceof运算符即可实现。
例如：
if(staff[1] instanceof Manager)
{
boss = (Manager)staff[1];
...
}
如果这个类型转换不成功，编译器就不会通过这个转换。
例如：
Date c = (Date)staff[1];
将会产生编译错误，因为Date不是Employee的子类。
综上所述：
- 只有在继承层次上才能进行类型转换；
- 在将超类转换成子类之前，需要使用instanceof进行检查。
实际上，通过类型转换调整对象的类型不是一种好方法，在我们的实际过程中，大多数情况下并不需要将Employee对象转换成Manager对象，两个类的对象都能够正确地调用getSalary方法，因为实现多态性的动态绑定机制能够自动地找到相应的方法。
只有在使用Manager中特有的方法的时候才需要进行类型转换，例如setBonus方法，如果鉴于某种原因，发现需要通过Employee对象调用setBonus方法，那么就应该检查一下超类的设计是否合理，重新设计并添加setBonus方法才是最正确的选择。
只要没有捕获ClassCaseException异常，程序就会终止，在一般情况下，尽量少用类型转换和instanceof运算符。
5.1.6 抽象类
位于上层的类更具有通用性，甚至可能更加抽象。从某种角度看，祖先类更加通用，人们只将它作为派生其他类的基类，而不作为想使用的特定的实例类。
学生和雇员都有姓名属性，因此可以将getName方法放置在继承关系较高层次的通用超类中。
现在，再增加一个getDescription方法，它可以返回对一个人的简短描述。例如：
an employee with a salary of $50000
a student majoring in computer science
在Employee类和Student类中实现这个方法很容易，但是在Person类中，除了姓名之外，Person类一无所知。所以，在这里更好的方法就是使用abstract关键字，这样就完全不需要实现这个方法了。
public abstract String getDescription();
为了提高程序的清晰度，包含一个或多个抽象方法的类本身必须被声明为抽象类。
abstract class Person
{
...
public abstract String getDescription();
}
除了抽象方法之外，抽象类还可以包含具体数据和具体方法。例如，Person类还保存着姓名和一个返回姓名的具体方法。
abstract class Person
{
private String name;
public Person(String n)
{
name = n;
}
public abstract String getDescription();
public String getName()
{
return name;
}
}
抽象方法充当着“占位”的角色，它们的具体实现是在子类中，抽象扩展类可以有两种选择。一种是在子类中定义部分抽象方法或抽象方法也不定义，这样就必须将子类也标记为抽象类；另一种是定义全部的抽象方法，这样子类就不是抽象的了。
类即使不包含抽象方法，也可以将类声明为抽象类。
抽象类不能被实例化，也就是说，如果将一个类声明为abstract，就不能创建这个类的对象。例如，由于Person是抽象类，表达式
new Person("Vince Vu")
这种方法是错的，但可以创建一个具体子类的对象。
虽然抽象类不能实例化，但是可以引用非抽象子类的对象。例如，
Person p = new Student("Vince Vu", "Economics");
这里的p是一个抽象类Person的变量，引用的是一个非抽象类Student的实例。
在之前定义的抽象类Person中有两个具体的方法：Person(String n)和String getName()方法。
class Student extends Person
{
private String major;
public Student(String n, String m)
{
super(n);
major = m;
}
public String getDescription()
{
return "a student majoring in" + major;
}
}
在Student类中定义了一getDescription方法，而且由于继承来的方法也是非抽象的，所以，Student类中的方法全部都是非抽象的，这个类也不再是抽象类。
Person类
package class_5_4;
public abstract class Person
{
public abstract String getDescription();
private String name;
public Person(String n)
{
name = n;
}
public String getName()
{
return name;
}
}
Employee类
package class_5_4;
import java.util.Date;
import java.util.GregorianCalendar;
public class Employee extends Person
{
private double salary;
private Date hireDay;
public Employee(String n, double s, int year, int month, int day)
{
super(n);
salary = s;
GregorianCalendar calender = new GregorianCalendar(year, month - 1, day);
hireDay = calender.getTime();
}
public double salary()
{
return salary;
}
public Date getHireDay()
{
return hireDay;
}
public String getDescription()
{
return String.format("an employee with a salary of %.2f", salary);
}
public void raiseSalary(double byPercent)
{
double raise = salary*byPercent/100;
salary += raise;
}
}
Student类
package class_5_4;
public class Student extends Person
{
private String major;
public Student(String n, String m)
{
super(n);
major = m;
}
public String getDescription()
{
return "a student majoring in " + major;
}
}
PersonTest.java
package class_5_4;
public class PersonTest
{
public static void main(String args[])
{
Person[] people = new Person[2];
people[0] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
people[1] = new Student("Maria Morris", "computer");
for(Person p:people)
{
System.out.println(p.getName() + "," + p.getDescription());
}
}
}
输出的结果为：
Harry Hacker,an employee with a salary of 50000.00 Maria Morris,a student majoring in computer
以上是关于5.1 类超类和子类的主要内容，如果未能解决你的问题，请参考以下文章