面向对象--继承--方法的重写

方法重写概述 

当子类中的方法与父类中的方法一样的时候，内部实现不一样
这种现象我们称之为方法的重写，方法的覆盖

重写的定义：

子类中的方法名与形参列表以及返回值类型都和父类一样（方法声明一样），只是内部实现不一样。

方法重写的应用：

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。 

面试题：

java中重写与重载的区别：

• Override ：重写是发生在继承的关系中，方法名，参数列表，返回值类型都和父类一样   
• Overload ：重载是发生在同一个类中，方法名字一样，参数列表不一样，与返回值无关

程序示例

/*
        当子类中的方法与父类中的方法一样的时候，内部实现不一样
        这种现象我们称之为方法的重写，方法的覆盖

        重写的定义：
            子类中的方法名与形参列表以及返回值类型都和父类一样（方法声明一样），只是内部实现不一样。

        面试题：
            java中重写与重载的区别：
                1、重写是发生在继承的关系中，方法名，参数列表，返回值类型都和父类一样
                2、重载是发生在同一个类中，方法名字一样，参数列表不一样，与返回值无关
*/

class OldPhone{
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
}

class NewPhone extends OldPhone{
  //方法重写：方法声明一样
    public void call(String name){
      //内部实现不同
        System.out.println("给"+name+"打电话");
        System.out.println("学习");
    }
}

public class ExtendsDemo4 {
    public static void main(String[] args) {
        NewPhone newPhone = new NewPhone();
        newPhone.call("小伟");
    }
}

方法重写的注意事项（存在于继承的关系中）

• 父类中的私有成员方法无法被子类重写
• 子类重写父类的方法的时候，访问权限不能比父类的访问权限要低

要么和父类定义方法的权限一致，要么就比它的访问权限高
建议重写的时候，子类与父类中方法定义的格式一致

• 父类中静态的成员方法，无法被子类重写，静态的成员是属于类本身的东西

程序示例

/*
        方法重写的注意事项（存在于继承的关系中）
            1、父类中的私有成员方法无法被子类重写
            2、子类重写父类的方法的时候，访问权限不能比父类的访问权限要低
                要么和父类定义方法的权限一致，要么就比它的访问权限高
                建议重写的时候，子类与父类中方法定义的格式一致
            3、父类中静态的成员方法，无法被子类重写，静态的成员是属于类本身的东西
*/

class Father3{
  
    public void PlayFootball(){
        System.out.println("踢足球");
    }
  
//   父类的私有成员方法fly（）  
    private void fly(){
        System.out.println("飞翔");
    }
    
  
//---------------------------------------
/*
   假如我把父类中的fly（）改成public修饰的
    public void fly(){
        System.out.println("飞翔"); 
    }
*/
  
      
    //父类的静态成员方法fly1（）
    public static void fly1(){
        System.out.println("飞翔");
    }
}

class Son3 extends Father3{
  
//   方法的重写
//@Override 今后看到这个符号，就代表重写了父类中的方法
  
   @Override
    public void PlayFootball() {
    System.out.println("功夫足球");
    }
  
//子类中也有一个fly（）的方法，但这不是方法的重写，这是子类自己定义的成员方法
//哪怕你把public改成private也不是对父类中fly（）方法的重写
//因为父类中的私有成员方法无法被子类重写
    public void fly(){
        System.out.println("飞");
    }  
  
  
//--------------------------------------- 
/*
而且我把子类中的fly（）改成private修饰的
这个时候又会报错，因为子类重写父类的方法的时候，访问权限不能比父类的访问权限要低
    private void fly(){
        System.out.println("飞");
    }
*/
  
  
  //哪怕子类中fly1（）方法写的和父类中的一样，但这也不是方法的重写
  //因为被static关键字修饰的成员属于类的本身，不可被子类重写
  //这是子类的静态成员方法fly1（）
    public static void fly1(){
        System.out.println("飞翔");
    }
}

public class ExtendsDemo5 {
    public static void main(String[] args) {
        Son3 son3 = new Son3();
        son3.PlayFootball();//输出：功夫足球
        son3.fly();//输出：飞
    }
}