Computer Science Unit 4 and 5 Study
The method addItUp(m, n) is intended to print the sum of the integers greater than or equal to m and less than or equal to n. For example, addItUp(2, 5) should return the value of 2 + 3 + 4 + 5. /* missing precondition */ public static int addItUp(int m, int n) { int sum = 0; for (int j = m; j <= n; j++) { sum += j; } return sum; } Which of the following is the most appropriate precondition for the method? A /* Precondition: m <= n */ B /* Precondition: n <= m */ C /* Precondition: m >= 0 and n >= 0 */ D /* Precondition: m <= 0 and n <= 0 */ E /* Precondition: m <= 0 and n >= 0 */
A /* Precondition: m <= n */
Consider the following class definition. public class Person { private String name; private int feet; private int inches; public Person(String nm, int ft, int in) { name = nm; feet = ft; inches = in; } public int heightInInches() { return feet * 12 + inches; } public String getName() { return name; } public String compareHeights(Person other) { if (this.heightInInches() < other.heightInInches()) { return name; } else if (this.heightInInches() > other.heightInInches()) { return other.getName(); } else return "Same"; } } The following code segment appears in a method in a class other than Person. Person andy = new Person("Andrew", 5, 6); Person ben = new Person("Benjamin", 6, 5); System.out.println(andy.compareHeights(ben)); What, if anything, is printed as a result of executing the code segment? A Andrew B Benjamin
A Andrew
Consider the class definition below. The method levelUp is intended to increase a Superhero object's strength attribute by the parameter amount. The method does not work as intended. public class Superhero { private String name; private String secretIdentity; private int strength; public Superhero(String realName, String codeName) { name = realName; secretIdentity = codeName; strength = 5; } public int levelUp(int amount) // line 14 { strength += amount; // line 16 } } Which of the following changes should be made so that the levelUp method works as intended? A In line 14, levelUp should be declared as type void. B In line 14, amount should be declared as type void. C Line 16 should be changed to strength + amount;. D Line 16 should be changed to return strength + amount;. E Line 16 should be changed to return amount;.
A In line 14, levelUp should be declared as type void.
Consider the following incomplete code segment, which is intended to print the sum of the digits in num. For example, when num is 12345, the code segment should print 15, which represents the sum 1 + 2 + 3 + 4 + 5. int num = 12345; int sum = 0; /* missing loop header */ { sum += num % 10; num /= 10; } System.out.println(sum); Which of the following should replace /* missing loop header */ so that the code segment will work as intended? A while (num > 0) B while (num >= 0) C while (num > 1) D while (num > 2) E while (num > sum)
A while (num > 0)
Consider the following code segment. int j = 1; while (j <= 5) { for (int k = 4; k > 1; k--) { System.out.println("ha"); // line 6 } j++; } How many times will the print statement on line 6 execute? A 15 B 16 C 20 D 24 E 25
A 15
Consider the following code segment. int a = 1; String result = ""; while (a < 20) { result += a; a += 5; } System.out.println(result); What, if anything, is printed as a result of executing the code segment? A 21 B 161116 C 161161 D 16111621 E Nothing is printing because of an infinite loop.
B 161116
Consider the following code segments, which differ only in their loop header. Code Segment I for (int i = 0; i < 10; i++) { System.out.print( "*" ); } Code Segment II for (int i = 1; i <= 10; i++) { System.out.print( "*" ); } Which of the following best explains how the difference in the two loop headers affects the output? A The output of the code segments is the same because the loops in each code segment terminate when i is 10. B The output of the code segments is the same because the loops in both code segments iterate 10 times. C The output of the code segments is different because code segment I iterates from i = 0 to i = 9 and code segment II iterates from i = 1 to i = 10. D The output of the code segments is different because code segment I iterates from i = 0 to i = 10 and code segment II iterates from i = 1 to i = 11. E Neither code segment produces output because both loop conditions are initially false.
B The output of the code segments is the same because the loops in both code segments iterate 10 times.
Consider the following class. The method getTotalSalaryAndBonus is intended to return an employee's total salary with the bonus added. The bonus should be doubled when the employee has 10 or more years of service. public class Employee { private String name; private double salary; private int yearsOfService; public Employee(String n, double sal, int years) { name = n; salary = sal; yearsOfService = years; } public double getTotalSalaryAndBonus(double bonus) { /* missing code */ } } Which of the following could replace /* missing code */ so that method getTotalSalaryAndBonus will work as intended? A if (years >= 10) { bonus *= 2; } return salary + bonus; B if (yearsOfService >= 10) { bonus *= 2; } return salary + bonus; C return salary + bonus; D if (years >= 10) { bonus *= 2; } return sal + bonus; E if (yearsOfService >= 10) { bonus *= 2; } return sal + bonus;
B if (yearsOfService >= 10) { bonus *= 2; } return salary + bonus;
The Thing class below will contain a String attribute, a constructor, and the helper method, which will be kept internal to the class. public class Thing { /* missing code */ } Which of the following replacements for /* missing code */ is the most appropriate implementation of the class? A private String str; private Thing(String s) { /* implementation not shown */ } private void helper() { /* implementation not shown */ } B private String str; public Thing(String s) { /* implementation not shown */ } private void helper() { /* implementation not shown */ } C private String str; public Thing(String s) { /* implementation not shown */ } public void helper() { /* implementation not shown */ } D public String str; private Thing(String s) { /* implementation not shown */ } public void helper() { /* implementation not shown */ }
B private String str; public Thing(String s) { /* implementation not shown */ } private void helper() { /* implementation not shown */ }
The Fraction class below will contain two int attributes for the numerator and denominator of a fraction. The class will also contain a method fractionToDecimal that can be accessed from outside the class. public class Fraction { /* missing code */ // constructor and other methods not shown } Which of the following replacements for /* missing code */ is the most appropriate implementation of the class? A private int numerator; private int denominator; private double fractionToDecimal() { return (double) numerator / denominator; } B private int numerator; private int denominator; public double fractionToDecimal() { return (double) numerator / denominator; } C public int numerator; public int denominator; private double fractionToDecimal() { return (double) numerator / denominator; } D public double fractionToDecimal() { private int numerator; private int denominator; return (double) numerator / denominator; }
B private int numerator; private int denominator; public double fractionToDecimal() { return (double) numerator / denominator;
Consider the following code segment. int count = 0; int number = 20; while (number > 0) { number = number / 2; count++; } What will be the value of count after executing the code segment? A 6 B 5 C 4 D 1 E 0
B 5
Consider the following code segment. String word = "computer"; int num = 3; String result = ""; for (int k = num; k >= 0; k--) { result += word.substring(0, k); } System.out.print(result); What is printed as a result of executing the code segment? A ccocom B comcoc C ccocomcomp D compcomcoc E comcomcomcom
B comcoc
Consider the following code segment where num is a properly declared integer initialized to a positive value. int total = 0; while (num > 0) { total += num % 10; num /= 10; } Which of the following code segments could replace the while loop without changing the resulting value of total? I. for (int h = 0; h < num; h++) { total += num % 10; num /= 10; } II. for (int j = num; j > 0; j--) { total += j % 10; } III. for (int k = num; k > 0; k /= 10) { total += k % 10; } A I only B II only C III only D I and II E II and III
C
Consider the following class definition. public class Contact { private String contactName; private String contactNumber; public Contact(String name, String number) { contactName = name; contactNumber = number; } public void doSomething() { System.out.println(this); } public String toString() { return contactName + " " + contactNumber; } } The following code segment appears in another class. Contact c = new Contact("Alice", "555-1234"); c.doSomething(); c = new Contact("Daryl", ""); c.doSomething(); What is printed as a result of executing the code segment? A Daryl B Daryl 555-1234 C Alice 555-1234 Daryl D Alice 555-1234 Daryl 555-1234 E this this
C Alice 555-1234 Daryl
Consider the following class definition. Each object of the class Employee will store the employee's name as name, the number of weekly hours worked as wk_hours, and hourly rate of pay as pay_rate. public class Employee { private String name; private int wk_hours; private double pay_rate; public Employee(String nm, int hrs, double rt) { name = nm; wk_hours = hrs; pay_rate = rt; } public Employee(String nm, double rt) { name = nm; wk_hours = 20; pay_rate = rt; } } Which of the following code segments, found in a class other than Employee, could be used to correctly create an Employee object representing an employee who worked for 20 hours at a rate of $18.50 per hour? I. Employee e1 = new Employee("Lili", 20, 18.5); II. Employee e2 = new Employee("Steve", 18.5); III. Employee e3 = new Employee("Carol", 20); A I only B III only C I and II only D I and III only
C I and II only
Consider the following class, which models a bank account. The deposit method is intended to update the account balance by a given amount; however, it does not work as intended. public class BankAccount { private String accountOwnerName; private double balance; private int accountNumber; public BankAccount(String name, double initialBalance, int acctNum) { accountOwnerName = name; balance = initialBalance; accountNumber = acctNum; } public void deposit(double amount) { double balance = balance + amount; } } What is the best explanation of why the deposit method does not work as intended? A The deposit method must have a return statement. B In the deposit method, the variable balance should be replaced by the variable initialBalance. C In the deposit method, the variable balance is declared as a local variable and is different from the instance variable balance.
C In the deposit method, the variable balance is declared as a local variable and is different from the instance variable balance.
Consider the following class definition. The method appendIt is intended to take the string passed as a parameter and append it to the instance variable str. For example, if str contains "week", the call appendIt("end") should set str to "weekend". The method does not work as intended. public Class StringThing { private String str; public StringThing(String myStr) { str = myStr; } public void appendIt(String s) // line 10 { str + s; // line 12 } } Which of the following changes should be made so that the appendIt method works as intended? A In line 10, the appendIt method should be declared as return type String. B Line 12 should be changed to str = s + str;. C Line 12 should be changed to str = str + s;. D Line 12 should be changed to return s + str;. E Line 12 should be changed to return str + s;.
C Line 12 should be changed to str = str + s;.
Consider the following class definition. public class Pet { private String name; private int age; public Pet(String str, int a) { name = str; age = a; } public getName() { return name; } } Which choice correctly explains why this class definition fails to compile? A The class is missing a mutator method. B The class is missing an accessor method. C The accessor method is missing a return type. D The accessor method returns a variable other than an instance variable. E The instance variables should be designated public instead of private.
C The accessor method is missing a return type.
Consider the following class definition. public class Gadget { private static int status = 0; public Gadget() { status = 10; } public static void setStatus(int s) { status = s; } } The following code segment appears in a method in a class other than Gadget. Gadget a = new Gadget(); Gadget.setStatus(3); Gadget b = new Gadget(); Which of the following best describes the behavior of the code segment? A The code segment does not compile because the setStatus method should be called on an object of the class Gadget, not on the class itself. B The code segment does not compile because the static variable status is not properly initialized. C The code segment creates two Gadget objects a and b. The class Gadget's static variable status is set to 10, then to 3, and then back to 10. D The code segment creates two Gadget objects a and b. After executing the code segment, the object a has a status value of 3 and the obj
C The code segment creates two Gadget objects a and b. The class Gadget's static variable status is set to 10, then to 3, and then back to 10.
Consider the following code segment. int n = 6; for (int i = 1; i < n; i = i + 2) // Line 2 { System.out.print(i + " "); } Which of the following best explains how changing i < n to i <= n in line 2 will change the result? A An additional value will be printed because the for loop will iterate one additional time. B One fewer value will be printed because the for loop will iterate one fewer time. C There will be no change to the program output because the loop will iterate the same number of times. D An infinite loop will occur because the loop condition will never be false. E The body of the loop will not execute at all because the loop condition will initially be false.
C There will be no change to the program output because the loop will iterate the same number of times.
Consider the following code segment. int a = 1; while (a <= 2) { int c = 1; while (/* missing condition */) { System.out.print("*"); c++; } a++; } The code segment is intended to print "******". Which of the following can be used to replace /* missing condition */ so that the code segment works as intended? A c <= 2 B c < 3 C c <= 3 D c > 2 E c >= 3
C c <= 3
The Employee class will contain a String attribute for an employee's name and a double attribute for the employee's salary. Which of the following is the most appropriate implementation of the class? A public class Employee { public String name; public double salary; // constructor and methods not shown } B public class Employee { public String name; private double salary; // constructor and methods not shown } C public class Employee { private String name; private double salary; // constructor and methods not shown } D private class Employee { public String name; public double salary; // constructor and methods not shown }
C public class Employee { private String name; private double salary; // constructor and methods not shown
Consider the following code segment. String str = "AP-CSA"; for (int i = 0; i < str.length(); i++) { if (str.substring(i, i + 1).equals("A")) { System.out.print(i + " "); } } What is printed as a result of executing the code segment? A 0 B 5 C 0 5 D 0 6 E 1 6
C 0 5
Consider the following code segment. String temp = "Mississippi"; String part = "si"; int position = 0; int count = 0; while(temp.indexOf(part) >= 0) { position = temp.indexOf(part); count++; temp = temp.substring(position + 1); } System.out.println(count); What, if anything, is printed as a result of executing the code segment? A 0 B 1 C 2 D 3 E Nothing is printed.
C 2
Consider the following code segment. int a = 100; while (a > 1) { System.out.println("$"); a /= 2; } How many $'s are printed as a result of executing the code segment? A 0 B 5 C 6 D 7 E 50
C 6
Consider the following code segment. int k = 35; while (k >= 0) { System.out.println("X"); k -= 5; } How many times will the string "X" be printed as a result of executing the code segment? A 1 B 7 C 8 D 35 E More than 35 times, because the code segment will cause an infinite loop.
C 8
Consider the following method substringFound, which is intended to return true if a substring, key, is located at a specific index of the string phrase. Otherwise, it should return false. public boolean substringFound(String phrase, String key, int index) { String part = phrase.substring(index, index + key.length()); return part.equals(key); } Which of the following is the best precondition for index so that the method will return the appropriate result in all cases and a runtime error can be avoided? A 0 <= index < phrase.length() B 0 <= index < key.length() C 0 <= index < phrase.length() + key.length() D 0 <= index <= phrase.length() - key.length() E 0 <= index < phrase.length() - index
D 0 <= index <= phrase.length() - key.length()
Consider the following class definition, which represents two scores using the instance variables score1 and score2. The method reset is intended to set to 0 any score that is less than threshold. The method does not work as intended. public class TestClass { private int score1; private int score2; public TestClass(int num1, int num2) { score1 = num1; score2 = num2; } public void reset(int threshold) { if (score1 < threshold) // line 14 { score1 = 0; // line 16 } else if (score2 < threshold) // line 18 { score2 = 0; } } } Which of the following changes can be made so that the reset method works as intended? A In lines 14 and 18, change < to >. B In lines 14 and 18, change < to <=. C In line 16, change score1 to num1 and in line 18, change score2 to num2. D In line 18, change else if to if. E In line 18, change else if to else.
D In line 18, change else if to if.
Consider the following definition of the class Student. public class Student { private int grade_level; private String name; private double GPA; public Student (int lvl, String nm, double gr) { grade_level = lvl; name = nm; GPA = gr; } } Which of the following object initializations will compile without error? A Student max = new Student ("Max", 10, 3.75); B Student max = new Student (3.75, "Max", 10); C Student max = new Student (3.75, 10, "Max"); D Student max = new Student (10, "Max", 3.75); E Student max = new Student (10, 3.75, "Max");
D Student max = new Student (10, "Max", 3.75);
Consider the following class. public class Help { private int h; public Help(int newH) { h = newH; } public double getH() { return h; } } The getH method is intended to return the value of the instance variable h. The following code segment shows an example of creating and using a Help object. Help h1 = new Help(5); int x = h1.getH(); System.out.println(x); Which of the following statements best explains why the getH method does not work as intended? A The getH method should have a double parameter. B The getH method should have an int parameter. C The getH method should return newH instead of h. D The getH method should have a return type of int. E The getH method should have a return type of void.
D The getH method should have a return type of int.
Consider the following class declaration. public class Student { private String name; private int age; public Student(String n, int a) { name = n; age = a; } public boolean isOlderThan5() { if (age > 5) { return true; } } } Which of the following best describes the reason this code segment will not compile? A The return type for the isOlderThan5 method should be void. B The return type for the isOlderThan5 method should be String. C The return type for the isOlderThan5 method should be int. D The isOlderThan5 method is missing a return statement for the case when age is less than or equal to 5. E The isOlderThan5 method should receive the variable age as a parameter.
D The isOlderThan5 method is missing a return statement for the case when age is less than or equal to 5.
Consider the following class definition. public class Email { private String username; public Email(String u) { username = u; } public void printThis() { System.out.println(this); } public String toString() { return username + "@example.com"; } } The following code segment appears in a method in another class. Email e = new Email("default"); e.printThis(); What, if anything, is printed as a result of executing the code segment? A e B default C [email protected] D [email protected] E Nothing is printed because the class will not compile.
Consider the following code segment. for (int k = 0; k < 4; k++) { /* missing loop header */ { System.out.print(k); } System.out.println(); } The code segment is intended to produce the following output. 0 11 222 3333 Which of the following can be used to replace /* missing loop header */ so that the code segment will work as intended? A for (int h = 0; h < k; h++) B for (int h = 1; h < k + 1; h++) C for (int h = 0; h < 3; h++) D for (int h = k; h >= 0; h--) E for (int h = k; h <= 0; h--)
D for (int h = k; h >= 0; h--)
Consider the following class definition. public class Person { private String name; /* missing constructor */ } The statement below, which is located in a method in a different class, creates a new Person object with its attribute name initialized to "Washington". Person p = new Person("Washington"); Which of the following can be used to replace /* missing constructor */ so that the object p is correctly created? A private Person() { name = n; } B private Person(String n) { name = n; } C public Person() { name = n; } D public Person(String n) { name = n; } E public Person(String name) { String n = name; }
D public Person(String n) { name = n; }
Consider the following code segment, which is intended to store the sum of all multiples of 10 between 10 and 100, inclusive (10 + 20 + ... + 100), in the variable total. int x = 100; int total = 0; while( /* missing code */ ) { total = total + x; x = x - 10; } Which of the following can be used as a replacement for /* missing code */ so that the code segment works as intended? A x < 100 B x <= 100 C x > 10 D x >= 10 E x != 10
D x >= 10
Consider the following method. /* missing precondition */ public void someMethod(int j, int k, String oldString) { String newString = oldString.substring(j, k); System.out.println("New string: " + newString); } Which of the following is the most appropriate precondition for someMethod so that the call to substring does not throw an exception? A /* Precondition: 0 <= oldString.length() */ B /* Precondition: 0 < j and 0 < k */ C /* Precondition: 0 <= j and 0 <= k */ D /* Precondition: j <= k */ E /* Precondition: 0 <= j <= k <= oldString.length() */
E /* Precondition: 0 <= j <= k <= oldString.length() */
Consider the following class definition. public class BoolTest { private int one; public BoolTest(int newOne) { one = newOne; } public int getOne() { return one; } public boolean isGreater(BoolTest other) { /* missing code */ } } The isGreater method is intended to return true if the value of one for this BoolTest object is greater than the value of one for the BoolTest parameter other, and false otherwise. The following code segments have been proposed to replace /* missing code */. return one > other.one; return one > other.getOne(); return getOne() > other.one; Which of the following replacements for /* missing code */ can be used so that isGreater will work as intended? A I only B II only C III only D I and II only E I, II and III
E I, II and III
Consider the following code segment. for (int i = 0; i < 5; i++) // Line 1 { for (int j = 0; j < 5; j++) { int k = i + j; System.out.print(k + " "); } } Which of the following best describes the result of changing i < 5 to i > 5 in line 1? A The numbers will be printed in the reverse order as they were in the original code segment because the outer loop will occur in reverse order. B Five additional values will be printed because the outer for loop will iterate one additional time. C An infinite loop will occur because the termination condition of the loop will never be reached. D There will be no change to the program output. E Nothing will be printed because the body of the outer for loop will not execute at all.
E Nothing will be printed because the body of the outer for loop will not execute at all.
Consider the following class declaration. The changeWeather method is intended to update the value of the instance variable weather and return the previous value of weather before it was updated. public class WeatherInfo { private String city; private int day; private String weather; public WeatherInfo(String c, int d, String w) { city = c; day = d; weather = w; } public String changeWeather(String w) { /* missing code */ } } Which of the following options should replace /* missing code */ so that the changeWeather method will work as intended? A String prev = w; return weather; B String prev = weather; return w; C String prev = w; return prev; D weather = w; String prev = weather; return prev; E String prev = weather; weather = w; return prev;
E String prev = weather; weather = w; return prev;
public class UnitsHandler { private static int totalUnits = 0; private static int containers = 0; private static int unitsPerContainer = 0; public UnitsHandler(int containerSize) { unitsPerContainer = containerSize; } public static void update(int c) { containers = c; totalUnits = unitsPerContainer * containers; } } The following code segment appears in a method in a class other than UnitsHandler. Assume that no other code segments have created or modified UnitsHandler objects. UnitsHandler large = new UnitsHandler(100); UnitsHandler.update(8); Which of the following best describes the behavior of the code segmen E The code segment creates a UnitsHandler object called large and sets the static variables unitsPerContainer, containers, and totalUnits to 100, 8, and 800, respectively.
E The code segment creates a UnitsHandler object called large and sets the static variables unitsPerContainer, containers, and totalUnits to 100, 8, and 800, respectively.
Consider the following class declaration. public class Student { private String firstName; private String lastName; private int age; public Student(String firstName, String lastName, int age) { firstName = firstName; lastName = lastName; age = age; } public String toString() { return firstName + " " + lastName; } } The following code segment appears in a method in a class other than Student. It is intended to create a Student object and then to print the first name and last name associated with that object. Student s = new Student("Priya", "Banerjee", -1); System.out.println(s); Which of the following best explains why the code segment does not work as expected? E The code segment will compile, but the instance variables will not be initialized correctly because the variable names firstName, lastName, and age refer to the local variables inside the constructor.
E The code segment will compile, but the instance variables will not be initialized correctly because the variable names firstName, lastName, and age refer to the local variables inside the constructor.
Consider the following code segment. for (int j = 0; j < 4; j++) { for (int k = 0; k < j; k++) { System.out.println("hello"); } } Which of the following best explains how changing the inner for loop header to for (int k = j; k < 4; k++) will affect the output of the code segment? A The output of the code segment will be unchanged. B The string "hello" will be printed three fewer times because the inner loop will iterate one fewer time for each iteration of the outer loop. C The string "hello" will be printed four fewer times because the inner loop will iterate one fewer time for each iteration of the outer loop. D The string "hello" will be printed three additional times because the inner loop will iterate one additional time for each iteration of the outer loop. E The string "hello" will be printed four additional times because the inner loop will iterate one additional time for each iteration of the outer loop.
E The string "hello" will be printed four additional times because the inner loop will iterate one additional time for each iteration of the outer loop.
Consider the following class definition. public class ClassP { private String str; public ClassP(String newStr) { String str = newStr; } } The ClassP constructor is intended to initialize the str instance variable to the value of the formal parameter newStr. Which of the following statements best describes why the ClassP constructor does not work as intended? A The constructor should have a return type of String. B The constructor should have a return type of void. C The instance variable str should be designated public. D The variable str should be designated public in the constructor. E The variable str should not be declared as a String in the constructor.
E The variable str should not be declared as a String in the constructor.
int total = 0; for (int k = 0; k <= 100; k += 2) { total += k; } Which of the following for loops could be used to replace the for loop in the original code segment so that the original and the revised code segments store the same value in total? A for (int k = 0; k < 100; k += 2) { total += k + 1; } B for (int k = 1; k < 101; k += 2) { total += k - 1; } C for (int k = 0; k <= 101; k += 2) { total += k + 1; } D for (int k = 1; k <= 101; k += 2) { total += k + 1; } E for (int k = 1; k <= 101; k += 2) { total += k - 1; }
E for (int k = 1; k <= 101; k += 2) { total += k - 1; }
Consider the following class definition. public class Beverage { private int numOunces; private static int numSold = 0; public Beverage(int numOz) { numOunces = numOz; } public static void sell(int n) { /* implementation not shown */ } } Which of the following best describes the sell method's level of access to the numOunces and numSold variables? A Both numOunces and numSold can be accessed and updated. B Both numOunces and numSold can be accessed, but only numOunces can be updated. C Both numOunces and numSold can be accessed, but only numSold can be updated. D numSold can be accessed but not updated; numOunces cannot be accessed or updated. E numSold can be accessed and updated; numOunces cannot be accessed or updated.
E numSold can be accessed and updated; numOunces cannot be accessed or updated.
