编写一个Animal类，并定义一些成员变量和成员方法，然后再编写一个 继承 Animal的子类，要求子类对父类中的成员方法进行重写。在测试类中使用 所能义的类，说明其效果。

好的，首先我们来创建一个简单的 `Animal` 类作为基础，它包含一些基本的成员变量和方法：

// Animal.java
public class Animal {
    private String name;
    private int age;

    // 构造函数
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 父类方法
    public void speak() {
        System.out.println("This animal makes a generic sound.");
    }

    // 获取方法
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

接着，我们创建一个名为 `Dog` 的子类，该子类从 `Animal` 继承并重写了 `speak()` 方法：

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

    @Override
    public void speak() {
        System.out.println("The dog barks.");
    }
}

现在，在测试类 `TestClass` 中，我们可以创建一个 `Animal` 对象以及一个 `Dog` 对象，演示多态性：

// TestClass.java
public class TestClass {
    public static void main(String[] args) {
        Animal myAnimal = new Animal("Generic", 5);
        Animal myDog = new Dog("Buddy", 3);

        // 使用父类引用，但实际操作的是子类实例
        myAnimal.speak(); // 输出 "This animal makes a generic sound."
        myDog.speak(); // 输出 "The dog barks."

        System.out.println("Name of the animal: " + myAnimal.getName());
        System.out.println("Age of the animal: " + myAnimal.getAge());

        // 虽然myDog是Dog类型，但通过Animal引用访问，显示的是Dog重写的属性和方法
        System.out.println("Name of the dog: " + myDog.getName()); // 输出 "Buddy"
        System.out.println("Age of the dog: " + myDog.getAge()); // 输出 "3"
    }
}

运行这个测试类，你会看到父类方法被子类的具体实现所替换，这就是多态性的体现。