方法名(参数列表) 要完全一致

发布时间：2025-06-24 20:11:32 作者：北方职教升学中心阅读量：881

方法名(参数列表) 要完全一致。非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。

然后我们用对象animal去调用它试试看能否运行。

public static void main(String[] args) {        Dog dog = new Dog("小白", 3);        Cat cat = new Cat("汤姆", 5);        eat(dog);        eat(cat);}

当类的调用者在编写 eat 这个方法的时候, 参数类型为Animal (父类), 此时在该方法内部并不知道, 也不关注当前的animal引用指向的是哪个类型(哪个子类)的实例。

class Animal {    public String name;    public int age;    public Animal(String name, int age) {        this.name = name;        this.age = age;    }    public void eat() {        System.out.println(name + "正在吃东西");    }}class Dog extends Animal {    public String color;    public Dog(String name, int age) {        super(name, age);        this.color = color;    }    /*@Override    public void eat() {        System.out.println(name +"正在吃狗粮");    }*/    public void bark() {        System.out.println(name + "汪汪汪");    }}class Cat extends Animal {    public Cat(String name, int age) {        super(name, age);    }    public void eat() {        System.out.println(name + "正在吃猫粮");    }    public void mew() {        System.out.println(name + "喵喵喵");    }}public class Test {    public static void eat(Animal animal) {        animal.eat();    }    public static void main(String[] args) {        Dog dog = new Dog("小白", 3);        Animal animal = dog;//animal这个引用指向了Dog对象        Cat cat = new Cat("汤姆", 5);        cat = (Cat) animal;        cat.mew();    }}

Animal向下转型为Cat，Cat本来就是猫，转换为猫，安全；Animal向下转型为Dog，Cat本来是猫，转换为狗，则不安全。

4.最后就可以对父类的方法进行重写，如果我们不小心把重写的方法名写错了，@Override就可以帮我们检测出来，使我们在重写方法时更加方便。

举个栗子：打印机的功能是打印文件，那么打印机又分为 彩色打印机和 黑白打印机。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为protected。重写

（一）重写的概念

重写(override)：也称为覆盖。

我们发现结果报错，这是因为color这个属性是Dog类中的，而animal无法访问到。向上转型和向下转型

（一）向上转型

向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。此时animal这个引用调用eat方法可能会有多种不同的表现(和animal引用的实例相关), 这种行为就称为多态。通过继承，子类可以重写父类的方法，从而实现多态性。
Tips：
向上转型的优点：让代码实现更简单灵活。
public class Test { public static void eat(Animal animal) { animal.eat(); } public static void main(String[] args) { Dog dog = new Dog("小白", 3); Animal animal = dog;//animal这个引用指向了Dog对象 Cat cat = new Cat("汤姆", 5); if (animal instanceof Cat) { cat = (Cat) animal; cat.mew(); } if (animal instanceof Dog) { dog = (Dog) animal; dog.bark(); } }}
运行结果：
五、

（二）重写的规则

1. 子类在重写父类的方法时，一般必须与父类方法原型一致：返回值类型、private修饰的方法、

三、
四、多态
（一）多态的概念
多态通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
3.访问权限不能比父类中被重写的方法的访问权限更低。
（三）多态的优缺点
多态的优点：
1. 能够降低代码的"圈复杂度", 避免使用大量的if - else，
2. 可扩展能力更强。构造方法都不能被重写。
操作步骤：1.点击鼠标右键，点击generate。也就是说子类能够根据需要实现父类的方法。
2.选择红色箭头所指向的部分。
语法格式：父类类型对象名 = new 子类类型()
Animal animal = new Cat("汤姆",5);
animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。在 Java中，多态通过继承和方法重写来实现，让我们能够编写灵活、

向上转型的缺陷：不能调用到子类特有的方法。那如果这时候我们在Dog类中加入一个color成员变量。我们这期多态的内容就分享到这里，希望能够对大家有所帮助，感谢各位对蜡笔小欣的鼓励支持，我们下次再见！！！

public class Test {    public static void eat(Animal animal) {        animal.eat();    }}

最后实例化对象，进行初始化赋值。多态

（一）多态的概念

（二）多态实现条件

（三）多态的优缺点

三、有了这个注解能帮我们进行一些合法性校验。

3.点击我们要重写的方法。总结

一、

多态缺陷：代码的运行效率降低。

运行结果：

因为animal实际指向的是狗，但现在要强制还原为猫，无法正常还原，所以运行时抛出类型转换异常。重写是子类对父类非静态、

5.重写的方法，可以使用 @Override 注解来显式指定。

（二）向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转型。重写

（一）重写的概念

（二）重写的规则

（三）重写和重载的区别

四、我们可以理解为将eat()方法定义为父子关系。可扩展且可维护的代码。

4.父类被static、

解决方法：
Java中为了提高向下转型的安全性，引入了 instanceof，如果该表达式为true，则可以安全转换。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。前言
二、

（三）重写和重载的区别
方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
（二）多态实现条件
多态实现的条件：
1. 必须在继承体系下，
2. 子类必须要对父类中方法进行重写，
3. 通过父类的引用调用重写的方法。
class Dog extends Animal { public Dog(String name, int age) { super(name, age); } public void eat() { System.out.println(name + "正在吃狗粮"); } public void bark() { System.out.println(name + "汪汪汪"); }}class Cat extends Animal { public Cat(String name, int age) { super(name, age); } public void eat() { System.out.println(name + "正在吃猫粮"); } public void mew() { System.out.println(name + "喵喵喵"); }}
然后我们在Test里面定义一个静态方法func()，父类Animal作为参数引用，再调用eat()方法。向上转型和向下转型
（一）向上转型
（二）向下转型
五、总结
多态是面向对象的一个关键概念，它允许对象以不同的方式表现，具体取决于它们的类型。前言
大家好，前几天蜡笔小欣带大家了解并学习了Java中的继承，子类通过extends关键字来继承父类。
二、例如不小心将方法名字拼写错了 (比如写成aet)，那么此时编译器就会发现父类中没有aet 方法，就会编译报错，提示无法构成重写。
class Animal { public String name; public int age; public Animal(String name, int age) { this.name = name; this.age = age; } public void eat() { System.out.println(name + "正在吃东西"); }}
接着我们定义两个子类，分别是Dog和Cat，都继承父类Animal，在这两个类中重写eat()方法。
简单来说就是同一件事情，发生在不同对象身上，会产生不同的结果。
下面我们举个例子看看：
class Animal { public String name; public int age; public Animal(String name, int age) { this.name = name; this.age = age; } public void eat() { System.out.println(name + "正在吃东西"); }}class Dog extends Animal { public Dog(String name, int age) { super(name, age); } @Override public void eat() { System.out.println(name +"正在吃狗粮"); } public void bark() { System.out.println(name + "汪汪汪"); }}public class Test { public static void eat(Animal animal) { animal.eat(); } public static void main(String[] args) { Dog dog = new Dog("小白", 3); Animal animal =dog;//animal这个引用指向了Dog对象 animal.eat(); }}
运行结果如下：

当我们把Dog类中eat()方法注释后，运行结果为：
我们会发现它执行了父类Animal中的eat()方法。