Java abstract 关键字

abstract是声明抽象类和抽象方法的关键字

包含抽象方法的类叫抽象类,如果一个类中包含一个或多个抽象方法,该类必须被限定为抽象的,否则编译器会报错,抽象类不可创建对象,创建抽象类的对象编译器会报错

//: interfaces/music4/Music4.java
// Abstract classes and methods.
package object;
import static net.mindview.util.Print.print;

enum Note {
    MIDDLE_C,MIDDLE_E,MIDDLE_F,
}
abstract class Instrument {
  private int i; // Storage allocated for each
  public abstract void play(Note n);
  public String what() { return "Instrument"; }
  public abstract void adjust();
}

class Wind extends Instrument {
  public void play(Note n) {
    print("Wind.play() " + n);
  }
  public String what() { return "Wind"; }
  public void adjust() {}
}

class Percussion extends Instrument {
  public void play(Note n) {
    print("Percussion.play() " + n);
  }
  public String what() { return "Percussion"; }
  public void adjust() {}
}

class Stringed extends Instrument {
  public void play(Note n) {
    print("Stringed.play() " + n);
  }
  public String what() { return "Stringed"; }
  public void adjust() {}
}    

class Brass extends Wind {
  public void play(Note n) {
    print("Brass.play() " + n);
  }
  public void adjust() { print("Brass.adjust()"); }
}

class Woodwind extends Wind {
  public void play(Note n) {
    print("Woodwind.play() " + n);
  }
  public String what() { return "Woodwind"; }
}    

public class Music4 {
  // Doesn‘t care about type, so new types
  // added to the system still work right:
  static void tune(Instrument i) {
    // ...
    i.play(Note.MIDDLE_C);
  }

  static void tuneAll(Instrument[] e)
  {
    for(Instrument i : e)
      tune(i);
  }
  public static void main(String[] args) {
    // Upcasting during addition to the array:
    Instrument[] orchestra = {
      new Wind(),
      new Percussion(),
      new Stringed(),
      new Brass(),
      new Woodwind()
    };
    tuneAll(orchestra);
  }
} /* Output:
Wind.play() MIDDLE_C
Percussion.play() MIDDLE_C
Stringed.play() MIDDLE_C
Brass.play() MIDDLE_C
Woodwind.play() MIDDLE_C
*///:~

原文地址:https://www.cnblogs.com/jiangfeilong/p/10204453.html

时间: 2024-11-05 20:24:30

Java abstract 关键字的相关文章

Java abstract关键字

抽象类: 1.语法定义:抽象类钱使用abstract关键字修饰,则该类为抽象类 2.使用场景: 在某些情况下,某个父类只是知道其子类应该包含怎样的方法,但无法准确知道这些子类如何实现这些方法 从多个具有相同特征的类中抽象出一个抽象类,以这个抽象类作为子类的模板,从而避免子类设计的随意性 3.作用: 限制规定子类必须实现某些方法,但不关注实现细节 4.使用规则: abstract定义抽象类 abstract定义抽象方法,只是声明,不需要实现 包含抽象方法的类是抽象类 抽象类中可以包含普通的方法,也

Java 抽象类和 abstract 关键字

抽象类的概念: 包含一个抽象方法的类就是抽象类 抽象方法: 声明而未被实现的方法就是抽象方法,抽象方法必须使用 abstract 关键字进行声明 需要注意的是, 1. 抽象类被子类继承时,子类(如果不是抽象类)必须重写抽象类中的『所有』抽象方法 2. 抽象类不能直接被实例化,需要通过其子类进行实例化 抽象类的定义格式: abstract class className{ 属性 方法 抽象方法 } 代码如下: package hello; abstract class Abs{ private i

Java之关键字abstract(抽象类与抽象方法)

/* * abstract关键字的使用 * 1.abstract:抽象的 * 2.abstract可以用来修饰的结构:类.方法 * * 3. abstract修饰类:抽象类 * > 此类不能实例化 * > 抽象类中一定有构造器,便于子类实例化时调用(涉及:子类对象实例化的全过程) * > 开发中,都会提供抽象类的子类,让子类对象实例化,完成相关的操作 * * * 4. abstract修饰方法:抽象方法 * > 抽象方法只有方法的声明,没有方法体 * > 包含抽象方法的类,一

java的关键字与保留字

1,Java 关键字列表 (依字母排序 共50组): abstract, assert, boolean, break, byte, case, catch, char, class, const(保留关键字), continue, default, do, double, else, enum, extends, final, finally, float, for, goto(保留关键字), if, implements, import, instanceof, int, interface

java abstract与interface解析

java abstract与interface解析 abstract 定义 在面向对象的概念中,所有的对象都是通过类来描述.但是,反过来,不是所有的类都是用来描述对象的(把类具体化).如果一个类没有包含足够的信息来描述一个具体的对象,那么这个类就是抽象类. 比如,我们进行一个图形编辑软件的开发,就会发现问题域中存在圆,三角形这样一些具体的概念,它们是不同的,但是它们又都属于形状这样一个概念.形状这个概念在问题域中是不存在的,它就是一个抽象的概念.正是因为抽象的概念在问题领域没有对应的具体概念,所

Java的关键字和保留字

JAVA的关键字对java的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等.保留字是为java预留的关键字,他们虽然现在没有作为关键字,但在以后的升级版本中有可能作为关键字. Java 关键字列表 (依字母排序 共50组): abstract, assert,boolean, break, byte, case, catch, char, class, continue, default, do, double, else, enum,extends, final, fina

java中关键字

访问控制 private protected public 省略 类,方法和变量修饰符 abstract class extends final implements interface native new static strictfp synchronized transient volatile 程序控制 break continue return do while if else for instanceof switch case default 异常处理 try cathc thr

java——super关键字、final关键字、抽象类、接口

super关键字: 当父类被重写之后,子类对象无法访问父类被重写的方法,super就是为了解决这个问题: 1.使用super关键字访问父类的成员变量和成员方法: super.成员变量 super.成员方法([参数1,...]) 2.使用super关键字访问父类的构造方法:(尽量在类中定义一个无参的构造方法,避免继承时出现错误). final关键字: 1.final关键字修饰的类不可被继承. 2.final关键字修饰的方法不可被重写. 3.java中被final修饰的变量称为常量,一旦被赋值,其值

JAVA常用关键字解释

下表是java中经常会用到的关键字:一:用于定义访问权限修饰符的关键字: 1) public 公共的 public 关键字是可以应用于类.方法或字段(在类中声明的变量)的访问控制修饰符.可能只会在其他任何类或包中引用 public 类.方法或字段. 2) protected 受保护的 protected 关键字是可以应用于类.方法或字段(在类中声明的变量)的访问控制修饰符.可以 在声明 protected 类.方法或字段的类.同一个包中的其他任何类以及任何子类(无论子类是在哪个包中声明的)中引用