CCNA Java Oop Questions

Option B is correct because the error message indicates that the variable 'value' has not been declared before use. In Java, every variable must be declared with a type and name before it can be referenced. The compiler cannot find a declaration for 'value' in the current scope, so it reports a 'cannot find symbol' error, which is the typical symptom of an undeclared variable.

Option C is correct because it applies the Open/Closed Principle: LibraryItem defines an abstract getBorrowMessage() method, and each subclass provides its own implementation. The borrow() method calls this polymorphic method without needing instanceof or type checks, so adding new item types (e.g., Magazine) only requires implementing getBorrowMessage() in the new subclass without modifying existing code.

Loose coupling is promoted by coding to interfaces and favoring composition over inheritance, as both reduce dependency on concrete implementations.

Option A is correct because inheritance allows a subclass to reuse fields and methods from a superclass without rewriting them. This directly reduces code duplication and promotes maintainability in Java.

A final method cannot be overridden in a subclass. Attempting to do so results in a compilation error.

Encapsulation is achieved by keeping fields private and providing public getters. A getter allows read-only access without exposing the internal representation.

The four main OOP principles are encapsulation, inheritance, polymorphism, and abstraction.

Checked exceptions must be handled; unchecked exceptions are runtime.

First define the interface, then create a class that implements it, implement all abstract methods, add extra methods, and then use the class.

The code fails to compile because the class `Document` does not have a `print()` method defined. In Java, you can only invoke methods that are declared in the class or inherited from its superclass. Since no such method exists, the compiler issues an error.

Strings are immutable in Java. The concat() method returns a new String but the original object remains unchanged because the result is not assigned.

Java automatically provides a default no-arg constructor with the same access as the class.

Option C is correct because the code creates a new Manager object with the name "Alice" and a level of 5, then calls getName() on it. Assuming Manager extends a class (likely Employee) that has a constructor setting the name field via super(name), getName() returns the stored name "Alice". The code compiles and runs without exception, printing "Alice".

Polymorphism applies: the accelerate() method of the actual object (Car) is called, which adds 20 to speed. The protected field speed is accessible because Car extends Vehicle.

Polymorphism in Java allows an object to take multiple forms, typically achieved through inheritance and interfaces. Option B demonstrates this by using an interface reference to invoke a method on an implementing object, where the actual method executed is determined at runtime based on the object's class, not the reference type.

Option B is correct because Circle is a concrete class that extends the abstract class Shape, which declares the abstract method draw(). A concrete subclass of an abstract class must provide an implementation for all inherited abstract methods, unless the subclass is also declared abstract. Circle provides an implementation of draw() with an empty body, which satisfies the override requirement.

The Singleton pattern ensures a class has only one instance and provides a global point of access. A private constructor prevents direct instantiation, and a static getInstance() method provides controlled access.

Interface methods are implicitly public, so implementing class must use public; if not implementing, class must be abstract.

Static variables are shared among all instances of a class. There is only one copy of the variable, regardless of the number of instances.

Option B is correct because it follows the encapsulation principle of object-oriented programming. By providing a public getBalance() method, subclasses can read the balance value without having direct access to the private field, thus preventing unintended modification. This is the standard Java pattern for controlled access to private instance variables.

Overloaded method resolution is based on compile-time types. The literal 3 and 4 are ints, so the int version is the most specific match and is called.

In Java, the protected access modifier allows access within the same package and by subclasses (even if they are in different packages). Option E correctly states this combination, which is the precise definition of protected access as specified in the Java Language Specification (JLS §6.6.2).

The code fails to compile because the reference variable 'obj' is of type Object, which does not have a length() method. The length() method is defined in the String class, not in Object. Since the compiler checks the declared type (Object) for method availability, it does not find length() and produces a compilation error.

Option D (protected) is correct because the protected access modifier allows access to members of a superclass by subclasses in different packages, provided the subclass inherits from the superclass. Option E (public) is also correct because public members are accessible from any class, regardless of package or inheritance.

The `final` keyword prevents a class from being subclassed. When a class is declared `final`, the compiler enforces that no other class can extend it, ensuring its implementation cannot be overridden or inherited. This is the correct mechanism in Java to prevent subclassing.

In Java, fields are not polymorphic; the reference type determines which field is accessed. v is of type Vehicle, so v.type refers to Vehicle's type field.

Option E is correct because an abstract class in Java can contain concrete (non-abstract) methods with full implementations, which subclasses can inherit or override. This is a key distinction from interfaces (prior to Java 8), which could only declare abstract methods. Abstract classes cannot be instantiated directly, but they provide a partial implementation that concrete subclasses complete.

Option A is correct because constructors in Java do not have a return type, not even void. If you attempt to add a return type to a constructor, the compiler treats it as a regular method, not a constructor, which can lead to unexpected behavior. This is a fundamental rule of Java syntax.

Abstract classes cannot be instantiated. The attempt to create a new Animal() causes a compile-time error because Animal is abstract.

Option D is correct because Java uses dynamic method dispatch (runtime polymorphism). Even though the reference variable is of type 'Vehicle', the actual object is a 'Car' instance. At runtime, the JVM calls the overridden 'move()' method of the 'Car' class, printing 'Car moves'.

The if-check and instantiation are not atomic. Two threads could both see instance == null and create separate instances, violating the singleton guarantee.

Interfaces can extend other interfaces and can have default methods with a body.

In Java, an overriding method can throw the same exception, a subclass of the exception thrown by the parent method, or no exception at all. The parent method throws IOException, so the overriding method may throw FileNotFoundException (a subclass of IOException). This follows the rule that the overriding method cannot throw a broader checked exception than the overridden method.

Option A is correct because, since Java 9, interfaces can contain private methods to share common code between default methods or static methods within the interface, without exposing that logic to implementing classes. Option D is correct because all variables declared in an interface are implicitly public, static, and final, meaning they are constants that cannot be changed once assigned.

Although the reference is Parent, the object is Child, and show() is overridden, so Child's version is called.

The `final` modifier prevents a method from being overridden in a subclass. When a method is declared as `final`, any attempt to override it in a subclass results in a compile-time error, ensuring the method's implementation remains unchanged.

Private members are accessible only within the same class.

The object is Photo, and print() is overridden, so dynamic binding calls Photo's print method.

In Java, a call to the superclass constructor using `super()` must be the first statement in a subclass constructor. This ensures that the superclass initialization completes before any subclass-specific code executes, maintaining the inheritance chain. Option B correctly identifies this requirement.

Polymorphism ensures that the overridden method in the actual object's class is called at runtime, even if the reference is of the superclass type.

A class that implements an interface must provide implementations for all abstract methods, or it must be declared abstract. Without the implementation and without being abstract, the class does not compile.

Polymorphism allows the Vehicle class to define a common method (e.g., startEngine()) that each subclass (Car, Truck, Motorcycle) overrides with its own specific implementation. When the method is called on a Vehicle reference, the JVM uses dynamic method dispatch at runtime to invoke the correct subclass version, enabling different engine-starting behaviors through a single interface.

Constructors can be overloaded to provide different initialization options, they cannot return a value (not even void), and if no constructor is defined, the compiler provides a default no-arg constructor.

The final modifier prevents a class from being subclassed, which is appropriate for security or design reasons.

Making all fields public violates the principle of encapsulation, which requires that an object's internal state be hidden from external access and only modifiable through controlled methods (getters/setters). In Java, public fields allow any class to directly read or modify the field, breaking data integrity and the ability to enforce invariants. Encapsulation is a core OOP concept that protects the internal representation of an object.