方法的重载与重写

方法的重载

1. 概念:在同一的类中，允许在存一个以上的同名方法，只要他们的参数的个数或者参数类型不同即可.
2. 特点：与返回值类型无关，只看参数列表，切参数列表必须不同。

• 发生在同一类中，方法名相同，参数列表不同

public class Aoo{
    void show(){}
    void show(String name){}
    void show(int age){}
    void show(String name,int age){}
    void show(int age,String name){}

    //int show(){ return 1; } //编译错误，重载与返回值类型无关，与第一个冲突了
    //void show(String address){} //编译错误，重载与参数名称无关，与第二个冲突了
}

• 编译器在编译时会根据方法的签名自动绑定方法

public class OverloadDemo {
    public static void main(String[] args) {
        Aoo o = new Aoo();
        o.show();
        o.show("zhangsan");
        o.show(25);
        o.show("zhangsan",25);
        o.show(25,"zhangsan");
    }
}

3. 重载的作用:

• 方法重载的主要好处就是不用为了对不同的参数类型或参数个数，而写多个函数。
• 重载的最直接作用是方便了程序员可以根据不同的参数个数，顺序，类型，自动匹配方法，减少写过个函数名或方法名的重复步骤。

方法的重写

1. 定义:子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作。重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
2. 方法的重写规则

• 参数列表与被重写方法的参数列表必须完全相同。

• 父类的成员方法只能被它的子类重写。

• 声明为 final 的方法不能被重写。

• 声明为 static 的方法不能被重写，但是能够被再次声明。

• 构造方法不能被重写。

• 需要遵循"两小两同一大"原则:

  • 两同:
    方法名相同
    参数列表相同
  • 两小
    派生类方法的返回值类型小于或等于超类方法的
    派生类方法抛出的异常小于或等于超类方法的
  • 一大
    派生类方法的访问权限大于或等于超类方法的

• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。

• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。

• 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

超类

import java.io.File;
import java.io.IOException;

public class Father {
    String name;
    int age;

    public Father() {
    }

    void eat(int age) {
        System.out.println("父亲"+age+"岁");
    }

    final void see() {
        System.out.println("好好工作");
    }
    static void watchTV(){
        System.out.println("父亲看电视");
    }
    short hi(){
        return 3;
    }
    public void hit(){
        System.out.println("以父之名");
    }
    public void add() throws IOException {
        new File("a.text");
    }
}

class Student{
    public Student(){}
}

派生类

class Son extends Father {
String name;
    int age;

    public Son() {
    }

    void eat(int age) {
        System.out.println("儿子"+age+"岁");
    }
    static void watchTV(){
        System.out.println("儿子看电视");
    }
   /*
   被final声明的方法不能被重写
   void see(){
        System.out.println("好好学习");
    }
    */
    /*
    派生类方法的返回值类型小于或等于超类方法的
    int hi(){
        return 3;
    }
    */
   /*
    派生类方法的访问权限大于或等于超类方法的
    void hit(){
        System.out.println("派生类方法访问权限要大于或等于派生类方法权限");
    }
*/
/*
        子类重写父类的方法时，子类如果选择抛出异常，那么抛出的异常类型不能大于父类的异常类型
   public void add() throws Exception{
       new File("b.txt");
   }
   */
}

测试

class Text2 {
    public static void main(String[] args) {
        Father s = new Son();
        s.eat(5);
        s.watchTV();//输出的还是父类中的watchTV方法
      /*
      Student st = new Student();
       st.eat();    Student不是Father的派生类所以调不出eat方法
       */
        try {
            s.add();
        } catch (IOException e) {
            System.out.println("错误");
        }
    }

}

重载和重写的区别

• 重写：发生在父子类中，方法名相同，参数列表相同
• 重载：发生在同一类中，方法名相同，参数列表不同
• 重载不表现为多态性而重写表现为多态性:
  重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。
  所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；
  而对于多态，只等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。