Methodenumschreiben und Methodenüberladung

Vererbung und Polymorphismus sind beides Merkmale der objektorientierten Programmierung. Mithilfe der Vererbung können Sie eine Unterklasse basierend auf einer übergeordneten Klasse erstellen. Diese Unterklasse verfügt nicht nur über die Eigenschaften und Methoden der übergeordneten Klasse, sondern kann auch eigene Eigenschaften und Methoden erstellen. Aufgrund der Beziehung zwischen Unterklassen und übergeordneten Klassen treten Probleme beim Umschreiben von Methoden und beim Überladen von Methoden auf. Es gibt viele Probleme bei der Anwendung von Methodenumschreibung und Methodenüberladung bei Vererbung und Polymorphismus. Die Beherrschung des Unterschieds zwischen Umschreibung und Überladung ist sehr wichtig, um zu lernen, wie man Programme schreibt und die Wartbarkeit verbessert das Fundament.

1. Methodenüberschreibung (0veriding)
So definieren Sie das Umschreiben: In einem Java-Programm kann die Vererbungsbeziehung einer Klasse eine Unterklasse erben, die über alle Funktionen verfügt Merkmale der übergeordneten Klasse, erbt alle Methoden und Variablen der übergeordneten Klasse. Unterklassen können neue Funktionen definieren, wenn eine Unterklasse einige Methoden der übergeordneten Klasse ändern muss, um die Funktionalität zu erweitern und zu erhöhen. Programmdesigner nennen einen solchen Vorgang häufig Methodenumschreiben, auch Überschreiben oder Überschreiben genannt. Das Umschreiben spiegelt die Überlegenheit von Java wider. Das Umschreiben basiert auf Vererbungsbeziehungen, wodurch die Sprachstruktur reicher wird. Bei der Vererbung in Java können Unterklassen Methoden der übergeordneten Klasse sowohl verbergen als auch darauf zugreifen und auch von der übergeordneten Klasse geerbte Methoden überschreiben. Das Überschreiben der geerbten übergeordneten Klassenmethode in Java wird durch Methodenumschreiben erreicht.

Das sogenannte Methodenumschreiben bedeutet, dass die Methode in der Unterklasse genau den gleichen Rückgabewerttyp, Methodennamen, die gleiche Anzahl von Parametern und den gleichen Parametertyp hat wie die von der übergeordneten Klasse geerbte Methode. Auf diese Weise können Sie die Methoden der übergeordneten Klasse überschreiben. Beispiel: Der folgende Code implementiert das Überschreiben von Methoden.

class Person//定义父类
fpublic void print(){//父类中的方法
System.out.println( 父类Person的print方法! );
}
}
class Student extends Person//定义子类继承Person类
{public void print(){//方法的重写
System.out.println( 子类Student的print方法! );
}
}
public class 0verrideExampleO1
{public static void main(String args[])
{Student s=new Student();
S.print();
}
}

Ergebnis ausführen: Druckmethode der Unterklasse Student!

Es ist ersichtlich, dass, wenn die Unterklasse die print()-Methode in der übergeordneten Klasse überschreibt, S verwendet wird Der Druck ()-Methode der Unterklasse aufgerufen und die print()-Methode der übergeordneten Klasse überschrieben. Mit anderen Worten: Wenn die Unterklasse jetzt die Methode in der übergeordneten Klasse überschreibt, ruft sie beim Aufruf definitiv die überschriebene Methode auf. Was ist, wenn die Methode in der übergeordneten Klasse jetzt aufgerufen werden muss? Dies wird durch die Verwendung des Super-Schlüsselworts erreicht. Wenn Sie auf die überschriebene Methode zugreifen möchten, verwenden Sie zum Aufrufen die Form „super.method name (Parameterliste)“.

Zum Beispiel:

Class Person
{public void print () {
System.out.println( 父类Person的print方法! );
}
}
class Student extends Person
{public void print () {
super.print(：//访问父类中被子类覆写过的方法
System.out.println(" 子类Student的print方法!" );
}
}
public class OverrideExample02
{public static void main(String args[])
{Student s=new Student();
S.print();
}
}

Ergebnis ausführen: Druckmethode der übergeordneten Klasse Person!

Druckmethode der Unterklasse Student!
Wenn Sie die Super verwenden möchten Schlüsselwort, nicht Es muss nach dem Umschreiben der Methode verwendet werden.

kann auch eindeutig angeben, dass eine Methode von der übergeordneten Klasse geerbt wird. Durch die Verwendung von super

wird lediglich deutlicher, dass Sie in der übergeordneten Klasse und nicht in der Unterklasse suchen möchten.

2. Regeln zum Umschreiben

Beim Umschreiben von Methoden müssen Sie die folgenden Regeln befolgen:

(1) Die Parameterliste der übergeordneten Klassenmethode muss vollständig mit der Methode übereinstimmen Von der untergeordneten Klasse überschrieben Die Parameterliste ist dieselbe, andernfalls kann sie nicht als Überschreibung, sondern als Überladung bezeichnet werden. ..
(2) Der Rückgabetyp der übergeordneten Klasse muss mit dem Rückgabetyp der von der Unterklasse überschriebenen Methode identisch sein, andernfalls kann er nicht als Überschreiben, sondern als Überladen bezeichnet werden. ..
(3) Java schreibt vor, dass Methoden, die von Unterklassen überschrieben werden, keine restriktiveren Zugriffsrechte haben dürfen als Methoden der übergeordneten Klasse. Die Beziehung zwischen Zugriffsberechtigungen ist:

Jeder, der Java-Programme geschrieben hat, weiß, dass Methoden in der übergeordneten Klasse unter keinen Umständen neu geschrieben werden können. Wenn der Zugriffsberechtigungsmodifikator der Methode in der übergeordneten Klasse privat ist, ist diese Methode Der Zugriff ist nur auf die eigene Klasse möglich, nicht auf externe Klassen, und die Klasse kann nicht in Unterklassen überschrieben werden. Wenn die in der übergeordneten Klasse definierte Methode öffentlich und die Methode in der Unterklasse als privat definiert ist, wird beim Ausführen des Programms ein Fehler gemeldet. Zum Beispiel:

class Person
{public void print()(//public访问权限
System.out.println( "父类Person的print方法! ");
}
}
Class Stedent extends Person
{private void print()(//重写方法降低了访问权限，错误
System.out.println( "子类Student的print方法!" );
}
}

(4) Da der Zugriffsberechtigungsmodifikator der übergeordneten Klasse größer sein muss als der Zugriffsberechtigungsmodifikator der von der Unterklasse überschriebenen Methode, sind private Berechtigungen die am kleinsten. Wenn also die Zugriffsberechtigung einer bestimmten Methode in der übergeordneten Klasse privat ist, kann sie in der Unterklasse nicht überschrieben werden. Wenn es neu definiert wird, definiert es nur eine neue Methode und erzielt nicht den Effekt des Umschreibens.

(5) Wenn während des Vererbungsprozesses eine Methode in der übergeordneten Klasse eine Ausnahme auslöst, muss beim Überschreiben der Methode der übergeordneten Klasse in der Unterklasse auch eine Ausnahme ausgelöst werden, und zwar die Anzahl der Ausnahmen Es dürfen nicht zu viele Ausnahmen in der übergeordneten Klasse ausgelöst werden (kann mit den in der übergeordneten Klasse ausgelösten Ausnahmen übereinstimmen). Mit anderen Worten: Die überschriebene Methode darf keine neue geprüfte Ausnahme oder eine geprüfte Ausnahme auslösen, die umfassender ist als die von der überschriebenen Methode deklarierte. Beispielsweise deklariert eine Methode der übergeordneten Klasse 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.

Wenn in ähnlicher Weise eine Mitgliedsvariable in einer Unterklasse erstellt wird und die Variable denselben Namen wie eine Variable in der
Elternklasse hat, spricht man von Variablenüberschreibung oder Attributüberschreibung. Dieses
-Konzept wird jedoch im Allgemeinen selten von Menschen studiert, da es wenig Bedeutung hat.

三、方法重载(Overloading)

(一)  如何定义重载。方法的重写和重载只有一个字不同，很多初学者认为这两者十分相似，其实不然。方法重载是让类以统一的方式处理不同类型数据的一种手段。调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法，这就是多态性。
所谓方法重载是指在一个类中，多个方法的方法名相同，但是参数列表不同。参数列表不同指的是参数个数、参数类型或者参数的顺序不同。方法的重载在实际应用中也会经常用到。不仅是一般的方法，构造方法也可以重载。下面通过一个实例来分析。
重载的定义和使用方法。 

Class Person {
{String name; 
int age;
void print(){ 
System.out.println("姓名：" +name+"年龄：" +age); 
}
void print(String a，int b){ 
System.out.println("姓名：" +a+"年龄："+b); 
void print(String a，int b，intC){ 
System.out.println("姓名："+a+"年龄：" +b+"ID号：" +c); 
}
void print(String a，int b，doubleC){ 
System.out.println("姓名："+a+"年龄：" +b+"ID号："+c); 
} 
}
public class OverLoadExampleOL 
{publicstaticvoidmain(String args[]) 
{Personpl=newPerson();
p1.nanle="李明";
p1.age=22;
p1.print(); 
p1.print("王小早",19); 
p1.print("金波",18,100325); 
p1.print("婉宁",25,110903); 
} 
}

在上面的程序中，可以看到Person类中有多个名为 void print的方法，这就是方法的重载。执行程序，运行结果如下：

姓名：李明年龄：22
姓名：王小早年龄：l9
姓名：金波年龄：18ID号：10 00325
姓名：婉宁年龄：25ID号：110903

在方法重载时，方法之间需要存在一定的联系，因为这样可以提高程序的可读性，一般只重载功能相似的方法重载规则。重载是指我们可以定义一些名称相同的方法，通过定义不同的参数来区分这些方法，然后再调用时，Java虚拟机就会根
据不同的参数列表来选择合适的方法执行。也就是说，当一个重载方法被调用时，Java用参数的类型和.. (或)个数来决定实际调用的重载方法。因此，每个重载方法的参数的类型或个数必须是不同。虽然每个重载方法可以有不同的返回类型，
但返回类型并不足以区分所使用的是哪个方法。当Java调用一个重载方法是，参数与调用参数匹配的方法被执行。在使用重载要注意以下的几点:

1.在使用重载时只能通过不同的参数列表，必须具有不同的参数列表。例如，不同的参数类型，不同的参数个数，不同的参数顺序。当然，同一方法内的几个参数类型必须不一样，例如可以是 fun(int，float)，但是不能为 fun(int，int)。
2.不能通过访问权限、返回类型、抛出的异常进行重载。
3.方法的异常类型和数目不会对重载造成影响。.. 
4.可以有不同的返回类型，只要参数列表不同就可以了。
5.可以有不同的访问修饰符。

6.可以抛出不同的异常。

四、方法重写与方法重载的区别
通过上面例子的分析，我们可以将方法重写和重载的区别总
结成这样一个表格，如下：

五、结束语
在面向对象程序设计的思想中，类的继承和多态性主要就是体现在子类重写父类的方法。而构造方法的重载作为方法重载的一个典型特例，可以通过重载构造方法来表达对象的多种初始化行为。灵活的运用方法重写与方法重载，不仅能减少编码的工作量，也能大大提高程序的可维护性及可扩展性。用好重写和重载
可以设计一个结构清晰而简洁的类，可以说重写和重载在编写代码过程中的作用非同一般。