On Friday, 16 August 2013 at 15:47:21 UTC, Joseph Rushton
Wakeling wrote:
On 08/16/2013 05:40 PM, JS wrote:
Can you describe how this helps?
Sure, if you use A the compiler should be able to optimize
method calls but you
can't use A in inheritance because it is a final class. e.g.,
The point is, you should be able to use _A for inheritance, A
for performance,
and they both have the same functionality.
Or am I mistaken?
You can't get them both at the same time though, which you might
just make _A final.
The whole point of inheritance is to treat derived classes as if
they were base classes.
e.g., code was designed to use class _A, you come along, extend
_A to A, but "trick" to the code to use your A(even though it
thinks it's an _A).
Now, when you use your final class A where _A's are suppose to
be, there can be no optimization made by the compiler(unless it
can determine the object really is an A).
e.g.,
class _A { void foo() { writeln(); } }
final class A : _A { }
...
_A a = new A;
...
a.foo(); // can't be inlined because a's type is not CT final.
A aa = new A;
...
aa.foo(); // can be inlined because aa's type is final(no need
for vtable)
The only difference is that a is _A and aa is A.
So when you use your final class with inheritance, it becomes
useless because it gets treated as the base class, which is not
final.
When one does
_A a = new A;
a is of type _A regardless of what we actually stick in a as far
as what the compiler see's(unless it's real smart but then, final
is not needed).
A final class is simply to stop someone from deriving from it.
The compiler can make optimizations based on this info IF it
knows that the object is from a final type.
Here is a more real world example
class Shape { }
final class fShape : Shape { }
class Rectangle : Shape { }
final class fRectangle : Rectangle { }
Shape s = new fRectangle; // useless, just use Rectangle, the
compiler will probably never know s is an fRectangle. (it might
in some cases but probably not worth it)
That is the oop way, this is not:
fShape s = new fRectangle; // invalid, fRectangle is not derived
from fShape.
// compiler knows s is a final class and can make optimizations
on it.
Because we can't assign concrete shapes to fShape(because they
have to derive from them, but can't because the class is final),
it becomes useless to use(no way to do oop).
To do oop you have to have derivation from base classes, but
final stops that. Hence your two goals(being able to use oop and
being able not to(using final) are mutually exclusive).
The only way it can be useful is if the compiler can determine if
an object is final at compile time... but if it can do this then
it doesn't need to be final in the first place(it will still be
able to inline methods).
