如果子类具有与基类相同的方法，那么它被称为 method overriding或者用另一个词，如果子类别向父母类中存在的任何方法提供特定的方法，那么它被称为 method overriding让我们从一个实时例子：

在一个小组织中，有两种员工例如： Manager和 Developer。
现在我们想打印员工的薪水。

在org.igi.theitroad中创建类员工.java

Employee.java

package org.igi.theitroad;
 
public class Employee { 
    int employeeId;
    String employeeName;
    double salary;
 
    public Employee(int employeeId, String employeeName, double salary) {
        super();
        this.employeeId = employeeId;
        this.employeeName = employeeName;
        this.salary = salary;
    }
 
    public int getEmployeeId() {
        return employeeId;
    }
    public void setEmployeeId(int employeeId) {
        this.employeeId = employeeId;
    }
    public String getEmployeeName() {
        return employeeName;
    }
    public void setEmployeeName(String employeeName) {
        this.employeeName = employeeName;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
       this.salary = salary;
    }
}

Manager.java：

package org.igi.theitroad;
 
public class Manager extends Employee{
 
    public static final double BONUSPERCENT=0.2;
    public Manager(int employeeId, String employeeName, double salary) {
        super(employeeId, employeeName, salary);
    }
    public double getSalary() {
        return salary+salary*BONUSPERCENT;
    }
}

Developer.java:

package org.igi.theitroad;
public class Developer extends Employee{ 
    public static final double BONUSPERCENT=0.1;
 
    public Developer(int employeeId, String employeeName, double salary) {
        super(employeeId, employeeName, salary);        
    }
 
    public double getSalary() {
 
        return salary+salary*BONUSPERCENT;
    }
}

MethodOverridingMain:

package org.igi.theitroad;
 
public class MethodOverridingMain {
 
    /**
     * @author igi Mandliya
     */
    public static void main(String[] args) {
        Developer d1=new Developer(1,"igi" ,20000);
        Developer d2=new Developer(2,"John" ,15000);
        Manager m1=new Manager(1,"Amit" ,30000);
        Manager m2=new Manager(2,"Ashwin" ,50000);
 
        System.out.println("Name of Employee:" +d1.getEmployeeName()+"---"+"Salary:"+d1.getSalary());
        System.out.println("Name of Employee:" +d2.getEmployeeName()+"---"+"Salary:"+d2.getSalary());
        System.out.println("Name of Employee:" +m1.getEmployeeName()+"---"+"Salary:"+m1.getSalary());
        System.out.println("Name of Employee:" +m2.getEmployeeName()+"---"+"Salary:"+m2.getSalary());
    }
}

运行它：当我们将运行MethodoverRiddingMain.java.you将获取以下输出：

员工姓名：igi-SALARY：22000.0员工姓名：John-Salary：16500.0雇员姓名：AMIT薪水：36000.0员工名称：Ashwin-Salary：60000.0

正如我们在这里看到的，我们在开发人员和经理中重写(overwriting)了员工类的GetsAlary()方法。
为什么我们需要重写(overwriting)Getsalary()？
因为我们需要基于类的GetSalary()方法的特定实现。
例如Developer Class和Manager类具有不同的奖励，因此我们需要不同的实现。

方法重写(overwriting)的规则

|参数|绝不能改变|
| --- - | --- |
|返回类型|除了协变量（亚型）返回之外无法改变|
|访问修改器|不得更具限制性。可以减少限制性。 |
|例外|可以减少或者消除但不能抛出新的/更广泛的检查异常|
|构造函数|不能过度重写(overwriting)|
|静态方法|不能过度重写(overwriting)|
|最终方法|不能过度重写(overwriting)|

现在，我会回答你可以拥有的一些明显的问题：

问题

为什么你不能让访问修饰者更具限制性(例如，公共到私有)？

它是OOP中的一个基本原则：子类是父类的完全成熟的实例，因此必须至少与父类相同的接口。
不那么可见会违反这个想法;我们可以使子类无法作为父类的实例。
让我们在举例的帮助下看：

class Employee{
 public double getSalary(){
      //some operation
    }
 }
 
 
class Developer extends Employee{
   private double id getSalary(){
       //some operation
   }
 }

现在我可以使用：

Employee e1=new Developer();
e1.getSalary();

因此，即使我们制作了Developer Private的GetSalary()方法，我们也能够使用员工(超级类)的参考访问开发人员的GotsAlary()方法，即使我们已私密。
因此，在重写(overwriting)方法时无法减少访问修改器。

为什么你不能重写(overwriting)静态方法？

因为静态方法与对象的类无关，所以我们可以在子类中声明静态方法，但与父类无关。
它是隐藏不重写(overwriting)的方法。

你能重写(overwriting)私有方法吗？

不，你不能。
无法重写(overwriting)私有方法，因为它是从任何其他类中都不可见的。
我们可以为子类声明一个与超类方法无关的新方法。
所以它不是方法重写(overwriting)。

为什么你不能重写(overwriting)最终方法？

因为最终的方法是不重写的。
我们声明了一个方法决定，因为我们不希望它在子类中被重写(overwriting)。

如果我们改变参数的数量怎么办？

如果我们更改参数的数量，那么方法将重新载载不重写(overwriting)。
父类方法和子类方法应具有相同的方法签名。

什么是动态绑定？

在运行时发生重写方法的绑定被称为动态绑定。

Super关键词

Super关键字可用于从子类调用特定的父类方法。

例如：

package org.igi.theitroad;
 
public class Employee{
 public double getSalary(){
  System.out.println("In Employee class getSalary() method");
  return 0;
 }
 
 public static void main(String args[])
 {
  Developer d1=new Developer();
  d1.getSalary();
 }
}
 
 
class Developer extends Employee{
 public double getSalary(){
               //calling parent class method
  super.getSalary();
  System.out.println("In Developer class getSalary() method");
  return 0;
 }
}

运行程序时，我们将获取以下输出：

In Employee class getSalary() method
In Developer class getSalary() method