Abstraction and Interface Concept

Question 1

What a class can’t do between normal class when it was declared as abstract?

Answer 1

The abstract class cannot be instantiated

Ball b = new Ball();  // Error

new keyword is creating a Ball object, but since Ball is abstract class, we can’t create object instance

Question 2

What does a normal class also call? (Class can be instantiated)

Answer 2

concrete class

Question 3

Create an abstract class Ball with hit methods

Answer 3

public abstract class Ball{
     public abstract int hit(int batSpeed);
}

Question 4

How to extend from Ball class?

public abstract class Ball{
     public abstract int hit(int batSpeed);
}

Answer 4

public class BaseBall extends Ball{
     public int hit(int batSpeed){
          // code here
     }
}

Subclass must provide an implementation for each abstract method in the abstract class

Question 5

Create BaseBall subclass with this abstract class and use all methods

public abstract class Ball {
    public abstract int hit(int batSpeed); 
    public abstract int score(int newScore); 
    
    public String message(String message) { 
        return "Ball says: " + message;
    }
}

Answer 5

public class BaseBall extends Ball{
    public int hit(int batSpeed){
          return batSpeed;
     }
    public int score(int newScore){
          return newScore;
    } 
}

BaseBall b = new BaseBall();
int speed = b.hit(10);
int newScore = b.score(20);

String message = "Speed : " + speed + ", Score : " + newScore ;
String returnMessage=b.message(message);
System.out.println(returnMessage);

    public String message(String message) { 
        return "Ball says: " + message;
    }

This concre method in abstract class is optinal, we can override it or just use it

Question 6

What is the different between abstract class and interface class?

Answer 6

A class can only inherit one abstract class / concrete class (extend) but interface class can inherit more than one (implements)

Question 7

Is this an error?

public abstract class D {
     private abstract void jump();
}

Answer 7

Yes, abstract methods cannot be private

Question 8

Can abstract class have constructor

Answer 8

Yes, it was used to initialize the abstract methods

But it can’t instantiated directly using the new keyword

Question 9

Can you create an abstract field in abstact class?

public abstract class Ball{
     public abstract int oldScore;
     public abstract int hit(int speed);
}

Answer 9

No, but we can create a normal fields (instance variable in an abstract class)

public abstract class Ball {
    public int oldScore; 
    public abstract int hit(int speed);
}

Question 10

What is an abstract method?

Answer 10

A method declared with the abstract keyword that has no implementation (no body). It ends with a semicolon instead of curly braces.

Question 11

Can an abstract class exist without any abstract methods?

Answer 11

Yes. Declaring a class abstract without abstract methods is legal. The primary purpose is simply to prevent anyone from creating an instance of that class.

Question 12

What must be done if a subclass does not implement all inherited abstract methods?

Answer 12

The subclass itself must also be declared as abstract.

Question 13

What is the purpose of a constructor in an abstract class?

Answer 13

To initialize the fields of the abstract class. It is called from the subclass’s constructor using the super() keyword, either explicitly or implicitly.

Question 14

Can an abstract method be declared as final?

Answer 14

No. abstract methods are designed to be overridden, whereas final methods cannot be. The two keywords are mutually exclusive.

Question 15

Can an abstract method be declared as static?

Answer 15

No. static methods belong to the class and cannot be overridden, which contradicts the purpose of an abstract method.

Question 16

What is an Interface in Java?

Answer 16

A reference type that is a collection of abstract methods. A class implements an interface, thereby inheriting its abstract methods. It is another way to achieve 100% abstraction.

Question 17

Key difference between an abstract class and an interface regarding constructors?

Answer 17

An abstract class can have constructors. An interface cannot.

Question 18

When should you use an abstract class over an interface?

Answer 18

When you want to share code among several closely related classes or provide a common base class with some default implementation (concrete methods) and state (fields).

Question 19

When should you use an interface over an abstract class?

Answer 19

When you expect that unrelated classes will implement it (e.g., Comparable, Serializable) or when you need to take advantage of multiple inheritance of type.

Question 20

What is the rule for access modifiers when implementing an abstract method?

Answer 20

The access level cannot be more restrictive than the abstract method’s. For example, a protected abstract method can be implemented as protected or public, but notprivate.

Question 21

Can an abstract class implement an interface?

Answer 21

Yes. An abstract class can implement an interface but does not need to provide implementations for the interface’s methods. That responsibility is passed to the first concrete subclass.

Question 22

Can you declare a variable using an abstract class as its type?

Answer 22

Yes. This is a core principle of polymorphism. For example: Ball b = new BaseBall();, where Ball is abstract and BaseBall is a concrete subclass.

Question 23

Can fields (instance variables) be declared abstract?

Answer 23

No. The abstract keyword can only be applied to classes and methods.

Question 24

Can a concrete method in an abstract class call one of its own abstract methods?

Answer 24

Yes. This is the ‘Template Method’ design pattern. At runtime, polymorphism ensures the subclass’s specific implementation of the abstract method is executed.

Question 25

Can an abstract class extend a concrete class?

Answer 25

Yes. An abstract class is free to inherit from a concrete class. It can add new abstract methods that its own concrete subclasses must then implement.

Question 26

``` public abstract class Account { private int balance; public Account(int initialBalance) { this.balance = initialBalance; } public abstract void deposit(int amount); public int getBalance() { return balance; } } public class SavingsAccount extends Account { // Line Z: Constructor implementation public SavingsAccount(int initial) { // Assume super() call is here } @Override public void deposit(int amount) { // Implementation here } public void showBalance() { System.out.println("Current: " + balance); // Line W } } ``` What must be in Line Z?

Answer 26

``` super(initial); ```

Question 27

``` public abstract class Processor { public abstract void process() throws IOException; } public class FileProcessor extends Processor { @Override public void process() throws Exception { // Line S // file processing logic } } ``` Will this execute?

Answer 27

No, the subclass method is allowed to throw fewer or same exception as the superclass method but cannot throw broader checked exceptions