JAVA的思考(关于接口,抽像类,内部类)

这样便带来了一个问题：

到底应该使用一个接口还是一个抽象类呢？若使用接口，我们可以同时获得抽象类以及接口的好处。所以假如想创建的基础类没有任何方法定义或者成员变量，那么无论如何都愿意使用接口，而不要选择抽象类。事实上，如果事先知道某种东西会成为基础类，那么第一个选择就是把它变成一个接口。只有在必须使用方法定义或者成员变量的时候，才应考虑采用抽象类。

interface Monster {

  void menace();

}

interface DangerousMonster extends Monster {

  void destroy();

}

interface Lethal {

  void kill();

}

class DragonZilla implements DangerousMonster {

  public void menace() {}

  public void destroy() {}

}

interface Vampire 
     
     

    extends DangerousMonster, Lethal {
     
     

  void drinkBlood();
     
     

}-----------------多接口继承

class HorrorShow {

  static void u(Monster b) { b.menace(); }

  static void v(DangerousMonster d) {

    d.menace();

    d.destroy();

  }

  public static void main(String[] args) {

    DragonZilla if2 = new DragonZilla();

    u(if2);

    v(if2);

  }

} ///:~

7.5.4 初始化接口中的字段
接口中定义的字段会自动具有static和final属性。它们不能是“空白final”，但可初始化成非常数表达式。例如：

//: RandVals.java

// Initializing interface fields with 

// non-constant initializers

import java.util.*;

public interface RandVals {

  int rint = (int)(Math.random() * 10);

  long rlong = (long)(Math.random() * 10);

  float rfloat = (float)(Math.random() * 10);

  double rdouble = Math.random() * 10;

} ///:~
     
     

7.6.4 static内部类
     
     

为正确理解static在应用于内部类时的含义，必须记住内部类的对象默认持有创建它的那个封装类的一个对象的句柄。然而，假如我们说一个内部类是static的，这种说法却是不成立的。static内部类意味着：
(1) 为创建一个static内部类的对象，我们不需要一个外部类对象。
(2) 不能从static内部类的一个对象中访问一个外部类对象。
但在存在一些限制：由于static成员只能位于一个类的外部级别，所以内部类不可拥有static数据或static内部类。
倘若为了创建内部类的对象而不需要创建外部类的一个对象，那么可将所有东西都设为static。为了能正常工作，同时也必须将内部类设为static

 

7.6.5 引用外部类对象
若想生成外部类对象的句柄，就要用一个点号以及一个this来命名外部类。举个例子来说，在Sequence.SSelector类中，它的所有方法都能产生外部类Sequence的存储句柄，方法是采用Sequence.this的形式。结果获得的句柄会自动具备正确的类型（这会在编译期间检查并核实，所以不会出现运行期的开销）。
有些时候，我们想告诉其他某些对象创建它某个内部类的一个对象。为达到这个目的，必须在new表达式中提供指向其他外部类对象的一个句柄，就象下面这样：

//: Parcel11.java

// Creating inner classes

package c07.parcel11;

public class Parcel11 {

  class Contents {

    private int i = 11;

    public int value() { return i; }

  }

  class Destination {

    private String label;

    Destination(String whereTo) {

      label = whereTo;

    }

    String readLabel() { return label; }

  }

  public static void main(String[] args) {

    Parcel11 p = new Parcel11();

    // Must use instance of outer class

    // to create an instances of the inner class:

    Parcel11.Contents c = p.new Contents();

    Parcel11.Destination d =

      p.new Destination("Tanzania");

  }

} ///:~

为直接创建内部类的一个对象，不能象大家或许猜想的那样——采用相同的形式，并引用外部类名Parcel11。此时，必须利用外部类的一个对象生成内部类的一个对象：
Parcel11.Contents c = p.new Contents();
因此，除非已拥有外部类的一个对象，否则不可能创建内部类的一个对象。这是由于内部类的对象已同创建它的外部类的对象“默默”地连接到一起。然而，如果生成一个static内部类，就不需要指向外部类对象的一个句柄。