Die Rolle der Verwendung der endgültigen Änderung der Parameter in Java
Das Hinzufügen des endgültigen Schlüsselworts vor den Methodenparametern besteht darin, zu verhindern, dass die Daten im Methodengewicht geändert werden.
Es gibt zwei Hauptsituationen: Zunächst verwenden Sie den grundlegenden Datentyp. Zweitens ändern Sie den Referenzdatentyp endgültig.
Ändern Sie im ersten Fall den grundlegenden Datentyp. Zu diesem Zeitpunkt kann der Wert des Parameters nicht in der Methodenkörper geändert werden, dh er kann nicht neu zugewiesen werden. Andernfalls wird die Zusammenstellung nicht verabschiedet.
Der zweite Fall besteht darin, den Referenztyp zu ändern. Zu diesem Zeitpunkt kann das von der Parametervariablen verwiesene Objekt nicht geändert werden. Für Referenzdatentypen ist es jedoch vollkommen in Ordnung, ihre Eigenschaften zu ändern.
Wenn Sie daher das endgültige Schlüsselwort verwenden möchten, verwenden Sie den grundlegenden Datentyp, der sehr nützlich ist.
Endgültige Variable:
Verwenden Sie endgültige für Grundtypen: Es ist eine Konstante, der Wert ist konstant und der Wert bleibt unverändert.
Verwenden Sie die endgültige Referenzen für Objekte: Machen Sie die Referenzkonstante und sobald die Referenz auf ein Objekt initialisiert ist, kann sie nicht so geändert werden, dass sie auf ein anderes Objekt verweist. Das Objekt selbst kann jedoch geändert werden, und Java bietet keine Möglichkeit, ein Objekt konstant zu machen. Diese Einschränkung verwendet auch Arrays, die Objekte sind.
Beispiel:
Klassenwert {int i; public value (int i) {this.i = i; }} public class FinalData {private static randal random = new random (47); private String -ID; public FinalData (String -ID) {this.id = id; } private endgültige int valueone = 9; private statische endgültige int value_two = 99; public static final int value_three = 39; private endgültige int i4 = random.nextint (20); statische endgültige int int_5 = random.nextint (20); privater Wert v1 = neuer Wert (11); privater Endwert V2 = neuer Wert (22); private statische endgültige Wert val_3 = neuer Wert (33); private endgültige int [] a = {1, 2, 3, 4, 5, 6}; public String toString () {return id + ":" + "i4 =" + i4 + ", int_5 =" + int_5; } public static void main (String [] args) {FinalData fd1 = new FinalData ("fd1"); //! fd1.ValueOne ++; // Da ValueOne eine Basistypkonstante ist, ist sein Wert konstant fd1.v2.i ++; // Der durch die endgültige geänderte Inhalt des Objekts kann geändert werden fd1.v1 = neuer Wert (9); für (int i = 0; i <fd1.a.length; i ++) fd1.a [i] ++; //! fd1.v2 = neuer Wert (0); // Da V2 ein nach endgültigem geänderter Referenztyp ist, kann seine Referenz nicht geändert werden, um auf ein anderes Objekt zu verweisen //! fd1.val_3 = neuer Wert (1); // Es nimmt einen Speicherraum ein, der nicht geändert werden kann //! fd1.a = new int [3]; // endgültige modifizierte Array System.out.println (fd1); System.out.println ("Neue finalData erstellen"); FinalData fd2 = new FinalData ("fd2"); System.out.println (fd1); System.out.println (fd2); }}/*Ausgabe: fd1: i4 = 15, int_5 = 18 neue finaldatafd1: i4 = 15, int_5 = 18fd2: i4 = 13, int_5 = 18*/analysieren:
Für FD1, FD2 zwei Objekte ist i4 eindeutig, dh jedes Objekt hat ein i4, aber int_5 wird als statisch deklariert, dh es wird von der Klasse, FD1 und FD2 Share Int_5, geteilt, was zum Zeitpunkt des Ladens initialisiert wird, anstatt jedes Mal zu initialisieren, wenn ein neues Objekt erstellt wurde (zum Beispiel i4). Es ist jedoch gleichzeitig auf endgültig eingestellt, sodass seine Referenz unveränderlich ist, dh es kann nicht geändert werden, um auf ein anderes Objekt zu verweisen.
Leeres Finale:
wird als endgültig deklariert, hat aber keinen Anfangswert angegeben. Das endgültige muss unter Verwendung von Ausdrücken in der Domänendefinition oder in jedem Konstruktor zugewiesen werden, weshalb die endgültige Domäne immer vor der Verwendung initialisiert wird.
Letzte Parameter:
Dies bedeutet
Beispiel:
Klasse Gizmo {int i = 0; public void spin () {}} öffentliche Klasse FinalArgumente {void mit (endgültig gizmo g) {//! g = neuer Gizmo (); // Die durch den endgültigen geänderte Referenz wird nicht so geändert, dass sie auf ein anderes Objekt G.i ++ verweist; // aber der Inhalt, auf den das endgültige Objekt hingewiesen wird, kann ohne (gizmo g) {g = new Gizmo () modifiziert werden; g.spin (); } // int g (endgültig int i) {// //! i ++; // Weil Parameter I ein konstanter Wert ist //} int g (endgültig int i) {return i + 1; } public static void main (String [] args) {FinalArgumente bf = new FinalArgumente (); bf.with (null); bf.with (null); }}analysieren:
Der Parameter wird als endgültig deklariert. Wenn es sich um einen Grundparameter handelt, ist es eine Konstante und kann nicht geändert werden. Wenn es sich um eine Referenzvariable handelt, kann es nicht so geändert werden, dass sie auf ein anderes Objekt verweisen, aber der Inhalt des von der Referenz genannten Objekts kann geändert werden.
FIANL -Methode:
Grund für den Gebrauch:
Alle privaten Methoden in der Klasse werden implizit als endgültig angegeben, und da die private Methode nicht angewendet werden kann, kann sie nicht überschrieben werden. Ein endgültiger Modifikator kann der privaten Methode hinzugefügt werden, dies gibt der Methode jedoch keine zusätzliche Bedeutung.
Beispiel:
Klasse withfinals {private final void f () {System.out.println ("withfinals.f ()"); } private void g () {System.out.println ("overridingPrivate.f ()"); }} class OverridingPrivate erweitert sich mit Finalen {private endgültige void f () {System.out.println ("overriedPrivate.f ()"); }} class OverridingPrivate2 erweitert das Überschreiben von { /** Bei Verwendung der Überschreibung Annotation, um die F () -Methode zu erzwingen, um die Methode f () der übergeordneten Klasse zu überschreiben, wird ein Fehler gemeldet*, da nicht weiß, ob die übergeordnete Klasse die Methode hat. Für die G () -Methode generiert sie nur eine neue Methode und überschreibt die G () -Methode in der übergeordneten Klasse nicht. *///@überschreiben öffentliche endgültige void f () {System.out.println ("overriedPrivate2.f ()"); } public void g () {System.out.println ("overridingPrivate2.g ()"); }} öffentliche Klasse Abschließung übertriebsillusion {public static void main (String [] args) {overriedPrivate2 op2 = new OverridingPrivate2 (); op2.f (); op2.g (); // Sie können OP2 -OP2 -OP2 -Aufwärtsbeschwerden transformieren. //! op.f (); // Die endgültige Methode in der übergeordneten Klasse ist für die Unterklasse unsichtbar //! op.g (); Mit Finalen wf = op2; // wf.f (); // wf.g (); }}/*output: overriedPrivate2.f () overriedPrivate2.g ()*//analysieren:
Wann tritt die Abdeckung auf:
1. Methoden, die in Unterklassen erscheinen, die genau mit denen von übergeordneten Klassen entsprechen
2. Eine Unterklasse kann in eine übergeordnete Klasse nach oben umgewandelt werden und die Methode in der übergeordneten Klasse aufrufen
Wenn eine Methode in der übergeordneten Klasse als endgültig oder privat erklärt wird, ist diese Methode für die Unterklasse unsichtbar. Auch wenn eine Methode, die genau wie die übergeordnete Klasse in der Unterklasse erstellt wird, in der Unterklasse erstellt wird, ist dies eine neue Methode und nicht eine Methode, die von der übergeordneten Klasse überschrieben ist.
Letzte Klasse:
Das heißt, diese Klasse kann nicht vererbt werden, ob es Sie oder andere sind, dh in dieser Klasse sind keine Änderungen erforderlich, noch erfordert sie Unterklassen wie die String -Klasse.
Beispiel:
Klasse Smallbrain {} Finale Klasse Dinosaurier {int i = 7; int j = 1; Smallbrain x = neuer smallbrain (); void f () {}} // Fehler: Der Typ weiter kann die endgültige Klasse Dinosaurier // Dinosaurierklasse nicht unterklassen. NF (); Ni = 40; N.J ++; }}Zusammenfassen
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass der Inhalt dieses Artikels einen gewissen Referenzwert für das Studium oder die Arbeit eines jeden hat. Wenn Sie Fragen haben, können Sie eine Nachricht zur Kommunikation überlassen. Vielen Dank für Ihre Unterstützung bei Wulin.com.