Java 抽象类和抽象方法语法知识点及案例代码

1. 抽象类和抽象方法的定义

抽象类：

• 抽象类是一个包含抽象方法的类，或者即使不包含抽象方法，但被设计为不能被实例化的类。
• 抽象类使用 abstract 关键字修饰。
• 抽象类不能被实例化，即不能创建它的对象实例，但可以作为其他类的基类。
• 抽象类中可以包含成员变量、常量、抽象方法以及非抽象方法。
  抽象方法：
• 抽象方法是一个没有实现的方法，即没有方法体（没有大括号 {} 和其中的代码）。
• 抽象方法通过 abstract 关键字来定义。
• 抽象方法的主要作用是为子类提供一个规范或接口，强制子类必须实现这个方法。

2. 抽象类和抽象方法的声明格式

抽象类声明格式：

public abstract class 类名 {成员变量;方法() { 方法体; } // 一般方法abstract 方法(); // 抽象方法
}

抽象方法声明格式：

修饰符 abstract 返回值类型 方法名(参数列表);

3. 抽象类和抽象方法的特点

• 抽象方法：

  • 抽象方法只有声明，没有实现。
  • 抽象方法不能用 private、final、static、native 修饰。

• 抽象类：

  • 抽象类不能被实例化，即使不包含抽象方法。
  • 抽象类中可以包含构造方法，供子类调用。
  • 抽象类中不一定包含抽象方法，但有抽象方法的类必定是抽象类。
  • 抽象类的子类必须实现父类中所有的抽象方法，否则子类也必须声明为抽象类。

4. 案例代码

以下是一个完整的示例，定义了一个抽象类 Shape，以及它的几个子类 Circle、Rectangle 和 Triangle，分别计算不同形状的面积和周长。

// 抽象类 Shape
public abstract class Shape {// 抽象方法，计算面积public abstract double area();// 抽象方法，计算周长public abstract double perimeter();// 具体方法，描述形状public void describe() {System.out.println("This is a shape.");}
}// 圆形类 Circle，继承 Shape 并实现抽象方法
public class Circle extends Shape {private double radius;public Circle(double radius) {this.radius = radius;}@Overridepublic double area() {return Math.PI * radius * radius;}@Overridepublic double perimeter() {return 2 * Math.PI * radius;}
}// 矩形类 Rectangle，继承 Shape 并实现抽象方法
public class Rectangle extends Shape {private double length;private double width;public Rectangle(double length, double width) {this.length = length;this.width = width;}@Overridepublic double area() {return length * width;}@Overridepublic double perimeter() {return 2 * (length + width);}
}// 三角形类 Triangle，继承 Shape 并实现抽象方法
public class Triangle extends Shape {private double a, b, c;public Triangle(double a, double b, double c) {this.a = a;this.b = b;this.c = c;}@Overridepublic double area() {double p = (a + b + c) / 2;return Math.sqrt(p * (p - a) * (p - b) * (p - c));}@Overridepublic double perimeter() {return a + b + c;}
}// 测试类
public class Test {public static void main(String[] args) {Shape circle = new Circle(5);Shape rectangle = new Rectangle(4, 6);Shape triangle = new Triangle(3, 4, 5);System.out.println("Circle area: " + circle.area());System.out.println("Circle perimeter: " + circle.perimeter());circle.describe();System.out.println("Rectangle area: " + rectangle.area());System.out.println("Rectangle perimeter: " + rectangle.perimeter());rectangle.describe();System.out.println("Triangle area: " + triangle.area());System.out.println("Triangle perimeter: " + triangle.perimeter());triangle.describe();}
}

5. 运行结果

运行上述测试类 Test，将会输出以下内容：

Circle area: 78.53981633974483
Circle perimeter: 31.41592653589793
This is a shape.
Rectangle area: 24.0
Rectangle perimeter: 20.0
This is a shape.
Triangle area: 6.0
Triangle perimeter: 12.0
This is a shape.

这个示例展示了如何使用抽象类和抽象方法来定义一个通用的接口，并在不同的子类中实现这些接口。
以下是一个使用

抽象类和抽象方法的具体案例

关于动物王国系统的简单实现：

动物王国系统

抽象类：Animal

首先，我们定义一个抽象类 Animal，它包含所有动物共有的抽象方法，如 makeSound 和 move。这些方法没有具体的实现，因为它们在不同的动物种类中会有不同的表现。

public abstract class Animal {// 抽象方法：发出声音public abstract void makeSound();// 抽象方法：移动public abstract void move();// 具体方法：描述动物public void describe() {System.out.println("This is an animal.");}
}

子类：Dog 和 Cat

接下来，我们定义两个具体的动物类 Dog 和 Cat，它们都继承自 Animal 类，并实现了其中的抽象方法。

// 狗类，继承自 Animal
public class Dog extends Animal {@Overridepublic void makeSound() {System.out.println("Woof! Woof!");}@Overridepublic void move() {System.out.println("The dog is running.");}// 狗类特有的方法：摇尾巴public void wagTail() {System.out.println("The dog is wagging its tail.");}
}// 猫类，继承自 Animal
public class Cat extends Animal {@Overridepublic void makeSound() {System.out.println("Meow! Meow!");}@Overridepublic void move() {System.out.println("The cat is walking.");}// 猫类特有的方法：抓老鼠public void catchMouse() {System.out.println("The cat is catching a mouse.");}
}

测试类：AnimalKingdom

最后，我们创建一个测试类 AnimalKingdom，用于展示如何使用这些类和方法。

public class AnimalKingdom {public static void main(String[] args) {// 创建 Dog 对象Animal dog = new Dog();dog.makeSound(); // 输出：Woof! Woof!dog.move();      // 输出：The dog is running.dog.describe();  // 输出：This is an animal.if (dog instanceof Dog) {((Dog) dog).wagTail(); // 强制类型转换后调用 Dog 类的特有方法}// 创建 Cat 对象Animal cat = new Cat();cat.makeSound(); // 输出：Meow! Meow!cat.move();      // 输出：The cat is walking.cat.describe();  // 输出：This is an animal.if (cat instanceof Cat) {((Cat) cat).catchMouse(); // 强制类型转换后调用 Cat 类的特有方法}}
}

运行结果

运行 AnimalKingdom 类，将会输出以下内容：

Woof! Woof!
The dog is running.
This is an animal.
The dog is wagging its tail.
Meow! Meow!
The cat is walking.
This is an animal.
The cat is catching a mouse.

案例总结

这个案例展示了如何使用抽象类和抽象方法来定义一个通用的动物接口，并在不同的动物子类中实现这些接口。通过使用抽象类，我们可以确保所有子类都实现了必要的方法，从而提供了一种结构化和可扩展的方式来管理动物王国的系统。同时，我们也看到了如何在运行时进行类型检查和强制类型转换，以调用子类特有的方法。

抽象类和抽象方法之间的区别

主要体现在以下几个方面：

定义与用途

• 抽象类：是一种特殊的类，它不能被实例化，主要用于定义一些通用的方法和属性，让子类继承并实现它们。抽象类中可以包含普通方法和属性，但至少要有一个抽象方法（尽管这不是强制性的，但包含抽象方法的类必须被声明为抽象类）。
• 抽象方法：是一种没有实现的方法，只有定义，需要在子类中被实现。抽象方法一般存在于抽象类或接口中，它没有方法体，只有方法签名。

声明与实现

• 抽象类：使用abstract关键字来修饰，它不能直接被实例化，但可以被其他类继承。继承抽象类的子类必须实现抽象类中的所有抽象方法（除非子类本身也是抽象类）。
• 抽象方法：同样使用abstract关键字来修饰，它只有方法声明，没有方法体。抽象方法必须在子类中被实现，否则子类也将被视为抽象类。

成员与继承

• 抽象类：可以包含普通方法和属性，这些方法和属性可以被子类直接使用（不必重写）。此外，抽象类还可以有构造方法，用于初始化属性。
• 抽象方法：不能是private、static或final修饰的，因为这些关键字都是和重写相违背的。抽象方法必须被子类重写，以提供具体的实现。

应用场景

• 抽象类：常用于定义一些通用的行为或属性，这些行为或属性在子类中有具体的实现。抽象类提供了一种模板或框架，让子类在此基础上进行扩展和实现。
• 抽象方法：常用于在抽象类或接口中定义一些需要子类实现的方法。这些方法是抽象的，没有具体的实现，留给子类去具体实现。

示例对比

• 抽象类示例：

public abstract class Animal {private String name;public Animal(String name) {this.name = name;}public String getName() {return name;}public abstract void eat(); // 抽象方法
}

• 抽象方法示例（通常与抽象类一起使用）：

public abstract class Animal {// ... 其他方法和属性 ...public abstract void eat(); // 抽象方法，没有实现
}public class Dog extends Animal {@Overridepublic void eat() {System.out.println("Dog is eating.");}
}

在上面的示例中，Animal是一个抽象类，它包含了一个抽象方法eat()。Dog类继承了Animal类，并实现了eat()方法。
综上所述，抽象类和抽象方法都是面向对象编程中的重要概念，它们共同构成了抽象机制的基础。抽象类提供了一种定义通用行为和属性的方式，而抽象方法则用于在子类中实现这些行为。