A possibly a bit better solution compared to the accepted answer: from better_abc import ABCMeta, abstract_attribute # see below class AbstractFoo(metaclass=ABCMeta): @abstract_attribute def bar(self): pass class Foo(AbstractFoo): def __init__(self): self.bar = 3 class BadFoo(AbstractFoo): def __init__(self): pass It will behave like this: Foo() # ok BadFoo() # will raise: NotImplementedError: Can’t instantiate abstract class BadFoo … Read more
There’s a useful example for this on Microsoft Docs – basically you can force a derived class to provide a new implementation for a method. public class D { public virtual void DoWork(int i) { // Original implementation. } } public abstract class E : D { public abstract override void DoWork(int i); } public … Read more
Use the abc module to create abstract classes. Use the abstractmethod decorator to declare a method abstract, and declare a class abstract using one of three ways, depending upon your Python version. In Python 3.4 and above, you can inherit from ABC. In earlier versions of Python, you need to specify your class’s metaclass as … Read more
For the interface, the addition of the abstract, or even the public keywords would be redundant, so you omit them: interface MyInterface { void Method(); } In the CIL, the method is marked virtual and abstract. (Note that Java allows interface members to be declared public abstract). For the implementing class, there are some options: … Read more
java.lang.AbstractMethodError is thrown when an application tries to call an abstract method. Normally, this error is caught by the compiler; this error can only occur at run time if the definition of some class has incompatibly changed since the currently executing method was last compiled. Seems like this problem is due to version incompatibility in … Read more
You can’t directly instantiate an abstract class, but you can create an anonymous class when there is no concrete class: public class AbstractTest { public static void main(final String… args) { final Printer p = new Printer() { void printSomethingOther() { System.out.println(“other”); } @Override public void print() { super.print(); System.out.println(“world”); printSomethingOther(); // works fine } … Read more
How to reproduce that error as simply as possible: Java code: package javaapplication3; public class JavaApplication3 { public static void main(String[] args) { } } class Cat implements Animal{ } interface Animal{ abstract boolean roar(); } Shows this compile time error: Cat is not abstract and does not override abstract method roar() in Animal Why … Read more
This code demonstrates why you should never call an abstract method, or any other overridable method, from a constructor: abstract class Super { Super() { doSubStuff(); } abstract void doSubStuff(); } class Sub extends Super { String s = “Hello world”; void doSubStuff() { System.out.println(s); } } public static void main(String[] args) { new Sub(); … Read more
According to the Java Language Specification, the abstract keyword for interfaces is obsolete and should no longer be used. (Section 9.1.1.1) That said, with Java’s propensity for backwards compatibility, I really doubt it will ever make a difference whether the abstract keyword is present.
The truth is: data classes do not play too well with inheritance. We are considering prohibiting or severely restricting inheritance of data classes. For example, it’s known that there’s no way to implement equals() correctly in a hierarchy on non-abstract classes. So, all I can offer: don’t use inheritance with data classes.