Operators in Java in Hindi – जावा में ऑपरेटर क्या है? और इसके प्रकार

जावा की इस लेख "Operators in Java in Hindi" में जानिए जावा में ऑपरेटर क्या हैं, ऑपरेटर कितने प्रकार के होते हैं और इसका उपयोग कैसे करें आदि।

द्वारा
Md Badiruddin
-

Operators in Java in Hindi: जावा में ऑपरेटर प्रोग्रामिंग में अंकगणित (arithmetic), तुलना (comparison) और तार्किक (logical) कार्यों जैसे संचालन करने के लिए उपयोग किए जाने वाले symbols हैं। और यह डेटा हेरफेर और गणना को सक्षम बनाता है।

अगर आप जावा प्रोग्रामिंग भाषा में मास्टर बनना चाहते हैं तो आपको जावा में ऑपरेटर क्या है (Operators in Java in Hindi) और इसके प्रकार को समझना होगा।

मूल रूप से, जावा ऑपरेटर सीखना महत्वपूर्ण है क्योंकि वे प्रोग्रामिंग में मौलिक उपकरण के रूप में काम करते हैं।

ऑपरेटर डेटा में हेरफेर करने में सक्षम बनाते हैं, गणितीय गणनाओं को सुविधाजनक बनाते हैं, तुलनाओं को संभालते हैं, तार्किक संचालन निष्पादित करते हैं और कोड की दक्षता बढ़ाते हैं।

नोट: जावा ऑपरेटर को अच्छी तरह समझने के लिए पहले आप जावा वेरिएबल और जावा में डेटा टाइप क्या है को समझें।

जावा में ऑपरेटर क्या है (Operators in Java in Hindi)?

जावा में, ऑपरेटर एक प्रतीक (symbol) या एक विशेष वर्ण होता है जो ऑपरेंड पर विशिष्ट संचालन करता है, जैसे कि चर या मान।

ये ऑपरेटर एक प्रोग्राम के भीतर विभिन्न कार्यों को करने में अभिन्न अंग हैं, जिसमें अंकगणितीय (arithmetic) गणना, मान निर्दिष्ट करना, अभिव्यक्तियों (expressions) की तुलना करना, तार्किक (logical) संचालन निष्पादित करना बिट्स में हेरफेर (manipulating) करना शामिल है।

जावा ऑपरेटरों को उनकी कार्यक्षमता (functionality) के आधार पर विभिन्न प्रकारों में वर्गीकृत (classified) किया जाता है, जिनमें से प्रत्येक प्रोग्रामिंग कार्यों में एक अलग उद्देश्य प्रदान करता है।

कुशल (efficient) और कार्यात्मक (functional) जावा कोड लिखने के लिए इन प्रतीकों को प्रभावी ढंग से समझना और उपयोग करना महत्वपूर्ण है, जो डेवलपर्स को अपने कार्यक्रमों के भीतर विविध संचालन (diverse operations) और गणनाओं (computations) को निर्बाध रूप से करने में सक्षम बनाता है।

सरल शब्दों में, जावा ऑपरेटर्स विशेष प्रतीक हैं जो ऑपरेंड पर गणितीय (mathematical) और तार्किक संचालन (logical operations) करते हैं और परिणाम लौटाते हैं।

  • उदाहरण के लिए, (+) ऑपरेटर प्रतीक दो या अधिक ऑपरेंड जोड़ता है और जोड़ लौटाता है। 

जावा में विभिन्न ऑपरेशन करने के लिए कई प्रकार के ऑपरेटरों का उपयोग किया जाता है।  तो आइये अब जानते हैं जावा ऑपरेटर के प्रकार।

जावा ऑपरेटरों के प्रकार (Types of Operators in Java)

जावा में, एक ऑपरेटर एक प्रतीक (symbol) है जो चर (variables) या मानों पर विशिष्ट संचालन (operations) करता है। ये प्रतीक किसी प्रोग्राम के अंदर विभिन्न कार्यों को निष्पादित (execute) करने में सहायक होते हैं।

जावा में कई प्रकार के ऑपरेटर होते हैं, यहां मुख्य रूप से जावा में 8 प्रकार के ऑपरेटर हैं:

  1. असाइनमेंट ऑपरेटर (Assignment Operators)।
  2. अर्थमेटिक ऑपरेटर (Arithmetic Operators)।
  3. रिलेशनल ऑपरेटर (Relational Operators)।
  4. यूनरी ऑपरेटर (Unary Operators)।
  5. लॉजिकल ऑपरेटर (Logical Operators)।
  6. कंडीशनल (टर्नरी) (Conditional (Ternary) Operators)।
  7. इंस्टेंसऑफ़ ऑपरेटर (InstanceOf Operators)।
  8. बिटवाइज़ ऑपरेटर (Bitwise Operators)।

तो आइए जावा के इन 8 प्रकार के ऑपरेटरों में से प्रत्येक को विस्तार से समझें:

1. असाइनमेंट ऑपरेटर (Assignment Operators in Java)

जावा असाइनमेंट ऑपरेटर को प्रतीक (symbol) ‘=‘ द्वारा दर्शाया जाता है और इसका उपयोग जावा प्रोग्रामिंग में वेरिएबल्स को मान निर्दिष्ट (assign values) करने के लिए किया जाता है। यह ऑपरेटर के दाईं ओर के वेरिएबल को बाईं ओर के वेरिएबल को मान निर्दिष्ट करता है।

उदाहरण के लिए, अभिव्यक्ति “int x = 10;” में, असाइनमेंट ऑपरेटर ‘=‘ वेरिएबल ‘x‘ को मान 10 निर्दिष्ट करता है।

यह ऑपरेटर वेरिएबल्स के लिए विशिष्ट मान निर्दिष्ट करके जावा प्रोग्राम के अंदर डेटा को संग्रहीत और हेरफेर करने के लिए मौलिक है, जो प्रोग्राम को इन निर्दिष्ट मानों के आधार पर संचालन और गणना करने में सक्षम बनाता है।

यहां जावा असाइनमेंट ऑपरेटर के उपयोग को प्रदर्शित करने वाला एक कोड उदाहरण दिया गया है:

public class AssignmentOperatorExample {
    public static void main(String[] args) {
        int x = 10; // Assigning the value 10 to the variable 'x' using the assignment operator
        System.out.println("The value of x is: " + x); // Output: The value of x is: 10

        String message = "Welcome to Tutorialinhindi.com!"; // Assigning a string value to the variable 'message'
        System.out.println(message); // Output: Hello, World!
    }
}

इस उदाहरण में, ‘=’ ऑपरेटर का उपयोग पूर्णांक (integer) चर ‘x’ और स्ट्रिंग “Tutorialinhindi.com में आपका स्वागत है!” को 10 मान निर्दिष्ट करने के लिए किया जाता है। वेरिएबल ‘संदेश’ के लिए। ये असाइनमेंट वेरिएबल्स को मान निर्दिष्ट करने के लिए जावा असाइनमेंट ऑपरेटर के मूल उपयोग को दर्शाते हैं, जिससे बाद के संचालन या प्रोग्राम में निर्दिष्ट मानों को प्रदर्शित करने की अनुमति मिलती है।

Output:

The value of x is: 10
Welcome to Tutorialinhindi.com!

2. अर्थमेटिक ऑपरेटर (Arithmetic Operators in Java)

जावा में अंकगणितीय ऑपरेटर संख्यात्मक ऑपरेंड पर गणितीय संचालन करने के लिए उपयोग किए जाने वाले प्रतीक हैं।

इन ऑपरेटरों में जोड़ (addition) (+), घटाव (subtraction) (-), गुणा (multiplication) (*), भाग (division) (/), और मापांक (modulus) (%) शामिल हैं।

ऑपरेटर्सनामव्याख्याउदाहरण
+जोड़ना (Addition)यह दो ऑपरेंड जोड़ता है।a + b
–घटाव (Subtraction)यह पहले से दूसरे ऑपरेंड को घटाता है।a – b
*गुणा (Multiplication)दो ऑपरेंड को गुणा करता है।a * b
/विभाजन (Division)पहले ऑपरेंड को दूसरे से विभाजित करता है।a / b
%मापांक (Modulus)पहले और दूसरे ऑपरेंड के बीच विभाजन का शेष भाग लौटाता है।q % b
++वृद्धि (Increment)किसी वेरिएबल का मान 1 से बढ़ा देता है++a
—घटती (Decrement)किसी वेरिएबल का मान 1 से कम कर देता है–a

कोड उदाहरण से समझें:

public class ArithmeticOperatorsExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        int sum = a + b; // Addition
        int difference = a - b; // Subtraction
        int product = a * b; // Multiplication
        int quotient = a / b; // Division
        int remainder = a % b; // Modulus

        System.out.println("Sum: " + sum);
        System.out.println("Difference: " + difference);
        System.out.println("Product: " + product);
        System.out.println("Quotient: " + quotient);
        System.out.println("Remainder: " + remainder);
    }
}

यह जावा कोड अंकगणितीय ऑपरेटरों के उपयोग को दर्शाता है। यह दो पूर्णांक चर ‘ए’ और ‘बी’ को परिभाषित करता है और इन चर पर जोड़, घटाव, गुणा, भाग और मापांक संचालन करता है। फिर इन परिचालनों के परिणामी मान कंसोल पर मुद्रित (printed) होते हैं।

Output:

Sum: 15
Difference: 5
Product: 50
Quotient: 2
Remainder: 0

3. रिलेशनल ऑपरेटर (Relational Operators in Java)

जावा में रिलेशनल ऑपरेटर्स दो मूल्यों या अभिव्यक्तियों (expressions) के बीच संबंध या तुलना स्थापित करने के लिए उपयोग किए जाने वाले प्रतीक हैं।

ये ऑपरेटर ऑपरेंड के बीच संबंध का मूल्यांकन (evaluation) करते हैं और तुलना के आधार पर एक बूलियन परिणाम (सही या गलत) लौटाते हैं।

जावा में रिलेशनल ऑपरेटरों में शामिल हैं:

ऑपरेटरनामविवरणउदाहरण
==के बराबर (Equal to)यह जाँचता है कि क्या दो ऑपरेंड बराबर हैं5 == 5 का मूल्यांकन करता है true
!=असमान (Not equal to)सत्यापित करता है कि क्या दो ऑपरेंड समान नहीं हैं10 != 5 का मूल्यांकन करता है true
>से अधिक (Greater than)जाँचता है कि बायाँ ऑपरेंड बड़ा है या नहीं8 > 3 का मूल्यांकन करता है true
<से कम (Less than)सत्यापित करता है कि बायां ऑपरेंड कम है या नहीं4 < 9 का मूल्यांकन करता है true
>=इससे बड़ा या इसके बराबर (Greater than or equal to)जाँचता है कि बायाँ ऑपरेंड बड़ा है या बराबर है6 >= 6 का मूल्यांकन करता है true
<=से कम या बराबर (Less than or equal to)सत्यापित करता है कि बायां ऑपरेंड कम है या बराबर है7 <= 3 का मूल्यांकन करता है false

इन रिलेशनल ऑपरेटरों का उपयोग दो मानों या अभिव्यक्तियों की तुलना करने के लिए किया जाता है, जो प्रत्येक ऑपरेटर द्वारा निर्दिष्ट तुलना मानदंडों के आधार पर एक बूलियन परिणाम उत्पन्न करते हैं।

कोड उदाहरण से समझें:

public class RelationalOperatorsExample {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 5;

        // Using relational operators
        boolean isEqual = (num1 == num2);
        boolean notEqual = (num1 != num2);
        boolean greaterThan = (num1 > num2);
        boolean lessThan = (num1 < num2);
        boolean greaterThanOrEqual = (num1 >= num2);
        boolean lessThanOrEqual = (num1 <= num2);

        // Outputting the results
        System.out.println("Is num1 equal to num2? " + isEqual);
        System.out.println("Is num1 not equal to num2? " + notEqual);
        System.out.println("Is num1 greater than num2? " + greaterThan);
        System.out.println("Is num1 less than num2? " + lessThan);
        System.out.println("Is num1 greater than or equal to num2? " + greaterThanOrEqual);
        System.out.println("Is num1 less than or equal to num2? " + lessThanOrEqual);
    }
}

इसका Output कुछ इस तरह आएगा:

Is num1 equal to num2? false
Is num1 not equal to num2? true
Is num1 greater than num2? true
Is num1 less than num2? false
Is num1 greater than or equal to num2? true
Is num1 less than or equal to num2? false

4. यूनरी ऑपरेटर (Unary Operators in Java)

जावा में यूनरी ऑपरेटर्स ऐसे ऑपरेटर हैं जो एकल ऑपरेंड पर संचालन करते हैं। ये ऑपरेटर केवल एक ऑपरेंड पर कार्य करते हैं, इसके मूल्य या व्यवहार को विभिन्न तरीकों से बदलते हैं।

जावा में यूनरी ऑपरेटर्स में शामिल हैं:

ऑपरेटरनामविवरणउदाहरण
+यूनरी प्लसएक सकारात्मक मान दर्शाता है (मूल्य में कोई परिवर्तन नहीं)int num = +5;
–यूनरी माइनसऑपरेंड के मूल्य को नकारता हैint negativeNum = -10;
++बढ़ती (Increment)ऑपरेंड का मान 1 से बढ़ जाता हैint count = 5; count++;
—घटती (Decrement)ऑपरेंड का मान 1 से कम हो जाता हैint value = 8; value--;
!तार्किक पूरक (Logical Complement)ऑपरेंड के बूलियन मान को उलट देता हैboolean flag = true; boolean invertedFlag = !flag;
~बिटवाइज़ पूरक (Bitwise Complement)ऑपरेंड के बिट्स को फ़्लिप करता है (बाइनरी नेगेशन)int num = 5; int complement = ~num;

ये यूनरी ऑपरेटर एकल ऑपरेंड पर विशिष्ट ऑपरेशन करते हैं, किए गए ऑपरेशन के आधार पर इसके मूल्य या स्थिति को बदलते हैं।

कोड उदाहरण:

public class UnaryOperators {

    public static void main(String[] args) {
        int p = 20;
        int res;
        System.out.println( "p : " +p);
        res = ++p;
        System.out.println("++p = " + res);
        res = p++;
        System.out.println("p++ : "+res);
        res = --p;
        System.out.println("--p = " + res);
        res = p--;
        System.out.println("p-- = " + res);
    }
}

उपरोक्त कोड का आउटपुट निम्नलिखित आउटपुट उत्पन्न करता है:

p : 20
++p = 21
p++ : 21
--p = 20
p-- = 20

5. लॉजिकल ऑपरेटर (Logical Operators in Java)

जावा में लॉजिकल ऑपरेटर्स प्रतीक हैं जिनका उपयोग बूलियन मानों या अभिव्यक्तियों पर तार्किक संचालन करने के लिए किया जाता है। ये ऑपरेटर मुख्य रूप से कई स्थितियों के मूल्यांकन के आधार पर निर्णय लेने में मदद करते हैं।

जावा में लॉजिकल ऑपरेटर्स में इन सभी ऑपरेटर शामिल हैं:

ऑपरेटरनामविवरणउदाहरण
&&Logical ANDयदि दोनों ऑपरेंड सत्य हैं तो सत्य लौटाता है; अन्यथा, गलत रिटर्न देता है।boolean result = (true && false);
||Logical ORयदि कम से कम एक ऑपरेंड सत्य है तो सत्य लौटाता है; अन्यथा, गलत रिटर्न देता है।boolean result = (true || false);
!Logical NOTऑपरेंड के बूलियन मान को उलट देता है; सत्य असत्य हो जाता है, और इसका विपरीत भी।boolean result = !true;

इन तार्किक ऑपरेटरों को बूलियन अभिव्यक्तियों को संयोजित करने और उनका मूल्यांकन करने के लिए नियोजित किया जाता है, जिससे प्रोग्रामर इन अभिव्यक्तियों के सत्य मूल्यों के आधार पर निर्णय लेने या अपने जावा प्रोग्राम के प्रवाह को नियंत्रित करने में सक्षम होते हैं।

यहां तार्किक ऑपरेटरों के उपयोग को प्रदर्शित करने वाला एक जावा कोड उदाहरण दिया गया है:

public class LogicalOperatorsExample {
    public static void main(String[] args) {
        boolean x = true;
        boolean y = false;

        // Logical AND (&&) operator
        boolean resultAND = x && y; // Evaluates to false

        // Logical OR (||) operator
        boolean resultOR = x || y; // Evaluates to true

        // Logical NOT (!) operator
        boolean resultNOT = !x; // Evaluates to false

        // Outputting the results
        System.out.println("Result of x && y: " + resultAND);
        System.out.println("Result of x || y: " + resultOR);
        System.out.println("Result of !x: " + resultNOT);
    }
}

यह जावा कोड तार्किक AND, OR, और NOT ऑपरेटरों को प्रदर्शित करता है। यह वेरिएबल्स ‘x’ और ‘y’ को बूलियन मान निर्दिष्ट करता है, फिर && (AND), || (OR) का उपयोग करके तार्किक संचालन करता है और ! (NOT) इन चर पर ऑपरेटर।

आउटपुट ‘x’ और ‘y’ के सत्य मानों के आधार पर इन तार्किक परिचालनों के परिणाम प्रदर्शित करता है।

इसका Output कुछ ऐसा आएगा:

Result of x && y: false
Result of x || y: true
Result of !x: false

6. कंडीशनल (टर्नरी) (Conditional (Ternary) Operators in Java)

जावा में कंडीशनल (टर्नरी) ऑपरेटर्स कंडीशनल स्टेटमेंट लिखने का एक संक्षिप्त तरीका प्रदान करते हैं।

यह जावा में उपलब्ध एकमात्र (only) टर्नरी ऑपरेटर है और तीन ऑपरेंड लेता है: एक शर्त जिसके बाद एक प्रश्न चिह्न (?) होता है, यदि शर्त सत्य है तो एक मान लौटाया जाता है, और यदि स्थिति गलत है तो एक मान लौटाया (returned) जाता है।

इसका syntax है:

condition ? valueIfTrue : valueIfFalse
  • यदि शर्त (condition) सत्य (true) है, तो ऑपरेटर प्रश्न चिह्न (?) के बाद मान लौटाता है।
  • यदि condition गलत (false) है, तो यह कोलन (:) के बाद मान लौटाता है।

उदाहरण के लिए:

int x = 10;
int y = 20;
int max = (x > y) ? x : y; // max will be assigned the greater value between x and y
  • इस उदाहरण में, यदि शर्त (x > y) ture है, तो ‘x‘ का मान ‘max‘ निर्धारित किया जाएगा।
  • यदि शर्त गलत (false) है, तो ‘y‘ का मान ‘max’ को निर्दिष्ट किया जाएगा। 

टर्नरी ऑपरेटर कोड की एक पंक्ति के भीतर स्थितियों के आधार पर मान निर्दिष्ट करने या त्वरित निर्णय लेने के लिए उपयोगी होते हैं।

संपूर्ण program उदाहरण:

public class TernaryOperators
{
        public static void main(String[] args) {
            int p = 10;
            int q = 20;
            int res = (p > 10) ? p : q;
            System.out.println("result 1 is: " + res);
            res = (q > 10) ? p : q;
            System.out.println("result 2 is: " + res);
        }
    }

इसका Output:

result 1 is: 20
result 2 is: 10

7. इंस्टेंसऑफ़ ऑपरेटर (InstanceOf Operator in Java)

जावा में instanceof ऑपरेटर का उपयोग यह जांचने (check) के लिए किया जाता है कि कोई ऑब्जेक्ट किसी विशेष class का उदाहरण है या इंटरफ़ेस लागू करता है। 

यह एक बूलियन मान लौटाता है, जो दर्शाता है कि ऑब्जेक्ट निर्दिष्ट प्रकार का है या उस प्रकार का उपप्रकार है।

Syntax:

object instanceof ClassName
  • object: जाँच की जा रही object।
  • ClassName: क्लास या इंटरफ़ेस का नाम।

उदाहरण से समझें:

class Vehicle {} // Base class
class Car extends Vehicle {} // Subclass extending Vehicle
class Bicycle extends Vehicle {} // Another subclass extending Vehicle

public class InstanceOfExample {
    public static void main(String[] args) {
        Vehicle car = new Car();
        Vehicle bicycle = new Bicycle();

        // Checking if car is an instance of Car or Vehicle
        boolean isCar = car instanceof Car; // Evaluates to true
        boolean isVehicle = car instanceof Vehicle; // Evaluates to true

        // Checking if bicycle is an instance of Car or Vehicle
        boolean isBicycle = bicycle instanceof Car; // Evaluates to false
        boolean isAlsoVehicle = bicycle instanceof Vehicle; // Evaluates to true

        // Outputting the results
        System.out.println("Is car a Car? " + isCar);
        System.out.println("Is car a Vehicle? " + isVehicle);
        System.out.println("Is bicycle a Car? " + isBicycle);
        System.out.println("Is bicycle a Vehicle? " + isAlsoVehicle);
    }
}

Output:

Is car a Car? true
Is car a Vehicle? true
Is bicycle a Car? false
Is bicycle a Vehicle? true

8. बिटवाइज़ ऑपरेटर (Bitwise Operators in Java)

जावा में बिटवाइज़ ऑपरेटर्स का उपयोग बाइनरी संख्याओं के व्यक्तिगत बिट स्तर पर संचालन करने के लिए किया जाता है।

ये ऑपरेटर बिट-दर-बिट संचालन (operations) करते हुए integers या boolean मानों के binary प्रतिनिधित्व में हेरफेर करते हैं।

जावा में बिटवाइज़ ऑपरेटरों में शामिल हैं:

ऑपरेटरनामविवरणउदाहरण
&Bitwise ANDप्रत्येक जोड़ी बिट्स पर “AND” ऑपरेशन करता हैint result = 5 & 3; // result = 1
|Bitwise ORबिट्स के प्रत्येक जोड़े पर “OR” ऑपरेशन निष्पादित करता हैint result = 5 | 3; // result = 7
^Bitwise XORप्रत्येक जोड़ी बिट्स पर “XOR” ऑपरेशन करता हैint result = 5 ^ 3; // result = 6
~Bitwise Complementप्रत्येक बिट को फ़्लिप करता है (किसी का पूरक)int result = ~5; // result = -6
<<Left Shiftनिर्दिष्ट संख्या में स्थानों द्वारा बिट्स को बाईं ओर स्थानांतरित करता हैint result = 5 << 2; // result = 20
>>Right Shiftनिर्दिष्ट संख्या में स्थिति द्वारा बिट्स को दाईं ओर स्थानांतरित करता हैint result = 5 >> 2; // result = 1
>>>Unsigned Right Shiftबिट्स को दाईं ओर शिफ्ट करता है, खाली बिट्स को शून्य से भरता हैint result = -5 >>> 2; // result = 1073741822

जावा में ये बिटवाइज ऑपरेटर पूर्णांक मानों के भीतर अलग-अलग बिट्स के हेरफेर को सक्षम करते हैं, जिससे संख्याओं के बाइनरी प्रतिनिधित्व के भीतर सेटिंग, क्लियरिंग, टॉगल या विशिष्ट बिट्स की जांच जैसे संचालन की अनुमति मिलती है।

यहां बिटवाइज़ ऑपरेटरों के उपयोग को प्रदर्शित करने वाला एक जावा कोड उदाहरण दिया गया है:

public class BitwiseOperatorsExample {
    public static void main(String[] args) {
        int a = 12; // Binary: 1100
        int b = 7;  // Binary: 0111

        // Bitwise AND (&) example
        int resultAND = a & b; // Performs AND operation on corresponding bits
        System.out.println("Result of a & b: " + resultAND); // Output: Result of a & b: 4

        // Bitwise OR (|) example
        int resultOR = a | b; // Performs OR operation on corresponding bits
        System.out.println("Result of a | b: " + resultOR); // Output: Result of a | b: 15

        // Bitwise XOR (^) example
        int resultXOR = a ^ b; // Performs XOR operation on corresponding bits
        System.out.println("Result of a ^ b: " + resultXOR); // Output: Result of a ^ b: 11

        // Bitwise NOT (~) example
        int resultNOTA = ~a; // Performs bitwise complement (NOT) on 'a'
        System.out.println("Result of ~a: " + resultNOTA); // Output: Result of ~a: -13

        // Left Shift (<<) example
        int resultLeftShift = a << 2; // Left shift 'a' by 2 positions
        System.out.println("Result of a << 2: " + resultLeftShift); // Output: Result of a << 2: 48

        // Right Shift (>>) example
        int resultRightShift = b >> 1; // Right shift 'b' by 1 position
        System.out.println("Result of b >> 1: " + resultRightShift); // Output: Result of b >> 1: 3

        // Unsigned Right Shift (>>>) example
        int c = -7; // Binary: 11111111111111111111111111111001
        int resultUnsignedRightShift = c >>> 1; // Unsigned right shift 'c' by 1 position
        System.out.println("Result of c >>> 1: " + resultUnsignedRightShift); // Output: Result of c >>> 1: 2147483644
    }
}

इसका Output कुछ ऐसा होगा:

Result of a & b: 4
Result of a | b: 15
Result of a ^ b: 11
Result of ~a: -13
Result of a << 2: 48
Result of b >> 1: 3
Result of c >>> 1: 2147483644

जावा ऑपरेटरों के लाभ (Benefits of Operators in Java in Hindi)

जावा में ऑपरेटर कई लाभ प्रदान करते हैं जो प्रोग्रामिंग अनुभव और जावा अनुप्रयोगों की कार्यक्षमता (functionality) को बढ़ाते हैं।

जावा में ऑपरेटरों के शीर्ष 8 फायदे यहां दिए गए हैं:

  1. जावा में ऑपरेटर वर्बोज़ कोडिंग को कम करते हुए arithmetic, logic और bitwise कार्यों को करने के लिए संक्षिप्त तरीके प्रदान करते हैं।
  2. वे प्रतीकात्मक (symbolically) रूप से संचालन का प्रतिनिधित्व करके, पठनीयता में सहायता करके कोड स्पष्टता (clarity) में सुधार करते हैं।
  3. ऑपरेटर विभिन्न गणनाओं और तुलनाओं का समर्थन करते हुए तेज़ और सटीक (accurate) डेटा हेरफेर सक्षम करते हैं।
  4. तार्किक संचालक निर्णय लेने में सहायता करते हैं, तार्किक स्थितियों के आधार पर सशर्त बयान (conditional statements) तैयार करते हैं।
  5. बिटवाइज ऑपरेटर बिट-स्तरीय (bit-level) कार्यों को संभालते हैं, जो हार्डवेयर इंटरफेसिंग और एन्क्रिप्शन जैसे निम्न-स्तरीय (low-level) प्रोग्रामिंग में फायदेमंद होते हैं।
  6. उचित उपयोग, विशेष रूप से बिटवाइज़ ऑपरेटर, बिट-स्तरीय संचालन को अनुकूलित करके कोड प्रदर्शन को बढ़ाता है।
  7. ऑपरेटर जटिल एल्गोरिदम का समर्थन करते हुए डेवलपर्स को एक ही पंक्ति में जटिल (complex) तर्क बनाने के लिए सशक्त (empower) बनाते हैं।
  8. जावा की विशेषताओं का अभिन्न अंग, ऑपरेटर इसकी बहुमुखी (versatility) प्रतिभा में योगदान करते हैं, जिसमें सशर्त और असाइनमेंट संचालन शामिल हैं।

FAQs

यहां “जावा में ऑपरेटर्स क्या हैं (Operators in Java in Hindi)” से संबंधित कुछ सामान्य अक्सर पूछे जाने वाले प्रश्न दिए गए हैं:

जावा में ऑपरेटर क्या हैं?

जावा में ऑपरेटर ऐसे प्रतीक हैं जिनका उपयोग अंकगणित, तुलना, तार्किक कार्यों आदि जैसे विभिन्न कार्यों को करने के लिए किया जाता है, जो कार्यक्रमों के भीतर डेटा हेरफेर और गणना में सहायता करते हैं।

ऑपरेटर जावा प्रोग्रामिंग में कैसे योगदान करते हैं?

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

जावा में ऑपरेटरों की विभिन्न श्रेणियां क्या हैं?

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

जावा प्रोग्रामिंग में ऑपरेटर क्यों आवश्यक हैं?

ऑपरेटर कोड को सरल बनाने, पठनीयता में सुधार करने, डेवलपर्स को गणना, तुलना और तार्किक संचालन कुशलतापूर्वक करने की अनुमति देने में महत्वपूर्ण भूमिका निभाते हैं।

क्या आप उदाहरण दे सकते हैं कि ऑपरेटर जावा में कैसे कार्य करते हैं?

निश्चित रूप से! ‘+’, ‘-‘, ‘&&’, ‘|’, और ‘<<‘ जैसे ऑपरेटर जावा प्रोग्रामिंग में अपनी विविध कार्यक्षमताओं को प्रदर्शित करते हुए क्रमशः जोड़, घटाव, तार्किक और, तार्किक OR और बाएं शिफ्ट संचालन करते हैं।

निष्कर्ष

जावा में ऑपरेटर अंकगणित, तार्किक और बिटवाइज़ संचालन करने के लिए मौलिक उपकरण हैं। उनकी भूमिका में कोड को सुव्यवस्थित करना, पठनीयता बढ़ाना और कुशल डेटा हेरफेर को सक्षम करना शामिल है।

उनकी विविध श्रेणियों को समझना डेवलपर्स को अनुकूलित कोड तैयार करने में सशक्त बनाता है, जिससे जावा प्रोग्रामिंग अधिक बहुमुखी और कुशल बन जाती है.

कुल मिलाकर, ऑपरेटर सटीक गणना के लिए महत्वपूर्ण हैं और मजबूत जावा एप्लिकेशन बनाने में महत्वपूर्ण योगदान देते हैं।

हमेशा याद रखें, जावा ऑपरेटरों में महारत हासिल करना प्रभावी और कार्यात्मक प्रोग्राम लिखने की कुंजी है, जो डेवलपर्स को विभिन्न कार्यों को कुशलतापूर्वक करने में सक्षम बनाता है।

मुझे उम्मीद है कि इस लेख “Operators in Java in Hindi” से आपको यह समझने में मदद मिली होगी कि जावा में ऑपरेटर क्या हैं, यह कितने प्रकार के होते हैं और इसका उपयोग कैसे करें आदि। यदि आपके पास कोई प्रश्न है तो अभी हमारे टेलीग्राम group में पूछें।

कोई जवाब दें

कृपया अपनी टिप्पणी दर्ज करें!
कृपया अपना नाम यहाँ दर्ज करें

nine − 2 =