方法重写与之前的方法重载不同
回顾一下方法重载，相同的方法名不同参数类型和参数数量以及参数顺序
|
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快速生成重写方法
Override重写方法
|
1 2 3 4 5 6 7 8 9 10 11 |
class A{ public void demo(){ System.out.println( "Ademo" ); } } class B 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 B 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静态方法，调用结果之和左边定义的类有关。方法重写与非静态方法有关
私有方法无法进行方法重写，重写的关键词只能是public不能是private私有的
重写小结：
方法重写需要有继承关系，子类重写父类的方法 子类方法与父类的方法方法名和修饰符必须相同 以及方法的参数列表必须相同，不相同则为方法重载 修饰符范围可以扩大但是不能缩小，private（小）–>proteated–>default–>public(大) 重写可能会抛出异常，异常范围可以被缩小但不能扩大为什么需要重写？
父类的功能子类不一定需要或者不一定满足，父类的东西太多了子类可能只需要一点快捷键Alt+insert
快速创建Override
总结
本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注的更多内容！
原文链接：https://blog.csdn.net/xuzhibin666/article/details/119487908
查看更多关于JavaSE-面向对象(方法重写)的详细内容...