What is a final class in php?

The final keyword prevents child classes from overriding a method or constant by prefixing the definition with final. If the class itself is being defined final then it cannot be extended.

Example #1 Final methods example

class BaseClass {
   public function test() {
       echo "BaseClass::test() called\n";
   }

      final public function

Example #2 Final class example

final class BaseClass {
   public function test() {
       echo "BaseClass::test() called\n";
   }// As the class is already final, the final keyword is redundant
   final public function moreTesting() {
       echo "BaseClass::moreTesting() called\n";
   }
}

class

Example #3 Final constants example as of PHP 8.1.0

class Foo
{
    final public const X = "foo";
}

class

Note: Properties cannot be declared final: only classes, methods, and constants (as of PHP 8.1.0) may be declared as final. As of PHP 8.0.0, private methods may not be declared final except for the constructor.

penartur at yandex dot ru ¶

15 years ago

Note that you cannot ovverride final methods even if they are defined as private in parent class.
Thus, the following example:
class parentClass {
    final private function someMethod() { }
}
class childClass extends parentClass {
    private function someMethod() { }
}
?>
dies with error "Fatal error: Cannot override final method parentClass::someMethod() in ***.php on line 7"

Such behaviour looks slight unexpected because in child class we cannot know, which private methods exists in a parent class and vice versa.

So, remember that if you defined a private final method, you cannot place method with the same name in child class.

someone dot else at elsewhere dot net ¶

8 years ago

@thomas at somewhere dot com

The 'final' keyword is extremely useful.  Inheritance is also useful, but can be abused and becomes problematic in large applications.  If you ever come across a finalized class or method that you wish to extend, write a decorator instead.

final class Foo
{
    public method doFoo()
    {
        // do something useful and return a result
    }
}

final class

mattsch at gmail dot com ¶

8 years ago

You can use final methods to replace class constants.  The reason for this is you cannot unit test a class constant used in another class in isolation because you cannot mock a constant.   Final methods allow you to have the same functionality as a constant while keeping your code loosely coupled.

Tight coupling example (bad to use constants):

interface FooInterface
{
}

class

cottton at i-stats dot net ¶

8 years ago

imo good to know:
class BaseClass
{
    protected static $var = 'i belong to BaseClass';

    public static function

santoshjoshi2003 at yahoo dot co dot in ¶

13 years ago

The use of final keyword is just like that occurs in Java
In java final has three uses
    1) prevent class Inheritance
    2) prevent method overriding or redifination of
        method in subclass
    3) and to declare constants
But the third point seems to be missing from the PHP
I guess, as i am a java developer Currently gaining competence in PHP

Anonymous ¶

11 years ago

The behaviour of FINAL is not as serious as you may think. A little explample:
class A {
     final private function method(){}    
}

class

Baldurien ¶

12 years ago

"Note for Java developers: the 'final' keyword is not used for class constants in PHP. We use the keyword 'const'."

http://php.net/manual/en/language.oop5.constants.php

This is more or less true, regardless of the fact that constant (being defined at class level or not) in PHP are only scalar (int, string, etc) while in Java they may be pure object (ex: java.awat.Color.BLACK). The only possible solution of having such kind of constant is :

class Bar {...}
class Foo {
  public static $FOOBAR;

  static function

slorenzo at clug dot org dot ve ¶

14 years ago

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
?>

t at bestcodepractise dot com ¶

8 years ago

@someone
@thomas
Decorating a finalized class is not possible. The decorator that's mentioned is incomplete. There's a fundamental flaw in it. Look:
//copy'n'paste your FooBar, Foo definition$f = new Foo;
$fd = new FooDecorator($f);var_dump($fd instanceof $f);  //FALSE
var_dump(is_a($fd, 'Foo')); //FALSE
fooFoo($fd);  //E_RECOVERABLE_ERROR here !!!;?>
What you've created is just an object that happens to have the same methods(a duck type). But if in the client code someone makes decision based on the type of your passed decorator they'll make incorrect decision - or to be more precise not the one that you, the author of the 'decorator' wants them to make.
FYI that's the correct implementation based on GoF:
class Foo
{
    public method doFoo()
    {
        // do something useful and return a result
    }
}//decorator must inherit the interface(the methods, type info etc.) //of the decorated class by *extending* it.
class FooDecorator extends Foo
{
    private $foo;

       public function

xavier dot inghels at gmail dot com ¶

7 years ago

Final is not really about overriding or overloading a method.
PHP doesn't support (yet ?) method ovverriding.

The final keyword however prevent you to redefine a method already previously declared.

suisuiruyi at gmail dot com ¶

6 years ago

Note: Properties cannot be declared final, only classes and methods may be declared as final.
you can use trait:
trait PropertiesTrait {
    public $same = true;
    public $different = false;
}

class

John smith ¶

5 years ago

Right way:
final protected function example() {
}

Wrong way:

protected final function example() {
}

Source: Practices