java编程abstract类和方法详解

第一步，我们需要明确什么是Java中的抽象类和抽象方法。

什么是抽象类？

Java中的抽象类是一种不能被实例化的类，它被用来在类层次结构中表示一个通用的概念或者抽象的基类。

抽象类中可以定义成员变量，构造方法，普通方法，也可以包含抽象方法。抽象类不能被实例化，只有子类可以继承抽象类并实现其中的抽象方法。

什么是抽象方法？

抽象方法是一种没有实现的方法，它只有方法的声明，没有方法的定义实现。抽象方法必须定义在抽象类中，它的定义格式如下：

public abstract returnType methodName(parameterList);

其中，关键字abstract表示该方法是抽象方法，没有具体实现；returnType表示返回值类型；methodName表示方法名；parameterList表示方法的参数列表。

实现一个抽象方法需要用@Override注解来明确地指示该方法是从父类继承而来，并且没有一个实际实现。

现在，我们已经了解了什么是抽象类和抽象方法，下面我们来看一下抽象类和抽象方法的使用。

抽象类和抽象方法的使用示例

示例一：动物园

我们来举一个简单的例子，假如我们在写一个动物园的类。这个类有两个动物，一个是猫，一个是狗。它们有一些共有的属性，比如说名字、年龄等等，我们就可以定义一个抽象类Animal来表示这些共有属性，代码如下：

public abstract class Animal {
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }

    public abstract void say();
}

在这个例子中，我们定义了一个抽象类Animal，它有两个私有成员变量name和age，以及一个带参构造方法和两个getter方法。注意到say()方法是一个抽象方法，没有方法体，因为它是由子类实现的。

接下来，我们定义两个具体的动物类Cat和Dog，它们继承自Animal类，代码如下：

public class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void say() {
        System.out.println("喵喵喵");
    }
}

public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void say() {
        System.out.println("汪汪汪");
    }
}

在这里，我们分别定义了Cat和Dog两个类来继承自Animal类，并实现了它们的抽象方法say()。Cat类的实现中输出了猫叫的声音，而Dog类的实现中输出了狗叫的声音。

下面我们来看一下动物园的测试代码：

public class Zoo {
    public static void main(String[] args) {
        Cat cat = new Cat("Tom", 2);
        Dog dog = new Dog("Snoopy", 3);

        System.out.println(cat.getName() + " " + cat.getAge() + "岁");
        cat.say();

        System.out.println(dog.getName() + " " + dog.getAge() + "岁");
        dog.say();
    }
}

在这个测试代码中，我们分别创建了一个Cat对象和一个Dog对象，然后输出了它们的名字、年龄以及叫声，运行结果如下：

Tom 2岁
喵喵喵
Snoopy 3岁
汪汪汪

示例二：图形类

再来看一个例子，假如我们现在需要编写一个图形类，用来表示各种图形（比如矩形、圆形等等）。我们可以定义一个抽象类Shape来表示图形，代码如下：

public abstract class Shape {
    private int x;
    private int y;

    public Shape(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public abstract double getArea();   // 计算图形面积

    public abstract double getPerimeter();  // 计算图形周长
}

在这个代码中，我们定义了AbstractShape类，它有两个私有成员变量x和y，以及一个带参构造方法。注意到它里面还有两个抽象方法getArea()和getPerimeter()，分别用于计算图形的面积和周长，这两个方法的实现由子类来完成。

我们可以衍生出不同的子类来继承自Shape类，比如Rectangle、Circle等等，代码如下：

public class Rectangle extends Shape {
    double width;
    double height;

    public Rectangle(int x, int y, double width, double height) {
        super(x, y);
        this.width = width;
        this.height = height;
    }

    @Override
    public double getArea() {
        return width * height;
    }

    @Override
    public double getPerimeter() {
        return 2 * (width + height);
    }
}

public class Circle extends Shape {
    double radius;

    public Circle(int x, int y, double radius) {
        super(x, y);
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI * Math.pow(radius, 2);
    }

    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

在这里，我们衍生出了Rectangle和Circle两个类，在其内部分别实现了计算面积和周长的抽象方法。

下面是具体的测试代码：

public class TestShape {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle(0, 0, 3, 4);
        System.out.println("矩形的面积是：" + rectangle.getArea());
        System.out.println("矩形的周长是：" + rectangle.getPerimeter());

        Circle circle = new Circle(0, 0, 5);
        System.out.println("圆形的面积是：" + circle.getArea());
        System.out.println("圆形的周长是：" + circle.getPerimeter());
    }
}

在测试代码中，我们创建了一个Rectangle对象和一个Circle对象，并输出了它们的面积和周长，运行结果如下：

矩形的面积是：12.0
矩形的周长是：14.0
圆形的面积是：78.53981633974483
圆形的周长是：31.41592653589793

以上就是Java编程中抽象类和抽象方法的详细讲解。