[JavaSE] 面向对象编程（多态 向上转型 动态绑定 方法重写）

目录

往期回顾，专栏一览

🔴多态

🔵向上转型

🔵 动态绑定

🔵方法重写

🍹欢迎各路大佬来到 Nick 主页指点

☀️本期文章将学习 [JavaSE] 面向对象编程（多态、向上转型、动态绑定、方法重写），我是博主Nick。✨

✨我的博客主页：Nick_Bears 🌹꧔ꦿ

🌹꧔ꦿ博文内容如对您有所帮助，还请给个点赞 + 关注 + 收藏✨

🔴多态

🔵向上转型

📝代码回顾

class Bird extends Animal {public Bird(String name) {super(name);}@Overridepublic String toString() {return "Bird{" +"name='" + name + '\'' +'}';}}class Animal {public String name;public Animal(String name) {this.name = name;}public void eat(String food) {System.out.println(name + "正在吃"+food);}}public class Demo {public static void main(String[] args) {//在这里开始写 }}

📝通过此专栏上一篇文章学习我们可以写如下代码

Bird bird = new Bird("小花");

📝方法1：直接赋值

Bird bird = new Bird("小花"); Animal bird2 = bird; // 或者写成下面的方式Animal bird2 = new Bird("小花");

🔹此时 bird2 是一个父类 (Animal) 的引用, 指向一个子类 (Bird) 的实例. 这种写法称为向上转型

🔸向上转型这样的写法可以结合 is - a 语义来理解

🔸打个比方：Nick让家人们去喂小花，我可以说:"家人们，小鸟喂了没？“因为小花就是一直小鸟

💬为啥叫 "向上转型"?

🔷在面向对象程序设计中, 针对一些复杂的场景(很多类, 很复杂的继承关系), 程序猿会画一种 UML 图的方式来表 示类之间的关系. 此时父类通常画在子类的上方. 所以我们就称为 "向上转型" ,表示往父类的方向转

💬向上转型发生的时机

直接赋值方法传参方法返回

方法2：方法传参

public class Demo {public static void main(String[] args) {//向上转型//直接赋值// Bird bird = new Bird("小花");// Animal animal=bird;// animal.eat("红豆");////方法传参Bird bird = new Bird("小花");birdEat(bird);}public static Animal myBird(){Bird bird = new Bird("小花");return bird;}}//执行结果//小花正在吃红豆！

🔸此时形参 animal 的类型是 Animal (基类), 实际上对应到 Bird (父类) 的实例

方法3：方法返回

public class Demo {public static void main(String[] args) {//向上转型//直接赋值// Bird bird = new Bird("小花");// Animal animal=bird;// animal.eat("红豆");//// //方法传参// Bird bird = new Bird("小花");// birdEat(bird);////方法返回Animal animal=myBird();animal.eat("红豆");}public static Animal myBird(){Bird bird = new Bird("小花");return bird;}public static void birdEat(Animal animal){animal.eat("红豆");}}//执行结果//小花正在吃红豆

🔸此时方法 myBird 返回的是一个 Animal 类型的引用, 但是实际上对应到 Bird 的实例.

🔵 动态绑定

🔷当子类和父类中出现同名方法的时候, 再去调用会出现什么情况呢? 对前面的代码稍加修改, 给 Bird 类也加上同名的 eat 方法, 并且在两个 eat 中分别加上不同的日志

class Animal {protected String name;public Animal(String name) {this.name = name;}public void eat(String food) {System.out.println("我是一只小动物");System.out.println(this.name + "正在吃" + food);}}class Bird extends Animal {public Bird(String name) {super(name);}public void eat(String food) {System.out.println("我是一只小鸟");System.out.println(this.name + "正在吃" + food);}}public class Demo {public static void main(String[] args) {Animal animal1= new Animal("小花");animal1.eat("红豆");Animal animal2= new Bird("小红");animal2.eat("绿豆");}}//执行结果我是一只小动物小花正在吃红豆我是一只小鸟小红正在吃绿豆

此时, 我们发现:

🔸animal1 和 animal2 虽然都是 Animal 类型的引用, 但是 animal1 指向 Animal 类型的实例animal2 指向 Bird 类型的实例.

🔸针对 animal1 和 animal2 分别调用 eat 方法, 发现 animal1.eat() 实际调用了父类的方法, 而 animal2.eat() 实际调用了子类的方法

🔷因此, 在 Java 中, 调用某个类的方法, 究竟执行了哪段代码 (是父类方法的代码还是子类方法的代码) , 要看究竟这个引 用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为动态绑定。

🔵方法重写

🔸针对刚才的 eat 方法来说:

🔸子类实现父类的同名方法, 并且参数的类型和个数完全相同, 这种情况称为覆写/重写/覆盖(Override).

🔻关于重写的注意事项

重写和重载完全不一样. 不要混淆(思考一下, 重载的规则是啥?)普通方法可以重写, static 修饰的静态方法不能重写 .重写中子类的方法的访问权限不能低于父类的方法访问权限.重写的方法返回值类型不一定和父类的方法相同(但是建议最好写成相同, 特殊情况除外,可以不同，这种情况叫协变).

🔸将子类的 eat 改成 默认

📝错误范例：

class Animal {public String name;public Animal(String name) {this.name = name;}public void eat(String food) {System.out.println(name + "正在吃"+food);}}class Bird extends Animal{public Bird(String name) {super(name);}@Overridevoid eat(String food) {System.out.println("小鸟吃"+food);}}public class Demo {public static void main(String[] args) {}}//执行结果Error:(20, 10) java: 重写.Bird中的eat(java.lang.String)无法覆盖重写.Animal中的eat(java.lang.String)正在尝试分配更低的访问权限; 以前为public

针对重写的方法, 可以使用@Override注解来显式指定

// Bird.java public class Bird extends Animal { @Override private void eat(String food) { ... } }

🔶有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有aet 方法, 就会编译报错, 提示无法构成重写.

🔸我们推荐在代码中进行重写方法时显式加上@Override 注解

🔸关于注解的详细内容, Nick后面的文章会详细介绍。

💠小结: 重载和重写的区别.

💠体会动态绑定和方法重写

🔸上面讲的动态绑定和方法重写是用的相同的代码示例.

🔸事实上, 方法重写是 Java 语法层次上的规则, 而动态绑定是方法重写这个语法规则的底层实现. 两者本质上描述 的是相同的事情, 只是侧重点不同