JavaSE-面向对象(方法重写)

时间:2022-10-07 09:04:19

方法重写与之前的方法重载不同

回顾一下方法重载,相同的方法名不同参数类型和参数数量以及参数顺序

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package Demo1;
import java.util.Arrays;
public class Demo011 {
    public static void main(String[] args) {
        Demo011 D11=new Demo011();
        D11.demo(12,232,43,3);      //4个实际参数,则调用第三个demo方法
    }
    public void demo(int a,int b){
        System.out.println(a+b);
    }
    public void demo(int a,int b,int c){
        System.out.println(a+b+c);
    }
    public void demo(int...ints){
        System.out.println(Arrays.toString(ints));
    }
}

方法重写

重写都是方法的重写与属性无关

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package Demo1;
public class Demo012 {
    public static void main(String[] args) {
            B b =new B();
            b.demo();
    }
}
class A{
    public static void demo(){
        System.out.println("Ademo");
    }
}
class B extends A{
    public static void demo(){
        System.out.println("Bdemo");
    }
}

执行结果:

Bdemo

父类的引用指向子类进行引用

?
1
2
3
4
5
6
7
8
public static void main(String[] args) {
//方法的调用只和数据类型有关
        B b =new B();       //调用的是B类的静态方法
        b.demo();
        //父类的引用指向子类
        A a = new A();      //调用的是A类的静态方法
        a.demo();
}

执行结果:

Bdemo
Ademo

使用快捷键Alt+insert快速生成重写方法

JavaSE-面向对象(方法重写)

JavaSE-面向对象(方法重写)

Override重写方法

?
1
2
3
4
5
6
7
8
9
10
11
class A{
    public  void demo(){
        System.out.println("Ademo");
    }
}
class extends A{
    @Override   //注解,有功能的注释
    public void demo() {
        super.demo();       //默认调用父类的demo()方法
    }
}

使用Override重写默认是调用父类的方法,我们可以在重写方法中调用自己的方法

?
1
2
3
4
5
6
7
8
9
10
11
12
class A{
    public  void demo(){
        System.out.println("Ademo");
    }
}
class extends A{
    @Override
    public void demo() {
        //super.demo(); 默认调用父类的demo()方法输出Ademo
        System.out.println("Bdemo");
    }
}

重写之后执行结果:

Bdemo
Bdemo

子类重写父类的demo()方法之后输出为demoB,但是并不是子类重写之后将父类的方法修改了,子类在进行调用的时候调用的是重写后父类的方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package Demo3;
public class demo005 {
    public static void main(String[] args) {
            DemoB DB =new DemoB();
            DB.demo();      //调用子类的demo
            DemoA DA=new DemoA();   //调用父类的demo
            DA.demo();
    }
}
class DemoA{
    public void demo(){
        System.out.println("demoA");
    }
}
class DemoB extends DemoA{      //继承
    @Override
    public void demo(){
        System.out.println("demoB");
    }
}

执行结果:

demoB
demoA

但是我可以完全不继承父类也能输出demoB,demoA

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package Demo3;
public class demo005 {
    public static void main(String[] args) {
            DemoB DB =new DemoB();
            DB.demo();
            DemoA DA=new DemoA();
            DA.demo();
    }
}
class DemoA{
    public void demo(){
        System.out.println("demoA");
    }
}
class DemoB{        //A与B没有继承关系
    public void demo(){
        System.out.println("demoB");
    }
}

执行结果:

demoB
demoA

两种方式有什么区别呢?

  • 子类继承父类重写方法,是通过子类调用父类的方法进行重写的,子类执行结果也是重写后的方法,但并不是子类把父类的方法修改了
  • 方式二是在两个不同类下创建demo()方法,通过对象进行调用。

父类方法若添加static修饰符则重写失败提示错误

进行方法重写时静态方法和非静态方法的区别很大,如果是加了static静态方法,调用结果之和左边定义的类有关。方法重写与非静态方法有关

JavaSE-面向对象(方法重写)

私有方法无法进行方法重写,重写的关键词只能是public不能是private私有的

JavaSE-面向对象(方法重写)

重写小结:

  • 方法重写需要有继承关系,子类重写父类的方法
  • 子类方法与父类的方法方法名和修饰符必须相同
  • 以及方法的参数列表必须相同,不相同则为方法重载
  • 修饰符范围可以扩大但是不能缩小,private(小)–>proteated–>default–>public(大)
  • 重写可能会抛出异常,异常范围可以被缩小但不能扩大

为什么需要重写?

  • 父类的功能子类不一定需要或者不一定满足,父类的东西太多了子类可能只需要一点

快捷键Alt+insert

快速创建Override

总结

本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注服务器之家的更多内容!

原文链接:https://blog.csdn.net/xuzhibin666/article/details/119487908