Java中的方法的重载与重写（覆盖）

在Java的继承机制中，提供了方法的重载和重写（覆盖），在日常学习和笔试面试时常常容易混淆，因此，下面我们一起讨论下，有不足给我发评论，立即修改。

       1.方法的重载

           方法的重载必须满足一下条件：

               *方法名相同

               *方法的参数类型、个数、顺序至少有一项不相同

               *方法的返回类型可以不相同

               *方法的修饰符可以不相同

       2.方法的覆盖(重写)

               1.子类的方法的名称、参数类型和返回类型与父类的方法的名称、参数类型和返回类型一致。

               2.子类方法不能缩小父类方法的访问权限。

               3.子类方法不能抛出比父类方法更多的异常。

               4.方法的覆盖（重写）只能存在于子类和父类（包括直接父类和间接父类）之间，在同一个类中方法只能被重载，不能被覆盖（重写）。

               5.父类的静态方法不能被子类覆盖（重写）为非静态的方法。

               6.子类可以定义与父类静态方法同名的静态方法，以便在子类中隐藏父类的静态方法，在编译时，子类定义的静态方法也必须满足与方法覆盖（重写）类似的约束。

               7.父类的静态方法不能被子类覆盖（重写）为非静态方法。

               8.父类的私有方法不能被子类覆盖（重写）。

               9.父类的抽象方法可以通过两种途径覆盖（重写）：一是子类实现父类的抽象方法；二是子类重新声明父类的抽象方法。

               10.父类的非抽象方法可以覆盖（重写）为抽象方法。

       3.方法覆盖（重写）和方法重载具有以下不同点:

            *方法覆盖（重写）要求参数签名必须一致，而方法重载要求参数签名必须不一致

＃

               *方法覆盖（重写）要求返回类型必须一致，而方法重载对此不做限制

               *方法覆盖（重写）只能用于子类覆盖（重写）父类的方法，方法重载用于同一个类的所有方法(包括从父类中继承而来的方法)。

               *方法覆盖（重写）对方法的访问权限和抛出的异常有特殊的要求，而方法重载在这力面没有任何限制。

               *父类的一个方法只能被子类覆盖（重写）一次，而一个方法在所在的类中可以被重载多次。

       方法的重载的小例子：

package Work;
public class Test002 {
    public static void main(String[] args) {
        System.out.println(add(3));
        System.out.println(add(3,4));
        System.out.println(add(3.1,4.2));
    }
    public static int add(int a,int b){
        return a+b;
    }
    //一下为方法的重载分别为参数类型不同，参数个数不同
    public static float add(float a,float b){
        return a+b;
    }
    public static double add(double a,double b){
        return a+b;
    }
    public static double add(double a){
        return a;
    }
}

程序运行的结果为：

总结：方法的重载都在一个类中，同类中的同名方法都为方法的重载。

方法的重写（覆盖）的小例子：

下面为父类的代码（注意printMessage（）方法）：

package Work;
public class Father {
    private String name ;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void printMessage(){
        System.out.println("我是Father类中的方法！！");
    }
}

下面是子类的代码（仅含有从父类继承过来的东西和对pringMessage()方法的重写）：

package Work;
public class Son extends Father{
    public void printMessage(){
        System.out.println("我是Son类中的方法！！！");
    }
}

   下面是我写的一个测试程序：

package Work;
public class Text {
    public static void main(String[] args) {
        Father son = new Son();
        son.printMessage();
        Father fat = son;//此为Java中的多太
        fat.printMessage();
    }
}

       程序的运行结果又是什么呢？？？？

       怎么能够然程序执行父类的printMessage()方法呢？？？？

程序代码：

package Work;
public class Text {
    public static void main(String[] args) {
        Father son = new Son();
        son.printMessage();
        Father fat = son;//此为Java中的多太
        fat.printMessage();
        fat = new Father();
        fat.printMessage();
    }
}

程序的运行结果：

总结：在父子类之间的同名方法，一般都为方法的重写（覆盖），如果方法的参数类型、个数和顺序都相同则一定是方法的重写（覆盖）。

转载于:https://blog.51cto.com/zhaoyanming/1259466