Java Language
Modificaties zonder toegang

Invoering

laatste

final in Java kan verwijzen naar variabelen, methoden en klassen. Er zijn drie eenvoudige regels:

• laatste variabele kan niet opnieuw worden toegewezen
• definitieve methode kan niet worden opgeheven
• laatste les kan niet worden verlengd

Bestemmingen

Goede programmeerpraktijk

Sommige ontwikkelaars vinden het een goede gewoonte om een variabele finale te markeren wanneer dat mogelijk is. Als u een variabele hebt die niet moet worden gewijzigd, moet u deze als definitief markeren.

Een belangrijk gebruik van het final trefwoord als voor methodeparameters. Als u wilt benadrukken dat een methode de invoerparameters niet wijzigt, markeert u de eigenschappen als definitief.

public int sumup(final List<Integer> ints);

Dit benadrukt dat de sumup de ints niet zal veranderen.

Innerlijke klasse toegang

Als uw anonieme binnenklasse toegang wenst tot een variabele, moet de variabele als final worden gemarkeerd

  public IPrintName printName(){
    String name;
    return new IPrintName(){
        @Override
        public void printName(){
            System.out.println(name);
        }
    };
}

Deze klasse compileert niet, omdat de name de variabele niet definitief is.

final static variabele

Hoewel de onderstaande code volledig legaal is wanneer de final variabele foo niet static , zal deze in het geval van static niet compileren:

class TestFinal {
    private final static List foo;

    public Test() {
        foo = new ArrayList();
    }
}

De reden is, laten we nog eens herhalen, dat de laatste variabele niet opnieuw kan worden toegewezen . Omdat foo statisch is, wordt het gedeeld door alle instanties van klasse TestFinal . Wanneer een nieuwe instantie van een klasse TestFinal wordt gemaakt, wordt de constructor ervan aangeroepen en daarom wordt foo opnieuw toegewezen die compiler niet toestaat. Een juiste manier om in dit geval variabele foo te initialiseren is:

class TestFinal {
    private static final List foo = new ArrayList();
    //..
}

of door een statische initialisatie te gebruiken:

class TestFinal {
    private static final List foo;
    static {
        foo = new ArrayList();
    }
    //..
}

final methoden zijn nuttig wanneer base class een aantal belangrijke functies implementeert waarvan afgeleide class niet geacht wordt deze te veranderen. Ze zijn ook sneller dan niet-definitieve methoden, omdat er geen concept van virtuele tabel bij betrokken is.

Alle wrapper-klassen in Java zijn definitief, zoals Integer , Long etc. Makers van deze klassen wilden niet dat iemand bijvoorbeeld Integer in zijn eigen klasse kon uitbreiden en het basisgedrag van de Integer-klasse kon veranderen. Een van de vereisten om een klasse onveranderlijk te maken, is dat subklassen methoden niet mogen overschrijven. De eenvoudigste manier om dit te doen, is door de klas als final te verklaren.

vluchtig

De volatile modifier wordt gebruikt in multi-threaded programmeren. Als u een veld als volatile , is dit een signaal naar threads dat ze de meest recente waarde moeten lezen, niet een lokaal gecachte waarde. Verder zijn volatile lees- en schrijfacties gegarandeerd atomair (toegang tot een niet- volatile long of double is niet atomair), waardoor bepaalde lees- / schrijffouten tussen meerdere threads worden vermeden.

public class MyRunnable implements Runnable
{
    private volatile boolean active;
 
    public void run(){ // run is called in one thread 
        active = true;
        while (active){
            // some code here
        }
    }
    
    public void stop(){ // stop() is called from another thread
        active = false;
    }
}

statisch

Het static trefwoord wordt gebruikt op een klasse, methode of veld om ze onafhankelijk van elke instantie van de klasse te laten werken.

• Statische velden zijn gemeenschappelijk voor alle instanties van een klasse. Ze hebben geen instantie nodig om toegang te krijgen.
• Statische methoden kunnen worden uitgevoerd zonder een instantie van de klasse waarin ze zich bevinden. Ze hebben echter alleen toegang tot statische velden van die klasse.
• Statische klassen kunnen binnen andere klassen worden gedeclareerd. Ze hebben geen instantie van de klasse waarin ze zitten nodig om te worden geïnstantieerd.

public class TestStatic
{
    static int staticVariable;

    static {
        // This block of code is run when the class first loads
        staticVariable = 11;
    }

    int nonStaticVariable = 5;

    static void doSomething() {
        // We can access static variables from static methods
        staticVariable = 10;
    }

    void add() {
        // We can access both static and non-static variables from non-static methods
        nonStaticVariable += staticVariable;
    }

    static class StaticInnerClass {
        int number;
        public StaticInnerClass(int _number) {
            number = _number;
        }

        void doSomething() {
            // We can access number and staticVariable, but not nonStaticVariable
            number += staticVariable;
        }

        int getNumber() {
            return number;
        }
    }
}


// Static fields and methods
TestStatic object1 = new TestStatic();

System.out.println(object1.staticVariable); // 11
System.out.println(TestStatic.staticVariable); // 11

TestStatic.doSomething();

TestStatic object2 = new TestStatic();

System.out.println(object1.staticVariable); // 10
System.out.println(object2.staticVariable); // 10
System.out.println(TestStatic.staticVariable); // 10

object1.add();

System.out.println(object1.nonStaticVariable); // 15
System.out.println(object2.nonStaticVariable); // 10

// Static inner classes
StaticInnerClass object3 = new TestStatic.StaticInnerClass(100);
StaticInnerClass object4 = new TestStatic.StaticInnerClass(200);

System.out.println(object3.getNumber()); // 100
System.out.println(object4.getNumber()); // 200

object3.doSomething();

System.out.println(object3.getNumber()); // 110
System.out.println(object4.getNumber()); // 200

abstract

Abstractie is een proces van het verbergen van de implementatiedetails en het tonen van alleen functionaliteit aan de gebruiker. Een abstracte klasse kan nooit worden geïnstantieerd. Als een klasse als abstract wordt verklaard, is het enige doel dat de klasse wordt uitgebreid.

abstract class Car
{
    abstract void tagLine();
}
 
class Honda extends Car
{
    void tagLine()
    {
        System.out.println("Start Something Special");
    }
}
 
class Toyota extends Car
{
    void tagLine()
    {
        System.out.println("Drive Your Dreams");
    }
}

gesynchroniseerd

Gesynchroniseerde modifier wordt gebruikt om de toegang van een bepaalde methode of een blok door meerdere threads te beheren. Slechts één thread kan een methode of een blok invoeren dat als gesynchroniseerd wordt verklaard. gesynchroniseerd trefwoord werkt op intrinsieke vergrendeling van een object, in het geval van een gesynchroniseerde methode gebruiken huidige objecten vergrendeling en statische methode klasseobject. Elke thread die probeert een gesynchroniseerd blok uit te voeren, moet eerst de objectvergrendeling verkrijgen.

class Shared
{
    int i;
 
    synchronized void SharedMethod()
    {
        Thread t = Thread.currentThread();
 
        for(int i = 0; i <= 1000; i++)
        {
            System.out.println(t.getName()+" : "+i);
        }
    }

    void SharedMethod2()
    {
        synchronized (this)
        {
            System.out.println("Thais access to currect object is synchronize "+this);
        }
    }
}
 
public class ThreadsInJava
{
    public static void main(String[] args)
    {
        final Shared s1 = new Shared();
 
        Thread t1 = new Thread("Thread - 1")
        {
            @Override
            public void run()
            {
                s1.SharedMethod();
            }
        };
 
        Thread t2 = new Thread("Thread - 2")
        {
            @Override
            public void run()
            {
                s1.SharedMethod();
            }
        };
 
        t1.start();
 
        t2.start();
    }
}

vergankelijk

Een variabele die als tijdelijk wordt verklaard, wordt niet geserialiseerd tijdens objectserialisatie.

public transient int limit = 55;   // will not persist
public int b; // will persist

strictfp

// strictfp keyword can be applied on methods, classes and interfaces.

strictfp class A{}

strictfp interface M{}

class A{  
    strictfp void m(){}
}