Spiegazione dettagliata di sovraccarico (overload) e sovrascrittura (override) in Java con esempi

　Molti studenti confondono overload e override, consiglio di non memorizzare passivamente le conoscenze concettuali, ma di comprenderle e memorizzarle.

　　

　　　 Prima di tutto, ditemi la mia definizione:

　　　 overload（sovraccarico）：In una classe o in classi con relazione di ereditarietà, un gruppo di metodi con lo stesso nome ma parametri diversi. In sostanza, è un nome diverso per diversi metodi.

　　　 override（sostituzione）：Esiste una relazione di ereditarietà tra due classi, nel metodo della classe figlia viene ridefinito il metodo esistente nella classe padre. In sostanza, è una diversa implementazione per lo stesso metodo.

　Prima di tutto, vediamo un esempio di sovraccarico:

public class OverloadParent{
  public String getPerson(String name){
    return “personA” + name;
  }
  public String getPerson(int age){
    return “personB” ;
  }
  public String getPerson(String name,int age){
    return “personC”;
  }
  public void getPerson(String name){
    System.out.println(“Sono il metodo sovraccaricato?”);
  }
}

public class OverloadChildextends OverloadParent {
  public void getPerson(double money){
     Sytem.out.println(“Sono il metodo sovraccaricato?”);
  }
}

　　　 Attenzione a osservare:

　　　 （1）OverloadParent ha 4 metodi con lo stesso nome

　　　 （2）I primi tre metodi hanno tipi e numeri di parametri diversi, ma valori di ritorno identici, costituiscono sovraccarico

　　　 （3）Il metodo 4 e il metodo 1 hanno solo un valore di ritorno diverso, non costituiscono sovraccarico, il compilatore non lo accetta.

　　　　　　　 ps: il valore di ritorno è il risultato dell'esecuzione del metodo, non specificiamo quando chiamiamo il metodo che 'voglio chiamare un metodo il cui valore di ritorno è del tipo xxx', non è una caratteristica di sovraccarico dei metodi.

　　　 （4）OverloadParent ha ereditato Demo, Demo possiede i metodi, che OverloadParent possiede anche. Si rende conto che i metodi esistenti non soddisfano le esigenze, quindi ha sovraccaricato uno di essi.

　　　　 重载的标志：方法名相同，参数不同（个数或者类型），与返回值无关。

　　　　 再来看一个覆写的例子：

  public class OverrideParent{
     public void fly(){
       System.out.println("I can fly!");
    }
  }

  public class OverrideChild extends OverrideParent{
    @override
    public void fly(){
         System.out.println("I can't fly, but I can run!");
    }

   public static void main(String[] args){
         OverwriteParent child= new OverwriteChild();
         child.fly();
    }
  }

　　　 执行OverrideChild的main方法，会输出什么呢？

　　　 答案是：I can't fly, but I can run!

　　　 我们看到：

　　　 （1）OverrideChild和OverrideParent都有一个fly方法

　　　 （2）fly的返回值和修饰符都一样，只有方法体不一样

　　　 （3）子类的fly方法前有一个@overwrite的注解，jdk1.5出现的，仅用于类的继承，1.6可用于接口实现。这个注解有助于编译器检查，不加也可以的。　　　　　　　

覆写的标志：子承父类，对相同的方法有不同的实现。　

应用场景

　　　　　　　　 重载：当方法功能相似，但需要传递不同的参数。

　　　　　　　　 覆写：子类有自己特有的行为，从父类继承而不能满足自身需要时。

　　　　　　　　 ps：重载和覆写都是多态的表现。前者是编译器多态，后者是运行期多态。

　　　　　　　　　 感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！