Actually, what is called is the implicitly defined operator = for Derived. The definition provided by the compiler in turn calls operator = for the Base and you see the corresponding output. The same is with the constructor and destructor. When you leave it to the compiler to define operator =, it defines it as … Read more
if(object instanceof WhereStatement) { WhereStatement where = (WhereStatement) object; doSomething(where); } Note that code like this usually means that your base class is missing a polymorphic method. i.e. doSomething() should be a method of Statement, possibly abstract, that is overridden by sub-classes.
If you want to selectively hide functions from B it does not make much sense to use public inheritance in the first place. Use private inheritance & selectively bring methods from B into the scope of A: struct B{ void method1(){}; void method2(){}; }; struct A : private B{ using B::method1; }; A a; a.method1(); … Read more
It’s often used to realize static polymorphism. Use cases are: Policy-based design Curiously recurring template pattern Barton–Nackman trick In general you have the benefits from dynamic polymorphism, without the extra runtime costs of virtual functions. But it’s only useful if the concrete type can be determined at compile time.
The standard containers do not have virtual destructors, thus you cannot handle them polymorphically. If you will not, and everyone who uses your code doesn’t, it’s not “wrong”, per se. However, you are better off using composition anyway, for clarity.
Yes it is possible if the annotation has @Inherited added to it. For example, the @Transactional annotation has @Inherited. From the docs: Indicates that an annotation type is automatically inherited. If an Inherited meta-annotation is present on an annotation type declaration, and the user queries the annotation type on a class declaration, and the class … Read more
You have to understand the mechanics behind Typescript and the spying. First on Typescript … I’m ignoring the extra parens in class Parent(). Typescript uses prototypal inheritance behind the curtain. Thus a prototype will copy the referenced properties from the “base class” to the new class. This is what the for loop does in the … Read more
You can map your discriminator as a read-only property: public class ApplicationProcess { … @Column(name = “apType”, insertable = false, updatable = false) private String apType; }
Another option could be to use an implicit operator. Example: class Foo { readonly string _value; public Foo(string value) { this._value = value; } public static implicit operator string(Foo d) { return d._value; } public static implicit operator Foo(string d) { return new Foo(d); } } The Foo class acts like a string. class Example … Read more
You’d need to extract the type of obj with the type() function: isinstance(obj2, type(obj1)) Note that the second argument is the class, the first is the instance to test. type() is returning the actual class object here, not any separate object. issubclass() works just fine for your usecase: issubclass(type(obj2), Item) Demo: >>> class Item: … … Read more