AP Computer Science A Hard practice

Which of the following correctly demonstrates the use of equals() from the Object class, and when would you override it?

public class Point {
    int x, y;
    public Point(int x, int y) { this.x = x; this.y = y; }
}
Point p1 = new Point(2, 3);
Point p2 = new Point(2, 3);
System.out.println(p1.equals(p2));

What is the state of array a after the following code executes?

int[][] a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[] temp = a[0];
a[0] = a[2];
a[2] = temp;

A programmer wants to use recursion to check if a string is a palindrome. Which recursive definition is correct?

public static boolean isPalin(String s) {
    if (s.length() <= 1) return true;
    if (s.charAt(0) != s.charAt(s.length() - 1)) return false;
    return isPalin(s.substring(1, s.length() - 1));
}

What does isPalin("racecar") return?

A student writes the following method to count elements equal to a target value in a 2D array:

public static int count(int[][] arr, int target) {
    int cnt = 0;
    for (int r = 0; r < arr.length; r++) {
        for (int c = 0; c < arr[0].length; c++) {
            if (arr[r][c] == target) cnt++;
        }
    }
    return cnt;
}

For which input would this method produce incorrect results?

Consider the following hierarchy:

public class Vehicle { public void move() { System.out.println("Vehicle moves"); } }
public class Boat extends Vehicle { public void move() { System.out.println("Boat sails"); } }
public class AmphibiousVehicle extends Boat { }

What is printed by:

Vehicle v = new AmphibiousVehicle();
v.move();

Which of the following recursive methods contains a flaw that would cause infinite recursion for the call badRecurse(5)?

// Option A
public static int badRecurse(int n) {
    if (n == 0) return 0;
    return n + badRecurse(n + 1);
}

A programmer writes:

public class Printer {
    public void print(String s) { System.out.println(s); }
    public void print(int n) { System.out.println(n * 2); }
}
Printer p = new Printer();
p.print(5);

What is the output, and what concept does this demonstrate?

What is the output of the following code?

public static String reverse(String s) {
    if (s.length() == 0) return "";
    return reverse(s.substring(1)) + s.charAt(0);
}
System.out.println(reverse("abc"));

Consider the following method:

public static int power(int base, int exp) {
    if (exp == 0) return 1;
    return base * power(base, exp - 1);
}

How many times total is power called (including the initial call) when evaluating power(2, 4)?