Scjp 6.0 _ Java _ Level 2

Reviewed by Editorial Team
The ProProfs editorial team is comprised of experienced subject matter experts. They've collectively created over 10,000 quizzes and lessons, serving over 100 million users. Our team includes in-house content moderators and subject matter experts, as well as a global network of rigorously trained contributors. All adhere to our comprehensive editorial guidelines, ensuring the delivery of high-quality content.
Learn about Our Editorial Process
| By LanFang
L
LanFang
Community Contributor
Quizzes Created: 2 | Total Attempts: 669
| Attempts: 175
SettingsSettings
Please wait...
  • 1/10 Questions

    Given: class X {     X() {         System.out.print(1);     }     X(int x) {         this();         System.out.print(2);     } } public class Y extends X {     Y() {         super(6);         System.out.print(3);     }     Y(int y) {         this();         System.out.println(4);     }     public static void main(String[] a) {         new Y(5);     } } What is the result? 

    • 13
    • 134
    • 1234
    • 2134
    • 2143
    • 4321
Please wait...
About This Quiz

The SCJP 6.0 JAVA level 2 quiz assesses advanced Java programming skills, focusing on class structures, inheritance, method overriding, constructors, and static contexts. It is designed for those preparing for Java certification exams, enhancing both theoretical knowledge and practical coding capabilities.

Certification Quizzes & Trivia

Quiz Preview

  • 2. 

    Given: public class ItemTest {     private final int id;     public ItemTest(int id) {         this.id = id;     }     public void updateId(int newId) {         id = newId;     }     public static void main(String[] args) {         ItemTest fa = new ItemTest(42);         fa.updateId(69);         System.out.println(fa.id);     } } Which four statments are true? 

    • Compilation fails.

    • An exception is thrown at runtime.

    • The attribute id in the ItemTest object remains unchanged.

    • The attribute id in the ItemTest object is modified to the new value.

    • A new ItemTest object is created with the preferred value in the id attribute.

    Correct Answer
    A. Compilation fails.
    Explanation
    The compilation fails because the variable "id" is declared as final, meaning it cannot be reassigned a new value once it has been initialized in the constructor. Therefore, the statement "id = newId;" in the "updateId" method causes a compilation error.

    Rate this question:

  • 3. 

    Given: public class SimpleCalc {     public int value;     public void calculate() {         value += 7;     } } And: public class MultiCalc extends SimpleCalc {     public void calculate() {         value -= 3;     }     public void calculate(int multiplier) {         calculate();         super.calculate();         value *= multiplier;     }     public static void main(String[] args) {         MultiCalc calculator = new MultiCalc();         calculator.calculate(2);         System.out.println("Value is: " + calculator.value);     } } What is the result? 

    • Value is: 8

    • Compilation fails.

    • Value is: 12

    • Value is: -12

    • The code runs with no output.

    • An exception is thrown at runtime.

    Correct Answer
    A. Value is: 8
    Explanation
    The result is "Value is: 8" because the calculate() method in the MultiCalc class subtracts 3 from the value, then the calculate(int multiplier) method calls the calculate() method, adds 7 to the value using the super.calculate() method from the parent class, and finally multiplies the value by the multiplier. In the main method, the calculate(2) method is called, so the value is initially 0, then it becomes -3, then it becomes 4 (after adding 7), and finally it becomes 8 (after multiplying by 2).

    Rate this question:

  • 4. 

    Given: public class Base {     public static final String FOO = "foo";     public static void main(String[] args) {         Base b = new Base();         Sub s = new Sub();         System.out.print(Base.FOO);         System.out.print(Sub.FOO);         System.out.print(b.FOO);         System.out.print(s.FOO);         System.out.print(((Base) s).FOO);     } } class Sub extends Base {     public static final String FOO = "bar"; } What is the result? 

    • Foofoofoofoofoo

    • Foobarfoobarbar

    • Foobarfoofoofoo

    • Foobarfoobarfoo

    • Barbarbarbarbar

    • Foofoofoobarbar

    • Foofoofoobarfoo

    Correct Answer
    A. Foobarfoobarfoo
    Explanation
    The correct answer is "foobarfoobarfoo" because when the code is executed, the first print statement "System.out.print(Base.FOO)" prints "foo" because it is accessing the static variable FOO from the Base class. The second print statement "System.out.print(Sub.FOO)" prints "bar" because it is accessing the static variable FOO from the Sub class. The third print statement "System.out.print(b.FOO)" also prints "foo" because it is accessing the static variable FOO from the Base class using an instance of the Base class. The fourth print statement "System.out.print(s.FOO)" prints "bar" because it is accessing the static variable FOO from the Sub class using an instance of the Sub class. The fifth print statement "System.out.print(((Base) s).FOO)" prints "foo" because it is accessing the static variable FOO from the Base class using a reference of the Base class that points to an object of the Sub class.

    Rate this question:

  • 5. 

    Given: 1. public class A{ 2.     public void doit(){ 3. } 4. public String doit(){ 5.     return "a"; 6. } 7. public double doit(int x){ 8.     return 1.0; 9. } 10.} What is the result? 

    • An exception is thrown at runtime.

    • Compilation fails because of an error in line 7.

    • Compilation fails because of an error in line 4.

    • Compilation succeeds and no runtime errors with class A occur.

    Correct Answer
    A. Compilation fails because of an error in line 4.
    Explanation
    The compilation fails because of an error in line 4. This is because the method "doit()" in line 4 has the same signature (same name and same return type) as the method "doit()" in line 2. In Java, methods are differentiated based on their signature, which includes the method name and the parameters. Since both methods have the same signature, the compiler cannot determine which method to call and therefore throws a compilation error.

    Rate this question:

  • 6. 

    Given: class Foo {     private int x;     public Foo(int x) {         this.x = x;     }     public void setX(int x) {         this.x = x;     }     public int getX() {         return x;     } } public class Gamma {     static Foo fooBar(Foo foo) {         foo = new Foo(100);         return foo;     }     public static void main(String[] args) {         Foo foo = new Foo(300);         System.out.print(foo.getX() + "-");         Foo fooFoo = fooBar(foo);         System.out.print(foo.getX() + "-");         System.out.print(fooFoo.getX() + "-");         foo = fooBar(fooFoo);         System.out.print(foo.getX() + "-");         System.out.print(fooFoo.getX());     } } What is the output? 

    • 300-100-100-100-100

    • 300-300-100-100-100

    • 300-300-300-100-100

    • 300-300-300-300-100

    Correct Answer
    A. 300-300-100-100-100
    Explanation
    The output is 300-300-100-100-100.

    In the main method, a new instance of the Foo class is created with x = 300. The getX() method is called on this instance, returning 300, which is printed.

    Then, the fooBar() method is called with the foo instance as an argument. Inside fooBar(), a new instance of Foo is created with x = 100, and this new instance is returned.

    Back in the main method, the getX() method is called on the original foo instance, which still has x = 300, returning 300, which is printed.

    Then, the getX() method is called on the fooFoo instance, which was assigned the returned value from fooBar(). Since fooFoo is now referencing the new Foo instance with x = 100, 100 is returned and printed.

    Finally, the foo instance is assigned the returned value from calling fooBar() with fooFoo as an argument. This means foo is now referencing the new Foo instance with x = 100. The getX() method is called on foo, returning 100, which is printed.

    The getX() method is called on fooFoo again, returning 100, which is printed.

    Rate this question:

  • 7. 

    Given: class One {     void foo() {     } } class Two extends One {     // insert method here } Which three methods, inserted individually at line 14, will correctly complete class Two? (Choose three.) 

    • Int foo(){/* more code here */}

    • Void foo(){/* more code here */}

    • Public void foo(){/* more code here */}

    • Private void foo(){/* more code here */}

    • Protected void foo(){/* more code here */}

    Correct Answer(s)
    A. Void foo(){/* more code here */}
    A. Public void foo(){/* more code here */}
    A. Protected void foo(){/* more code here */}
    Explanation
    The correct answer is void foo(){/* more code here */}, public void foo(){/* more code here */}, and protected void foo(){/* more code here */}. These three methods correctly complete class Two because they have the same name and return type as the foo() method in the superclass One. Additionally, they have different access modifiers (void, public, and protected) which are allowed to be less restrictive than the access modifier in the superclass.

    Rate this question:

  • 8. 

    Given: class Mammal { } class Raccoon extends Mammal {     Mammal m = new Mammal(); } class BabyRaccoon extends Mammal { } Which four statments are true? (Choose four.) 

    • Raccoon is-a Mammal.

    • Raccoon has-a Mammal.

    • BabyRaccoon is-a Mammal.

    • BabyRaccoon is-a Raccoon.

    • BabyRaccoon has-a Mammal.

    • BabyRaccoon is-a BabyRaccoon.

    Correct Answer(s)
    A. Raccoon is-a Mammal.
    A. Raccoon has-a Mammal.
    A. BabyRaccoon is-a Mammal.
    A. BabyRaccoon is-a BabyRaccoon.
    Explanation
    The first statement is true because Raccoon is a subclass of Mammal, indicating that Raccoon is a type of Mammal. The second statement is also true because Raccoon has a Mammal instance variable. The third statement is true because BabyRaccoon is a subclass of Mammal, indicating that BabyRaccoon is a type of Mammal. The fourth statement is true because BabyRaccoon is a subclass of Raccoon, indicating that BabyRaccoon is a type of Raccoon.

    Rate this question:

  • 9. 

    Given: public class Hello {     String title;     int value;     public Hello() {         title += " World";     }     public Hello(int value) {         this.value = value;         title = "Hello";         Hello();     } } And: Hello c = new Hello(5); System.out.print(c.title); What is the result? 

    • Hello

    • Hello World

    • Compilation fails.

    • Hello World 5

    • The code runs with no output.

    • An exception is thrown at runtime.

    Correct Answer
    A. Compilation fails.
    Explanation
    The code fails to compile because there is a syntax error in the constructor. The line "Hello();" is not a valid statement. It seems like the intention was to call the default constructor within the parameterized constructor, but the correct syntax for calling a constructor is "this()".

    Rate this question:

  • 10. 

    Which four statements are true? (Choose four.) 

    • Has-a relationships should never be encapsulated.

    • Has-a relationships should be implemented using inheritance.

    • Has-a relationships can be implemented using instance variables.

    • Is-a relationships can be implemented using the extends keyword.

    • Is-a relationships can be implemented using the implements keyword.

    • The relationship between Movie and Actress is an example of an is-a relationship.

    • An array or a collection can be used to implement a one-to-many has-a relationship.

    Correct Answer(s)
    A. Has-a relationships can be implemented using instance variables.
    A. Is-a relationships can be implemented using the extends keyword.
    A. Is-a relationships can be implemented using the implements keyword.
    A. An array or a collection can be used to implement a one-to-many has-a relationship.
    Explanation
    - Has-a relationships can be implemented using instance variables, as an object can have another object as a member variable.
    - Is-a relationships can be implemented using the extends keyword, as a class can inherit from another class.
    - Is-a relationships can also be implemented using the implements keyword, as a class can implement an interface.
    - An array or a collection can be used to implement a one-to-many has-a relationship, as multiple objects can be stored in an array or collection.

    Rate this question:

Quiz Review Timeline (Updated): Mar 18, 2023 +

Our quizzes are rigorously reviewed, monitored and continuously updated by our expert board to maintain accuracy, relevance, and timeliness.

  • Current Version
  • Mar 18, 2023
    Quiz Edited by
    ProProfs Editorial Team
  • Jan 02, 2013
    Quiz Created by
    LanFang
Back to Top Back to top
Advertisement
×

Wait!
Here's an interesting quiz for you.

We have other quizzes matching your interest.