SE 109 - Lecture 4: Data Types, Operators, Control Flow, and Arrays

public class Test {
    public static void main(String args[]) {
        int a = 60; /* 60 = 0011 1100 */
        int b = 13; /* 13 = 0000 1101 */
        int c = 0;

        // Bitwise AND (&)
        c = a & b; // 0011 1100 & 0000 1101 = 0000 1100 (12)
        System.out.println("a & b = " + c ); // Output: a & b = 12

        // Bitwise OR (|)
        c = a | b; // 0011 1100 | 0000 1101 = 0011 1101 (61)
        System.out.println("a | b = " + c ); // Output: a | b = 61

        // Bitwise XOR (^)
        c = a ^ b; // 0011 1100 ^ 0000 1101 = 0011 0001 (49)
        System.out.println("a ^ b = " + c ); // Output: a ^ b = 49

        // Bitwise Complement (~) - Inverts bits (affects sign due to two's complement)
        c = ~a;    // ~0011 1100 = 1100 0011 (-61 in two's complement)
        System.out.println("~a = " + c); // Output: ~a = -61

        // Left Shift (<<) - Multiplies by 2^n
        c = a << 2; // 0011 1100 << 2 = 1111 0000 (240)
        System.out.println("a << 2 = " + c); // Output: a << 2 = 240

        // Signed Right Shift (>>) - Divides by 2^n, preserves sign
        c = a >> 2; // 0011 1100 >> 2 = 0000 1111 (15)
        System.out.println("a >> 2 = " + c); // Output: a >> 2 = 15

        // Unsigned Right Shift (>>>) - Divides by 2^n, fills with 0
        c = a >>> 2; // 0011 1100 >>> 2 = 0000 1111 (15)
        System.out.println("a >>> 2 = " + c); // Output: a >>> 2 = 15
        // Difference between >> and >>> matters for negative numbers
        int neg_a = -60; // 1100 0100
        System.out.println("-60 >> 2 = " + (neg_a >> 2));   // Output: -60 >> 2 = -15 (1111 0001)
        System.out.println("-60 >>> 2 = " + (neg_a >>> 2)); // Output: -60 >>> 2 = 1073741809 (0011 1100 01...) - fills with 0s
    }
}

public class MainClass {
    public static void main(String args[]) {
        int a = 1, b = 2, c = 3;

        a += 5; // a = a + 5 --> a becomes 6
        b *= 4; // b = b * 4 --> b becomes 8
        // c += a * b; is equivalent to c = c + (a * b)
        c += a * b; // c = 3 + (6 * 8) = 3 + 48 = 51
        c %= 6; // c = c % 6 --> c = 51 % 6 = 3 (remainder of 51/6)

        System.out.println("a = " + a); // Output: a = 6
        System.out.println("b = " + b); // Output: b = 8
        System.out.println("c = " + c); // Output: c = 3
    }
}

public class Test {
    public static void main(String args[]){
        int a = 10, b;
        int x = 5, y = 10;

        b = (a == 1) ? 20 : 30; // a is 10, condition is false, b becomes 30
        System.out.println( "Value of b is : " + b ); // Output: Value of b is : 30

        b = (a == 10) ? 20 : 30; // a is 10, condition is true, b becomes 20
        System.out.println( "Value of b is : " + b ); // Output: Value of b is : 20

        // Example from slide 18
        int larger = (x >= y) ? x : y; // x=5, y=10. Condition false. larger becomes y (10).
        System.out.println("Larger is: " + larger); // Output: Larger is: 10

        // Example from slide 18
        int n = -5;
        int absValue = (n < 0) ? -n : n; // n=-5. Condition true. absValue becomes -(-5) = 5.
        System.out.println("Absolute value is: " + absValue); // Output: Absolute value is: 5
    }
}

public class Test {
    public static void main(String args[]){
        String name = "James";
        Integer number = 10;

        // following will return true since name is type of String
        boolean result1 = name instanceof String;
        System.out.println( "name instanceof String: " + result1 ); // Output: name instanceof String: true

        boolean result2 = name instanceof Object; // All classes inherit from Object
        System.out.println( "name instanceof Object: " + result2 ); // Output: name instanceof Object: true

        // boolean result3 = number instanceof String; // Compile error: Incompatible types
        // System.out.println( "number instanceof String: " + result3 );

         boolean result4 = number instanceof Integer;
         System.out.println( "number instanceof Integer: " + result4 ); // Output: number instanceof Integer: true

         Object obj = name; // Assign String to Object reference
         boolean result5 = obj instanceof String;
         System.out.println( "obj instanceof String: " + result5 ); // Output: obj instanceof String: true

         obj = number; // Assign Integer to Object reference
         boolean result6 = obj instanceof Integer;
         System.out.println( "obj instanceof Integer: " + result6 ); // Output: obj instanceof Integer: true
    }
}

String Comparison Example:

String s1 = "Hello";       // From pool
String s2 = "Hello";       // From pool (same object as s1)
String s3 = new String("Hello"); // New object on heap
String s4 = new String("Hello"); // Another new object on heap
String s5 = "He" + "llo";  // Concatenated literal, resolves to "Hello", from pool (same as s1)

System.out.println("s1 == s2: " + (s1 == s2)); // true (both point to same pool object)
System.out.println("s1 == s3: " + (s1 == s3)); // false (different objects)
System.out.println("s3 == s4: " + (s3 == s4)); // false (different objects on heap)
System.out.println("s1 == s5: " + (s1 == s5)); // true (s5 resolves to the same pool object)

System.out.println("s1.equals(s2): " + s1.equals(s2)); // true (content matches)
System.out.println("s1.equals(s3): " + s1.equals(s3)); // true (content matches)
System.out.println("s3.equals(s4): " + s3.equals(s4)); // true (content matches)
System.out.println("s1.equals(s5): " + s1.equals(s5)); // true (content matches)

Example: Odd or Even

import java.util.Scanner;

public class TestInputOddorEven {
    public static void main(String[] args) {
        System.out.println("Please type an integer");
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();

        // Check if the remainder when divided by 2 is not 0
        if ((x % 2) != 0) {
            System.out.println(x + " is odd");
        } else {
            System.out.println(x + " is even");
        }
         sc.close(); // Good practice to close scanner
    }
}

Example: Compare Two Integers

import java.util.Scanner;

public class TestInput {
    public static void main(String[] args) {
        System.out.println("Please type two integers.");
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        int y = sc.nextInt();

        if (x >= y) {
            System.out.println(x + " is the larger or they are equal.");
        } else {
            System.out.println(y + " is the larger.");
        }
         sc.close();
    }
}

Example: Find Largest of Three Numbers

// Assuming x, y, z are integers and largest is an int variable
if (x >= y) {
    // x is potentially the largest
    if (x >= z) {
        largest = x;
    } else { // x < z, and x >= y --> z is largest
        largest = z;
    }
} else { // x < y, so y is potentially the largest (or z)
    if (y >= z) {
        largest = y;
    } else { // y < z, and y > x --> z is largest
        largest = z;
    }
}
System.out.println("The largest number is: " + largest);

Example: Simple Calculator

public class CalcClass {
    public static void main(String[] arg) {
        int a = 10, b = 3; // Changed values for clarity
        char op = '+'; // Example operator

        if (op == '+') {
            System.out.println("sum is " + (a + b)); // Output: sum is 13
        } else if (op == '-') {
            System.out.println("sub is " + (a - b));
        } else if (op == '*') {
            System.out.println("mul is " + (a * b));
        } else if (op == '/') {
             if (b != 0) { // Avoid division by zero
                System.out.println("div is " + (a / b)); // Integer division
             } else {
                 System.out.println("Cannot divide by zero");
             }
        } else {
            System.out.println("Invalid operator");
        }
    }
}

int x = 5, y = 5, z = 5;
int a = -1, b = -2;

// Logical AND Example
if ((x == y) && (y == z)) { // true && true --> true
    System.out.println("x, y and z are equal."); // This will print
}

if ((a < 0) && (b < 0)) { // true && true --> true
    System.out.println("Both values are negative."); // This will print
}

// Logical OR Example
x = 3; // Change x
if ((x < y) || (x < z)) { // 3 < 5 (true) || (doesn't matter) --> true
    System.out.println("x is not the largest."); // This will print
}

a = 10; // Change a
if ((a < 0) || (b < 0)) { // false || true --> true
    System.out.println("At least one is negative."); // This will print
}

// Logical NOT Example
boolean isOverdrawn = false;
if (!isOverdrawn) { // !false --> true
    System.out.println("Account is not overdrawn. Permit debit."); // This will print
}

Example: Day of the week (with fall-through)

public class Main {
    public static void main(String[] args) {
        int day = 2; // Example: Tuesday

        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                // No break here - deliberate fall-through!
            case 3:
                System.out.println("Wednesday");
                break; // Exits after printing Wednesday
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            default:
                System.out.println("Weekend or Invalid day");
        }
        // Output for day = 2:
        // Tuesday
        // Wednesday
    }
}

Example: Character Switch

public class MainClass {
    public static void main(String[] args) {
        char i = '2'; // Example input

        switch (i) {
            case '1':
                System.out.println("One.");
                break;
            case '2':
                System.out.println("Two."); // This will print
                break; // Exits
            case '3':
                System.out.println("Three.");
                break;
            default:
                System.out.println("You did not enter a valid value (1, 2, or 3).");
        }
        // Output: Two.
    }
}

Example: Default Position (Default doesn't have to be last, but break is important)

public class Main {
    public static void main(String[] args) {
        int day = 4; // Example: Thursday

        switch (day) {
            default: // Default can appear anywhere, but execution continues if no break
                System.out.println("Looking forward to the Weekend");
                // break; // <-- If break was here, only this would print for day=4

            case 6:
                System.out.println("Today is Saturday");
                break;
            case 7:
                System.out.println("Today is Sunday");
                break;
        }
        // Output for day = 4:
        // Looking forward to the Weekend
        // Today is Saturday
    }
}

Example: Print Squares 0-9

// Example from Slide 3
for (int i = 0; i < 10; i++) { // i is local to this loop
    System.out.println(i + " squared is " + (i * i));
}
// 'i' cannot be accessed here

Output:

0 squared is 0
1 squared is 1
2 squared is 4
3 squared is 9
4 squared is 16
5 squared is 25
6 squared is 36
7 squared is 49
8 squared is 64
9 squared is 81

Example: Multiple Variables

// Example from Slide 4
for (int i = 0, j = 10; i < 10; i++, j--) { // i increments, j decrements
    System.out.println(i + " " + j);
    // Variables i and j are local to this loop
}

Output:

0 10
1 9
2 8
3 7
4 6
5 5
6 4
7 3
8 2
9 1

Example: Print Elements of a String Array

String[] names = {"Alice", "Bob", "Charlie"};

System.out.println("Names in the array:");
for (String name : names) { // For each String 'name' in the 'names' array
    System.out.println(name);
}

Output:

Names in the array:
Alice
Bob
Charlie

Example: Iterating Over a 2D Array

int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };

System.out.println("Numbers in the 2D array:");
// Outer loop iterates through each row (which is an int[] array)
for (int[] row : myNumbers) {
    // Inner loop iterates through each integer 'i' in the current 'row'
    for (int i : row) {
        System.out.println(i);
    }
}

Output:

Numbers in the 2D array:
1
2
3
4
5
6
7

Example: Print Squares 0-9

// Example from Slide 5
int i = 0; // Initialization
while (i < 10) { // Condition
    System.out.println(i + " squared is " + (i * i));
    i++; // Update
}

(Output is the same as the `for` loop example above).

Example: Print Squares 0-9

// Example from Slide 6
int i = 0; // Initialization
do {
    System.out.println(i + " squared is " + (i * i));
    i++; // Update
} while (i < 10); // Condition checked after the first iteration

(Output is the same as the `for` and `while` loop examples above).

When to use which loop?

• Use for when the number of iterations is predetermined.
• Use while or do-while when the number of iterations depends on a condition that might change within the loop, and you don't know beforehand how many times it will run.
• Use do-while if you need the loop body to execute at least once.

Example: Using break

// Example from Slide 8
public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i == 4) {
                break; // Exit the loop when i is 4
            }
            System.out.println(i);
        }
        // Output after loop: (Loop exited when i was 4)
        System.out.println("Loop finished.");
    }
}

Output:

0
1
2
3
Loop finished.

Example: Using continue

// Example from Slide 9
public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i == 4) {
                continue; // Skip the rest of this iteration when i is 4
            }
            System.out.println(i); // This line is skipped when i is 4
        }
         System.out.println("Loop finished.");
   }
}

Output:

0
1
2
3
5
6
7
8
9
Loop finished.

Example: Outer/Inner Loop Execution

// Example from Slide 10
// Outer loop
for (int i = 1; i <= 2; i++) {
    System.out.println("Outer: " + i); // Executes 2 times

    // Inner loop
    for (int j = 1; j <= 3; j++) {
        System.out.println(" Inner: " + j); // Executes 3 times for each outer loop iteration (6 times total)
    }
}

Output:

Outer: 1
 Inner: 1
 Inner: 2
 Inner: 3
Outer: 2
 Inner: 1
 Inner: 2
 Inner: 3

Example: Simple Triangle Pattern

// Based on Slide 13 (corrected System.out.println usage)
public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) { // Outer loop controls rows
            // Inner loop controls columns in the current row
            for (int j = 0; j <= i; j++) { // Prints '*' j times, up to i
                System.out.print("*"); // print() stays on the same line
            }
            System.out.println(); // Moves to the next line after inner loop finishes
        }
    }
}

Output:

*
**
***
****
*****

Example: Print all cars

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

// Using a standard for loop
System.out.println("Using standard for loop:");
for (int i = 0; i < cars.length; i++) {
    System.out.println(cars[i]);
}

// Using an enhanced for loop (for-each loop) - simpler syntax
System.out.println("\nUsing enhanced for loop:");
for (String car : cars) { // For each String 'car' in the 'cars' array
    System.out.println(car);
}

Output (for both loops):

Volvo
BMW
Ford
Mazda

Example: Method to create an array of characters A-Z

public class ArrayExample {

    // This method creates and returns an array of characters 'A' through 'Z'
    public static char[] createAlphabetArray() {
        // Declare a reference variable 's' for a char array
        char[] s;

        // Create the char array object with size 26
        // and assign its reference to 's'
        s = new char[26]; // Elements initialized to '\u0000'

        // Alternative: Initialize with literals (but not A-Z easily)
        // char[] s = {'a', 'b', 'c', ... };

        // Fill the array with characters 'A' through 'Z'
        for (int i = 0; i < 26; i++) {
            // 'A' has an ASCII/Unicode value. Adding 'i' gives subsequent values.
            // The result of ('A' + i) is an int, so it must be cast back to char.
            s[i] = (char) ('A' + i);
        }
        return s; // Return the reference to the created array
    }

    public static void main(String[] args) {
        char[] alphabet = createAlphabetArray(); // Call the method

        // Print the returned array
        System.out.println("Created Alphabet Array:");
        for (int i = 0; i < alphabet.length; i++) {
            System.out.print(alphabet[i] + " ");
        }
        System.out.println();
        // Output: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
    }
}

Notes:

• The method `createAlphabetArray` declares, creates, populates, and then returns a reference to the character array.
• The `main` method calls `createAlphabetArray`, stores the returned reference in the `alphabet` variable, and then iterates through the array using the reference to print its contents.
• The cast `(char)` is necessary because adding an `int` (`i`) to a `char` (`'A'`) results in an `int` value in Java.