11.19. Medium Multiple Choice QuestionsΒΆ

These problems are similar to those you will see on the AP CS A exam.

    10-13-1: Given the following class declarations, what is the output from Student s1 = new GradStudent(); followed by s1.getInfo();?

    public class Student {
       public String getFood() {
          return "Pizza";
       }
       public String getInfo()  {
          return this.getFood();
       }
    }
    
    public class GradStudent extends Student {
       public String getFood() {
          return "Taco";
       }
    }
    
  • Won't compile since GradStudent doesn't have a getInfo method
  • GradStudent will inherit the getInfo method from Student. This would be true if getInfo was a private method.
  • Taco
  • Objects know what class they are created as and all methods are resolved starting with that class at run time. If the method isn't found in that class the parent class is checked (and so on until it is found). So it will first look for getInfo in GradStudent and when it doesn't find it it will look in Student. In getInfo it calls this.getFood. Again, it will first look for this method in GradStudent. It will find the getFood method there and return "Taco".
  • Pizza
  • This would be true if it was Student s1 = new Student();
  • Won't compile since you are creating a GradStudent, not a Student
  • An object of a subclass can be substituted for a parent class object. A GradStudent is a Student.
  • Won't compile since you use this.getFood()
  • In object methods if you leave off the this. when invoking an object method it will be added for you by the compiler. The keyword this refers to the current object which is implicitly passed to all object methods.

    10-13-2: Given the following class declarations, and EnhancedItem enItemObj = new EnhancedItem(); in a client class, which of the following statements would compile?

    public class Item
    {
       private int x;
    
       public void setX(int theX)
       {
          x = theX;
       }
       // ... other methods not shown
    }
    
    public class EnhancedItem extends Item
    {
       private int y;
    
       public void setY(int theY)
       {
          y = theY;
       }
    
      // ... other methods not shown
    }
    
    I. enItemObj.y = 32;
    II. enItemObj.setY(32);
    III. enItemObj.setX(52);
    
  • I only
  • I is wrong because y is a private field and thus can not be directly accessed from code in a client class.
  • II only
  • I is wrong because y is a private field and thus can not be directly accessed from code in a client class. II is correct because EnhancedItem has setY as a public method. III is correct because EnhancedItem inherits the public method setX from Item.
  • I and II only
  • I is wrong because y is a private field and thus can not be directly accessed from code in a client class.
  • II and III only
  • I is wrong because y is a private field and thus can not be directly accessed from code in a client class. II is correct because EnhancedItem has setY as a public method. III is correct because EnhancedItem inherits the public method setX from Item.
  • I, II, and III
  • I is wrong because y is a private field and thus can not be directly accessed from code in a client class.

    10-13-3: Given the following class declarations and initializations in a client program, which of the following is a correct call to method1?

    public class Test1
    {
       public void method1(Test2 v1, Test3 v2)
       {
          // rest of method not shown
       }
    }
    
    public class Test2 extends Test1
    {
    }
    
    public class Test3 extends Test2
    {
    }
    
    The following initializations appear in a different class.
    Test1 t1 = new Test1();
    Test2 t2 = new Test2();
    Test3 t3 = new Test3();
    
  • t1.method1(t1,t1);
  • You can't pass an object of class Test1 since it is not either an object of type Test2 or an object of type Test3. You can pass the specified type or an object that is a subclass of the specified type but Test1 is not a subclass of Test2 or Test3.
  • t2.method1(t2,t2);
  • You can't pass an object of class Test2 as a parameter of type Test3. Test2 is the parent class of Test3 not a subclass. You can pass an object of the specified type or an object of any subclass.
  • t3.method1(t1,t1);
  • You can't pass an object of class Test1 since it is not either an object of type Test2 or an object of type Test3. You can pass the specified type or an object that is a subclass of the specified type but Test1 is not a subclass of Test2 or Test3.
  • t2.method1(t3,t2);
  • You can't pass t2 as an object of type Test3 since it is an object of class Test2 and class Test2 is not either class Test3 or a subclass of class Test3. Class Test2 is the parent of class Test3.
  • t3.method1(t3,t3);
  • Since method1 is a public method of class Test1 objects of any subclasses of Test1 can invoke the method. So, it can be invoked on t3 since it is an object of Test3 and this is a subclass of Test1. And, since method1 takes an object of class Test2 and Test3 as parameters. This actually means it can take an object of Test2 or any subclass of Test2 and an object of Test3 or any subclass of Test3. So it can take t3 which is an object of class Test3 as an object of Test2 since Test3 is a subclass of Test2.

    10-13-4: If you have a parent class Animal that has a method speak() which returns: Awk. Cat has a speak method that returns: Meow. Bird does not have a speak method. Dog has a speak method that returns: Woof. Pig does not have a speak method. Cow has a speak method that returns: Moo. What is the output from looping through the array a created below and asking each element to speak()?

    Animal[] a = { new Cat(), new Cow(), new Dog(), new Pig(), new Bird() }
    
  • Meow Moo Woof Awk Awk
  • Objects keep a reference to the class that created them. So, even if you put them in an array of Animal objects, they know what they are and all methods are resolved starting with the class of the object. Bird and Pig do not override speak so the speak method in Animal will execute.
  • Awk Awk Awk Awk Awk
  • Methods are always resolved starting with the class of the object, so Cat, Cow, and Dog will all execute their overridden speak methods, so the output will be: Meow Moo Woof Awk Awk.
  • This will not compile
  • Because Bird, Cow, Cat, Dog, and Pig are subclasses of Animal, they can be stored in an array declared as Animal without any compile time errors.
  • This will have runtime errors
  • Because Bird, Cow, Cat, Dog, and Pig are subclasses of Animal, they can be stored in an array declared as Animal without any runtime errors.
  • Meow Moo Woof Oink Awk
  • The Pig class did not override the speak method, so it will use the method from Animal, thus the output should be: Meow Moo Woof Awk Awk

    10-13-5: Given the following class declarations and code, what is the result when the code is run?

    public class Car
    {
       private int fuel;
    
       public Car() { fuel = 0; }
       public Car(int g) { fuel = g; }
    
       public void addFuel() { fuel++; }
       public void display() { System.out.print(fuel + " "); }
    }
    
    public class RaceCar extends Car
    {
       public RaceCar(int g) { super(2*g); }
    }
    
    What is the result when the following code is compiled and run?
    
    Car car = new Car(5);
    Car fastCar = new RaceCar(5);
    car.display()
    car.addFuel();
    car.display();
    fastCar.display();
    fastCar.addFuel();
    fastCar.display();
    
  • The code compiles and runs with no errors, the output is 5 6 5 6
  • RaceCar, while it inherits methods from Car via inheritance, has a separate and different constructor that sets the initial fuel amount to 2 * g, thus in this case, fuel for fastCar is set to 10 initially.
  • The code compiles and runs with no errors, the output is: 5 6 10 11
  • The code compiles correctly, and because RaceCar extends the Car class, all the public methods of Car can be used by RaceCar objects. Also, a variable Car can refer to a Car object or an object of any subclass of Car. An object always knows the class that created it, so even though fastCar is declared to be a Car the constructor that is executed is the one for RaceCar.
  • The code compiles and runs with no errors, the output is 10 11 10 11
  • The variable car is a Car object, so the constructor used is not the same as the fastCar object which is a RaceCar. The car constructor does not change the passed in parameter, so it is set to 5 initially.
  • The code won't compile.
  • RaceCar inherits from the Car class so all the public methods in Car can be accessed by any object of the RaceCar class.
  • You get a runtime error ClassCastException, when fastCar.addFuel() is executed.
  • RaceCar inherits from the Car class so all the public methods in Car can be accessed by any object of the RaceCar class.

    10-13-6: Given the following class declarations and code, what is the result when the code is run?

    public class Book
    {
       public String getISBN()
       {
          // implementation not shown
       }
    
       // constructors, fields, and other methods not shown
    }
    
    public class Dictionary extends Book
    {
       public String getDefinition(String word)
       {
          // implementation not shown
       }
    
       // constructors, fields, and methods not shown
    }
    
    Assume that the following declaration appears in a client class.
    
    Book b = new Dictionary();
    
    Which of the following statements would compile without error?
    I.  b.getISBN();
    II. b.getDefinition("wonderful");
    III. ((Dictionary) b).getDefinition("wonderful");
    
  • I only
  • Both I and III are correct. I is correct because variable b has been declared to be an object of the class Book so you can invoke any public methods that are defined in the Book class or in parents of Book. II is not correct because you can't invoke methods in the Dictionary class directly on b since b is declared to be of type Book not type Dictionary and Dictionary is a subclass of Book not a parent class of Book. III is correct because you can cast b to type Dictionary and then invoke public methods in Dictionary.
  • II only
  • You can't invoke methods in the Dictionary class directly on b since b is declared to be of type Book not type Dictionary and Dictionary is a subclass of Book not a parent class of Book. The compiler checks that the method exists on the declared class type, not the run-time type of the object.
  • I and III only
  • I is correct because variable b has been declared to be an object of the class Book so you can invoke any public methods that are defined in the Book class or in parents of Book. II is not correct because you can't invoke methods in the Dictionary class directly on b since b is declared to be of type Book not type Dictionary and Dictionary is a subclass of Book not a parent class of Book. III is correct because you can cast b to type Dictionary and then invoke public methods in Dictionary.
  • III only
  • I is also correct.
  • I, II, and III
  • You can't invoke methods in the Dictionary class directly on b since b is declared to be of type Book not type Dictionary and Dictionary is a subclass of Book not a parent class of Book. The compiler checks that the method exists on the declared class, not the run-time class.
Next Section - 11.20. Hard Multiple Choice Questions