java的抽象类和办法[Java编程]

在我们全部乐器（Instrument）例子中,底子类Instrument内的办法都必定是“伪”办法.若去调用这些办法,就会呈现错误.那是由于Instrument的企图是为从它衍生出去的全部类都成立一个通用接口.
之所以要成立这个通用接口,唯一的缘由就是它能为差别的子范例作出差别的表示.它为我们成立了一种基本情势,使我们能定义在全部衍生类里“通用”的一些东西.为阐述这个见解,另一个办法是把Instrument称为“抽象底子类”（简称“抽象类”）.若想通过该通用接口处理一系列类,就需求成立一个抽象类.对全部与底子类声明的签名符合的衍生类办法,都可以通过动态绑定机制举行调用（但是,正如上一节指出的那样,假如办法名与底子类相同,但自变量或参数差别,就会呈现过载现象,那大概并非我们所乐意的）.
假若有一个象Instrument那样的抽象类,那个类的对象几近必定没有什么意义.换言之,Instrument的作用仅仅是表达接口,而不是表达一些具体的实施细节.所以成立一个Instrument对象是没有意义的,并且我们普通都应禁止用户那样做.为到达这个目的,可令Instrument内的全部办法都显示出错消息.但这样做会耽误信息到运行期,并要求在用户那一面举行完好、坚固的测试.无论若何,最好的办法都是在编译期间捕捉到问题.
针对这个问题,Java专门供应了一种机制,名为“抽象办法”.它属于一种不完好的办法,只含有一个声明,没有办法主体.下面是抽象办法声明时采取的语法:
abstract void X();
包含了抽象办法的一个类叫作“抽象类”.假如一个类里包含了一个或多个抽象办法,类就必须指定成abstract（抽象）.不然,编译器会向我们报告一条出错消息.
若一个抽象类是不完好的,那么一旦有人试图生成那个类的一个对象,编译器又会采纳什么行动呢?由于不能安全地为一个抽象类成立属于它的对象,所以会从编译器那边得到一条出错提醒.通过这种办法,编译器可保证抽象类的“纯真性”,我们没必要耽忧会误用它.
假如从一个抽象类担当,并且想生成新范例的一个对象,就必须为底子类中的全部抽象办法供应办法定义.假如不这样做（完好可以挑选不做）,则衍生类也会是抽象的,并且编译器会逼迫我们用abstract关键字标志那个类的“抽象”本质.
即便不包含任何abstract办法,亦可将一个类声明成“抽象类”.假如一个类没必要拥有任何抽象办法,并且我们想禁止那个类的全部实例,这种本领就会显得非常有效.
Instrument类可很轻松地转换成一个抽象类.只有此中一部份办法会变成抽象办法,因为使一个类抽象今后,并不会逼迫我们将它的全部办法都同时变成抽象.下面是它看起来的模样:

下面是我们改正过的“管弦”乐器例子,此中采取了抽象类以及办法:

//: Music4.java
// Abstract classes and methods
import java.util.*;

abstract class Instrument4 {
  int i; // storage allocated for each
  public abstract void play();
  public String what() {
    return "Instrument4";
  }
  public abstract void adjust();
}

class Wind4 extends Instrument4 {
  public void play() {
    System.out.println("Wind4.play()");
  }
  public String what() { return "Wind4"; }
  public void adjust() {}
}

class Percussion4 extends Instrument4 {
  public void play() {
    System.out.println("Percussion4.play()");
  }
  public String what() { return "Percussion4"; }
  public void adjust() {}
}

class Stringed4 extends Instrument4 {
  public void play() {
    System.out.println("Stringed4.play()");
  }
  public String what() { return "Stringed4"; }
  public void adjust() {}
}

class Brass4 extends Wind4 {
  public void play() {
    System.out.println("Brass4.play()");
  }
  public void adjust() { 
    System.out.println("Brass4.adjust()");
  }
}

class Woodwind4 extends Wind4 {
  public void play() {
    System.out.println("Woodwind4.play()");
  }
  public String what() { return "Woodwind4"; }
}

public class Music4 {
  // Doesn't care about type, so new types
  // added to the system still work right:
  static void tune(Instrument4 i) {
    // ...
    i.play();
  }
  static void tuneAll(Instrument4[] e) {
    for(int i = 0; i < e.length; i++)
      tune(e[i]);
  }
  public static void main(String[] args) {
    Instrument4[] orchestra = new Instrument4[5];
    int i = 0;
    // Upcasting during addition to the array:
    orchestra[i++] = new Wind4();
    orchestra[i++] = new Percussion4();
    orchestra[i++] = new Stringed4();
    orchestra[i++] = new Brass4();
    orchestra[i++] = new Woodwind4();
    tuneAll(orchestra);
  }
} ///:~