实现Java代码，写一个动物类(抽象类Animal),它有两个子类(狗类Dog)和猫类(Cat)实现抽象类Animal,在Animal类中有一个排序方法, sort()，让两个子类重写父类的sort()方法，其中Dog类按年龄升序排列并输出排序结果，Cat按年龄降序排列并输出排序结果。再定义一个接口ability(),让Dog和Cat实现这个接口。

好的，我可以回答这个问题。以下是Java代码实现：

抽象类Animal：

public abstract class Animal implements Comparable<Animal> {
    protected int age;

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

    public abstract void ability();

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Animal o) {
        return Integer.compare(age, o.age);
    }

    public abstract void sort();
}

狗类Dog：

public class Dog extends Animal implements Ability {
    public Dog(int age) {
        super(age);
    }

    @Override
    public void ability() {
        System.out.println("我是一只会看家护院的狗");
    }

    @Override
    public void sort() {
        List<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog(3));
        dogs.add(new Dog(1));
        dogs.add(new Dog(2));
        Collections.sort(dogs);
        for (Dog dog : dogs) {
            System.out.println("狗的年龄：" + dog.getAge());
        }
    }
}

猫类Cat：

public class Cat extends Animal implements Ability {
    public Cat(int age) {
        super(age);
    }

    @Override
    public void ability() {
        System.out.println("我是一只会抓老鼠的猫");
    }

    @Override
    public void sort() {
        List<Cat> cats = new ArrayList<>();
        cats.add(new Cat(3));
        cats.add(new Cat(1));
        cats.add(new Cat(2));
        Collections.sort(cats, Collections.reverseOrder());
        for (Cat cat : cats) {
            System.out.println("猫的年龄：" + cat.getAge());
        }
    }
}

接口Ability：

public interface Ability {
    void ability();
}

以上就是实现Java代码的动物类，其中狗类按年龄升序排列并输出排序结果，猫类按年龄降序排列并输出排序结果，并且两个子类都实现了接口Ability。