1) Arithmetic operators
2) Assignment operators
3) Comparison operators / Relational operators
4) Logical operators
5) bitwise operators
>> Arithmetic Operators ---
Java mein arithmetic operators (अंकगणितीय ऑपरेटर) hote hain, jo mathematics operations ko perform karne mein istemal hote hain. Ye operators aksar numbers ke saath istemal hote hain aur aap inka istemal addition, subtraction, multiplication, division, modulus, etc. ke liye kar sakte hain. Niche kuch mukhy arithmetic operators diye gaye hain:
1. **Addition (+):** Is operator ka istemal do numbers ko add karne ke liye hota hai. Jaise `a + b` mein `a` aur `b` ke values ko add karke ek result produce hota hai.
2. **Subtraction (-):** Is operator ka istemal do numbers ke beech mein difference nikalne ke liye hota hai. Jaise `a - b` mein `a` se `b` ko subtract karke ek result produce hota hai.
3. **Multiplication (*):** Is operator ka istemal do numbers ko multiply karne ke liye hota hai. Jaise `a * b` mein `a` aur `b` ko multiply karke ek result produce hota hai.
4. **Division (/):** Is operator ka istemal do numbers ko divide karne ke liye hota hai. Jaise `a / b` mein `a` ko `b` se divide karke ek result produce hota hai.
5. **Modulus (%):** Is operator ka istemal ek number ko dusre number se divide karne ke baad bache hue remainder (shesh) ko nikalne ke liye hota hai. Jaise `a % b` mein `a` ko `b` se divide karke bache hue remainder ko produce karta hai.
6. **Increment (++):** Is operator ka istemal ek variable ke value ko ek unit badhane ke liye hota hai. Jaise `a++` mein `a` ki value ek se badh jati hai.
7. **Decrement (--):** Is operator ka istemal ek variable ke value ko ek unit ghatane ke liye hota hai. Jaise `a--` mein `a` ki value ek se ghat jati hai.
Yahan ek example hai jo kuch arithmetic operators ka istemal dikhata hai:
```java
int a = 10;
int b = 5;
int addition = a + b; // 15
int subtraction = a - b; // 5
int multiplication = a * b; // 50
int division = a / b; // 2
int modulus = a % b; // 0
```
Yeh operators Java mein common hain aur aksar mathematical calculations mein istemal hote hain.
>> Assignment Operators ---
Java mein, assignment operator ek prakar ka operator hota hai jo ek variable ko ek value se assign karne ke liye istemal hota hai. Assignment operator "=" (equal to) hota hai. Is operator ka istemal ek variable ke left side par ek value ko assign karne ke liye hota hai.
Yahan kuch assignment operator ke udaharan hain:
1. **Assignment Operator (=):** Is operator ka istemal ek variable ko ek value se assign karne ke liye hota hai.
```java
int x = 10; // Variable x ko 10 ke barabar assign karte hue
```
2. **Addition Assignment Operator (+=):** Is operator ka istemal ek variable ko ek value se add karke usi variable mein assign karne ke liye hota hai.
```java
int a = 5;
a += 3; // a = a + 3; ke barabar hota hai, isse a ki value 8 ho jati hai.
```
3. **Subtraction Assignment Operator (-=):** Is operator ka istemal ek variable se ek value ko subtract karke usi variable mein assign karne ke liye hota hai.
```java
int b = 10;
b -= 4; // b = b - 4; ke barabar hota hai, isse b ki value 6 ho jati hai.
```
4. **Multiplication Assignment Operator (*=):** Is operator ka istemal ek variable ko ek value se multiply karke usi variable mein assign karne ke liye hota hai.
```java
int c = 3;
c *= 2; // c = c * 2; ke barabar hota hai, isse c ki value 6 ho jati hai.
```
5. **Division Assignment Operator (/=):** Is operator ka istemal ek variable ko ek value se divide karke usi variable mein assign karne ke liye hota hai.
```java
int d = 12;
d /= 4; // d = d / 4; ke barabar hota hai, isse d ki value 3 ho jati hai.
```
Assignment operators variables ko update karne mein aur expressions ko concise banane mein madadgar hote hain. Ye variables ki values ko modify karne ke liye use hote hain.
>> Comparison Operators ---
Java mein, comparison operators (तुलना ऑपरेटर) ek prakar ke operators hote hain jo do values ya expressions ki tulanakriya (comparison) karne ke liye istemal hote hain. Ye operators true (सच) ya false (झूठ) ki sthiti ko prapt karne mein madad karte hain.
Niche kuch mukhy comparison operators hain jo Java mein istemal hote hain:
1. **Equal to (==):** Is operator ka istemal do values ke samantar hone ki tulanakriya karne ke liye hota hai. Agar do values ek-dusre ke saman hain to yeh operator `true` return karta hai, anyatha `false` return karta hai.
2. This is called Relational operator also
Example:
```java
int a = 5;
int b = 5;
boolean isEqual = (a == b); // isEqual mein true aayega
```
2. **Not Equal to (!=):** Is operator ka istemal do values ke alag hone ki tulanakriya karne ke liye hota hai. Agar do values alag hain to yeh operator `true` return karta hai, agar woh saman hain to `false` return karta hai.
Example:
```java
int x = 10;
int y = 20;
boolean isNotEqual = (x != y); // isNotEqual mein true aayega
```
3. **Greater than (>):** Is operator ka istemal ek value ko doosri value se bada hone ki tulanakriya karne ke liye hota hai. Agar pahli value doosri se badi hai to yeh operator `true` return karta hai, anyatha `false` return karta hai.
Example:
```java
int p = 15;
int q = 10;
boolean isGreaterThan = (p > q); // isGreaterThan mein true aayega
```
4. **Less than (<):** Is operator ka istemal ek value ko doosri value se choti hone ki tulanakriya karne ke liye hota hai. Agar pahli value doosri se choti hai to yeh operator `true` return karta hai, anyatha `false` return karta hai.
Example:
```java
int m = 7;
int n = 12;
boolean isLessThan = (m < n); // isLessThan mein true aayega
```
5. **Greater than or Equal to (>=):** Is operator ka istemal ek value ko doosri value se bada ya saman hone ki tulanakriya karne ke liye hota hai. Agar pahli value doosri se badi ya saman hai to yeh operator `true` return karta hai, anyatha `false` return karta hai.
Example:
```java
int r = 25;
int s = 25;
boolean isGreaterOrEqual = (r >= s); // isGreaterOrEqual mein true aayega
```
6. **Less than or Equal to (<=):** Is operator ka istemal ek value ko doosri value se choti ya saman hone ki tulanakriya karne ke liye hota hai. Agar pahli value doosri se choti ya saman hai to yeh operator `true` return karta hai, anyatha `false` return karta hai.
Example:
```java
int u = 30;
int v = 35;
boolean isLessOrEqual = (u <= v); // isLessOrEqual mein true aayega
```
Yeh comparison operators conditions ko evaluate karne mein aur control flow mein istemal hote hain, jaise if-else statements mein aur loops mein. In operators ki madad se aap program mein tulanakriya aur nirnay (decision-making) kar sakte hain.
>> Logical Operator ----------
Java mein, logical operators (मानवीय ऑपरेटर) ek prakar ke operators hote hain jo boolean values (true ya false) ke saath kaam karte hain. In operators ki madad se aap multiple conditions ko combine karke ek hi condition ko check kar sakte hain aur uska result nikal sakte hain. Java mein kuch mukhy logical operators hote hain:
1. **Logical AND (&&):** Logical AND operator do boolean expressions ko evaluate karta hai. Agar dono expressions true hote hain, toh yeh operator `true` return karta hai; agar kisi bhi ek expression mein false hota hai, toh woh `false` return karta hai.
Logical and sign called ............ ampersand ...................
And Operators me dono expression true hona chahiye to hi true statement print aayega agr ek bhi false rha to statement false aayega
Example:
```java
boolean isJavaFun = true;
boolean isLearningEasy = true;
boolean result = isJavaFun && isLearningEasy; // result mein true aayega
```
2. **Logical OR (||):** Logical OR operator do boolean expressions ko evaluate karta hai. Agar kisi ek expression mein bhi true hota hai, toh yeh operator `true` return karta hai; agar dono expressions mein se koi bhi false hota hai, toh woh `false` return karta hai.
This is called double pipe
Note: agr dono me se ek bhi true hoga to statement evaluate hoga true
Example:
```java
boolean isSunnyDay = true;
boolean isWeekend = false;
boolean result = isSunnyDay || isWeekend; // result mein true aayega
```
3. **Logical NOT (!):** Logical NOT operator ek boolean expression ko negate karta hai, yani ki true ko false aur false ko true mein badal deta hai.
Example:
```java
boolean isCloudy = true;
boolean isNotCloudy = !isCloudy; // isNotCloudy mein false aayega
```
4. **Short-Circuit AND (&&) and Short-Circuit OR (||):** Java mein `&&` aur `||` operators short-circuit evaluation follow karte hain. Yadi pehli expression se hi condition solve ho sakta hai (yani ki pehli expression se hi `false` milta hai `&&` ke case mein ya pehli expression se hi `true` milta hai `||` ke case mein), toh dusri expression evaluate nahi ki jati. Isse performance me sudhar hota hai aur unwanted calculations se bacha ja sakta hai.
Example:
```java
boolean isSunnyDay = true;
boolean isWeekend = false;
boolean result = isSunnyDay && isWeekend; // isWeekend ko evaluate hi nahi kiya jata, result mein false aayega
```
In logical operators ki madad se aap complex conditions ko build kar sakte hain aur program me decision-making ko control kar sakte hain. Ye operators if statements, while loops, aur doosre control structures ke sath istemal hote hain.
>> Bitwise Operator ----------
Java mein, bitwise operators (बिटवाइज ऑपरेटर) ek prakar ke operators hote hain jo binary representation (0 aur 1) mein numbers ke bits (bitwise) ke saath kaam karte hain. Ye operators individual bits par operations perform karte hain. Java mein kuch mukhy bitwise operators hote hain:
1. **Bitwise AND (`&`):** Bitwise AND operator do numbers ke bits ke beech mein AND operation perform karta hai. Har corresponding bit par, agar dono numbers mein se dono 1 hain, toh result mein 1 aata hai, anyatha 0 aata hai.
Example:
```java
int a = 5; // Binary: 0101
int b = 3; // Binary: 0011
int result = a & b; // Result: 0001 (1 in decimal)
```
2. **Bitwise OR (`|`):** Bitwise OR operator do numbers ke bits ke beech mein OR operation perform karta hai. Har corresponding bit par, agar kisi ek number mein 1 hai to result mein 1 aata hai, otherwise 0 aata hai.
Example:
```java
int x = 12; // Binary: 1100
int y = 6; // Binary: 0110
int result = x | y; // Result: 1110 (14 in decimal)
```
3. **Bitwise XOR (`^`):** Bitwise XOR (Exclusive OR) operator do numbers ke bits ke beech mein XOR operation perform karta hai. Har corresponding bit par, agar sirf ek number mein 1 hai to result mein 1 aata hai, otherwise 0 aata hai.
Example:
```java
int p = 9; // Binary: 1001
int q = 5; // Binary: 0101
int result = p ^ q; // Result: 1100 (12 in decimal)
```
4. **Bitwise NOT (`~`):** Bitwise NOT operator ek number ke bits ke saare bits ko flip (invert) karta hai. 1 ko 0 bana deta hai aur 0 ko 1 bana deta hai.
Example:
```java
int num = 7; // Binary: 0111
int result = ~num; // Result: 11111111111111111111111111111000 (-8 in decimal)
```
5. **Left Shift (`<<`):** Left Shift operator ek number ke bits ko left shift karta hai, jisse uska value multiply ho jata hai. Har shift ke saath, number ka value 2 guna ho jata hai.
Example:
```java
int value = 5; // Binary: 0101
int result = value << 2; // Result: 20 (5 * 2^2)
```
6. **Right Shift (`>>`):** Right Shift operator ek number ke bits ko right shift karta hai, jisse uska value divide ho jata hai. Har shift ke saath, number ka value 2 se divide ho jata hai.
Example:
```java
int number = 16; // Binary: 10000
int result = number >> 2; // Result: 4 (16 / 2^2)
```
7. **Unsigned Right Shift (`>>>`):** Unsigned Right Shift operator ek number ke bits ko right shift karta hai, lekin left-most bit ko bina change kiye shift karta hai. Isse positive numbers ka correct division hota hai.
Example:
```java
int num = -8; // Binary: 11111111111111111111111111111000
int result = num >>> 2; // Result: 1073741821 (positive value)
```
Bitwise operators low-level operations mein aur bit-level calculations mein istemal hote hain. Yeh aksar hardware programming aur data compression me bhi kaam aate hain.
Comments
Post a Comment