什么是抽象类? 好的!让我们举个例子，你对化学了解不多，我们有一个元素碳(符号C)。碳有一些基本的原子结构，你不能改变，但用碳你可以制造很多化合物，如(CO2)，甲烷(CH4)，丁烷(C4H10)。

所以这里碳是抽象类，你不想改变它的基本结构，但你想让他们的孩子(CO2,CH4等)使用它。但是以他们自己的方式

解决方案——基类(抽象)

public abstract class Place {

String Name;
String Postcode;
String County;
String Area;

Place () {

        }

public static Place make(String Incoming) {
        if (Incoming.length() < 61) return (null);

        String Name = (Incoming.substring(4,26)).trim();
        String County = (Incoming.substring(27,48)).trim();
        String Postcode = (Incoming.substring(48,61)).trim();
        String Area = (Incoming.substring(61)).trim();

        Place created;
        if (Name.equalsIgnoreCase(Area)) {
                created = new Area(Area,County,Postcode);
        } else {
                created = new District(Name,County,Postcode,Area);
        }
        return (created);
        }

public String getName() {
        return (Name);
        }

public String getPostcode() {
        return (Postcode);
        }

public String getCounty() {
        return (County);
        }

public abstract String getArea();

}

抽象类是不能被实例化的类。抽象类是通过创建可实例化的继承子类来使用的。抽象类为继承的子类做了一些事情:

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

这里有一个例子:

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()这样的东西时，它无法知道应该做什么。

这是一个正确的实现类。

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!"); }
}

您不能这样做，因为AbstractClass中finalMethod()的实现被标记为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类型，但它显示为“override !”。这是因为我们实例化的对象实际上是一个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!"); }
}

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

它是一个不能被实例化的类，并且强制实现类尽可能地实现它概述的抽象方法。

抽象类是声明为抽象的类——它可以包含也可以不包含抽象方法。抽象类不能被实例化，但可以被子类化。

换句话说，用abstract关键字声明的类在java中称为抽象类。它可以有抽象方法(没有主体的方法)和非抽象方法(有主体的方法)。

重要提示: 抽象类不能用于实例化对象，它们可以用于创建对象引用，因为Java的运行时多态性方法是通过使用超类引用实现的。因此，必须能够创建对抽象类的引用，以便可以使用它指向子类对象。您将在下面的示例中看到该特性

abstract class Bike{  
  abstract void run();  
}  

class Honda4 extends Bike{  
    void run(){
        System.out.println("running safely..");
    }  

    public static void main(String args[]){  
       Bike obj = new Honda4();  
       obj.run();  
    }  
} 

An abstract class is one that isn't fully implemented but provides something of a blueprint for subclasses. It may be partially implemented in that it contains fully-defined concrete methods, but it can also hold abstract methods. These are methods with a signature but no method body. Any subclass must define a body for each abstract method, otherwise it too must be declared abstract. Because abstract classes cannot be instantiated, they must be extended by at least one subclass in order to be utilized. Think of the abstract class as the generic class, and the subclasses are there to fill in the missing information.