Was ist der Unterschied zwischen Umschreiben und Überladen in Java?

Unterschied: Beim Umschreiben schreibt eine Unterklasse den Implementierungsprozess einer Methode neu, die den Zugriff auf die übergeordnete Klasse ermöglicht. Der Methodenname und die Parameterliste sind identisch und weder der Rückgabewert noch die formalen Parameter können geändert werden. Von einer Überladung spricht man, wenn in derselben Klasse gleichzeitig mehrere Funktionen mit demselben Namen und unterschiedlicher Anzahl oder Typen von Parametern mit demselben Methodennamen und unterschiedlichen Parameterlisten vorhanden sind.

Verwandte Empfehlungen: „Java Video Tutorial“

F: Was sind Java-Überladung und Umschreiben? Was ist der Unterschied?

Antwort:
　　Overload (Überladung) ist ein Mittel für eine Klasse, um verschiedene Arten von Daten auf einheitliche Weise zu verarbeiten. Die tatsächliche Leistung besteht aus mehreren Funktionen mit demselben Namen (der Rückgabewerttyp ist optional und der Rückgabetyp kann nicht als Kriterium zur Unterscheidung überladener Funktionen verwendet werden) ist gleichzeitig in derselben Klasse vorhanden, was eine Manifestation des Polymorphismus in einer Klasse ist (beim Aufruf). Eine Methode, <code> wird übergeben. Unterschiedliche Anzahl von Parametern und Parametertypen bestimmen, welche Methode verwendet werden soll (Polymorphismus). 同名函数（返回值类型可随意，不能以返回类型作为重载函数的区分标准）同时存在于同一个类中，是一个类中多态性的一种表现（调用方法时通过传递不同参数个数和参数类型来决定具体使用哪个方法的多态性）。

图1. Android类中的一个重载例子

重写（Override）是父类与子类之间的多态性，实质是对父类的函数进行重新定义，如果在子类中定义某方法与其父类有相同的名称和参数则该方法被重写，不过子类函数的访问修饰权限不能小于父类的；若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法，如需父类中原有的方法则可使用 super 关键字。

图2. Android类中的常见的一个重写例子

----------

**重载规则：**必须具有不同的参数列表； 可以有不同的返回类型；可以有不同的访问修饰符；可以抛出不同的异常。

重写规则：参数列表必须完全与被重写的方法相同，否则不能称其为重写；返回类型必须一直与被重写的方法相同，否则不能称其为重写；访问修饰符的限制一定要大于等于被重写方法的访问修饰符；重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常，譬如父类方法声明了一个检查异常 IOException，在重写这个方法时就不能抛出 Exception，只能抛出 IOException 的子类异常，可以抛出非检查异常。

重载与重写是 Java 多态性的不同表现。
　　重写是父类与子类之间多态性的表现，在运行时起作用（动态多态性，譬如实现动态绑定）
　　而重载是一个类中多态性的表现，在编译时起作用（静态多态性，譬如实现静态绑定）。

---

问：Java 构造方法能否被重写和重载？

答：
　　重写是子类方法重写父类的方法，重写的方法名不变，而类的构造方法名必须与类名一致，假设父类的构造方法如果能够被子类重写则子类类名必须与父类类名一致才行，所以 Java 的构造方法是不能被重写的。而重载是针对同一个的，所以构造方法可以被重载。

问：下面程序的运行结果是什么，为什么？

public class Demo {
    public boolean equals( Demo other) {
        System.out.println("use Demo equals." );
        return true;    }
    public static void main(String[] args) {    
    Object o1 =new Demo ();
    Object o2 =new Demo ();        
    Demo o3 =new Demo ();
    Demo o4 =new Demo ();

   if (o1.equals(o2)) {
            System.out.println("o1 is equal with o2.");
        }

   if(o3.equals(o4)) {             
            System.out.println("o3 is equal with o4.");
        }
    }}

答：上面程序的运行结果如下。

use Demo equals.
o3 is equal with o4.

因为 Demo 类中的 public boolean equals(Demo other) 方法并没有重写 Object 类中的 public boolean equals(Object obj) 方法，原因是其违背了参数规则，其中一个是 Demo 类型而另一个是 Object 类型，因此这两个方法是重载关系（发生在编译时）而不是重写关系；故当调用 o1.equals(o2) 时，o2 是 Object 类型参数，实际上调用了 Object 类中的 public boolean equals(Object obj) 方法

Abbildung 1. Ein Überladungsbeispiel in der Android-Klasse

Override🎜 ist der Polymorphismus zwischen der übergeordneten Klasse und der untergeordneten Klasse. Das Wesentliche besteht darin, die Funktionen der übergeordneten Klasse neu zu schreiben Wenn eine in einer Unterklasse definierte Methode denselben Namen und dieselben Parameter wie ihre übergeordnete Klasse hat, wird die Methode überschrieben, die Zugriffsänderungsrechte der Unterklassenfunktion dürfen jedoch nicht geringer sein als die der übergeordneten Klasse, wenn die Methode in der Unterklasse vorhanden ist unterscheidet sich von der Methode in der übergeordneten Klasse. Wenn eine Methode denselben Methodennamen, denselben Rückgabetyp und dieselbe Parameterliste hat, überschreibt die neue Methode die ursprüngliche Methode. Wenn Sie die ursprüngliche Methode in der übergeordneten Klasse benötigen, können Sie das Schlüsselwort super verwenden . 🎜🎜🎜 Abbildung 2. Ein häufiges Überschreibungsbeispiel in Android-Klassen🎜----------🎜🎜**Überladungsregeln:**Müssen unterschiedliche Parameterlisten haben; es kann unterschiedliche Rückgaben geben Es können unterschiedliche Zugriffsmodifikatoren vorhanden sein, und es können unterschiedliche Ausnahmen ausgelöst werden. 🎜🎜🎜Regeln zum Umschreiben: 🎜Die Parameterliste muss genau mit der überschriebenen Methode übereinstimmen, andernfalls kann sie nicht als Überschreibung bezeichnet werden. Der Rückgabetyp muss immer mit der überschriebenen Methode identisch sein, andernfalls kann sie nicht aufgerufen werden override ;Der Zugriffsmodifikatorgrenzwert muss größer oder gleich dem Zugriffsmodifikator der überschriebenen Methode sein. Die überschriebene Methode darf keine neue geprüfte Ausnahme oder eine geprüfte Ausnahme auslösen, die umfassender als die überschriebene Methodendeklaration ist, z Die übergeordnete Klassenmethode deklariert eine geprüfte Ausnahme IOException. Beim Überschreiben dieser Methode können Sie keine Ausnahmen auslösen. Sie können nur Ausnahmen von Unterklassen von IOException auslösen. 🎜🎜🎜Überladen und Umschreiben sind verschiedene Erscheinungsformen des Java-Polymorphismus. 🎜Überladen ist eine Manifestation des Polymorphismus in einer Klasse, der zur Kompilierungszeit funktioniert (statischer Polymorphismus, wie z. B. statische Bindung). 🎜🎜

---

🎜🎜🎜F: Können Java-Konstruktoren überschrieben und überladen werden? 🎜🎜🎜🎜Antwort: 🎜 Überschreiben ist eine Methode, bei der eine Unterklassenmethode die übergeordnete Klasse überschreibt. Der überschriebene Methodenname bleibt unverändert und der Konstruktormethodenname der Klasse muss mit dem Namen der übergeordneten Klasse übereinstimmen Die Konstruktormethode kann zum Überschreiben in Unterklassen unterteilt werden. Der Klassenname der Unterklasse muss mit dem Namen der übergeordneten Klasse übereinstimmen, sodass „Javas Konstruktionsmethode“ nicht überschrieben werden kann. Überladen gilt für dasselbe, sodass der Konstruktor überladen werden kann. 🎜🎜🎜🎜F: Was ist das Ergebnis des folgenden Programms und warum? 🎜🎜🎜rrreee🎜Antwort: Die laufenden Ergebnisse des oben genannten Programms sind wie folgt. 🎜rrreee🎜Da die öffentliche boolesche Methode equals(Demo other) in der Demo-Klasse die öffentliche boolesche Methode equals(Object obj) in der Object-Klasse nicht überschreibt, liegt der Grund darin, dass sie gegen die Parameterregeln verstößt, von denen eine die Demo ist Typ und die andere ist der Objekttyp, sodass diese beiden Methoden überladen (zur Kompilierzeit) und nicht überschrieben werden. Wenn also o1.equals(o2) aufgerufen wird, ist o2 ein Objekttypparameter und die Objektklasse ist es Die tatsächlich aufgerufene öffentliche boolesche Methode equals(Object obj) in liegt daran, dass o1 und o2 zur Kompilierungszeit beide Objekttypen sind und die equal-Methode der Object-Klasse beim Aufruf von o3.equals false zurückgibt (o4) wird tatsächlich die Methode equal(Demo other) in der Demo-Klasse aufgerufen. Da o3 und o4 zur Kompilierungszeit beide vom Typ Demo sind, ist der obige Ausdruck vorhanden. 🎜

Das obige ist der detaillierte Inhalt vonWas ist der Unterschied zwischen Umschreiben und Überladen in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!