Partial abstraction in Java - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of partial abstraction with abstract and concrete methods

What is the output of this Java code that uses partial abstraction with an abstract class and a concrete subclass?

Java

abstract class Vehicle {
    abstract void start();
    void stop() {
        System.out.println("Vehicle stopped");
    }
}

class Car extends Vehicle {
    void start() {
        System.out.println("Car started");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle v = new Car();
        v.start();
        v.stop();
    }
}

A Car started\nVehicle stopped

B Vehicle started\nVehicle stopped

C Car started

D Compilation error due to abstract method

💡 Hint

Remember that abstract classes can have both abstract and concrete methods, and the subclass must implement abstract methods.

The abstract class Vehicle has an abstract method start() and a concrete method stop(). The subclass Car implements start(). When we call start() on the Vehicle reference pointing to Car, Car's start() runs. The stop() method is inherited and runs as is.

🧠 Conceptual

intermediate

Understanding partial abstraction in Java

Which statement best describes partial abstraction in Java?

A A class that cannot have any methods.

B A class that has only concrete methods and can be instantiated.

C A class that has only abstract methods and can be instantiated.

D A class that has both abstract and concrete methods and cannot be instantiated.

💡 Hint

Think about what makes a class abstract and what partial abstraction means.

Partial abstraction means a class has some methods with implementation (concrete) and some without (abstract). Such a class is abstract and cannot be instantiated directly.

🔧 Debug

advanced

Identify the error in partial abstraction usage

What error will this code produce?

Java

abstract class Animal {
    abstract void sound();
    void sleep() {
        System.out.println("Sleeping");
    }
}

class Dog extends Animal {
    // Missing implementation of sound()
}

public class Test {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.sound();
        a.sleep();
    }
}

A Compilation error: Dog must implement abstract method sound()

B Output:\nSleeping

C Runtime error: NullPointerException

D Compilation error: Cannot instantiate abstract class Animal

💡 Hint

Check if all abstract methods are implemented in the subclass.

The Dog class does not implement the abstract method sound(), so it must be declared abstract or implement the method. Since it is not abstract and does not implement sound(), compilation fails.

📝 Syntax

advanced

Correct syntax for partial abstraction

Which option shows the correct syntax for declaring a partially abstract class with one abstract and one concrete method?

A abstract class Shape { abstract void draw() {} void erase(); }

B class Shape { abstract void draw(); void erase() { System.out.println("Erased"); } }

C abstract class Shape { abstract void draw(); void erase() { System.out.println("Erased"); } }

D abstract class Shape { void draw(); abstract void erase() { System.out.println("Erased"); } }

💡 Hint

Remember abstract methods cannot have a body and abstract classes must be declared with the abstract keyword.

Option C correctly declares an abstract class with an abstract method draw() (no body) and a concrete method erase() with a body. Option C is invalid because abstract methods cannot be in non-abstract classes. Options C and D have syntax errors with abstract methods having bodies or concrete methods without bodies.

🚀 Application

expert

Number of methods in a partially abstract class hierarchy

Given this code, how many methods can be called on the object 'obj' of type Parent?

Java

abstract class Parent {
    abstract void methodA();
    void methodB() { System.out.println("B"); }
}

class Child extends Parent {
    void methodA() { System.out.println("A"); }
    void methodC() { System.out.println("C"); }
}

public class Test {
    public static void main(String[] args) {
        Parent obj = new Child();
        // How many methods can be called on obj?
    }
}

A Cannot call any methods on obj

B 2 methods: methodA() and methodB()

C 1 method: methodA() only

D 3 methods: methodA(), methodB(), and methodC()

💡 Hint

Remember the reference type determines accessible methods, not the object type.

The variable obj is of type Parent, so only methods declared in Parent are accessible: methodA() (abstract, implemented in Child) and methodB() (concrete). methodC() is declared only in Child and is not accessible via Parent reference.

Practice

1.

What does partial abstraction mean in Java?

easy

A. An abstract class can have both abstract and concrete methods.

B. An abstract class can only have abstract methods.

C. An abstract class can be instantiated directly.

D. All methods in an abstract class must be static.

Solution

1. Step 1: Understand abstract class capabilities

   Partial abstraction means an abstract class can have some methods with implementation (concrete) and some without (abstract).

2. Step 2: Compare options with definition

   Only An abstract class can have both abstract and concrete methods. correctly states this; others are incorrect or false statements.

3. Final Answer:

   An abstract class can have both abstract and concrete methods. -> Option A

4. Quick Check:

   Partial abstraction = abstract + concrete methods [OK]

Hint: Abstract class can mix method types, not only abstract [OK]

Common Mistakes:

• Thinking abstract classes must have only abstract methods
• Believing abstract classes can be instantiated
• Confusing static methods with abstract methods

2.

Which of the following is the correct way to declare an abstract method inside an abstract class?

public abstract class Shape {
    ?
}

easy

A. public void draw();

B. void draw() {}

C. abstract void draw();

D. public abstract void draw();

Solution

1. Step 1: Recall abstract method syntax

   Abstract methods must be declared with the 'abstract' keyword and no body, and usually have a visibility modifier.

2. Step 2: Check each option

   public abstract void draw(); correctly declares 'public abstract void draw();'. public void draw(); misses 'abstract', C misses visibility, D has a method body which is invalid for abstract methods.

3. Final Answer:

   public abstract void draw(); -> Option D

4. Quick Check:

   Abstract method = 'public abstract' + no body [OK]

Hint: Abstract methods have no body and use 'abstract' keyword [OK]

Common Mistakes:

• Omitting the 'abstract' keyword
• Providing a method body for abstract methods
• Missing visibility modifier

3.

What will be the output of the following code?

abstract class Animal {
    abstract void sound();
    void sleep() {
        System.out.println("Sleeping");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Bark");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.sound();
        a.sleep();
    }
}

medium

A. Compilation error

B. Sleeping\nBark

C. Bark\nSleeping

D. Runtime error

Solution

1. Step 1: Understand method calls on abstract class reference

   Variable 'a' is of type Animal but refers to Dog instance. Calling 'sound()' invokes Dog's override, printing 'Bark'. Calling 'sleep()' uses Animal's concrete method, printing 'Sleeping'.

2. Step 2: Check output order

   First 'a.sound()' prints 'Bark', then 'a.sleep()' prints 'Sleeping'.

3. Final Answer:

   Bark Sleeping -> Option C

4. Quick Check:

   Abstract ref calls subclass method then superclass concrete method [OK]

Hint: Abstract class ref calls subclass override methods [OK]

Common Mistakes:

• Expecting abstract class to instantiate directly
• Confusing method call order
• Thinking abstract methods have implementation

4.

Identify the error in the following code snippet:

abstract class Vehicle {
    abstract void move();
}

class Car extends Vehicle {
    void start() {
        System.out.println("Car started");
    }
}

medium

A. Car class must implement the move() method or be abstract.

B. Vehicle class cannot have abstract methods.

C. Car class cannot have methods other than move().

D. No error, code is correct.

Solution

1. Step 1: Check abstract method implementation

   Vehicle declares abstract method move(). Any concrete subclass must implement it or be declared abstract.

2. Step 2: Analyze Car class

   Car does not implement move() and is not abstract, so this causes a compilation error.

3. Final Answer:

   Car class must implement the move() method or be abstract. -> Option A

4. Quick Check:

   Concrete subclass must implement all abstract methods [OK]

Hint: Concrete subclass must implement all abstract methods [OK]

Common Mistakes:

• Forgetting to implement abstract methods in subclass
• Thinking abstract class can't have abstract methods
• Believing subclass can skip abstract methods without being abstract

5.

Given the abstract class below, which subclass implementation correctly uses partial abstraction?

abstract class Appliance {
    abstract void turnOn();
    void plugIn() {
        System.out.println("Plugged in");
    }
}

Choose the correct subclass:

hard

A. class Fan extends Appliance {}

B. class Fan extends Appliance {
void turnOn() {
System.out.println("Fan is on");
}
}

C. class Fan extends Appliance {
void turnOn() {
System.out.println("Fan is on");
}
void plugIn() {
System.out.println("Fan plugged in");
}
}

D. class Fan extends Appliance {
void plugIn() {
System.out.println("Fan plugged in");
}
}

Solution

1. Step 1: Check abstract method implementation

   Subclass must implement abstract method turnOn() to be concrete.

2. Step 2: Analyze each subclass option

   class Fan extends Appliance { void turnOn() { System.out.println("Fan is on"); } } implements turnOn() only, using inherited plugIn() as is, which is valid partial abstraction. class Fan extends Appliance { void plugIn() { System.out.println("Fan plugged in"); } } misses turnOn(), causing error. class Fan extends Appliance { void turnOn() { System.out.println("Fan is on"); } void plugIn() { System.out.println("Fan plugged in"); } } overrides plugIn() unnecessarily but is valid. class Fan extends Appliance {} misses turnOn(), causing error.

3. Final Answer:

   class Fan extends Appliance { void turnOn() { System.out.println("Fan is on"); } } -> Option B

4. Quick Check:

   Implement abstract methods, inherit concrete ones [OK]

Hint: Implement abstract methods, inherit concrete ones unchanged [OK]

Common Mistakes:

• Not implementing abstract methods in subclass
• Overriding concrete methods unnecessarily
• Leaving subclass empty without abstract method implementation