重写

1. 重写：重写需要有继承关系，子类重写父类的方法！

   1、方法名必须相同

   2、参数列表必须相同

   3、修饰符：范围可以扩大

   public > Protected > Default > private

   4、抛出的异常：范围可以被缩小，但不能扩大

   ClassNotFoundException ---> Exception(大)

   5、注意：重写，子类的方法和父类必须一致，方法体不同！

2. 注意：

   重写，子类的方法和父类必须一致，方法体不同！

   快捷键：Alt + Insert 选择 override

   为什么需要重写：父类的功能，子类不一定需要，或者不一定满足

3. 静态的方法和非静态的方法区别很大

   静态方法：方法的调用只和左边(定义的数据类型)有关

   非静态方法：重写

   关键字：Override 重写 ——> 子类重写父类的方法

   

    

4. 实例：

    1 package oop.demo8;
    2 
    3 /**
    4  * 重写：重写需要有继承关系，子类重写父类的方法！
    5  *  1.方法名必须相同
    6  *  2.参数列表必须相同
    7  *  3.修饰符：范围可以扩大
    8  *      public > Protected > Default > private
    9  *  4.抛出的异常：范围可以被缩小，但不能扩大
   10  *      ClassNotFoundException ---> Exception(大)
   11  * 注意：重写，子类的方法和父类必须一致，方法体不同！
   12  * 快捷键：Alt + Insert  选择override
   13  * 为什么需要重写：
   14  *  父类的功能，子类不一定需要，或者不一定满足
   15  */
   16 public class Application {
   17 
   18     public static void main(String[] args) {
   19 
   20         /**
   21          * 静态的方法和非静态的方法区别很大
   22          * 静态方法：
   23          *  方法的调用只和左边(定义的数据类型)有关
   24          * 非静态方法：
   25          *  重写
   26          */
   27         A a = new A();
   28         a.test(); //调用A类test方法
   29 
   30         //父类的引用指向了子类
   31         B b = new A();
   32         b.test(); //调用B类test方法
   33 
   34         System.out.println("------ 分隔符 ------");
   35 
   36         A a2 = new A();
   37         a2.test2(); //调用A类test2方法
   38 
   39         //父类的引用指向了子类
   40         B b2 = new A(); //子类重写了父类的方法
   41         b2.test2(); //调用B类的test2方法
   42 
   43     }
   44 
   45 }

父类

1. 初识：

   父类：

   重写都是方法的重写，和属性无关

2. 示例：

   

    

3. 实例：

    1 package oop.demo8;
    2 
    3 /**
    4  * 父类
    5  * 重写都是方法的重写，和属性无关
    6  */
    7 public class B {
    8 
    9     public static void test(){
   10         System.out.println("B=>test()");
   11     }
   12 
   13     public void test2(){
   14         System.out.println("B=>test()");
   15     }
   16 
   17 }

子类：extends关键字继承父类

1. 初识：

   子类：

   子类继承父类

2. 示例：

   

    

3. 实例：

    1 package oop.demo8;
    2 
    3 /**
    4  * 子类
    5  * 继承
    6  */
    7 public class A extends B {
    8 
    9     public static void test(){
   10         System.out.println("A=>test()");
   11     }
   12 
   13     /**
   14      * Override重写
   15      * 子类重写父类的方法
   16      */
   17     @Override
   18     public void test2() {
   19         System.out.println("A=>test()");
   20     }
   21 
   22 }