Basic Arithmetic:

int a = 15, b = 4;

int sum = a + b;        // 19
int difference = a - b; // 11
int product = a * b;    // 60
int quotient = a / b;   // 3 (integer division)
int remainder = a % b;  // 3 (modulus)

// Floating-point division
double result = (double) a / b;  // 3.75

Unary Operators:

int x = 10;

int positive = +x;    // +10
int negative = -x;    // -10

// Pre-increment/decrement
int preInc = ++x;     // x=11, preInc=11
int preDec = --x;     // x=10, preDec=10

// Post-increment/decrement  
int postInc = x++;    // postInc=10, x=11
int postDec = x--;    // postDec=11, x=10

Operator Behavior:

Comparison Operations:

int a = 10, b = 20, c = 10;

boolean equal = (a == c);        // true
boolean notEqual = (a != b);     // true  
boolean less = (a < b);          // true
boolean greater = (a > b);       // false
boolean lessEqual = (a <= c);    // true
boolean greaterEqual = (a >= b); // false

// String comparison (special case)
String str1 = "Hello";
String str2 = "Hello";
String str3 = new String("Hello");

boolean strEqual1 = (str1 == str2);     // true (string pool)
boolean strEqual2 = (str1 == str3);     // false (different objects)
boolean strEqual3 = str1.equals(str3);  // true (content comparison)

Relational Operators Table:

Logical AND (&&) - Short-circuit:

boolean result1 = true && true;   // true
boolean result2 = true && false;  // false
boolean result3 = false && true;  // false
boolean result4 = false && false; // false

// Short-circuit behavior
int x = 5;
boolean test = (x > 10) && (++x > 0);
// x is still 5 because ++x is not evaluated

Logical OR (||) - Short-circuit:

boolean result1 = true || true;   // true
boolean result2 = true || false;  // true
boolean result3 = false || true;  // true
boolean result4 = false || false; // false

// Short-circuit behavior
int y = 5;
boolean test2 = (y < 10) || (++y > 0);
// y is still 5 because ++y is not evaluated

Logical NOT (!):

boolean flag = true;
boolean notFlag = !flag;    // false

boolean result = !(5 > 3);  // false
boolean complex = !(x > 0 && y < 10);  // De Morgan's law

Truth Tables:

Simple Assignment:

int x = 10;           // Basic assignment
int y = x;            // Assign value of x to y
boolean flag = true;  // Boolean assignment

// Multiple assignments (right to left)
int a, b, c;
a = b = c = 5;  // All variables get value 5

Compound Assignment:

int num = 10;

num += 5;   // num = num + 5;  → 15
num -= 3;   // num = num - 3;  → 12  
num *= 2;   // num = num * 2;  → 24
num /= 4;   // num = num / 4;  → 6
num %= 5;   // num = num % 5;  → 1

// String concatenation assignment
String msg = "Hello";
msg += " World";  // msg = msg + " World"; → "Hello World"

Assignment Operators Table:

Syntax & Basic Usage:

// Syntax: condition ? value1 : value2
int a = 10, b = 20;

// Find maximum
int max = (a > b) ? a : b;  // max = 20

// Find minimum  
int min = (a < b) ? a : b;  // min = 10

// Check even/odd
String result = (a % 2 == 0) ? "Even" : "Odd";  // "Even"

// Absolute value
int num = -15;
int absolute = (num < 0) ? -num : num;  // 15

Nested Ternary:

int marks = 85;

String grade = (marks >= 90) ? "A" : 
               (marks >= 80) ? "B" :
               (marks >= 70) ? "C" :
               (marks >= 60) ? "D" : "F";
// grade = "B"

Ternary vs if-else:

// Using ternary operator
int x = 5, y = 10;
int max1 = (x > y) ? x : y;

// Equivalent if-else
int max2;
if (x > y) {
    max2 = x;
} else {
    max2 = y;
}

Complex Expressions:

int age = 20;
boolean hasLicense = true;

String canDrive = (age >= 18) ? 
                  (hasLicense ? "Can drive" : "Need license") : 
                  "Too young";

// Type compatibility
double result = (x > 0) ? x : -1.5;  // int promoted to double

Precedence Rules (High to Low):

Precedence Examples:

// Expression evaluation examples
int result1 = 5 + 3 * 2;        // 11 (not 16)
int result2 = (5 + 3) * 2;      // 16

boolean test1 = 5 > 3 && 2 < 4; // true
boolean test2 = !false || true && false; // true

// Associativity examples
int a = 10, b = 5, c = 2;
int result3 = a - b - c;        // (10-5)-2 = 3
int result4 = a = b = c;        // a = (b = c) = 2

// Mixed operators
int x = 5;
int result5 = ++x * 2 + --x;    // 6*2 + 5 = 17

Best Practices:

• Use parentheses for clarity
• Break complex expressions into steps
• Don't rely on precedence memory
• Consider readability over brevity