Java Language
गैर-पहुंच संशोधक

परिचय

अंतिम

जावा में final चर, विधियों और कक्षाओं को संदर्भित कर सकता है। तीन सरल नियम हैं:

• अंतिम चर को पुन: असाइन नहीं किया जा सकता है
• अंतिम विधि को ओवरराइड नहीं किया जा सकता है
• अंतिम वर्ग बढ़ाया नहीं जा सकता

उपयोगों

अच्छा प्रोग्रामिंग अभ्यास

जब आप कर सकते हैं तो कुछ डेवलपर वैरिएबल फाइनल को चिन्हित करना अच्छा अभ्यास मानते हैं। यदि आपके पास एक चर है जिसे बदला नहीं जाना चाहिए, तो आपको इसे अंतिम रूप से चिह्नित करना चाहिए।

यदि विधि मापदंडों के लिए final कीवर्ड का एक महत्वपूर्ण उपयोग है। यदि आप इस बात पर ज़ोर देना चाहते हैं कि कोई विधि इसके इनपुट मापदंडों को नहीं बदलती है, तो गुणों को अंतिम रूप से चिह्नित करें।

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

इस पर जोर देती है कि sumup पद्धति को बदलने के लिए नहीं जा रहा है ints ।

इनर क्लास एक्सेस

यदि आपका अनाम आंतरिक वर्ग एक चर का उपयोग करना चाहता है, तो चर को final रूप से चिह्नित किया जाना चाहिए

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

यह वर्ग संकलित नहीं करता है, जैसा कि चर name , अंतिम नहीं है।

final static चर

हालांकि कोड के नीचे पूरी तरह से कानूनी है जब final चर foo नहीं है static , के मामले में static यह संकलन नहीं होगा:

class TestFinal {
    private final static List foo;

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

कारण है, चलो फिर से दोहराते हैं, अंतिम चर को फिर से असाइन नहीं किया जा सकता है । चूंकि foo स्थिर है, इसलिए इसे क्लास TestFinal सभी उदाहरणों के बीच साझा किया गया है। जब एक क्लास TestFinal का एक नया उदाहरण बनाया जाता है, तो इसके निर्माता को आमंत्रित किया जाता है और इसलिए फू को TestFinal किया जाता है कि कौन सा संकलक अनुमति नहीं देता है। इस मामले में चर foo को आरंभ करने का एक सही तरीका या तो है:

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

या एक स्थिर इनिशियलाइज़र का उपयोग करके:

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

final तरीके तब उपयोगी होते हैं जब बेस क्लास कुछ महत्वपूर्ण कार्यक्षमता को लागू करता है जो व्युत्पन्न वर्ग इसे बदलने के लिए नहीं माना जाता है। वे गैर-अंतिम तरीकों से भी तेज़ हैं, क्योंकि इसमें वर्चुअल टेबल की कोई अवधारणा शामिल नहीं है।

Java में सभी आवरण वर्ग अंतिम हैं, जैसे कि Integer , Long इत्यादि। इन वर्गों के निर्माता यह नहीं चाहते थे कि कोई भी उदाहरण के तौर पर Integer को अपनी कक्षा में विस्तारित कर सके और Integer वर्ग के मूल व्यवहार को बदल सके। एक वर्ग को अपरिवर्तनीय बनाने की आवश्यकताओं में से एक यह है कि उपवर्ग विधियों को ओवरराइड नहीं कर सकते हैं। ऐसा करने का सबसे सरल तरीका वर्ग को final घोषित करना है।

परिवर्तनशील

volatile संशोधक का उपयोग बहु थ्रेडेड प्रोग्रामिंग में किया जाता है। यदि आप किसी क्षेत्र को volatile घोषित करते हैं, तो यह थ्रेड्स के लिए एक संकेत है कि उन्हें सबसे हाल का मूल्य पढ़ना चाहिए, न कि स्थानीय रूप से कैश्ड। इसके अलावा, volatile पढ़ना और लिखना परमाणु होने की गारंटी है (गैर- volatile long या double का उपयोग परमाणु नहीं है), इस प्रकार कई थ्रेड्स के बीच कुछ पढ़ने / लिखने की त्रुटियों से बचा जाता है।

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

स्थिर

static खोजशब्द का उपयोग किसी वर्ग, विधि, या क्षेत्र पर किया जाता है ताकि वे कक्षा के किसी भी उदाहरण से स्वतंत्र रूप से काम कर सकें।

• स्थैतिक क्षेत्र एक वर्ग के सभी उदाहरणों के लिए सामान्य हैं। उन्हें एक्सेस करने के लिए उन्हें किसी इंस्टेंस की जरूरत नहीं है।
• वे जिस कक्षा में हैं, उसके उदाहरण के बिना स्टेटिक तरीके चलाए जा सकते हैं।
• अन्य वर्गों के अंदर स्टेटिक कक्षाएं घोषित की जा सकती हैं। उन्हें उस वर्ग के उदाहरण की आवश्यकता नहीं है, जिसे वे तात्कालिक होना चाहते हैं।

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

सिंक्रनाइज़

सिंक्रोनाइज़्ड मॉडिफायर का उपयोग किसी विशेष विधि या कई थ्रेड्स द्वारा ब्लॉक को एक्सेस करने के लिए किया जाता है। केवल एक धागा एक विधि या एक ब्लॉक में प्रवेश कर सकता है जिसे सिंक्रनाइज़ के रूप में घोषित किया गया है। सिंक्रनाइज़ किए गए कीवर्ड किसी ऑब्जेक्ट के आंतरिक लॉक पर काम करता है, एक सिंक्रनाइज़ पद्धति के मामले में वर्तमान ऑब्जेक्ट लॉक और स्टेटिक विधि क्लास ऑब्जेक्ट का उपयोग करता है। सिंक्रनाइज़ किए गए ब्लॉक को निष्पादित करने का प्रयास करने वाले किसी भी धागे को पहले ऑब्जेक्ट लॉक प्राप्त करना होगा।

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

क्षणिक

एक चर जिसे क्षणिक के रूप में घोषित किया जाता है, वस्तु क्रमांकन के दौरान क्रमबद्ध नहीं होगा।

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