PHP: Ключевое слово final

Ключевое слово final

Ключевое слово final, которое указали перед определением метода, свойства или константы, не разрешает дочерним классам переопределять метод, свойство или константу. Ключевое слово не разрешит расширить класс, если класс определили окончательным.

Пример #1 Пример окончательных методов

<?php

class BaseClass
{
   public function test()
   {
       echo "Вызван метод BaseClass::test()\n";
   }

   final public function moreTesting()
   {
       echo "Вызван метод BaseClass::moreTesting()\n";
   }
}

class ChildClass extends BaseClass
{
   public function moreTesting()
   {
       echo "Вызван метод ChildClass::moreTesting()\n";
   }
}
// Переопределение финального метода вызовет ошибку Fatal error: Cannot override final method BaseClass::moreTesting()

?>

Пример #2 Пример окончательного класса

<?php

final class BaseClass
{
    public function test()
    {
        echo "Вызвали метод BaseClass::test()\n";
    }

    // Поскольку класс уже окончательный, ключевое слово final избыточно
    final public function moreTesting()
    {
        echo "Вызвали метод BaseClass::moreTesting()\n";
    }
}

class ChildClass extends BaseClass {}
// Наследование финального класса вызовет ошибку Fatal error: Class ChildClass may not inherit from final class (BaseClass)

?>

Пример #3 Пример финального свойства, которые появились с PHP 8.4.0

<?php

class BaseClass
{
   final protected string $test;
}

class ChildClass extends BaseClass
{
    public string $test;
}

// Переопределение финального свойства вызовет ошибку Fatal error: Cannot override final property BaseClass::$test

?>

Пример #4 Пример финальной константы, которые появились с PHP 8.1.0

<?php

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

class Bar extends Foo
{
    public const X = "bar";
}

// Переопределение финальной константы вызовет ошибку Fatal error: Bar::X cannot override final constant Foo::X

?>

Замечание: С PHP 8.0.0 закрытые методы, за исключением конструкторов , нельзя объявлять финальными.

Замечание: Свойства, которые объявили c закрытой видимостью области установки значения private(set), неявно получают ключевое слово final.

Нашли ошибку?

Инструкция • Исправление • Сообщение об ошибке

＋Добавить

Примечания пользователей 11 notes

down

304

jriddy at gmail dot com ¶

15 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

down

106

penartur at yandex dot ru ¶

17 years ago

Note that you cannot ovverride final methods even if they are defined as private in parent class.

Thus, the following example:

<?php

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.

down

Rumour ¶

1 year ago

Class constants CAN be “finalised” since PHP8.1. To partly contradict to the most popular user contribution, that was written a long time ago, they were still absolutely right.

down

someone dot else at elsewhere dot net ¶

10 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.

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

final class FooDecorator
{
    private $foo;
    
    public function __construct(Foo $foo)
    {
        $this->foo = $foo;
    }
    
    public function doFoo()
    {
          $result = $this->foo->doFoo();
          // ... customize result ...
          return $result;
    }
}
?>

down

slorenzo at clug dot org dot ve ¶

17 years ago

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

down

mattsch at gmail dot com ¶

10 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):

<?php
interface FooInterface
{
}

class Foo implements FooInterface
{
    const BAR = 1;

    public function __construct()
    {
    }
}

interface BazInterface
{
    public function getFooBar();
}

// This class cannot be unit tested in isolation because the actual class Foo must also be loaded to get the value of Foo::BAR
class Baz implements BazInterface
{
    private $foo;

    public function __construct(FooInterface $foo)
    {
        $this->foo = $foo;
    }

    public function getFooBar()
    {
        return Foo::BAR;
    }

}

$foo = new Foo();
$baz = new Baz($foo);
$bar = $baz->getFooBar();
?>

Loose coupling example (eliminated constant usage):

<?php
interface FooInterface
{
    public function bar();
}

class Foo implements FooInterface
{
    public function __construct()
    {
    }

    final public function bar()
    {
        return 1;
    }
}

interface BazInterface
{
    public function getFooBar();
}

// This class can be unit tested in isolation because class Foo does not need to be loaded by mocking FooInterface and calling the final bar method.
class Baz implements BazInterface
{
    private $foo;

    public function __construct(FooInterface $foo)
    {
        $this->foo = $foo;
    }

    public function getFooBar()
    {
        return $this->foo->bar();
    }

}

$foo = new Foo();
$baz = new Baz($foo);
$bar = $baz->getFooBar();
?>

down

cottton at i-stats dot net ¶

10 years ago

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

    public static function test()
    {
        echo '<hr>'.
            'i am `'.__METHOD__.'()` and this is my var: `'.self::$var.'`<br>';
    }
    public static function changeVar($val)
    {
        self::$var = $val;
        echo '<hr>'.
            'i am `'.__METHOD__.'()` and i just changed my $var to: `'.self::$var.'`<br>';
    }
    final public static function dontCopyMe($val)
    {
        self::$var = $val;
        echo '<hr>'.
            'i am `'.__METHOD__.'()` and i just changed my $var to: `'.self::$var.'`<br>';
    }
}

class ChildClass extends BaseClass
{
    protected static $var = 'i belong to ChildClass';

    public static function test()
    {
        echo '<hr>'.
            'i am `'.__METHOD__.'()` and this is my var: `'.self::$var.'`<br>'.
            'and this is my parent var: `'.parent::$var.'`';
    }
    public static function changeVar($val)
    {
        self::$var = $val;
        echo '<hr>'.
            'i am `'.__METHOD__.'()` and i just changed my $var to: `'.self::$var.'`<br>'.
            'but the parent $var is still: `'.parent::$var.'`';
    }
    public static function dontCopyMe($val) // Fatal error: Cannot override final method BaseClass::dontCopyMe() in ...
    {
        self::$var = $val;
        echo '<hr>'.
            'i am `'.__METHOD__.'()` and i just changed my $var to: `'.self::$var.'`<br>';
    }
}

BaseClass::test();  // i am `BaseClass::test()` and this is my var: `i belong to BaseClass`
ChildClass::test(); // i am `ChildClass::test()` and this is my var: `i belong to ChildClass`
                    // and this is my parent var: `i belong to BaseClass`
ChildClass::changeVar('something new'); // i am `ChildClass::changeVar()` and i just changed my $var to: `something new`
                                        // but the parent $var is still: `i belong to BaseClass`
BaseClass::changeVar('something different'); // i am `BaseClass::changeVar()` and i just changed my $var to: `something different`
BaseClass::dontCopyMe('a text'); // i am `BaseClass::dontCopyMe()` and i just changed my $var to: `a text`
ChildClass::dontCopyMe('a text'); // Fatal error: Cannot override final method BaseClass::dontCopyMe() in ...
?>

down

santoshjoshi2003 at yahoo dot co dot in ¶

16 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

down

Anonymous ¶

14 years ago

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

class B extends A {
    private function method(){}
}
?>

Normally you would expect some of the following will happen:
- An error that final and private keyword cannot be used together
- No error as the private visibility says, that a method/var/etc. is only visible within the same class

But what happens is PHP is a little curios: "Cannot override final method A::method()"

So its possible to deny method names in subclasses! Don't know if this is  a good behavior, but maybe its useful for your purpose.

down

Anonymous ¶

4 months ago

When desiring a special class structure finalizing magic methods maybe helpful.

<?php

abstract class A { 
  final public function __construnct(){ echo "A"; } 
}

class B extends A {
  public function __construct(){ echo "B"; }
}

$b = new B(); // outputs: PHP Fatal error:  Cannot override final method a\A::__construct()

?>

down

Baldurien ¶

14 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 :

<?php
class Bar {...}
class Foo {
  public static $FOOBAR;

  static function __init() {
    static $init = false;
    if ($init) throw new Exception('Constants were already initialized');
    self::$FOOBAR = new Bar();
    $init = true;
  }
}
Foo::__init();
?>
That said, perhaps it is useless unless PHP automatically calls the __init() method.

However, one alternative that could be done in certain case is this : 

<?php
function __autoload($className) { 
  ... require the file where the class is ...
  if (interface_exists($className, false)) return;
  if (class_exists($className, false)) {
    $rc = new ReflectionClass($className); 
    if (!$rc->hasMethod('__init')) return;
    $m = $rc->getMethod('__init');
    if (!($m->isStatic() && $m->isPrivate())) {
      throw new Exception($className . ' __init() method must be private and static !');
    }
    $m->invoke(null);
    return;
  }
  throw new Exception('Class or interface not found ' . $className);
}
?>

This can only work when one class is defined per file, since we are assured that __autoload() will be called to load the file containing the class.

eg: 

test2.php:
<?php
class B {
 public static $X;
 private static function __init() {
   echo 'B', "\n"; 
   self::$X = array(1, 2);
 }
}
class A {
  public static $Y;
  private static function __init() {
    echo 'A', "\n"; 
    self::$Y = array(3, 4);
  }
}
?>
test.php:
<?php
function __autoload($n) {
  if ($n == 'A' || $n == 'B') require 'test2.php';
  ... do our __init() trick ...
}
var_dump(B::$X); // shows B, then array(2) (1, 2)
var_dump(A::$Y); // shows NULL.
?>

＋Добавить