java 利用多态，方法重写的方式 不使用instanceof关键字，调用各个对象的say方法。

1. 创建所有动物的基类Animal类
2. 创建狗类（Dog）, 猪类（Pig）继承至动物类
3. 为Dog添加say方法，输出“惹我罗，咬死你！”
4. 为Pig添加say方法，输出“洗个澡，真凉快！”。
   5、在测试类中的main方法中，创建一个Animal类数组用来保存狗类和猪类
   6、分别创建2个狗类和2个猪类对象，并添加到数组中
   7、循环遍历数组，调用各个对象的say方法
   利用多态，方法重写的方式
   不使用instanceof关键字，调用各个对象的say方法。

这是一个Java的多态和方法重写的例子。首先，我们创建一个Animal基类，然后让Dog和Pig类继承这个基类。然后，我们为Dog和Pig类添加say方法。

// 创建Animal基类
public abstract class Animal {
    public abstract void say();
}

// 创建Dog类，继承Animal类
public class Dog extends Animal {
    @Override
    public void say() {
        System.out.println("惹我罗，咬死你！");
    }
}

// 创建Pig类，继承Animal类
public class Pig extends Animal {
    @Override
    public void say() {
        System.out.println("洗个澡，真凉快！");
    }
}

接下来，我们在main方法中创建一个Animal数组，然后创建两个Dog和两个Pig对象，并将它们添加到数组中。然后，我们遍历数组，调用每个对象的say方法。由于Java的动态绑定机制，即使我们将对象向上转型为Animal，在运行时也会调用正确的say方法。

public class Main {
    public static void main(String[] args) {
        // 创建一个Animal数组
        Animal[] animals = new Animal[4];
        
        // 创建两个Dog对象和两个Pig对象，并添加到数组中
        animals[0] = new Dog();
        animals[1] = new Dog();
        animals[2] = new Pig();
        animals[3] = new Pig();
        
        // 循环遍历数组，调用各个对象的say方法
        for (Animal animal : animals) {
            animal.say();
        }
    }
}

在这个例子中，我们没有使用instanceof关键字，而是使用了多态和方法重写。这是因为在Java中，我们可以利用多态的特性，通过向上转型来调用正确的方法，而不需要使用instanceof关键字来判断对象的类型。

【以下回答由 GPT 生成】

首先，我们需要将狗类(Dog)和猪类(Pig)分别继承自Animal类。在Animal类中，我们可以定义一个抽象方法say，用来输出各个动物类实例的特定信息。

abstract class Animal {
    public abstract void say();
}

class Dog extends Animal {
    @Override
    public void say() {
        System.out.println("惹我罗，咬死你！");
    }
}

class Pig extends Animal {
    @Override
    public void say() {
        System.out.println("洗个澡，真凉快！");
    }
}

然后，在测试类的main方法中，我们可以创建一个Animal类的数组来保存狗和猪的对象。这个数组类型可以选择Animal类型，因为狗和猪都是Animal类的子类。

public static void main(String[] args) {
    Animal[] animals = new Animal[4];
    animals[0] = new Dog();
    animals[1] = new Dog();
    animals[2] = new Pig();
    animals[3] = new Pig();

    // 循环遍历数组，调用各个对象的say方法
    for (Animal animal : animals) {
        animal.say();
    }
}

通过使用多态和方法重写的方式，我们不需要使用instanceof关键字来判断具体是狗对象还是猪对象，而是直接调用它们的say方法。由于say方法是在Animal类中声明的抽象方法，在运行时会根据实际对象的类型来执行相应的实现代码。这样可以实现动态绑定，即在运行时确定具体调用哪个子类的say方法，从而实现多态。