🎈🎈 作者: whispar
🎈🎈 专栏 :Java由浅入深🌈刷题,面试,求职,快来牛客网一起成为offer收割机!🌈
目录
一、方法的重写
重写(override):也称为覆盖。重写是子类对父类非静态、非private修饰,非final修饰,非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变,核心重写!
class Animal{
public int size;
public String color;
public Animal(int size, String color) {
this.size = size;
this.color = color;
}
public void move(){
System.out.println("此动物正在移动");
}
}
class Dog extends Animal{
public String name;
public int age;
public Dog(int size, String color, String name, int age) {
super(size, color);
this.name = name;
this.age = age;
}
//子类对父类方法进行重写
@Override
public void move() {
System.out.println("正在快速移动");
}
}
方法重写的规则
-
子类在重写父类方法时,一般必须与父类方法原型一致:返回值类型 方法名(参数列表)要完全一致,使用@Override注解来进行合法性检验
-
被重写的方法的返回值一般要相同
-
重写之后的方法,访问权限不能比父类中被重写的方法的访问权限更低
✅方法重写与重载的区别?
区别点 重写(override) 重载(override) 参数列表 一定不能修改 必须修改 返回类型 一定不能修改【除非可以构成父子类关系】 可以修改 访问限定符 一定不能做更严格的限制(可以降低限制) 可以修改 方法名称 必须相同 必须相同
方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现
二、向上转型和向下转型
-
向上转型
class Fruit{
public void show() {
System.out.println("this is a fruit");
}
}
class Apple extends Fruit{
@Override
public void show() {
System.out.println("this is a apple");
}
public void test() {
System.out.println("i am a apple");
}
}
public class TestDemo {
public static void main(String[] args) {
//向上转型
//实例化Apple类,并新建一个Fruit类的引用变量引用该实例,调用实例的show()方法
Fruit fruit = new Apple();
fruit.show();
}
}
调用实例的test()方法
fruit.test();
分析:
向上转型即使用父类的引用变量去引用子类的实例,当向上转型之后,父类引用变量可以访问子类中属于父类的属性和方法,但是不能访问子类独有的属性和方法。
例子中由于子类重写了父类的show()方法,所以调用的show()方法是子类的show()方法,输出结果为:“this is a apple”,而调用子类的test()方法则会报错
下面代码中一个引用调用一个方法,因为这个引用所引用的对象不一样,导致调用的这个方法,所表现的行为不一样,这种思想就叫做多态。
class Fruit{
public void show() {
System.out.println("this is a fruit");
}
}
class Orange extends Fruit{
@Override
public void show(){
System.out.println("this is a C");
}
}
class Apple extends Fruit{
@Override
public void show() {
System.out.println("this is a apple");
}
public void test() {
System.out.println("i am a apple");
}
}
public class TestDemo {
public static void main(String[] args) {
Apple apple = new Apple();
Orange orange = new Orange();
func(apple);
func(orange);
}
//方法传参
public static void func(Fruit fruit){
fruit.show();
}
//方法返回
public static Fruit func2(){
return new Apple();
}
}
-
向下转型
public class TestDemo {
public static void main(String[] args) {
Fruit fruit = new Apple();
Apple apple = (Apple)fruit;
fruit.show();
}
}
上述代码是允许的,因为fruit引用的对象原本就是Apple对象向上转型得到的,在对fruit向下转型后得到的还是Apple类的对象,能够被Apple类的引用变量引用。
实例化Apple类,并新建一个Fruit类的引用变量“fruit”引用该实例,然后新建一个Orange类的引用变量,引用向下转型的“fruit”变量,代码如下:
Fruit fruit = new Apple();
Orange orange = (Orange) fruit;
上述代码虽然能够编译成功,但是在运行的时候会报错,因为fruit对象是由Apple对象向上转型得到的,只能够向下转型成Apple对象,不能够向下转型成Orange对象。
向下转型用的比较少,而且不安全,万一转换失败,运行时就会抛异常。Java中为了提高向下转型的安全性,引入了 instanceof ,如果该表达式为true,则可以安全转换
public class TestDemo {
public static void main(String[] args) {
Fruit fruit = new Apple();
if(fruit instanceof Apple){
Apple apple = (Apple)fruit;
}
fruit.show();
}
三、多态的优缺点
-
提高了代码的可维护性,主要体现在每一个派生类编写功能调用,只需要对抽象基类进行处理即可。
-
提高了代码的可扩展性,主要体现在派生类的功能可以被基类的方法或引用变量所调用。
❗避免在构造方法中调用重写的方法
class B {
public B() {
func();
}
public void func() {
System.out.println("B.func()");
}
}
class D extends B {
private int num = 1;
@Override
public void func() {
System.out.println("D.func() " + num);
}
}
public class TestDemo2{
public static void main(String[] args) {
D d = new D();
}
}
【说明】
构造D对象的同时,会调用B的构造方法;
B的构造方法中调用了 func方法,此时会触发 动态绑定,会调用到D中的 func,并且由于没有初始化num,所以num = 0.
💖如果文章对你有帮助,请多多点赞、收藏、评论、关注支持!!💖