In Java, when a class extends an abstract class that contains abstract methods, it must implement those abstract methods. The purpose of implementing abstract methods is to provide a specific implementation for a method that has been declared in an abstract class but not implemented.

To implement an abstract method, a subclass must provide a method body for the abstract method. The method signature of the implemented method must match the method signature of the abstract method exactly. If the subclass fails to implement any abstract methods declared in the abstract class, then the subclass itself must also be declared abstract.

Here is an example of implementing an abstract method in Java:

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

public class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double getArea() {
        return Math.PI * radius * radius;
    }
}

In this example, the abstract Shape class contains an abstract method called "getArea()", which is implemented in the Circle class by providing a method body. The Circle class extends the Shape class and provides a specific implementation of the "getArea()" method, which calculates the area of a circle using the radius field.

If a subclass does not implement an abstract method declared in an abstract class, the subclass itself must also be declared abstract, as shown in this example:

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

public abstract class Quadrilateral extends Shape {
    private double side1;
    private double side2;
    private double side3;
    private double side4;

    public Quadrilateral(double side1, double side2, double side3, double side4) {
        this.side1 = side1;
        this.side2 = side2;
        this.side3 = side3;
        this.side4 = side4;
    }
}

public class Rectangle extends Quadrilateral {
    public Rectangle(double width, double height) {
        super(width, height, width, height);
    }

    public double getArea() {
        return super.side1 * super.side2;
    }
}

In this example, the Quadrilateral class extends the Shape class but does not implement the "getArea()" abstract method. As a result, the Quadrilateral class itself is declared abstract. The Rectangle class extends the Quadrilateral class and provides a specific implementation of the "getArea()" method, which calculates the area of a rectangle.