CODEWITHSUNDEEP
javainheritance
Vlad Ilie
Vlad Ilie

Reputation: 1409

Extending an abstract class - implementing abstract methods

Greetings and salutations!

I currently have an abstract class A, and many classes subclassing it. The code is common to all the subclasses I've put in the oneMethod() and the code that's specific to each implementation I've put into two abstract methods.

public abstract class AbstractA {
     public oneMethod() {
          //do some intelligent stuff here
          abstractMethodOne();
          abstractMethodTwo();
     }
     protected abstract void abstractMethodOne();
     protected abstract void abstractMethodTwo();
}

I have a class that overrides the oneMethod() method.

public class B extends AbstractA {
     @Override
     public oneMethod() {
          //do some other intelligent stuff here
     }
}

Is there any way to skip making a stub implementation of the two abstract methods in the subclass? I mean the only place they're used is in the overridden method.

Any help is appreciated!

Upvotes: 1

Views: 37618

Answers (8)

Arafat_19AK
Arafat_19AK

Reputation: 81

An abstract method from an abstract class can be used in a class in the way shown below. I would appreciate your opinion if you find any wrong in my answer. Thank you. Code using Java

public abstract class AbstractClassA {
protected abstract void method1();
public abstract void method2();
}

public class ClassB extends AbstractClassA{
    @Override
    protected void method1(){}
    public void method2(){}
}

Upvotes: 0

Eric Stein
Eric Stein

Reputation: 13692

No. If you extend an abstract class, you must either make the child class abstract or it must fulfill the contract of the parent class.

As a design observation, I would suggest that you try to make oneMethod() either final or abstract. It's hard to maintain programs that allow extension the way you're implementing it. Use other abstract methods to give child classes hooks into the functionality of oneMethod().

Upvotes: 5

Fernando
Fernando

Reputation: 7905

Well, if abstractMethodTwo and abstractMethodOne are implementation specific, why you put these methods in the base abstract class ? Maybe a common interface or some specific design-pattern is what you're looking for!

Upvotes: 0

Adam Arold
Adam Arold

Reputation: 30578

Since abstractMethodOne() and abstractMethodTwo() are implementation specific but you know that you will always call them you can use composition like this:

public interface SomeInterface {
    void abstractMethodOne();
    void abstractMethodTwo();
}

and create a class like this:

public class SomeClass {
    public void executeThem(SomeInterface onSomeObject) {
        onSomeObject.abstractMethodOne();
        onSomeObject.abstractMethodTwo();
    }
}

then you can compose this in any of your classes where you should call those methods like this:

public class SomeImplementation implements SomeInterface {

    public void abstractMethodOne() {
        // ...
    }
    public void abstractMethodTwo() {
        // ...
    }

    public void executeThem() {
        new SomeClass().executeThem(this);
    }
}

This way you got rid of the inheritance altogether and you can be more flexible in your classes implementing SomeInterface.

Upvotes: 1

Joop Eggen
Joop Eggen

Reputation: 109613

Just make class B also abstract.

public abstract class B extends AbstractA {

Upvotes: 3

OldCurmudgeon
OldCurmudgeon

Reputation: 65889

You could pull oneMethod up into a superclass:

public abstract class AbstractC {
  public void oneMethod() {
  }
}

public abstract class AbstractA extends AbstractC {
  @Override
  public void oneMethod() {
    //do some intelligent stuff here
    abstractMethodOne();
    abstractMethodTwo();
  }

  protected abstract void abstractMethodOne();

  protected abstract void abstractMethodTwo();

}

public class B extends AbstractC {
  @Override
  public void oneMethod() {
    //do some other intelligent stuff here
  }
}

see now how you don't need any more in AbstractC than you need.

Upvotes: 2

Julien
Julien

Reputation: 2584

If your classes B and A have to implement their own oneMethod it's maybe because there are not in an inheritance link but they just should implement the same interface ?

Upvotes: 0

Joni
Joni

Reputation: 111389

You have to provide an implementation to all abstract methods. Even if no part of the program calls them now a class can be created in the future that does call them, or the super class implementation may be changed. A stub is needed even if it's just for binary compatibility.

Upvotes: 4

Related Questions