Java Language
Ändringar utan åtkomst

Introduktion

slutlig

final i Java kan hänvisa till variabler, metoder och klasser. Det finns tre enkla regler:

• den slutliga variabeln kan inte tilldelas
• den slutliga metoden kan inte åsidosättas
• slutklass kan inte förlängas

användningsområden

Bra programmeringspraxis

Vissa utvecklare anser det vara bra att markera en variabel final när du kan. Om du har en variabel som inte bör ändras bör du markera den som slutlig.

En viktig användning av det final nyckelordet för metodparametrar. Om du vill betona att en metod inte ändrar dess inmatningsparametrar, markera egenskaperna som slutliga.

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

Detta betonar att sumup inte kommer att förändra ints .

Inre klass Access

Om din anonyma inre klass vill komma åt en variabel bör variabeln markeras som final

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

Denna klass sammanställer inte, eftersom variabelns name inte är slutgiltigt.

final static variabel

Även om koden nedan är helt lagligt när final variabel foo är inte static , vid static kommer det inte att sammanställa:

class TestFinal {
    private final static List foo;

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

Anledningen är, låt oss upprepa igen, slutlig variabel kan inte tilldelas . Eftersom foo är statisk, delas det mellan alla instanser av klass TestFinal . När en ny instans av en klass TestFinal skapas, TestFinal dess konstruktör och därför får foo tilldelas vilken kompilator inte tillåter. Ett korrekt sätt att initialisera variabel foo i detta fall är antingen:

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

eller med hjälp av en statisk initialisator:

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

final metoder är användbara när basklass implementerar vissa viktiga funktioner som härledd klass inte ska förändra den. De är också snabbare än icke-slutgiltiga metoder, eftersom det inte finns något koncept med virtuella tabeller inblandade.

Alla omslagsklasser i Java är slutgiltiga, som Integer , Long etc. Skapare av dessa klasser ville inte att någon t ex kan utöka heltal till sin egen klass och ändra grundläggande beteende för heltalsklass. Ett av kraven för att göra en klass immutabel är att underklasser inte får åsidosätta metoder. Det enklaste sättet att göra detta är att förklara klassen som final .

flyktig

Den volatile modifieraren används i multigängad programmering. Om du förklarar ett fält som volatile är det en signal till trådarna att de måste läsa det senaste värdet, inte ett lokalt cachelagrat. Vidare garanteras volatile läsningar och skrivningar att vara atomära (tillgång till en icke- volatile long eller double är inte atomisk), vilket undviker vissa läs- / skrivfel mellan flera trådar.

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;
    }
}

statisk

Det static nyckelordet används i en klass, metod eller fält för att få dem att fungera oberoende av någon instans av klassen.

• Statiska fält är vanliga för alla instanser i en klass. De behöver inte en instans för att få åtkomst till dem.
• Statiska metoder kan köras utan en instans av klassen de befinner sig i. De kan dock bara komma åt statiska fält för den klassen.
• Statiska klasser kan förklaras inuti andra klasser. De behöver inte en instans av klassen för att bli instanserad.

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

abstrakt

Abstraktion är en process för att dölja implementeringsdetaljer och endast visa funktionalitet för användaren. En abstrakt klass kan aldrig instanseras. Om en klass förklaras som abstrakt är det enda syftet att klassen utvidgas.

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");
    }
}

synkroniserad

Synkroniserad modifierare används för att kontrollera åtkomsten till en viss metod eller ett block av flera trådar. Endast en tråd kan gå in i en metod eller ett block som förklaras som synkroniserat. synkroniserat nyckelord fungerar på ett objektets inre lås, i fallet med en synkroniserad metod, nuvarande objektlås och statisk metod använder klassobjekt. Varje tråd som försöker köra ett synkroniserat block måste först skaffa objektlåset.

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();
    }
}

transitorisk

En variabel som deklareras som transient kommer inte att serialiseras under objektserialisering.

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(){}
}