7.11 Java方法重写

7.11 Java方法重写

这里首先要确定的是重写跟属性没有关系，重写都是方法的重写，与属性无关

1. 带有关键字Static修饰的方法的重写实例

   父类实例

   package com.baidu.www.oop.demo05;
   
   public class B {
       public static void test(){
           System.out.println("这是父类方法的重写");
       }
   }
   

   子类实例

   package com.baidu.www.oop.demo05;
   
   public class A extends B{
       public static void test(){
           System.out.println("这是子类方法的重写");
       }
   }
   

   主程序实例

   package com.baidu.www.oop;
   
   import com.baidu.www.oop.demo05.A;
   import com.baidu.www.oop.demo05.B;
   
   public class Application {
       public static void main(String[] args) {
           A a = new A();
           a.test();
           //父类的引用指向了子类
           B b = new A();
           b.test();
           /*
           * 这里new的都是A但是输出结果不同
           * a.test()调用的是A类中的静态方法
           * b.test()调用的是B类中的静态方法
           * A类与B类之间又有继承关系
           * 有了继承关系在new A()的时候，子类是可以指向父类的
           * 也就是B b = new A（）中父类的引用b可以指向子类
           * 因为类型之间可以转化
           * 在这个实例中我们也能看出，方法的调用只跟等号左边的类有关
           * 也就是定义的数据类型有关
           * 也就是与右边的new A()没有什么关系*/
       }
   }
   /*
   * 这是子类方法的重写
   这是父类方法的重写
   
   Process finished with exit code 0*/
   

2. 不带Static关键字的方法的重写

   在IDEA中可以使用alt+insert快捷键实现快速插入方法的重写如图

   

   选择相应的父类方法可以重写，同时在方法上会自动生成一个注解

   @Override//注解跟注释一样，只不过这是一个又功能的注释
       public void test1() {
           super.test1();//默认调用父类的方法
       }
   }
   

   Override就是重写的意思，生成的重写的方法默认的是调用父类的方法。

   不带Static关键字修饰的父类实例

   package com.baidu.www.oop.demo05;
   
   public class B {
       public static void test(){
           System.out.println("这是父类static修饰的方法的重写");
       }
       public void test1(){
           System.out.println("这是父类没有static修饰的方法的重写");
       }
   
   }
   

   不带Static关键字修饰的子类实例

   package com.baidu.www.oop.demo05;
   
   public class A extends B{
       public static void test(){
           System.out.println("这是子类static修饰的方法的重写");
       }
   
       @Override
       public void test1() {
           System.out.println("这是子类没有static修饰的方法的重写");
       }
   }
   

   不带Static关键字修饰的主程序实例

   package com.baidu.www.oop;
   
   import com.baidu.www.oop.demo05.A;
   import com.baidu.www.oop.demo05.B;
   
   public class Application {
       public static void main(String[] args) {
           A a = new A();
           a.test();
           a.test1();
           //父类的引用指向了子类
           B b = new A();
           b.test();
           b.test1();
           /*
           * 这里new的都是A但是输出结果不同
           * a.test()调用的是A类中的静态方法
           * b.test()调用的是B类中的静态方法
           * A类与B类之间又有继承关系
           * 有了继承关系在new A()的时候，子类是可以指向父类的
           * 也就是B b = new A（）中父类的引用b可以指向子类
           * 因为类型之间可以转化
           * 在这个实例中我们也能看出，关键字static修饰的静态方法的调用只跟等号左边的类有关
           * 也就是定义的数据类型有关，就像double i = 1;虽然赋值了整型，但是数值类型还是double
           * 也就是与右边的new A()没有什么关系*/
       }
   }
   /*
   这是子类static修饰的方法的重写
   这是子类没有static修饰的方法的重写
   这是父类static修饰的方法的重写
   这是子类没有static修饰的方法的重写
   
   
   Process finished with exit code 0*/
   

   从运行结果可以看出没有Static关键字修饰的方法的重写，虽然B b= new A()；但是用Static关键字修饰的test()方法重写的调用是调用的父类的方法，而没有Static关键字修饰的test1()方法则是调用了子类的方法的重写。这里我们就得出一个结论静态方法与非静态方法是有区别的，没事的时候不要写一些静态的方法去玩，如果是使用了Static修饰的静态方法是与左边的定义类型有关的，而么有Static修饰的非静态方法则是与右侧赋值的方法有关，这也就是子类重写了父类的方法

   这里一定要注意重写只与非静态的方法有关，与静态方法没有关系，因为静态方法在类加载的时候就已经进入内存。而且重写方法的关键词也必须是public修饰的。

   这里我们也看出方法的重写与父类的方法名一模一样，只是实现的代码不同，与重载不同的是

   1. 重载是在同一个类中的，而重写则是在父类与子类之间的
   2. 重载是同一个类中的同一方法名但参数不同，而重写则是在不同类中的同一方法，只不过实现代码也就是方法体不同

   重写：前提：必须要有继承关系，而且是子类重写父类的方法！
   1.方法名必须相同
   2.参数列表必须相同
   3.修饰符：范围可以扩大，但是不能缩小，比如父类如果是一个Private私有类型的，假设可以被继承，那么子类可以写成public的，但是如果父类是public的子类重写时不能变成Private的类型。这里修饰符的优先级public > protected > default > private，也就是范围可以扩大但是不能缩小。
   4.抛出的异常：重写可能会抛出异常，异常的范围可以被缩小，但不能扩大，这与方法重写修饰符刚好相反，也就是子类本身是继承父类的方法，如果抛出异常，只在子类中抛出异常就行，不能再连累父类。
   

3. 为什么需要重写

   1. 生活中我们经常遇到父类的功能子类不一定需要或者不一定满足，父类中方法实现功能太多了，子类只需要少部分即可满足，或者父类太简单了，不能满足子类的，所以就需要子类重写父类的方法。