Consider the following class definition and main method:

</>Java
public class NumberModifier {
    public static void modify(int a, int b) {
        a = a * 2;
        b = b - 3;
        System.out.print(a + " " + b + " ");
    }
    
    public static void main(String[] args) {
        int a = 4;
        int b = 8;
        modify(a, b);
        System.out.print(a + " " + b);
    }
}

What is printed as a result of executing the main method?

Consider the following code segment:

</>Java
public class LoopReturn {
    public static int processLoop(int limit) {
        int sum = 0;
        for (int k = 1; k <= limit; k++) {
            sum += k;
            if (sum >= 6) {
                return sum;
            }
        }
        return sum;
    }
    
    public static void main(String[] args) {
        System.out.print(processLoop(5));
    }
}

What is printed as a result of executing the main method?

Consider the following class definition and main method:

</>Java
public class ScoreTracker {
    private int score = 10;
    
    public void updateScore(int score) {
        score = score + 5;
        this.score = this.score + score;
    }
    
    public void printScore() {
        System.out.print(score);
    }
    
    public static void main(String[] args) {
        ScoreTracker game = new ScoreTracker();
        game.updateScore(4);
        game.printScore();
    }
}

What is printed as a result of executing the main method?

The following method is intended to return the number of times the digit d appears in the positive integer num.

</>Java
public int countDigit(int num, int d) {
    int count = 0;
    while (num > 0) {
        /* missing code */
    }
    return count;
}

Which of the following can replace /* missing code */ so the method works as intended?

The method hasEvenDigit is intended to return true if the positive integer n contains at least one even digit, and false otherwise.

</>Java
public boolean hasEvenDigit(int n) {
    while (n > 0) {
        int digit = n % 10;
        /* missing code */
        n /= 10;
    }
    return false;
}

Which of the following can replace /* missing code */ so the method works as intended?

A class contains a method intended to calculate and return the exact decimal average of two integer parameters, a and b. Which of the following method headers and return statements correctly implements this behavior?

A library charges a late fee of $0.50 per day for the first 10 days a book is late, and $1.00 per day for each day after that. The method calculateFee is intended to return the total fee for a book that is daysLate days late.

</>Java
public double calculateFee(int daysLate) {
    if (daysLate <= 0) {
        return 0.0;
    }
    /* missing code */
}

Which of the following can replace /* missing code */ so the method works as intended?

The Counter class is intended to maintain a running total. The addValue method is intended to add the parameter value to the instance variable value.

</>Java
public class Counter {
    private int value;
    
    public void addValue(int value) {
        /* missing code */
    }
}

Which of the following code segments can replace /* missing code */ so that the method works as intended?

Consider the following class declaration.

</>Java
public class Book {
    private String author;
    private int pages;

    public Book(String a, int p) {
        author = a;
        pages = p;
    }

    public String getAuthor() {
        return author;
    }

    public static boolean isSameAuthor(Book b1, Book b2) {
        return b1.getAuthor().equals(b2.getAuthor());
    }
}

Which of the following best describes the behavior of the isSameAuthor method?

Consider the following class declaration and code segment.

</>Java
public class Server {
    private static int activeConnections = 0;
    private static final int MAX_CONNECTIONS = 3;
    private boolean isConnected = false;

    public static boolean canConnect() {
        return activeConnections < MAX_CONNECTIONS;
    }

    public void connect() {
        if (canConnect() && !this.isConnected) {
            this.isConnected = true;
            activeConnections++;
        }
    }
}

/* 
 * The following code segment appears in a method in another class.
 */
Server s1 = new Server();
Server s2 = new Server();
Server s3 = new Server();
Server s4 = new Server();

s1.connect();
s2.connect();
s3.connect();
s4.connect();
s1.connect();

Which of the following best describes the state of the objects after the code segment executes?