第七章读后感

第七章    多态

继承允许将对象视为它自己本身的类型或其基类型来加以处理。这种能力很重要，因为它允许将多种类型视为同一类型来处理，而同一份代码也就可以毫无差别地运行在这些不同类型之上了。

 

一个对象变量可以指向多种实际类型的现象被称为多态。而在运行时自动选择正确的方法进行调用的现象被称为“动态绑定”。

 

这种把对某个对象的引用视为对其基类型的引用的做法被称为“向上转型”。

 

动态绑定：

1）编译器检查对象的声明类型和方法名

2）编译器检查方法调用中提供的参数类型

3）若方法是private、final或static的，或者是一个构造器，则编译器能准确判断应调用哪个方法，称为静态绑定；而对于其他方法，要调用哪个方法只有根据隐式参数的实际类型来决定，并在运行时使用动态绑定。

4）当程序运行并且使用动态绑定调用方法时，虚拟机必须调用同隐式参数所指对象的实际类型相匹配的方法版本。

 

将某个方法声明为final有两个作用：防止别人覆盖该方法；可以有效关闭“动态绑定”，告诉编译器不需要对其进行动态绑定，可以生成更有效的代码。但是，最好根据设计来决定是否使用final，而不是出于试图提高性能的目的。

 

不能有这样的两个方法，它们具有相同的名字和参数类型，但是返回值却不同。这样会使得编译器不知该调用哪个方法。

 

class Haa{

private void f(){

        System.out.println("private");

}

}

 

public class Ha extends Haa{

public void f(){

        System.out.println("public");

}

public static void main(String[] args){

        Ha aHa=new Ha();

                     

        aHa.f();

}}//private方法被自动认为是final方法，而且对导出类是屏蔽的。Ha中的f方法是一

//个全新的方法。而且基类中的f方法在Ha中不可见，所以也不能被重载

 

仅有声明而没有方法体的是抽象方法。包含一个或多个抽象方法的类是抽象类，不需要所有的方法都是抽象的。如果从一个抽象类继承，并创建新类的对象，就要为新类中的所有抽象方法提供方法定义。

 

抽象类可以有具体方法，接口不可以。

 

构造器的工作顺序，如下

class Meal {

  Meal() { System.out.println("Meal()"); }

}

 

class Bread {

  Bread() { System.out.println("Bread()"); }

}

 

class Cheese {

  Cheese() { System.out.println("Cheese()"); }

}

 

class Lettuce {

  Lettuce() { System.out.println("Lettuce()"); }

}

 

class Lunch extends Meal {

  Lunch() { System.out.println("Lunch()"); }

}

 

class PortableLunch extends Lunch {

  PortableLunch() { System.out.println("PortableLunch()");}

}

 

public class Sandwich extends PortableLunch {

  private Bread b = new Bread();

  private Cheese c = new Cheese();

  private Lettuce l = new Lettuce();

  public Sandwich () {

    System.out.println(" Sandwich ()");

  }

  public static void main(String[] args) {

    new Sandwich ();

   

  }

} ///:~   输出为

Meal()

Lunch()

PortableLunch()

Bread()

Cheese()

Lettuce()

Sandwich ()

从这个例子中可以看出，在复杂对象调用构造器时，要遵照的顺序为：

1）  调用基类构造器（并执行基类中的初始化语句）

2）  按声明顺序调用成员的初始化方法

3）  调用导出类构造器的主体

但是，按照我的观察，如果把上述程序改为：

class a{

a(){System.out.println("Hello");}}

class Meal {

a aa=new a();

  Meal() { System.out.println("Meal()"); }

}

 

class Bread {

  Bread() { System.out.println("Bread()"); }

}

 

class Cheese {

  Cheese() { System.out.println("Cheese()"); }

}

 

class Lettuce {

  Lettuce() { System.out.println("Lettuce()"); }

}

 

class Lunch extends Meal {

  Lunch() { System.out.println("Lunch()"); }

}

 

class PortableLunch extends Lunch {

  PortableLunch() { System.out.println("PortableLunch()");}

}

 

public class Sandwich extends PortableLunch {

  private Bread b = new Bread();

  private Cheese c = new Cheese();

  private Lettuce l = new Lettuce();

  public Sandwich () {

    System.out.println(" Sandwich ()");

  }

  public static void main(String[] args) {

    new Sandwich ();

   

  }

} ///:~  输出为

Hello

Meal()

Lunch()

PortableLunch()

Bread()

Cheese()

Lettuce()

Sandwich ()

红色的代码是新添加的。由此我们可以看出，在调用基类构造器时，是将基类中的初始化语句也执行了的。所以在上面的总结中添加了括号中的红色说明。

 

一般来说，通过继承和组合来创建新类时，永远不必担心对象的清理问题。如果确实需要清理的问题，那么必须为新类创建dispose()方法，或者在导出类中覆盖dispose()方法。当覆盖基类的dispose（）方法时，务必一定要调用基类版本的dispose（）方法。

对于子对象和字段，销毁的顺序应该和初始化（子对象）和声明（字段）的顺序相反。并且，先对导出类清理，后对基类清理。

 

看看下面这个例子：

abstract class Glyph {

  abstract void draw();

  Glyph() {

    System.out.println("Glyph() before draw()");

    draw();

    System.out.println("Glyph() after draw()");

  }

}

 

class RoundGlyph extends Glyph {

  private int radius = 1;

  RoundGlyph(int r) {

    radius = r;

    System.out.println(

      "RoundGlyph.RoundGlyph(), radius = " + radius);

  }

  void draw() {

    System.out.println(

      "RoundGlyph.draw(), radius = " + radius);

  }

}

 

public class PolyConstructors {

  public static void main(String[] args) {

    new RoundGlyph(5);

   

  }

} ///:~   输出为

Glyph() before draw()

RoundGlyph.draw(), radius = 0

Glyph() after draw()

RoundGlyph.RoundGlyph(), radius = 5

逻辑上看似可以，其实结果却不是我们想要的。所以，初始化的顺序为：

1）在其他任何事务发生之前，将分配给对象的存储空间初始化成二进制的零

2）调用基类构造器（并执行基类中的初始化语句）

3）按声明顺序调用成员的初始化方法

4）  调用导出类构造器的主体

 

当不能十分确定应该使用继承还是组合时，更好的方式是首先选择组合。一条通用的准则是：用继承表达行为间的差异，并用字段表示状态上的变化。

 

在Java中，所有类型转换都会得到检查。这一点对于向下转型尤其重要。