Multiple choice technology

Given: 1. public class Base { 2. public static final String FOO = "foo"; 3. public static void main(String[] args) { 4. Base b = new Base(); 5. Sub s = new Sub(); 6. System.out.print(Base.FOO); 7. System.out.print(Sub.FOO); 8. System.out.print(b.FOO); 9. System.out.print(s.FOO); 10. System.out.print(((Base)s).FOO); 11. } } 12. class Sub extends Base {public static final String FOO="bar";} What is the result?

  1. foofoofoofoofoo

  2. foobarfoobarbar

  3. foobarfoofoofoo

  4. foobarfoobarfoo

  5. barbarbarbarbar

  6. foofoofoobarbar
Reveal answer Fill a bubble to check yourself
D Correct answer
Explanation

Static members are accessed based on the reference type, not the actual object type. Base.FOO prints 'foo' (accessing Base's static variable). Sub.FOO prints 'bar' (accessing Sub's static variable). b.FOO prints 'foo' because b is declared as Base type. s.FOO prints 'bar' because s is declared as Sub type. ((Base)s).FOO prints 'foo' because the cast changes the reference type to Base. The result is 'foobarfoobarfoo'. Static members are not polymorphic - they depend on compile-time type.

AI explanation

To determine the result of the given code, let's go through each line and understand the behavior:

  1. The code starts with the declaration of the Base class.
  2. Line 2 declares a public static final variable FOO with the value "foo".
  3. Line 3 starts the main method.
  4. Line 4 creates a new instance of the Base class and assigns it to a variable b.
  5. Line 5 creates a new instance of the Sub class (which extends Base) and assigns it to a variable s.
  6. Line 6 prints the value of Base.FOO, which is "foo".
  7. Line 7 prints the value of Sub.FOO, which is "bar".
  8. Line 8 prints the value of b.FOO, which is "foo". Here, b refers to an instance of the Base class, so it accesses the FOO variable of the Base class.
  9. Line 9 prints the value of s.FOO, which is "bar". Here, s refers to an instance of the Sub class, so it accesses the FOO variable of the Sub class.
  10. Line 10 prints the value of ((Base)s).FOO, which is "bar". Here, we cast s to type Base, so it accesses the FOO variable of the Base class.
  11. The code ends with line 11.

Based on the above analysis, the result of the code will be:

D. foobarfoobarfoo

This is because the first four print statements (lines 6-9) output "foo", "bar", "foo", and "bar" respectively. The fifth print statement (line 10) outputs "bar" because the cast (Base)s allows access to the FOO variable of the Base class.

Keep practicing — related questions