多态性:
- 是什么
- 怎么做
优点:
- 代码组织以及可读性均能获得改善
- 创建“易于扩展”的程序
Polymorphism - 动态绑定、推迟绑定或者运行期绑定
能够不顾衍生类,只让自己的代码与基础类打交道,那么省下的工作量将是难以估计的。
可在运行期间判断对象的类型,并分别调用适当的方法;
也就是说,编译器此时已然不知道对象的类型,但方法调用机制能自己去调查,找到正确的方法主体。
Java中绑定的所有方法都采用后期绑定技术,除非一个方法已被声明成final
final的使用:
- 防止其他人覆盖这个方法
- 有效“关闭”动态绑定,或者告诉编译器不需要进行动态绑定 - 编译器就可为final方法调用生成效率更高的代码
在一个设计良好的OOP程序中,而且只与基础类接口通信。
我们说这样的程序具有“扩展性”,因为可以从通用的基础类继承新的数据类型,从而新添一些功能。如果是为了适应新类的要求,那么对基础类接口进行操纵的方法根本不需要改变。
将发生改变的东西同没有发生改变的东西区分开
// accidentally changing the interface
class NoteX{
public static final int
MIDDLE_C = 0, C_SHARP=1, C_FLAT=2;
}
class InstrumentX{
public void play(int Notex){
System.out.println("InstrumentX.play()");
}
}
class WindX extends InstrumentX{
// OOPS! Changes the method interface:
public void play(NoteX n){
System.out.println("WindX.play(NoteX n)");
}
}
public class WindError {
public static void tune(InstrumentX i){
// ...
i.play(NoteX.MIDDLE_C);
}
public static void main(String[] args) {
WindX flute = new WindX();
tune(flute); //Not the desired behavior!
}
}
/**
* “过载”是指同一样东西在不同的地方具有多种含义;
* “覆盖”是指它随时随地都只有一种含义,只是原先的含义完全被后来的含义取代了。
* 在tune 中,“InstrumentX i”会发出play()消息,同时将某个 NoteX 成员作为自变量使用(MIDDLE_C)。
* 由于NoteX 包含了int 定义,过载的play()方法的int 版本会得到调用。同时由于它尚未被“覆盖”,所以会使用基础类版本。
*/
抽象类:
Java 专门提供了一种机制,名为“抽象方法”。它属于一种不完整的方法,只含有一个声
明,没有方法主体。
包含了抽象方法的一个类叫作“抽象类”。如果一个类里包含了一个或多个抽象方法,类就必须指定成
abstract(抽象)。否则,编译器会向我们报告一条出错消息。
编译器可保证抽象类的“纯洁性”,我们不必担心会误用它。
如果从一个抽象类继承,而且想生成新类型的一个对象,就必须为基础类中的所有抽象方法提供方法定义。如果不这样做(完全可以选择不做),则衍生类也会是抽象的,而且编译器会强迫我们用abstract 关键字标志那个类的“抽象”本质。
接口:
“interface”(接口)关键字使抽象的概念更深入了一层。
我们可将其想象为一个“纯”抽象类。它允许创建者规定一个类的基本形式:方法名、自变量列表以及返回型,但不规定方法主体。
接口也包含了基本数据类型的数据成员,但它们都默认为static 和final。
注意接口中的每个方法都严格地是一个声明,它是编译器唯一允许的。
接口只是比抽象类“更纯”的一种形式;
但它用途并不止于此,由于接口根本没有具体的实施细节 - 也就是说,没有与存储空间与“接口”关联在一起 - 所以没有任何办法可以防止多个接口合并到一起。
/**
* 接口的规则是:我们可以从它继承(稍后就会看到),但这样得到的将是另一个接口。
* 如果想创建新类型的一个对象,它就必须是已提供所有定义的一个类。尽管Hero 没有为 fight()明确地提供
* 一个定义,但定义是随同ActionCharacter 来的,所以这个定义会自动提供,我们可以创建Hero 的对象。
*
* ActionCharacter.fight()
* ActionCharacter.fight()
*/
// Multiple interfaces
interface CanFight{
void fight();
}
interface CanSwim{
void swim();
}
interface CanFly{
void fly();
}
class ActionCharacter{
public void fight(){System.out.println("ActionCharacter.fight()");}
}
// 合并一个具体类与接口的时候,具体类必须首先出现,然后才是接口(否则编译器会报错)
class Hero extends ActionCharacter implements CanFight, CanSwim, CanFly{
public void swim(){}
public void fly(){}
}
public class Adventure {
static void t(CanFight x){x.fight();}
static void u(CanSwim x){x.swim();}
static void v(CanFly x){x.fly();}
static void w(ActionCharacter x){x.fight();}
public static void main(String[] args) {
Hero i = new Hero();
t(i); // Treat it as a CanFight
u(i); // Treat it as a CanSwim
v(i); // Treat it as a CanFly
w(i); // Treat it as an ActionCharacter
}
}
接口可以:能上溯造型至多个基础类。
所以假如想创建的基础类没有任何方法定义或者成员变量,那么无论如何都愿意使用接口,而不要选择抽象类。事实上,如果事先知道某种东西会成为基础类,那么第一个选择就是把它变成一个接口。只有在必须使用方法定义或者成员变量的时候,才应考虑采用抽象类。
由于置入一个接口的所有字段都自动具有static 和final 属性,所以接口是对常数值进行分组的一个好工具:
// Using interfaces to create groups of constants
public interface Months {
int
JANUARY = 1, FEBRUARY = 2, MARCH = 3,
APRIL = 4, MAY = 5, JUNE = 6, JULY = 7,
AUGUST = 8, SEPTEMBER = 9, OCTOBER = 10,
NOVEMBER = 11, DECEMBER = 12;
}
// Returning a handle to an inner class
abstract class Contents{
abstract public int value();
}
interface Destination{
String readLabel();
}
public class Parcel3 {
private class PContents extends Contents{
private int i = 11;
public int value(){
return i;
}
}
protected class PDestination implements Destination{
private String label;
private PDestination(String whereTo){
label = whereTo;
}
public String readLabel(){
return label;
}
}
public Destination dest(String s){
return new PDestination(s);
}
public Contents cont(){
return new PContents();
}
}
class Test{
public static void main(String[] args){
Parcel3 p = new Parcel3();
Contents c = p.cont();
Destination d = p.dest("Su Zhou");
//Illegal -- can't access private class:
//! Parcel3.PContents c = p.new PContents();
}
}
package chapter07.innerscopes;
interface Destination {
String readLabel();
}
package chapter07.innerscopes;
interface Contents {
int value();
}
package chapter07.innerscopes;
public class Wrapping {
private int i;
public Wrapping(int x){
i = x;
}
public int value(){
return i;
}
}
package chapter07.innerscopes;
public class Parcel4 {
public Destination dest(String s){
class PDestination implements Destination{
private String label;
private PDestination(String whereTo){
label = whereTo;
}
public String readLabel(){
return label;
}
}
return new PDestination(s);
}
public static void main(String[] args) {
Parcel4 p = new Parcel4();
Destination d = p.dest("Su Zhou");
}
}
package chapter07.innerscopes;
public class Parcel6 {
public Contents cont(){
// 创建从Contents 衍生出来的匿名类的一个对象
// 由new表达式返回的句柄会自动上溯造型成一个Contents句柄。
return new Contents(){
private int i = 11;
public int value(){
return i;
}
}; // Semicolon required in this case
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
package chapter07.innerscopes;
// 若试图定义一个匿名内部类,并想使用在匿名内部类外部定义的一个对象,则编译器要求外部对象为final属性。
public class Parcel8 {
// Argument must be final to use inside anonymous inner class
public Destination dest(final String dest){
return new Destination() {
private String label = dest;
@Override
public String readLabel() {
return label;
}
};
}
public static void main(String[] args) {
Parcel8 p = new Parcel8();
Destination d = p.dest("Su Zhou");
}
}
// 必须利用外部类的一个对象生成内部类的一个对象:
Parcel11.Contents c = p.new Contents();
// 除非已拥有外部类的一个对象,否则不可能创建内部类的一个对象
// 先是封装类的名字,再跟随一个$,
// 再跟随内部类的名字。
WithInner$Inner.class
// 如果内部类是匿名的,那么编译器会简单地生成数字,把它们作为内部类标识符使用
内部类:
- 在单独一个类里表达一个控制框架应用的全部实施细节,从而完整地封装与那个实施有关的所有东西。内部类用与表达多种不同类型的的action,用于解决实际的问题。
- 内部类使我们具体的实施变得更加巧妙,因为能方便地访问外部类的任何成员。