Let’s use the following classes for demonstration: class A(object): def m(self): print(‘m’) class B(A): pass Unbound super object doesn’t dispatch attribute access to class, you have to use descriptor protocol: >>> super(B).m Traceback (most recent call last): File “<stdin>”, line 1, in <module> AttributeError: ‘super’ object has no attribute ‘m’ >>> super(B).__get__(B(), B) <super: <class … Read more
This is not possible, since everything you define in a class becomes a valid member only in an instance of that class, unless you define a method with @staticmethod, but there is no such property for a class. So, this won’t work either: class Foo(object): x = 10 class A(object): pass class B(object): other = … Read more
Well, first of all, I’ll remind everyone that the design of the solution to implement polymorphism is an ABI decision outside of the Standard. For example, MSVC and the Itanium ABI (followed by gcc, clang, icc, …) have different ways to implement this. With that out of the way, I think that this is an … Read more
As others have noted, it is certainly possible to implement this in C. Not only is it possible, it is a fairly common mechanism. The most commonly used example is probably the file descriptor interface in UNIX. A read() call on a file descriptor will dispatch to a read function specific to the device or … Read more
My guess is that it’s allowed because explicitly disallowing it would add another requirement to Java’s identifier naming rules for very little benefit. Unlike, say, C++, Java always requires that constructors are called with the new keyword, so there’s never any ambiguity about whether an identifier refers to a method or a constructor. I do … Read more
Encapsulation helps in isolating implementation details from the behavior exposed to clients of a class (other classes/functions that are using this class), and gives you more control over coupling in your code. Consider this example, similar to the one in Robert Martin’s book Clean Code: public class Car { //… public float GetFuelPercentage() { /* … Read more
For reference types, == checks whether the references are equal, i.e. whether they point to the same object. For primitive types, == checks whether the values are equal. java.lang.Integer is a reference type. int is a primitive type. Edit: If one operand is of primitive type, and the other of a reference type that unboxes … Read more
The core idea behind building a fluent interface is one of readability – someone reading the code should be able to understand what is being achieved without having to dig into the implementation to clarify details. In modern OO languages such as C#, VB.NET and Java, method chaining is one way that this is achieved, … Read more
One of the best ways would be using the enum polymorphism technique: public class EnumTest { public enum Foo { A { @Override public Bar getBar() { return Bar.Alpha; } }, B { @Override public Bar getBar() { return Bar.Delta; } }, C { @Override public Bar getBar() { return Bar.Alpha; } }, ; public … Read more
Property Set is for objects (e.g., class instances) Property Let is for “normal” datatypes (e.g., string, boolean, long, etc.)