You can do the following: class C { struct Interface { virtual void bar() = 0; virtual ~Interface(){} }; template <class T> struct Interfacer : Interface { T t; Interfacer(T t):t(t){} void bar() { t.bar(); } }; std::unique_ptr<Interface> interface; public: template <class T> C(const T & t): interface(new Interfacer<T>(t)){} void bar() { interface->bar(); } }; … Read more
using <class>.__bases__ seems to be what you’re looking for… >>> class p1(object): pass >>> class p2(p1): pass >>> p2.__bases__ (<class ‘__main__.p1’>,)
This is a good question and a real problem. The easiest way to deal with it in Java likely involves the use of generics, as mentioned in Jochen’s answer. There’s a good discussion of the issue and a reasonable solution in this blog entry on Using Inheritance with Fluent Interfaces, which combines generics with the … Read more
Use the __mro__ attribute: >>> class A: … pass … >>> class B: … pass … >>> class C(A, B): … pass … >>> C.__mro__ (<class ‘__main__.C’>, <class ‘__main__.A’>, <class ‘__main__.B’>, <class ‘object’>) This is a special attribute populated at class instantiation time: class.__mro__ This attribute is a tuple of classes that are considered when … Read more
if the member or constructor is declared private, then access is permitted if and only if it occurs within the body of the top level class (§7.6) that encloses the declaration of the member or constructor. http://docs.oracle.com/javase/specs/jls/se7/html/jls-6.html#jls-6.6.1
? as a type parameter can only be used in methods. eg: printAll(MyList<? extends Serializable>) I cannot define classes with ? as type parameter. A wildcard (?) isn’t a formal type parameter, but rather can be used as a type argument. In the example you give, ? extends Serializable is given as a type argument … Read more
That is how Java works. The constructors of the parent classes are called, all the way up the class hierarchy through Object, before the child class’s constructor is called. Quoting from the docs: With super(), the superclass no-argument constructor is called. With super(parameter list), the superclass constructor with a matching parameter list is called. Note: … Read more
For single inheritance, super() is just a fancier way to refer to the base type. That way, you make the code more maintainable, for example in case you want to change the base type’s name. When you are using super everywhere, you just need to change it in the class line. The real benefit comes … Read more
Your idea to have a variable of type Animal is good. But you also have to make sure to use the right constructor: Animal animal; // define a variable for whatever animal we will create if (condition) { Dog dog = new Dog(); // create a new Dog using the Dog constructor dog.setD(..); dog.setE(..); animal … Read more
Because it will ensure that when a constructor is invoked, it can rely on all the fields in its superclass being initialised. see 3.4.4 in here