抽象类(abstract 类)
1. 非抽象类不能包含抽象方法,包含抽象方法的类必须是抽象的
2. 在一个抽象类扩展出来的非抽象类中,所有的抽象方法必须实现
3. 允许声明没有抽象方法的抽象类
public class InstrumentTest {
public static void main(String[] args){
Instrument[] orchestra ={
new Wind(),
new Percussion(),
new Stringed(),
new Brass(),
new WoodWind()
};
tuneAll(orchestra);
}
public static void tune(Instrument i) {
i.play("Savage gradon");
}
public static void tuneAll(Instrument[] e) {
for(Instrument i: e) {
tune(i);
}
}
}
abstract class Instrument{
abstract void play(String s);
abstract void adjust();
abstract String what();
}
class Wind extends Instrument{
public void play(String x){
System.out.println("WindSavage gradon");
}
public void adjust(){}
public String what(){
return null;
}
}
class Percussion extends Instrument{
public void play(String x){
System.out.println("PercussionSavage gradon");
}
public void adjust(){}
public String what(){
return null;
}
}
class Stringed extends Instrument{
public void play(String x){
System.out.println("StringledSavage gradon");
}
public void adjust(){}
public String what(){
return null;
}
}
class WoodWind extends Wind{
public void play(String x){
System.out.println("WoodWindSavage gradon");
}
}
class Brass extends Wind{
public void play(String x){
System.out.println("BrassSavage gradon");
}
}
// 运行结果
/*
WindSavage gradon
PercussionSavage gradon
StringledSavage gradon
BrassSavage gradon
WoodWindSavage gradon
*/
public class TestGeometricObject {
public static void main(String[] args){
GeometricObject geoObject1 = new Circle(5);
GeometricObject geoObject2 = new Rectangle(5, 3);
System.out.println("Same area? " + equalArea(geoObject1, geoObject2));
displayGeometricObject(geoObject1);
displayGeometricObject(geoObject2);
}
public static boolean equalArea(GeometricObject object1, GeometricObject object2){
return object1.getArea() == object2.getArea();
}
public static void displayGeometricObject(GeometricObject object){
System.out.println();
System.out.println("The perimeter is " + object.getPerimeter());
System.out.println("The area is " + object.getArea());
}
}
abstract class GeometricObject{
private String color = "white";
private boolean filled;
private java.util.Date dataCreated;
protected GeometricObject(){
dataCreated = new java.util.Date();
}
protected GeometricObject(String color, boolean filled){
this.color = color;
this.filled = filled;
dataCreated = new java.util.Date();
}
public void setColor(String color){
this.color = color;
}
public String getColor() {
return color;
}
public void setFilled(boolean filled) {
this.filled = filled;
}
public boolean isFilled() {
return filled;
}
public java.util.Date getDataCreated(){
return dataCreated;
}
public abstract double getPerimeter();
public abstract double getArea();
public String toString(){
return ("created on " + dataCreated + "\ncolor: " + color + "and filled: " + filled);
}
}
class Circle extends GeometricObject{
public double radius;
public Circle(){
this(1.0);
}
public Circle(double radius){
this.radius = radius;
}
public Circle(double radius, String color, boolean filled){
super(color, filled);
this.radius = radius;
}
public void setRadius(double radius){
this.radius = radius;
}
public double getRadius(){
return radius;
}
public double getPerimeter(){
return (2 * radius * Math.PI);
}
public double getArea(){
return (radius * radius * Math.PI);
}
public String toString(){
return ("[Circle] radius = " + radius);
}
}
class Rectangle extends GeometricObject{
private double width;
private double height;
public Rectangle(){}
public Rectangle(double width, double height){
this.width = width;
this.height = height;
}
public void setWidth(double width) {
this.width = width;
}
public double getWidth() {
return width;
}
public void setHeight(double height) {
this.height = height;
}
public double getHeight() {
return height;
}
public double getPerimeter() {
return (2 *(width * height));
}
public double getArea(){
return (width * height);
}
}
// 运行结果
/*
Same area? false
The perimeter is 31.41592653589793
The area is 78.53981633974483
The perimeter is 30.0
The area is 15.0
*/
接口(interface)
public class MatchTest {
public static void main(String[] args) {
FootballExtends ft = new FootballExtends();
HockeyExtends he = new HockeyExtends();
Sports s = ft;
s.setHomeTeam("a");
s.setVisitingTeam("b");
Football f = ft;
f.homeTeamScored(3);
s = he;
s.setHomeTeam("a");
s.setVisitingTeam("b");
Hockey h = he;
h.endOfPeriod(3);
}
}
interface Sports{
abstract void setHomeTeam(String x);
abstract void setVisitingTeam(String y);
}
interface Football extends Sports{
abstract void setHomeTeam(String x);
abstract void setVisitingTeam(String y);
abstract void homeTeamScored(int a);
}
interface Hockey extends Sports{
abstract void setHomeTeam(String x);
abstract void setVisitingTeam(String y);
abstract void endOfPeriod(int b);
}
class FootballExtends implements Football{
public void setHomeTeam(String x){
System.out.println("Football homeTeam is " + x);
};
public void setVisitingTeam(String y){
System.out.println("Football visitingTeam is " + y);
}
public void homeTeamScored(int a){
System.out.println("Football homeTeam scored " + a);
}
}
class HockeyExtends implements Hockey{
public void setHomeTeam(String x){
System.out.println("Football homeTeam is " + x);
};
public void setVisitingTeam(String y){
System.out.println("Football visitingTeam is " + y);
}
public void endOfPeriod(int b){
System.out.println("Football homeTeam scored " + b);
}
}
// 运行结果
/*
Football homeTeam is a
Football visitingTeam is b
Football homeTeam scored 3
Football homeTeam is a
Football visitingTeam is b
Football homeTeam scored 3
*/
public class MyInterfaceTest {
public static void main(String[] args){
MyInterfaceUse m = new MyInterfaceUse("类A: ");
m.show();
}
}
interface MyInterface{
public static double G = 88;
public abstract void show();
}
class MyInterfaceUse implements MyInterface{
String s;
public MyInterfaceUse(String s){
this.s = s;
}
public void show(){
System.out.println(s + "G = " + G);
}
}
// 运行结果
/*
类A: G = 88.0
*/
接口和抽象类
1. 在接口中,数据必须是常量;而抽象类可以有非常量的数据域。
2. Java对类的扩展只允许单重继承;但对接口允许多重继承。