Modifizierer

Modifizierer steuern die Lebensdauer, die Sichtbarkeit und die Veränderbarkeit von Klassen, Methoden (bzw. Funktionen) und Variablen.

Folgende Modifizierer sind in Java bekannt:

1. public
2. private
3. protected
4. static
5. final
6. transient
7. volatile
8. Standard (package scoped)

public

Elemente die mit public modifiziert sind während ihrer Lebensdauer überall sicht- bzw. manipuliertbar. Diese Modifikation ist ebenfalls dann notwendig, wenn z.B. Klassen über Pakete hinaus verfügbar sein sollen.

private

Methoden und Variablen bzw. Attribute werden mit private modifiziert, wenn sie nur innerhalb einer Klasse sichtbar sein sollen. Außerhalb der umgebenden Klasse sind sie unsichtbar.

Bei der Modifizierung von Klassen mit private gibt eine Einschränkung, so dass sich innere Klassen zur nächstäußeren als sichtbar zeigen, zur nächstweiter-äußeren nicht sichtbar.

public class TestModifizierer {
    public static void main(String[] args) {  
        ClassA testSichtbarkeit = new ClassA();
        System.out.println(testSichtbarkeit.getprivateAttributeAusClassB()); //TestB
    } 
}

class ClassA{
    ClassB innerB;
    public ClassA(){
        this.innerB=new ClassB();
    }
    public String getprivateAttributeAusClassB(){
        return this.innerB.attributeAusClassB;
    }
    private class ClassB{
        private String attributeAusClassB = "TestB";       
    }    
}

protected

Elemente aus der Modifikation proitected sind im eigenen Paket sichtbar. Darüberhinaus sind sie für alle abgeleiteten Klassen sichtbar.

static

Mit static deklarierte Prozeduren sind instanzungebunden und somit Funktionen. Das heißt, ihre Lebensdauer wird beeinflusst, indem sie solange erreichbar sind, solange die Klasse geladen ist. In Java ist der hybride Anteil der prozeduralen Programmierung mit dem Zusatz static möglich.

public class TestStatic {
    
    public static void main(String[] args) {
        
        System.out.println(TestFuerStatic.getTextInstanzUngebunden()); //Ich bin instanzUNgebunden.
        System.out.println(TestFuerStatic.getTextInstanzgebunden()); //COMPILERFEHLER
        
        TestFuerStatic notwendigeInstanz = new TestFuerStatic();
        System.out.println(notwendigeInstanz.getTextInstanzgebunden()); //Ich bin instanzgebunden.
        
    }
}

class TestFuerStatic{
    public String getTextInstanzgebunden(){
        return "Ich bin instanzgebunden.";
    }
    public static String getTextInstanzUngebunden(){
        return "Ich bin instanzUNgebunden.";
    } 
}

final

Elemente der Deklaration final dürfen nicht verändert werden. Das gilt für Attribute, Methoden und Klassen. Für Klassen bedeutet diese Einschränkung, dass sie nicht abgeleitet, also spzialisiert ("vererbt"), werden dürfen. Methoden dürfen nicht überlagert werden. Aus Attributen als final-Mitglied ergeben sich somit Konstanten, sie werden nach camelNotation groß geschrieben.

transient

Elemente, die mit transient modifiziert wurden sind nicht persisent und werden bei der Serialisierung und Deserialisierung ignoriert.

volatile

Eine Elementmodifikation mit volatile findet Verwendung beispielsweise bei Multithreading. Es signalisiert, dass Elemente in neuen Threads verändert werden können und sich nicht auf den Speicher der VM beziehen. Sie werden also bei Verwendung neuer Threads neu geladen.

Standard (package scoped)

Elemente ohne explizit genannten Modifizierer sind im standard modifiziert und somit paketweise sichtbar. Ihr Unterschied zu den protected-Elementen ist ihre nicht vorhandene Sichtbarkeit in abgeleiteten Klassen.