抽象类是无法实例化的类。通过创建可以实例化的继承子类来使用抽象类。抽象类为继承的子类做一些事情：

1. 定义继承子类可以使用的方法。
2. 定义继承子类必须实现的抽象方法。
3. 提供一个公共接口，该接口允许子类与所有其他子类互换。

这是一个例子：

abstract public class AbstractClass
{
    abstract public void abstractMethod();
    public void implementedMethod() { System.out.print("implementedMethod()"); }
    final public void finalMethod() { System.out.print("finalMethod()"); }
}

请注意，“ abstractMethod（）”没有任何方法主体。因此，你不能执行以下操作：

public class ImplementingClass extends AbstractClass
{
    // ERROR!
}

没有实现的方法abstractMethod()！因此，当JVM收到类似的信息时，它就无法知道应该做什么new ImplementingClass().abstractMethod()。

这是正确的ImplementingClass。

public class ImplementingClass extends AbstractClass
{
    public void abstractMethod() { System.out.print("abstractMethod()"); }
}

请注意，你不必定义implementedMethod()或finalMethod()。它们已经由定义AbstractClass。

这是另一个正确的说法ImplementingClass。

public class ImplementingClass extends AbstractClass
{
    public void abstractMethod() { System.out.print("abstractMethod()"); }
    public void implementedMethod() { System.out.print("Overridden!"); }
}

在这种情况下，你已覆盖implementedMethod()。

但是，由于存在final关键字，因此无法执行以下操作。

public class ImplementingClass extends AbstractClass
{
    public void abstractMethod() { System.out.print("abstractMethod()"); }
    public void implementedMethod() { System.out.print("Overridden!"); }
    public void finalMethod() { System.out.print("ERROR!"); }
}

你不能这样做，因为finalMethod()in的实现AbstractClass被标记为的最终实现finalMethod()：永远不允许其他实现。

现在，你还可以实现两次抽象类：

public class ImplementingClass extends AbstractClass
{
    public void abstractMethod() { System.out.print("abstractMethod()"); }
    public void implementedMethod() { System.out.print("Overridden!"); }
}

// In a separate file.
public class SecondImplementingClass extends AbstractClass
{
    public void abstractMethod() { System.out.print("second abstractMethod()"); }
}

现在，你可以在其他地方编写另一种方法。

public tryItOut()
{
    ImplementingClass a = new ImplementingClass();
    AbstractClass b = new ImplementingClass();

    a.abstractMethod();    // prints "abstractMethod()"
    a.implementedMethod(); // prints "Overridden!"     <-- same
    a.finalMethod();       // prints "finalMethod()"

    b.abstractMethod();    // prints "abstractMethod()"
    b.implementedMethod(); // prints "Overridden!"     <-- same
    b.finalMethod();       // prints "finalMethod()"

    SecondImplementingClass c = new SecondImplementingClass();
    AbstractClass d = new SecondImplementingClass();

    c.abstractMethod();    // prints "second abstractMethod()"
    c.implementedMethod(); // prints "implementedMethod()"
    c.finalMethod();       // prints "finalMethod()"

    d.abstractMethod();    // prints "second abstractMethod()"
    d.implementedMethod(); // prints "implementedMethod()"
    d.finalMethod();       // prints "finalMethod()"
}

请注意，即使我们声明b了AbstractClass类型，它也会显示"Overriden!"。这是因为我们实例化的对象实际上是一个ImplementingClass，它implementedMethod()当然会被覆盖。（你可能已经将其称为多态。）

如果我们希望访问特定于特定子类的成员，则必须首先将其转换为该子类：

// Say ImplementingClass also contains uniqueMethod()
// To access it, we use a cast to tell the runtime which type the object is
AbstractClass b = new ImplementingClass();
((ImplementingClass)b).uniqueMethod();

最后，你不能执行以下操作：

public class ImplementingClass extends AbstractClass, SomeOtherAbstractClass
{
    ... // implementation
}

一次只能扩展一个类。如果需要扩展多个类，则它们必须是接口。你可以这样做：

public class ImplementingClass extends AbstractClass implements InterfaceA, InterfaceB
{
    ... // implementation
}

这是一个示例界面：

interface InterfaceA
{
    void interfaceMethod();
}

这基本上与以下内容相同：

abstract public class InterfaceA
{
    abstract public void interfaceMethod();
}

唯一的区别是第二种方法不让编译器知道它实际上是一个接口。如果你希望人们仅实现你的界面而没有其他人，则这将很有用。但是，作为一般初学者的经验法则，如果抽象类仅具有抽象方法，则可能应将其设为接口。

以下是非法的：

interface InterfaceB
{
    void interfaceMethod() { System.out.print("ERROR!"); }
}

你不能在接口中实现方法。这意味着，如果你实现两个不同的接口，则这些接口中的不同方法不会冲突。由于接口中的所有方法都是抽象的，因此你必须实现该方法，并且由于你的方法是继承树中的唯一实现，因此编译器知道它必须使用你的方法。