黑马程序员_继承的基础常识整理

-------android培训、java培训、期待与您交流！ ----------

继承：利用继承，人们可以基于已存在的类构造一个新类。继承已存在的类就是复用（继承）这些类的方法和域。在此基础上，还可以添加一些新的方法和域，以满足新的要求。

class Manager extends Employee
{
   //添加方法和域
｝

关键字extends表明正在构造的新类派生于一个已存在的类。已存在的类被称为超类（superclass）、基类（base class）或父类（parent class），新类被称为子类（subclass）、派生类类（derived class）或孩子类（child class）。

子类比超类拥有的功能更加丰富。

在通过超类定义子类的时候，仅需支持子类与超类的不同之处。因此在设计类的时候，应该将通用的方法放在超类中，而将具有特殊用途的方法放在子类中。

然而，超类中的有些方法对子类不一定适用。为此，需要提供一个新的方法来覆盖（override）超类中的这个方法。

子类中的方法不能够直接访问超类的私有域。如果一定要访问私有域，就必须借助公有的接口。

这里需要指出，我们希望调用超类中的方法，而不是当前类的这个方法，为此，可以使用特定的关键字super解决这个问题：

public double getSalary()
{
	double baseSalary =super.getSalary();
	return baseSalary = bouns;
}

在子类中可以增加域、增加方法或覆盖超类的方法，然而绝对不能删除继承的任何域和方法。

 

关键字super：super(name,salary,year,month,day);是“调用吵了Employee中含有name、salary、year、month和day参数的构造器”的简写形式。

由于子类的构造器不能访问超类的私有域，所以必须利用超类的构造器对这部分的私有域进行初始化。我们可以利用super实现对超类构造器的调用。使用super调用构造器的语句必须是子类构造器的第一条语句。

如果子类的构造器没有显式地调用超类的构造器，则将自动调用超类默认（没有参数）的构造器。如果超类没有不带参数的构造器，并且在子类的构造器中又没有显示的调用超类的其他构造器，则Java编译器将报告错误。

 

关键字this与关键字super：关键字this有两个用途：一是引用隐式参数，二是调用该类的其他构造器；同样，super关键字也有两个用途：一是调用超类的方法，二是调用超类的构造器。在调用构造器时，调用构造器的语句只能作为一个构造器的第一条语句出现。

 

多态：

一个对象变量（例如：变量e）可以引用多种实际类型的现象被称为多态（polymorphism）。

有一个用来判断是否应该设计为继承关系的简单规则，这就是“is-a”规则，它表明子类的每个对象也是超类的对象。

“is-a“规则的另一种表述方式是置换法则。它表明程序中出现超类对象的任何地方都可以用子类对象置换。例如，可以将一个子类的对象赋给超类变量。

Employee e;
e = new Employee(…); //OK
e = new Manager(…); //OK

在Java程序设计语言中，对象变量是多态的，一个超类变量（如Employee的变量）既可以引用一个Employee类的对象，也可以引用一个Employee类的任何一个子类的对象。

但是，超类的变量不能调用子类的方法。

另外，不能将一个超类的引用赋给子类变量。

 

动态绑定：

一个对象变量（例如：变量e）在运行时能够自动选择调用哪个方法的现象称为动态绑定（dynamic binding）。

弄清调用对象的方法执行过程十分重要，下面是调用过程的详细描述：

1)     编译器查看对象的声明类型和方法名。假设调用x.f(param)，且隐式参数x声明为C类的对象。需要注意的是：有可能存在多个名为f，但参数类型不一样的方法。例如：可能存在方法f(int)和f方法(String)。编译器会一一列举所有C类中名为f的方法和其超类中访问属性为public且名为f的方法。

至此，编译器已获得所有可能被调用的候选方法。

2)     接下来，编译器将查看调用方法时提供的参数类型。如果在所有名为f的方法中存在一个与提供的参数类型完全匹配，就选择这个方法。这个过程被称为重载解析(overloadingresolution)。例如，对于调用x.f(“Hello”)来说，编译器会挑选f(String)，而不是f(int)。由于允许类型转换（int可以转换成double，Manager可以转换成Employee，等等），所以这个过程可能很复杂。如果编译器没有找到与参数类型匹配的方法，或者发现经过转换后有多个方法与之匹配，就会报告一个错误。

至此，编译器已获得需要调用的方法的名字和参数类型。

PS：从Java SE 5.0开始，允许子类将覆盖方法的返回类型定义为原返回类型的子类型。

3)     如果是private方法、static方法、final方法或者构造器，那么编译器可以准确的知道应该调用哪个方法，我们将这种调用方式称为静态绑定（static binding）。与此对应的是，调用的方法依赖于隐式参数的实际类型，并且在运行时实行动态绑定。

4)     当程序运行时，并且采用动态绑定调用方法时，虚拟机一定调用与x所引用对象的实际类型最合适的那个类的方法。假设x的实际类型是D，它是C类的子类。如果D类定义了方法f(String)，就直接调用它，否则，将在D类的超类中寻找f(String)，以此类推。

 

每次调用方法都要进行搜索，时间开销相当大。因此，虚拟机预先为每个类创建了一个方法表(methodtable)。其中列出了所有方法的签名和调用方法。这样一来，在真正调用方法的时候，虚拟机仅查找这个表就行了。

如果调用super.f(param)，编译器将对隐式参数的方法表进行搜索。

 

动态绑定有一个非常重要的特性：无需对现存的代码进行修改，就可以对程序进行扩展。假设增加一个新类Executive，并且变量e有可能引用这个新类的对象，我们不需要对包含调用e.getSalary()的代码重新编译，如果e恰好调用了一个Executive类的对象，就会自动地调用Executive.getSalary()方法。

PS：在覆盖一个方法的时候，子类方法低于超类方法的可见性。特别是，如果超类方法是public，子类方法一定要声明为public。

 

阻止继承：final类和方法

有时候  ，可能希望阻止人们利用某个类定义子类。不允许扩展的类被称为final类。如果在定义类的时候使用了final修饰符就表示这个类是final类。

final class Executive extends Manager
{
	//代码省略
}

类中的方法也可以被声明为final。如果这样做，子类就不能覆盖这个方法了（final类中的所有的方法自动的称为final方法）。

public final String getName()
{
	return this.name;
}

PS：如果将一个类声明为final，只有其中的方法自动的成为final，而不包括域。

将方法或类声明为final可以确保它们不会在子类中改变语义。

 

强制类型转换

将一个类强制转换成另外一个类型的过程被称为类型转换。

进行类型转换的唯一原因是：在忽视对象的实际类型之后，使用对象的全部功能。

将一个值存入变量时，编译器将检查是否允许该操作。将一个子类的引用赋给一个超类，编译器是允许的，但是将一个超类的引用赋给一个子类变量，必须进行类型转换，这样才能够通过运行时检查。

       Manager boss = (Manager)staff[1];   //ERROR

运行这个程序时，Java运行时系统将报告这个错误，并产生一个ClassCastException异常，如果没有捕获这个异常，那么程序就会终止。因此，应该养成一个良好的程序设计习惯，在进行类型转换之前，先看一下是否能够成功的转换。这个过程简单的使用instanceof运算符就可以实现：

if( staff[1] instanceof Manager)
{
	Manager boss = (Manager)staff[1];
	//代码省略
}

最后，如果这个类型转换不可能成功，编译器就不会进行转换。例如，下面这个类型转换：

Date c = (Date)staff[1];

将会产生编译错误，这是因为Date不是Employee的子类。

综上所述：

1.     只能在继承层次内进行类型转换。

2.     再将超类转换成子类之前，应该使用instanceof检查。

 

抽象类

如果自下而上仰视类的继承层次结果，位于上层的类更具有通用性，甚至可能更加抽象。从某种角度来看，祖先类更加通用，人们只将它作为派生其他类的基类，而不作为想使用的特定的实例类。

在方法中添加abstract关键字，这样就完全不需要实现这个方法了：

public abstract String getDescription();
//no implementation required

为了提供程序的清晰度，包含一个或多个抽象类方法的类本身必须声明为抽象的：

abstract class Person
{
	…
	public abstract StringgetDescription();
}

除了抽象方法之外，抽象类还可以包含具体数据和具体方法。

 

抽象方法充当这占位的角色，它们具体的实现在子类中。扩展抽象类可以有两种选择。一种是在子类中定义部分抽象方法或抽象方法也不定义，这样就必须将子类也标记为抽象类；另一种是定义全部的抽象方法，这样一来，子类就不是抽象的了。

类即使不含抽象方法，也可以将类声明为抽象类。

抽象类不能被实例化，也就是说，如果将一个类声明为abstract，就不能创建这个类的对象，但是，可以创建一个具体子类的对象。

需要注意，可以定义一个抽象类的对象变量，但是它只能引用非抽象子类的对象：

Person p = new Student(“Vince Vu”,”Economics”);

这个的p是一个抽象类Person的变量，它引用了一个非抽象类Student的实例。

由于不能构造抽象类Person的对象，所有变量p永远不会引用Person对象，而是引用诸如Employee或Student这样的具体子类对象，而在这些对象中都定义了getDescription方法。

是否可以省略Person超类中的抽象方法，而仅在Employee和Student子类中定义getDescription方法呢？如果这样的话，就不能通过变量p调用getDescription方法了。编译器只允许调用在类中声明的方法。

 

Object：所有类的超类

Object类是Java中所有类的最终祖先，在Java中每个类都是由它扩展而来的。

可以使用Object类型的变量引用任何类型的对象：

Object obj = new Employee(“Harry Hacker”,35000);

当然，Object类型的变量只能作为各种值的通用持有至，要想对其中的内容进行具体的操作，还需要清楚对象的原始类型，并进行相应的类型转换：

Employee e = (Employee)obj;

在Java中，只有基本类型（primitive types）不是对象。所有的数组类型，不管是对象数组还是基本类型的数组都扩展于Object类。