final method -> object oriented programming

[johnnnn]

Recently I've been looking into object oriented programming (OOP) and I've picked up on it rather fast. The only thing that I'm confused on is, the final method. By "override", does that mean, for example if function doWrite() exists in class myClass it can not be "replace with" function doWrite() in mySecondClass? What exacty does "override" mean, rather stupid question, sorry.

[funnymoney]

nice example by slorenzo comment on php.net

PHP Code:

<?php
class parentClass {
    public function someMethod() { }
}
class childClass extends parentClass {
    public final function someMethod() { } //override parent function
}

$class = new childClass;
$class->someMethod(); //call the override function in chield class
?>

Well, now when i look at it, it's not so nice at all, should be.

When i look at it a bit, it looks like class naming restriction rather than anything else

[Fou-Lu]

Override exists to allow runtime binding of methods based on the object in use. This is tougher to see easily in PHP since its datatype weak, so we'll use an example with typehinting a function with an interface:

PHP Code:

interface IMyInterface
{
    public function myMethod();
}

class Parent implements IMyInterface
{
    // Parent is typeof IMyInterface
    public function myMethod()
    {
        print __METHOD__;
    }
}

class Child extends Parent
{
    // Child is typeof Parent making it implicitly typeof IMyInterface
    public function myMethod()
    {
        print __METHOD__;
    }
}

function execMyMethod(IMyInterface $imiObj)
{
    $imiObj->myMethod();
}

$p = new Parent();
$c = new Child();

execMyMethod($p); // Prints Parent::myMethod
execMyMethod($c); // Prints Child::myMethod 


What this does is allows any child of Parent to dynamically override via erasure the myMethod to replace the desired functionality of Child into Parent. The execMyMethod would also work with a typeof Parent.

Final simply indicates last in chain allowed, and cannot be overridden from that point on. Can be applied from either a class or method level, including static methods:

PHP Code:

class Parent
{
    public function myMethod(){}
}
class Child extends Parent
{
    public final function myMethod(){}
}
class Child2 extends Child
{
    public function myMethod(){} // Fatal error, cannot override final method declared in Child
}

final class Child3 extends Parent
{
}
class Child4 extends Child3 // Fatal error, cannot override final class Chiild3
{
} 


Does that make sense?

[johnnnn]

Thanks

I thanked both of you, and I have a better understanding now.