Unit 2: Using Objects

Key Concepts

• Objects and Classes: A class is a blueprint for creating objects.
• Methods: Define the behavior of an object.
• Constructors: Special methods used to initialize objects.
• String Class: Used to manipulate text with methods like length(), substring(), and equals().
• Wrapper Classes: Convert primitive data types into objects (e.g., Integer, Double).
• Null References: A reference that does not point to any object.

Example Code: Advanced Objects

// Example: Advanced Object Operations in Java
public class AdvancedObjectsExample {
    public static void main(String[] args) {
        // String manipulation
        String text = "Hello, World!";
        String reversed = reverseString(text);
        String[] words = text.split(" ");
        
        // StringBuilder example
        StringBuilder sb = new StringBuilder();
        sb.append("Hello");
        sb.append(" ");
        sb.append("World");
        String result = sb.toString();
        
        // Wrapper class operations
        Double d1 = Double.valueOf("3.14");
        Double d2 = Double.valueOf(2.718);
        Double sum = d1 + d2; // Auto-unboxing
        
        // Null handling
        String nullString = null;
        if (nullString != null) {
            System.out.println("Length: " + nullString.length());
        } else {
            System.out.println("String is null");
        }
        
        // Print results
        System.out.println("Reversed: " + reversed);
        System.out.println("Words: " + String.join(", ", words));
        System.out.println("StringBuilder result: " + result);
        System.out.println("Sum of doubles: " + sum);
    }
    
    private static String reverseString(String str) {
        StringBuilder reversed = new StringBuilder(str);
        return reversed.reverse().toString();
    }
}
              

String Manipulation Techniques

Common String Methods:

String Concatenation:

// Using + operator
String name = "John";
String greeting = "Hello, " + name + "!";  // "Hello, John!"

// Using concat() method
String s1 = "Hello";
String s2 = "World";
String result = s1.concat(" ").concat(s2);  // "Hello World"

// Using StringBuilder (more efficient for multiple concatenations)
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
String finalString = sb.toString();  // "Hello World"
              

String Comparison:

// Using equals() for content comparison
String s1 = "Hello";
String s2 = "hello";
boolean isEqual = s1.equals(s2);  // false

// Using equalsIgnoreCase() for case-insensitive comparison
boolean isEqualIgnoreCase = s1.equalsIgnoreCase(s2);  // true

// Using compareTo() for lexicographical comparison
int comparison = s1.compareTo(s2);  // negative (H comes before h)
              

String Manipulation Tips:

• Strings are immutable - operations return new strings
• Use StringBuilder for multiple concatenations
• Remember that string indices start at 0
• Be careful with substring() end index (exclusive)
• Use equals() instead of == for string comparison

Common Pitfalls and Debugging Tips

Common Mistakes:

• String Comparison: Using == instead of equals()

  
  String s1 = "Hello";
  String s2 = new String("Hello");
  System.out.println(s1 == s2);  // false (compares references)
  System.out.println(s1.equals(s2));  // true (compares content)
                    

• Null References: Forgetting to check for null

  
  String s = null;
  System.out.println(s.length());  // NullPointerException
                    

• String Index Out of Bounds: Using invalid indices

  
  String s = "Hello";
  System.out.println(s.charAt(5));  // StringIndexOutOfBoundsException
                    

Debugging Tips:

• Use System.out.println() to print object states
• Check for null references before method calls
• Verify string indices are within bounds
• Use StringBuilder for complex string operations
• Test edge cases (empty strings, null values)

AP Exam Tips:

• Know the difference between == and equals()
• Understand string immutability
• Be able to trace string method calls
• Know when to use StringBuilder
• Understand string comparison methods

AP Exam-Style Practice Problems

String s = "Hello, World!";
String result = s.substring(7, 12);
System.out.println(result);
                

String s1 = "Hello";
String s2 = new String("Hello");
String s3 = s1;
System.out.println(s1 == s2);
System.out.println(s1 == s3);
                

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");
sb.insert(5, ",");
System.out.println(sb.toString());
                

String s = "Programming is fun!";
int index = s.indexOf("is");
String result = s.substring(index, index + 4);
System.out.println(result);
                

Practice Problems

1. Write a program that takes a string as input and prints its length, first character, and last character.
2. Write a program that extracts and prints the middle three characters of a string.
3. Write a program that converts a String to an Integer and performs arithmetic operations.
4. Write a program that checks if a string is null and prints an appropriate message.
5. Write a program that compares two strings and prints whether they are equal.
6. Create a program that reverses a string using StringBuilder.
7. Write a program that counts the number of vowels in a string.
8. Create a program that converts a string to title case (first letter of each word capitalized).

Interactive Code Playground

Try out your own object-oriented code here! The code will run in a safe environment.

Note: This is a simulated environment. For actual Java code execution, please use an IDE or online Java compiler.

Test Your Knowledge