详解：Java的重写方法与示例

在父类中已经存在的子类中声明一个方法称为方法重写。进行了覆盖，以便子类可以将其自己的实现提供给父类已经提供的方法。在这种情况下，父类中的方法称为覆盖方法，子类中的方法称为覆盖方法。在本指南中，我们将了解Java中什么是方法重写以及为什么使用它。

方法覆盖示例

让我们举一个简单的例子来理解这一点。我们有两个班级：一个孩子班，一个男孩班，一个父母班，人类班。在Boy类扩展Human类。这两个类都有一个通用的方法void eat()。Boy类为方法提供了自己的实现，eat()换句话说，它重写了eat()方法。

方法覆盖的目的在这里很清楚。子类希望给出自己的实现，以便在调用此方法时，它打印出Boy正在吃而不是Human正在吃。

class Human{
   //Overridden method
   public void eat()
   {
      System.out.println("Human is eating");
   }
}
class Boy extends Human{
   //Overriding method
   public void eat(){
      System.out.println("Boy is eating");
   }
   public static void main( String args[]) {
      Boy obj = new Boy();
      //This will call the child class version of eat()
      obj.eat();
   }
}

输出：

Boy is eating

方法覆盖的优势

方法重写的主要优点是，类可以将自己的特定实现提供给继承的方法，而无需修改父类代码。

当一个类具有多个子类时，这很有用，因此，如果一个子类需要使用父类方法，则可以使用它，而其他想要实现不同的类可以使用重写功能进行更改，而无需接触父类。码。

方法覆盖和动态方法调度

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

class ABC{
   //Overridden method
   public void disp()
   {
	System.out.println("disp() method of parent class");
   }	   
}
class Demo extends ABC{
   //Overriding method
   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();
   }
}

输出：

disp() method of parent class
disp() method of Child class

在上面的示例中，使用第二个对象（obj2）调用disp（）方法是运行时多态性（或动态方法分派）。 注意：在动态方法分派中，对象可以调用子类的重写方法和基类的所有非重写方法，但不能调用在子类中新声明的方法。在上述示例中，对象obj2正在调用disp()。但是，如果尝试newMethod()使用obj2 调用该方法（已在Demo类中新声明），则会出现编译错误并显示以下消息：

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

Java中的方法重写规则

1. 参数列表：覆盖方法（子类的方法）的参数列表必须与Overridden方法（父类的方法）匹配。参数的数据类型及其顺序应完全匹配。
2. 覆盖方法（子类的方法）的访问修饰符不能比父类的覆盖方法的限制更多。例如，如果父类方法的访问修饰符是公共的，则覆盖方法（子类方法）不能具有私有，受保护的默认访问修饰符，因为这三个访问修饰符都比公共更严格。 例如，这是不允许的，因为子类disp方法比基类（公共）更具限制性（受保护） 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(); } } 输出： Exception in thread "main" java.lang.Error: Unresolved compilation problem: Cannot reduce the visibility of the inherited method from MyBaseClass 但是，这是完全有效的方案，因为公众的限制比受保护的限制要少。相同的访问修饰符也是有效的。 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(); } } 输出： Child class method
3. 私有，静态和最终方法不能被覆盖，因为它们在类中是本地的。但是可以在子类中重新声明静态方法，在这种情况下，子类方法的行为会有所不同，并且与父类的相同静态方法无关。
4. 重写方法（子类的方法）可以引发未经检查的异常，而不管被重写的方法（父类的方法）是否引发任何异常。但是，重载方法不应抛出比被重载方法声明的异常新的或更广泛的检查异常。我们将在即将到来的教程中通过示例详细讨论这一点。
5. 覆盖的方法的绑定在运行时发生，这称为动态绑定。
6. 如果一个类正在扩展一个抽象类或实现一个接口，则它必须重写所有抽象方法，除非该类本身是一个抽象类。

方法覆盖中的超级关键字

该super关键字用于调用父类的方法/构造函数。super.myMethod()调用基类的myMethod（）方法，同时super()调用基类的构造函数。让我们看看在方法重写中使用super的方法。 众所周知，我们在子类中重写了一个方法，然后使用子类对象调用该方法将调用重写的方法。通过使用super，我们可以调用重写的方法，如下例所示：

class ABC{
   public void myMethod()
   {
	System.out.println("Overridden method");
   }	   
}
class Demo extends ABC{
   public void myMethod(){
	//This will call the myMethod() of parent class
	super.myMethod();
	System.out.println("Overriding method");
   }
   public static void main( String args[]) {
	Demo obj = new Demo();
	obj.myMethod();
   }
}

输出：

Class ABC: mymethod()
Class Test: mymethod()

如你所见，使用超级关键字，我们可以访问重写方法。