Unit 3 Lesson

Lessons

3.1

Learning Objective

• Evaluate Boolean expressions that use relational operators in program code

Types of Rational Operators

• Operators
  • Primitives
  • Equal to: ==
  • Not Equal to: !=
• Arithmetic
  • Greater than: >
  • Less than: >
  • Greater than or equal to: >=
  • Less than or equal to: <=

All operators give a true or False value

Operators SHOULD NOT be used on String . String comparisons should be done using .equal or .compareTo

• This is because
  • In Java, strings should not be compared using the == operator because it checks for reference equality, not value equality.
  • When you use == with objects (including strings), it checks if the references to the objects are the same. In other words, it checks if they point to the same method in the memory.
  • String literals in Java are stored in a special memory area called the “String Pool”. When you create a string literal, Java checks if a string with the same content already exists in the pool. If it does, it returns a reference to that existing string; if not, it creates a new string.

Comparing Numbers

Select two numbers and check their relation:

First Number: 0 1 2 Relation: = >= <= > < Second Number: 0 1 2

public class Test {
    public static void main(){
        String a = "Hello";
        String b = new String("Hello");

        System.out.println( a == b);
    }
}
Test.main()

//output is false because the strings are objects so the data in the objects are different thus it prints false even if the values are the same

false

3.2 3.3 and 3.4

Learning Objective

• Represent branching logical processes by using conditional statements

We all know how if and else statements work

We all know how if and else statements work

Syntax

if-else Syntax

        if (condition) {
            // Code to execute if the condition is true
        } else {
            // Code to execute if the condition is false
        }
      

else-if Syntax

        if (condition1) {
            // Code to be executed if condition1 is true
        } else if (condition2) {
            // Code to be executed if condition2 is true
        } else if (condition3) {
            // Code to be executed if condition3 is true
        } else {
            // Code to be executed if none of the conditions are true
        }
      

</html>

3.5

Learning Objectives:

• Understand nested if-else statements and their role in representing branching logical processes.
• Evaluate compound boolean expressions using logical operators like && and ||.
• Introduce short-circuited evaluation in compound boolean expressions.

Nested if-else statements

Nested if-else statements allow for multiple levels of decision-making within a program.

public class Nested {
    public static void main() {
        int x = 5;
        int y = -10;

        if (x > 0) {
            if (y > 0) {
                System.out.println("Both x and y are positive.");
            } else {
                System.out.println("x is positive, but y is not.");
            }
        } else {
            System.out.println("x is not positive.");
        }
            }
}
Nested.main()

x is positive, but y is not.

Compound Boolean Expressions:

Compound boolean expressions involve using logical operators like && (and) and || (or) to combine multiple conditions.

public class Compound {
    public static void main(){
        int age = 25;
        boolean isStudent = true;

        if (age >= 18 && isStudent) {
            System.out.println("You are an adult student.");
        } else if (age >= 18 || isStudent) {
            System.out.println("You are either an adult or a student.");
        } else {
            System.out.println("You are neither an adult nor a student.");
        }
            }
}
Compound.main()

You are an adult student.

Short-Circuited Evaluation:

Short-circuited evaluation is an optimization technique where the second condition in a compound expression is only evaluated if the first condition is true (for &&) or false (for ||).

public class Short {
    public static void main() {
        boolean condition1 = true;
        boolean condition2 = false;

        if (condition1 || condition2) {
            System.out.println("This will be printed.");
        }
    }
}

Short.main()

This will be printed.

Coding Practice

Calculate the final grade based on the following criteria:

• If the student didn’t complete homework, the grade is automatically “F.”
• If the student completed homework and the average of midterm and final exam scores is >= 70, the grade is “Pass.”
• Otherwise, the grade is “Fail.”

import java.util.Scanner;

public class GradeCalculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print(" Enter your midterm score (0-100): \n");
        int midtermScore = scanner.nextInt();
        System.out.print(midtermScore);

        System.out.print("\n Enter your final exam score (0-100): \n");
        int finalExamScore = scanner.nextInt();
        System.out.print(finalExamScore);

        System.out.print("\n Did you complete the homework (yes/no): \n");
        String homeworkComplete = scanner.next().toLowerCase();
        System.out.print(homeworkComplete);

        // write code here

        char grade;

        if (homeworkComplete.equals("no")) {
            grade = 'F'; 
            System.out.println("Your final grade is: " + grade);
        } else {
            int averageScore = (midtermScore + finalExamScore) / 2;
            if (averageScore >= 70) {
                grade = 'P'; 
                System.out.println("Your final grade is: " + grade);
            } else {
                grade = 'F'; 
                System.out.println("Your final grade is: " + grade); 
            }
        }
        }

}


GradeCalculator.main(null)

 Enter your midterm score (0-100): 
78
 Enter your final exam score (0-100): 
90
 Did you complete the homework (yes/no): 
yesYour final grade is: P

3.6

Learning Objective

• Compare and contrast equivalent Boolean expressions

De Morgan’s Law

• Augustus De Morgan was a 19th century mathematician whose laws or rules about boolean logic allow us to simplify expressions when they are negated Given two Boolean variables a and b:

De Morgan's Law provides a set of rules for negating complex boolean expressions.

Example:

Using && operators:

Using || operator:

More:

• !(x > 0) → (x <= 0)
• Distributing a “not” with a boolean expression “flips” the relational operator to the opposite relational operator
  • !(x < 0) → (x >= 0)
  • !(x >= 0) → (x < 0)
  • !(x == 0) → (x != 0)
  • ! (x != 0) → ( x == 0)

A bit more complex:

Proving the law using tables

public class Example {
    public static void main(){
        boolean x = true;
        boolean y = false;

        // Original expression
        boolean originalExp = !(x && y);

        // Applying De Morgan's Law
        boolean equivalentExp = !x || !y;

        // Checking if the results are equivalent
        System.out.println("Are the expressions equivalent? " + (originalExp == equivalentExp));

    }
}
Example.main()

Are the expressions equivalent? true

public class Example2 {
    public static void main(){
        boolean p = true;
        boolean q = true;

        // Original expression
        boolean originalExp2 = !(p || q);

        // Applying De Morgan's Law
        boolean equivalentExp2 = !p && !q;

        // Checking if the results are equivalent
        System.out.println("Are the expressions equivalent? " + (originalExp2 == equivalentExp2));
    }
}

Example2.main()

Are the expressions equivalent? true

public class Example3 {
    public static void main(){
        boolean a = true;
        boolean b = false;
        boolean c = true;

        // Original expression
        boolean originalExp3 = !(a && b) || (c || !b);

        // Applying De Morgan's Law
        boolean equivalentExp3 = (!a || !b) || (c || b);

        // Checking if the results are equivalent
        System.out.println("Are the expressions equivalent? " + (originalExp3 == equivalentExp3));

    }
}

Example3.main()

Are the expressions equivalent? true

De Morgan’s Law Practice

Negate the following expressions:

1. !(A || B) (!A && !B)

2. !(A || B && C) (!A && !B

!C)

3. !(A && (B || C)) (!A

!B && !C)

4. !(A < (B > C)) A >= !(B > C) -> (A >= B <= C)

3.7

Learning Objective

• Compare object reference using boolean expressions in program code

An if statement using == to compare myHouse and momsHouse will be true but false for myHouse and annasHouse because the objects are not the same even though they have same parameters. This means that == will only return true if it is the same object, not a reference or copy of that object.

String a = "Hello";
String b = "Hello";
String c = a;
String d = new String("Hello");

System.out.println(a == c);
System.out.println(d == b);
System.out.println(a == b);
System.out.println(a == d);

true
false
true
false

When you want to compare objects you can use the .equal() method, it will return true if the objects have the same attributes even if they aren’t identical.

String a = "Hello";
String b = "Hello";
String c = a;
String d = new String("Hello");

System.out.println(a.equals(c));
System.out.println(d.equals(b));
System.out.println(a.equals(b));
System.out.println(a.equals(d));

true
true
true
true

Hacks

• Complete popcorn hacks - 0.1 points
• Coding hacks - 0.8 points
  • Complexity: 0.4 points
  • Functionality: 0.4 points

Coding Practice

Create a program that validates a user’s password based on the following criteria:

1. The password must be at least 8 characters long.
2. The password must contain at least one uppercase letter.
3. The password must contain at least one lowercase letter.
4. The password must contain at least one digit (0-9).
5. The password must contain at least one special character (!, @, #, $, %, ^, &, *).

Write a Java program that prompts the user to enter a password and then checks if it meets the above criteria. If the password meets all the criteria, print “Password is valid.” If not, print a message indicating which criteria the password fails to meet.

import java.util.Scanner;

public class PasswordChecker {

    private int length;
    private boolean uppercase;
    private boolean lowercase;
    private boolean digit;
    private boolean special;

    public PasswordChecker(int length, boolean uppercase, boolean lowercase, boolean digit, boolean special) {
        this.length = length;
        this.uppercase = uppercase;
        this.lowercase = lowercase;
        this.digit = digit;
        this.special = special;
    }

    public boolean checkUppercase(String myPassword) {
        for (int i = 0; i < myPassword.length(); i++) {
            if (Character.isUpperCase(myPassword.charAt(i))) {
                return true;
            }
        }
        System.out.println("Password contains no uppercase characters");
        return false;
    }

    public boolean checkLowercase(String myPassword) {
        for (int i = 0; i < myPassword.length(); i++) {
            if (Character.isLowerCase(myPassword.charAt(i))) {
                return true;
            }
        }
        System.out.println("Password contains no lowercase characters");
        return false;
    }

    public boolean checkDigit(String myPassword) {
        for (int i = 0; i < myPassword.length(); i++) {
            if (Character.isDigit(myPassword.charAt(i))) {
                return true;
            }
        }
        System.out.println("Password contains no digits");
        return false;
    }

    public boolean checkSpecial(String myPassword){
        Pattern p = Pattern.compile(
            "[^a-z0-9 ]", Pattern.CASE_INSENSITIVE);
        Matcher m = p.matcher(myPassword);
        boolean res = m.find();
        if (res){
            return true;
        }
        System.out.println("Password contains no special characters");
        return false;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter your password: ");
        String myPassword = scanner.nextLine();

        PasswordChecker check1 = new PasswordChecker(8, true, true, true, false);

        boolean isUppercaseValid = check1.checkUppercase(myPassword);
        boolean isLowercaseValid = check1.checkLowercase(myPassword);
        boolean isDigitValid = check1.checkDigit(myPassword);
        boolean isSpecial = check1.checkSpecial(myPassword);

        if (myPassword.length() >= 8 && isUppercaseValid && isLowercaseValid && isDigitValid && isSpecial) {
            System.out.println("Password is valid");
        } else {
            System.out.println("Password is invalid");
        }
    }
}

PasswordChecker.main(null);

Enter your password: Password contains no uppercase characters
Password contains no digits
Password contains no special characters
Password is invalid