Java教程22—Java中的方法覆盖

r囧r小猫 2022-05-13 00:52 225阅读 0赞

## 方法覆盖 ##

在子类中声明已存在于父类中的方法称为方法覆盖。  
完成方法覆盖，以便子类可以将父类已经提供的方法有了自己的实现。  
这种情况下，父类中的方法称为被重写的方法，子类中的方法称为重写方法。  
在本指南中，我们将看到Java中的方法覆盖是什么以及我们使用它的原因。

--------------------

## 方法覆盖示例 ##

让我们举一个简单的例子来理解这一点。  
我们有两个类：一个子类Boy和一个父类Human。  
Boy类继承了Human类。这两个类都有一个共同的方法void eat()。  
Boy类为eat()方法提供了自己的实现，换句话说，它覆盖了eat()方法。

方法覆盖的目的在这里很清楚。  
Child类想要给出自己的实现，这样当它调用这个方法时，就会打印出Boy的eat而不是Human的eat。

class Human{
        
        //被覆盖的方法
        public void eat(){
            System.out.println("Human is eating");
        }
    }
    class Boy extends Human{
        
        //覆盖方法
        public void eat(){
            System.out.println("Boy is eating");
        }
        public static void main( String args[]) {
            Boy obj = new Boy();
            //将调用子类版本的eat()
            obj.eat();
        }
    }
    
    Output:
    
    Boy is eating

--------------------

## 方法覆盖的优点 ##

方法重写的主要优点是**类可以为继承的方法提供自己的特定实现，这样就不需要修改父类代码。**

当一个类有多个子类时，这很有用，所以如果一个子类需要使用父类方法。  
它可以使用它，而其他想要有不同实现的类可以使用覆盖功能进行更改而不触及父类码。

## 方法覆盖和动态方法调度 ##

方法覆盖是**运行时多态**的示例。  
当父类引用指向子类对象时，则在运行时确定对重写方法的调用，因为在方法调用期间，要执行哪个方法(父类或子类)由对象类型确定。  
在运行时解析对覆盖方法的调用的过程称为动态方法调度。  
让我们看一个例子来理解这个：

class ABC{
        
        //父类方法
        public void disp()
        {
            System.out.println("disp() method of parent class");
        }
    }
    class Demo extends ABC{
        
        //覆盖父类方法
        public void disp(){
            System.out.println("disp() method of Child class");
        }
        public void newMethod(){
            System.out.println("new method of child class");
        }
        public static void main( String args[]) {
            /* 当父类引用引用了父类对象时
             * 父类的方法被调用
             */
            ABC obj = new ABC();
            obj.disp();
    
            /* 当父类引用引用了子类对象时
             * 子类的方法被调用
             */
            ABC obj2 = new Demo();
            obj2.disp();
        }
    }
    
    Output:
    
    disp() method of parent class
    disp() method of Child class

--------------------

在上面的示例中，使用第二个对象(obj2)调用disp()方法是运行时多态(或动态方法调度)。  
注意：在动态方法调度中，对象可以调用子类的重写方法和基类的所有非重写方法，但是它不能调用子类中新声明的方法。  
在上面的例子中，对象obj2正在调用disp()。  
但是，如果您尝试使用obj2调用newMethod() 方法(已在Demo类中新声明)，那么您将使用以下消息给出编译错误：

Exception in thread "main" java.lang.Error: Unresolved compilation 
    problem: The method newMethod() is undefined for the type ABC

--------------------

## Java中方法覆盖规则 ##

*  1、参数列表：重写方法的参数列表(子类的方法)必须与Overridden方法(父类的方法)匹配。  
    参数的数据类型及其序列应完全匹配。
 *  2、覆盖方法的访问修饰符(子类的方法)不能比父类的重写方法更具限制性。  
    例如，如果父类方法的访问修饰符是public，则覆盖方法(子类方法)不能具有private，protected和default 限制修饰符。  
    因为所有这三个访问修饰符都比public更具限制性。  
    这是不允许的，因为子类disp方法比基类(public)更具限制性(protected).

class MyBaseClass{
        
        public void disp()
        {
            System.out.println("Parent class method");
        }
    }
    class MyChildClass extends MyBaseClass{
        
        protected void disp(){
            System.out.println("Child class method");
        }
        public static void main( String args[]) {
            MyChildClass obj = new MyChildClass();
            obj.disp();
        }
    }
    
    Output:
    
    Exception in thread "main" java.lang.Error: Unresolved compilation
    problem: Cannot reduce the visibility of the inherited method from MyBaseClass

然而，下面这个是完全有效的情况，因为public的限制性比protected的要小些。  
相同的访问修饰符也是有效的。

class MyBaseClass{
        
        protected void disp()
        {
            System.out.println("Parent class method");
        }
    }
    class MyChildClass extends MyBaseClass{
        
        public void disp(){
            System.out.println("Child class method");
        }
        public static void main( String args[]) {
            MyChildClass obj = new MyChildClass();
            obj.disp();
        }
    }
    Output:
    
            Child class method

*  3、private，static和final方法不能被覆盖，因为它们是类的本地方法。  
    但是，静态方法可以在子类中重新声明，在这种情况下，子类方法将采取不同的行为，并且与父类的相同静态方法无关。
 *  4、重写方法(子类的方法)可以抛出未经检查的异常，无论被覆盖的方法(父类的方法)是否抛出任何异常。  
    但是，重写方法不应抛出新的或更广泛的检查异常，而不是重写方法声明的异常。  
    我们将在即将到来的教程中使用示例详细讨论这个问题。
 *  5、重写方法的绑定在运行时发生，称为动态绑定。
 *  6、如果类扩展抽象类或实现接口了，那么它必须覆盖所有抽象方法，除非类本身是抽象类。

--------------------

## 方法覆盖中的super关键字 ##

该super关键字用于调用父类的方法/构造函数。  
super.myMethod()在调用基类super()的构造函数时调用基类的myMethod()方法。  
让我们看看在子类覆盖方法中使用super。  
通过使用super，我们可以调用重写方法，如下例所示：

class ABC{
        
        public void myMethod()
        {
            System.out.println("Overridden method");
        }
    }
    class Demo extends ABC{
        
        public void myMethod(){
            //将调用父类方法
            super.myMethod();
            System.out.println("Overriding method");
        }
        public static void main( String args[]) {
            Demo obj = new Demo();
            obj.myMethod();
        }
    }
    Output:
    
            Class ABC: mymethod()
            Class Test: mymethod()

如您所见，使用super关键字，我们可以访问父类被覆盖的方法。

--------------------

原文地址：

https://beginnersbook.com/2014/01/method-overriding-in-java-with-example/