public class Foo { public abstract void A(); public abstract void B(); } public class Bar extends Foo { public void A() { ... } public void B() { ... } }
and
interface Foo { public void A(); public void B(); } public class Bar implements Foo { public void A() { ... } public void B() { ... } }
assuming it's Java (I think Sepples has interfaces too now but I don't know if there's implements keyword), the big difference is that you can multiply inherit interfaces but not classes. by convention, this is a useful kludge for something like duck typing. it allows you to still have a typical enterprisey OOP class hierarchy and add weird utility functions to only certain classes.
so there can be public class Anus extends BodyPart implements Serializable, Haxable that works with your usual BodyPartFactoryFactorySingletonFlywheelBeanControllerProviderStrategy but also with a third-party AbstractThreadSafeHaxExecutorProviderCommand without each BodyPart also being Haxable (after all, we know that it's possible to HAX MY ANUS but it's not possible to HAX MY NOSE) (Horrible!)
does it mean that Java needs convoluted bullshit for things that would be easier in other languages? well yes, it does mean exactly that.