详解Java语言中的抽象类与继承

下面是“详解Java语言中的抽象类与继承”的完整攻略。

什么是抽象类

抽象类是用于继承的，不能被实例化的类。抽象类中可以包含抽象方法或者非抽象方法的实现，但是抽象类中至少需要有一个抽象方法。抽象方法没有实际的实现，只有方法定义，其具体实现由子类去完成。

抽象类与普通类的区别

抽象类不能被实例化，而普通类可以被实例化。
抽象类中可以包含抽象方法或者非抽象方法的实现，而普通类只包含非抽象方法的实现。
抽象类中至少需要有一个抽象方法，而普通类中没有。

什么是继承

继承是面向对象编程中用于继承类属性和方法的一种方式。当一个类继承另一个类时，它可以拥有另一个类的所有属性和方法，从而减少了代码的冗余。

继承的优点

减少了代码的冗余，提高了代码的可维护性和可读性。
可以提高代码的复用性，增加了程序的扩展性。

实现继承

在Java语言中，可以通过使用关键字extends实现继承。例如：

public class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat() {
        System.out.println(name + " is eating.");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    public void bark() {
        System.out.println(name + " is barking.");
    }
}

上面的例子中，Dog 继承自 Animal，Dog 可以通过继承 Animal 类中的所有属性和方法，同时 Dog 还新增了 bark() 方法。

实现抽象类

在Java语言中，可以通过使用关键字abstract实现抽象类。一个类如果包含至少一个抽象方法，则该类必须声明为抽象类。例如：

public abstract class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat() {
        System.out.println(name + " is eating.");
    }
    public abstract void sound();
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    public void sound() {
        System.out.println(name + " is barking.");
    }
}

上面的例子中，Animal 是一个抽象类，包含了一个抽象方法 sound()，因此必须声明为抽象类。而 Dog 继承自 Animal，必须实现抽象方法 sound()。

示范示例

示例一

abstract class Shape {
    public abstract double area();
}

class Circle extends Shape {
    private double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    public double area() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double width;
    private double height;
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    public double area() {
        return width * height;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle c = new Circle(2.0);
        Rectangle r = new Rectangle(2.0, 3.0);
        System.out.println("Area of circle: " + c.area());
        System.out.println("Area of rectangle: " + r.area());
    }
}

上面的例子中，抽象类 Shape 包含了抽象方法 area()，Circle 和 Rectangle 继承自 Shape 并实现了 area() 方法。

输出结果：

Area of circle: 12.566370614359172
Area of rectangle: 6.0

示例二

abstract class Bird {
    public abstract void fly();
}

class Eagle extends Bird {
    public void fly() {
        System.out.println("Eagle is flying high in the sky.");
    }
}

class Penguin extends Bird {
    public void fly() {
        System.out.println("Penguin cannot fly.");
    }
}

public class Main {
    public static void main(String[] args) {
        Eagle e = new Eagle();
        Penguin p = new Penguin();
        e.fly();
        p.fly();
    }
}

上面的例子中，抽象类 Bird 包含了抽象方法 fly()，Eagle 和 Penguin 继承自 Bird 并实现了 fly() 方法。