Assume we have some interface, abstract class and contrete class:
interface I {
void foo();
void bar();
}
abstract class A implements I {
public void barFoo() {
bar(); // Compile Failure
foo(); // Compile Failure
}
}
class B extends A {
public void foo() {
System.debug('foo');
}
public void bar() {
System.debug('bar');
}
}
The A
abstract class won't compile because of:
Compile failure on line x, column y: Method does not exist or incorrect signature:
void bar()
from the typeA
And this is interesting because such code is absolutely valid in JAVA:
interface I {
void foo();
void bar();
}
abstract class A implements I {
public void fooBar() {
foo();
bar();
}
}
class B extends A {
@Override
public void foo() {
System.out.println("foo");
}
@Override
public void bar() {
System.out.println("bar");
}
}
public class Program {
public static void main(String[] args) {
new B().fooBar();
// foo
// bar
}
}
I found out that explicit declaration of the interface methods as abstract within abstract class resolved the compile error:
abstract class A implements I {
public void barFoo() {
bar(); // Works
foo(); // Works
}
public abstract void foo();
public abstract void bar();
}
class B extends A {
public override void foo() {
System.debug('foo');
}
public override void bar() {
System.debug('bar');
}
}
However, I didn't find any information in ApexDocs about such behavior. Is it a bug or (undocumented) intentionally designed behavior? Or maybe I'm missing something?
barFoo()
method can be invoked only on an instance of a class that extends the abstract class and this class must override the interface methods if they have not been overridden before in the abstract class as non-abstract.