Wann final verwenden?

[Maik.Neumann]

Juten Tach,

wann genau nutze ich am beste die final Deklarartion?

Nutze ich sie z.B. immer, wenn ich einen beliebigen Wert als Parameter einer Methode übergeben möchte und dieser in der Methode selbst nur gelesen-, aber nicht verändert werden soll?

Und wann setze ich eine Referenzvariable z.B. als final? Ebenfalls nur dann, wenn aus diesem Objekt ausschließlich nur gelesen werden soll?

Maik

 

[stg]

final (Java) - Wikipedia, the free encyclopedia

 

[kaoZ]

final

musst du unter anderem auch verwenden wenn du aus inneren Klassen auf Variablen anderer Methoden zugreifen möchtest, da dies nur funktioniert wenn diese Eindeutig und unveränderbar sind.

da ich zzt. an einem Projekt arbeite in welchem ich mir grade Gedanken über das Flexible erzeugen von beliebigen Frames für ein Programm mache, arbeite ich genau jetzt mit final, hier mal ein Beispiel :

Spoiler: final

import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class FrameFactory {

	public static JFrame createFrame(String title, int width, int height, int closeOp, JFrame parent, boolean value){
		JFrame frame = new JFrame();
		
		frame.setTitle(title);
		frame.setSize(width, height);
		frame.setDefaultCloseOperation(closeOp);
		frame.setLocationRelativeTo(parent);
		frame.setVisible(value);
		
		return frame;
	}
	
	public static void main(String[] args) {
		
		Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
		JPanel p = new JPanel();
		JButton b = new JButton("Klick mich");
		
		final JFrame frame = FrameFactory.createFrame("Editor",(int) d.getWidth(), (int) d.getHeight(), 2, null, true);
		p.add(b);
		frame.add(p);
		
		b.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				FrameFactory.createFrame("Dialog", 300, 150, 2, frame, true);
				
				/*
				 * Hier erhält der erzeugte Frame nur zugriff auf das Elternelement (frame ), insofern dieses als 
				 * final deklariert ist.
				 */
				
			}
		});
	}
}

Ohne den Einsatz von

final

an dieser Stelle, hätte ich z.B aus dem Listener keinen zugriff auf die Variable frame, da diese lokal definiert ist .

Oder selbstverständlich überall dort wo du ein Überschreiben, eine erneute Wertzuweisung unterbinden möchtest (Variablen / Konstanten / Methoden), oder du sicherstellen willst das keine Weiteren Unterklassen (Klasse / Vererbung) erzeugt werden können.

 

[fisherman]

Final deklariert man auch Klassen, von denen man nicht möchte, dass andere Klassen von ihnen erben. Etliche Klassen der Java Standard API sind daher final.

 

[Gucky]

Praktisch ist sie auch, wenn du eine Konstante definieren, dafür aber kein ENUM verwenden willst. Da musst du nur aufpassen, da der Compiler den Namen der Variable durch ihren Wert ersetzen darf, so es ein primitiver Datentyp (oder String?) ist.
Wenn du den Wert dann änderst und nicht sämtliche Teile des Projektes neu kompilierst, in dem du diese Konstanten verwendest, bleibt der Wert so stehen.
Da nehmen sie ein bisschen die Position des Präprozessors aus C/C++ aus, wenn dir das hilft.

 

[Exorcist]

final kann je nachdem, wo sie steht, verschiedene Bedeutungen annehmen

-Eine als final deklarierte Variable wird zu einer Konstante und ist über die gesamte Laufzeit des Programmes nicht mehr veränderbar

-Eine als final gekennzeichnete Klasse kann nicht mehr per extends vererbt werden.

- Eine als final deklarierte Methode lässt sich nicht mehr überschreiben

Falls du also eine Variable hast, die über die gesamte Laufzeit des Programmes den Wert nicht verändert, so kannst du sie als final markieren, so wird sie zur Konstante. Möchte irgendwann jemand im Code die Variable ändern, so gibt der Compiler eine Fehlermeldung aus.