抽象类是无法实例化的类。通过创建可以实例化的继承子类来使用抽象类。抽象类为继承的子类做一些事情：
- 定义继承的子类可以使用的方法。
- 定义继承子类必须实现的抽象方法。
- 提供一个公共接口，该接口允许子类与所有其他子类互换。
这是一个例子：
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收到类似的信息时，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!"); }
}
您不能在接口中实现方法。这意味着，如果您实现两个不同的接口，则这些接口中的不同方法不会冲突。由于接口中的所有方法都是抽象的，因此您必须实现该方法，并且由于您的方法是继承树中的唯一实现，因此编译器知道它必须使用您的方法。
