All About Java Operators

public class ArithmeticDemo {
    public static void main(String[] args) {
        int a = 15;
        int b = 4;

        // Addition
        int addition = a + b;
        System.out.println("Addition: " + addition);

        // Subtraction
        int subtraction = a - b;
        System.out.println("Subtraction: " + subtraction);

        // Multiplication
        int multiplication = a * b;
        System.out.println("Multiplication: " + multiplication);

        // Division
        int division = a / b;
        System.out.println("Division: " + division);

        // Modulus
        int modulus = a % b;
        System.out.println("Modulus: " + modulus);

        // Increment
        a++;
        System.out.println("Increment: " + a);

        // Decrement
        b--;
        System.out.println("Decrement: " + b);
    }
}

public class ComparisonDemo {
    public static void main(String[] args) {
        int x = 10;
        int y = 20;

        // Equal to
        boolean isEqual = x == y;
        System.out.println("Is Equal: " + isEqual); // Expected: false

        // Not equal to
        boolean isNotEqual = x != y;
        System.out.println("Is Not Equal: " + isNotEqual); // Expected: true

        // Greater than
        boolean isGreaterThan = x > y;
        System.out.println("Is Greater Than: " + isGreaterThan); // Expected: false

        // Less than
        boolean isLessThan = x < y;
        System.out.println("Is Less Than: " + isLessThan); // Expected: true

        // Greater than or equal to
        boolean isGreaterThanOrEqual = x >= y;
        System.out.println("Is Greater Than or Equal: " + isGreaterThanOrEqual); // Expected: false

        // Less than or equal to
        boolean isLessThanOrEqual = x <= y;
        System.out.println("Is Less Than or Equal: " + isLessThanOrEqual); // Expected: true
    }
}

public class LogicalOperatorsExample {
    public static void main(String[] args) {
        int age = 20;
        boolean hasTicket = true;
        boolean isRaining = false;

        // Logical AND (&&)
        // Check if the person is over 18 and has a ticket
        if (age > 18 && hasTicket) {
            System.out.println("Eligible to enter concert.");
        } else {
            System.out.println("Not eligible to enter concert.");
        }

        // Logical OR (||)
        // Check if the person is either under 18 or it is raining
        if (age < 18 || isRaining) {
            System.out.println("Eligible for free entry to the museum.");
        } else {
            System.out.println("Regular entry fees apply for the museum.");
        }

        // Logical NOT (!)
        // Check if it is not raining
        if (!isRaining) {
            System.out.println("Great weather for a walk!");
        } else {
            System.out.println("Stay indoors, it's raining.");
        }
    }
}

public class BitwiseOperatorsExample {
    public static void main(String[] args) {
        int a = 12; // binary representation: 1100
        int b = 5;  // binary representation: 0101

        // Bitwise AND
        int andResult = a & b; // Both bits must be 1
        System.out.println("Bitwise AND: " + andResult);

        // Bitwise OR
        int orResult = a | b; // At least one bit must be 1
        System.out.println("Bitwise OR: " + orResult);

        // Bitwise XOR
        int xorResult = a ^ b; // Bits must be different
        System.out.println("Bitwise XOR: " + xorResult);

        // Bitwise NOT
        int notResult = ~a; // Invert all bits
        System.out.println("Bitwise NOT: " + notResult);

        // Shift Left
        int shiftLeftResult = a << 2; // Shift bits of 'a' left by 2 positions
        System.out.println("Shift Left: " + shiftLeftResult);

        // Shift Right
        int shiftRightResult = a >> 2; // Shift bits of 'a' right by 2 positions
        System.out.println("Shift Right: " + shiftRightResult);

        // Unsigned Shift Right
        int unsignedShiftRightResult = a >>> 2; // Shift bits of 'a' right by 2 positions, fill with 0
        System.out.println("Unsigned Shift Right: " + unsignedShiftRightResult);
    }
}

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

        // Simple assignment
        int c = a; // assigns the value of 'a' to 'c'
        System.out.println("Simple Assignment: c = " + c);

        // Add and assign
        a += b; // equivalent to a = a + b
        System.out.println("Add and Assign: a = " + a);

        // Subtract and assign
        a -= b; // equivalent to a = a - b
        System.out.println("Subtract and Assign: a = " + a);

        // Multiply and assign
        a *= b; // equivalent to a = a * b
        System.out.println("Multiply and Assign: a = " + a);

        // Divide and assign
        a /= b; // equivalent to a = a / b
        System.out.println("Divide and Assign: a = " + a);

        // Modulus and assign
        a %= b; // equivalent to a = a % b
        System.out.println("Modulus and Assign: a = " + a);

        // Bitwise AND and assign
        a &= b; // equivalent to a = a & b
        System.out.println("Bitwise AND and Assign: a = " + a);

        // Bitwise OR and assign
        a |= b; // equivalent to a = a | b
        System.out.println("Bitwise OR and Assign: a = " + a);

        // Bitwise XOR and assign
        a ^= b; // equivalent to a = a ^ b
        System.out.println("Bitwise XOR and Assign: a = " + a);

        // Shift left and assign
        c <<= 2; // equivalent to c = c << 2
        System.out.println("Shift Left and Assign: c = " + c);

        // Shift right and assign
        c >>= 2; // equivalent to c = c >> 2
        System.out.println("Shift Right and Assign: c = " + c);

        // Unsigned shift right and assign
        c >>>= 2; // equivalent to c = c >>> 2
        System.out.println("Unsigned Shift Right and Assign: c = " + c);
    }
}

public class UnaryOperatorsExample {
    public static void main(String[] args) {
        int a = 10;
        boolean flag = false;

        // Unary plus
        int positive = +a; // Indicates positive value explicitly
        System.out.println("Unary Plus: " + positive); // Outputs 10

        // Unary minus
        int negative = -a; // Negates the value
        System.out.println("Unary Minus: " + negative); // Outputs -10

        // Increment operator
        int preIncrement = ++a; // Increments 'a' by 1 before using it in the expression
        System.out.println("Pre-Increment: " + preIncrement); // Outputs 11
        int postIncrement = a++; // Increments 'a' by 1 after using it in the expression
        System.out.println("Post-Increment: " + postIncrement); // Outputs 11, but 'a' is now 12

        // Decrement operator
        int preDecrement = --a; // Decrements 'a' by 1 before using it in the expression
        System.out.println("Pre-Decrement: " + preDecrement); // Outputs 11
        int postDecrement = a--; // Decrements 'a' by 1 after using it in the expression
        System.out.println("Post-Decrement: " + postDecrement); // Outputs 11, but 'a' is now 10

        // Logical NOT
        boolean notFlag = !flag; // Inverts the boolean value of 'flag'
        System.out.println("Logical NOT: " + notFlag); // Outputs true
    }
}

public class TernaryOperatorGrading {
    public static void main(String[] args) {
        int score = 85;  // Score obtained by the student
        String grade;    // Variable to hold the grade

        // Using ternary operator to assign grade based on the score
        grade = (score >= 90) ? "A" : 
                (score >= 80) ? "B" : "C";

        System.out.println("The student's grade is: " + grade);
    }
}

public class ShiftOperatorsExample {
    public static void main(String[] args) {
        int number = 8; // Binary representation: 1000

        // Left Shift Operator
        int leftShift = number << 2; // Shifts the bits of 'number' 2 places to the left
        System.out.println("Left Shift: " + leftShift + " (Binary: " + Integer.toBinaryString(leftShift) + ")");

        // Right Shift Operator
        int rightShift = number >> 2; // Shifts the bits of 'number' 2 places to the right
        System.out.println("Right Shift: " + rightShift + " (Binary: " + Integer.toBinaryString(rightShift) + ")");

        // Unsigned Right Shift Operator
        int unsignedRightShift = number >>> 2; // Shifts the bits of 'number' 2 places to the right, fills with zero
        System.out.println("Unsigned Right Shift: " + unsignedRightShift + " (Binary: " + Integer.toBinaryString(unsignedRightShift) + ")");

        // Demonstrate right shift on a negative number
        int negativeNumber = -8; // Binary representation will be in two's complement
        int negativeRightShift = negativeNumber >> 2; // Shifts the bits of 'negativeNumber' 2 places to the right
        System.out.println("Negative Right Shift: " + negativeRightShift + " (Binary: " + Integer.toBinaryString(negativeRightShift) + ")");
    }
}

public class MiscellaneousOperatorsExample {
    public static void main(String[] args) {
        // Using 'instanceof' to check the type of an object
        Object text = "Hello, Java!";
        boolean isString = text instanceof String; // Check if 'text' is an instance of String
        System.out.println("Is 'text' an instance of String? " + isString);

        // Using casting to convert double to int
        double pi = 3.14159;
        int integerPart = (int) pi; // Cast double to int, truncating the decimal part
        System.out.println("Integer part of pi: " + integerPart);
    }
}