java学习之路 之 高级类特性2-抽象类、接口

抽象类(abstract class)

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，

以至于它没有具体的实例，这样的类就可以声明为抽象类。

抽象类与具体类

具体类 — 对现实世界一种实体的抽象定义。

抽象类 — 对现实世界一种类型的多种实体的统一抽象定义。

例如： Pet类应定义为抽象类

Bird类应定义为具体类

抽象类中可声明抽象方法

示例：

public abstract class Pet {
public abstract void speak();
……
}

抽象类：

用abstract关键字来修饰一个类时，这个类叫做抽象类；

用abstract来修饰一个方法时，该方法叫做抽象方法。

抽象方法：

只有方法的声明，没有方法的实现。以分号结束：

abstract int abstractMethod( int a );

含有抽象方法的类必须被声明为抽象类。抽象类不能被实例化。

抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。

不能用abstract修饰属性、私有方法、构造器、静态方法、final的方法。

抽象类中可以包含的成员包括：

属性

构造器

具体方法

抽象方法

抽象类举例：

public abstract class Pet {
private String name;
private int age;
private int weight;

public Pet(String name, int age, int weight) {
this.name = name;
this.age = age;
this.weight = weight;
}
public String getName()     {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract void speak();
public abstract void eat();
}

抽象类不能被实例化

子类（具体类）可继承抽象父类 ，实现抽象方法

具体子类适用抽象父类的多态

举例：

public class Bird extends Pet {
private int flySpeed;

public Bird(String name, int age, int weight, int flySpeed) {
super(name, age, weight);
this. flySpeed = flySpeed;
}

public int getFlySpeed() {
return flySpeed;
}
public void speak() {
System.out.println("布谷布谷...");
}
public void eat() {
System.out.println("Eating...");
}
}

public class TestAbstract {
public static void main(String args[]) {
Pet pet = new Bird("小布", 1, 100, 20);
pet.speak();
}
}

抽象类应用:

抽象类是用来模型化那些父类无法确定全部实现，而是由其子类提供具体实现的对象的类。

例题：

在航运公司系统中，Vehicle类需要定义两个方法分别计算运输工具的燃料效率和行驶距离。

问题：卡车(Truck)和驳船(RiverBarge)的燃料效率和行驶距离的计算方法完全不同。Vehicle类不能提供计算方法，但子类可以。

解决方案:

Java允许类设计者指定：超类声明一个方法但不提供实现，该方法的实现由子类提供。这样的方法称为抽象方法。有一个或更多抽象方法的类称为抽象类。

Vehicle是一个抽象类，有两个抽象方法。

public abstract class Vehicle{
public abstract double calcFuelEfficiency();    //计算燃料效率的抽象方法
public abstract double calcTripDistance();  //计算行驶距离的抽象方法
}
public class Truck extends Vehicle{
public double calcFuelEfficiency( )   { //写出计算卡车的燃料效率的具体方法   }
public double calcTripDistance( )    {  //写出计算卡车行驶距离的具体方法   }
}
public class RiverBarge extends Vehicle{
public double calcFuelEfficiency( ) { //写出计算驳船的燃料效率的具体方法  }
public double calcTripDistance( )  {  //写出计算驳船行驶距离的具体方法}
}

注意：抽象类不能实例化 new Vihicle()是非法的

模板方法设计模式(TemplateMethod)：

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

解决的问题：当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。

接口(interface)工厂方法(FactoryMethod)和代理模式(Proxy)

接口：

接口的用途是用来定义现实世界不同类型事物的共同行为特征。

例如：

飞行特征（包括起飞，飞行、着陆等行为）是鸟和飞机所共有的。

鸟和飞机可定义为具体类

它们的共同行为特征可被定义在接口中

接口中所有方法均为抽象方法

示例：

public interface Flyer {
public void takeoff();
……
}

接口可以包含以下成员：

属性：接口中的所有属性均被视静态常量。

例如，下面几种方式的声明是等效的：

int num = 10;

public int num = 10;

public static final int num = 10;

抽象方法：接口中所有方法均为抽象方法。

例如，下面两种方式的声明是等效的：

public abstract void takeoff();

public void takeoff();

有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。

一个类可以实现多个接口，

接口不能被实例化

具体类（子类）可以实现接口（父类） ，并实现接口中的抽象方法

class SubClass implements InterfaceA{ }

具体类适用父接口的多态

接口也可以继承其它接口。

实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。

接口的主要用途就是被实现类实现。（面向接口编程）

一个类可以同时继承父类并实现接口

一个类可以实现多个无关的接口

与继承关系类似，接口与实现类之间存在多态性

接口的其他问题：

如果实现接口的类中没有实现接口中的全部方法，必须将此类定义为抽象类

接口也可以继承另一个接口，使用extends关键字。

interface MyInterface{
String s=“MyInterface”;
public void absM1();
}
interface SubInterface extends MyInterface{
public void absM2();
}
public class SubAdapter implements SubInterface{
public void absM1({
System.out.println(“absM1”);
}
public void absM2(){
System.out.println(“absM2”);
}
}

实现类SubAdapter必须给出接口SubInterface以及父接口MyInterface中所有方法的实现。