多态不能使用子类的特有方法

这种说法并不完全正确。在面向对象编程中，多态是指同一个方法在不同的对象实例上可以有不同的实现方式。如果子类中存在特有方法，那么在父类中无法直接使用该方法。但是，如果我们将子类对象转换为子类类型后，就可以调用子类中特有的方法。

例如，假设有一个Animal类和一个Dog类继承自Animal类，并且Dog类中有一个特有的方法bark()，那么在Animal类中无法直接调用bark()方法。但是，如果我们将一个Dog对象转换为Dog类型后，就可以调用它的bark()方法了。

Animal animal = new Dog();
//animal.bark(); //错误，Animal类中没有bark()方法
Dog dog = (Dog) animal;
dog.bark(); //正确，调用Dog类中的bark()方法

需要注意的是，如果我们将一个Animal对象转换为Dog类型而它并不是一个Dog对象，就会抛出ClassCastException异常。因此，在进行类型转换时需要保证转换的对象实例是正确的类型。

相关问题

定义父类：Animal，实现eat（）方法动物吃东西、show()方法，输出动物名字、年龄 子类：pig、cat、dog继承父类Animal,重写父类方法实现pig吃白菜；cat吃鱼、抓老鼠；dog吃骨头 （多态不能使用子类特有功能；非静态内部类需要实例化）

很棒的问题！下面是我的回答：

父类Animal的定义如下：

public class Animal {
    private String name;
    private int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void eat() {
        System.out.println("动物正在吃东西");
    }
    
    public void show() {
        System.out.println("动物的名字是" + this.name + "，年龄是" + this.age + "岁");
    }
}

子类pig、cat、dog的定义如下：

public class pig extends Animal {
    public pig(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void eat() {
        System.out.println("小猪正在吃白菜");
    }
}

public class cat extends Animal {
    public cat(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void eat() {
        System.out.println("小猫正在吃鱼");
    }
    
    public void catchMouse() {
        System.out.println("小猫正在抓老鼠");
    }
}

public class dog extends Animal {
    public dog(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void eat() {
        System.out.println("小狗正在吃骨头");
    }
    
    public void bark() {
        System.out.println("汪汪汪！");
    }
}

当然，也可以将eat方法进行参数化，使得不同的子类可以传入不同的食物：

public void eat(String food) {
    System.out.println("动物正在吃" + food);
}

希望这些代码能够帮到你，如果有任何问题，欢迎进行进一步的提问！

利用多态实现编程。（使用方法重写和上转型对象，这个上转型对象就可以调用子类重写的方法。）

多态是指同一个方法在不同对象上有不同的实现。在Java中可以通过方法重写和上转型对象实现多态。

方法重写是指在子类中重新定义父类中已经存在的方法，使得在执行子类对象的该方法时，调用的是子类中的方法而不是父类中的方法。实现方法重写需要满足以下条件：

1. 方法名、参数列表和返回类型必须与父类中被重写的方法相同。
2. 子类方法的访问权限不能低于父类方法的访问权限。
3. 子类方法不能抛出比父类方法更宽泛的异常类型。

上转型对象是指将子类对象转换为父类类型的对象，即将一个子类实例赋值给一个父类引用变量。由于子类继承了父类的所有方法和属性，因此使用父类类型的引用变量来引用子类对象，可以调用子类重写的方法。

下面是一个例子：

public class Animal {
    public void move() {
        System.out.println("Animal can move");
    }
}

public class Dog extends Animal {
    @Override
    public void move() {
        System.out.println("Dog can run and walk");
    }
    public void bark() {
        System.out.println("Dog can bark");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 上转型对象
        animal.move(); // 调用子类重写的方法
        // animal.bark(); // 编译错误，父类类型的引用变量不能调用子类特有的方法
    }
}

运行结果为：

Dog can run and walk