Detailed explanation of the principles and usage of abstract, final and static in PHP

The examples in this article describe the principles and usage of abstract, final and static in PHP. Share it with everyone for your reference, the details are as follows:

abstract(abstract)

PHP 5 supports abstract classes and abstract methods. Classes defined as abstract cannot be instantiated. Any class must be declared abstract if at least one method in it is declared abstract. A method defined as abstract only declares its calling method (parameters), and cannot define its specific function implementation.

When inheriting an abstract class, the subclass must define all abstract methods in the parent class; In addition,The access control of these methods must be the same as that in the parent class (or more relaxed). For example, if an abstract method is declared as protected, then the method implemented in the subclass should be declared as protected or public (strictness: private>protected>public), but cannot be defined as private. In addition, the calling method of the method must match, that is, the type and number of required parameters must be consistent. For example, if a subclass defines an optional parameter that is not included in the declaration of an abstract method of the parent class, there is no conflict between the two declarations. This also applies to constructors since PHP 5.4. Constructor declarations before PHP 5.4 could be different.

Related learning recommendations: PHP programming from entry to proficiency

Summary:

• Abstract classes cannot be instantiated;

• If there are any abstract methods in the class, this class must also be abstract;

• Abstract classes only Can declare the calling method and parameters, but cannot define specific function implementation;

• Subclasses that inherit an abstract class must implement all abstract methods of the abstract class;

• The access control of abstract methods implemented in the subclass must be stricter than the access control of the parent class;

• The calling method and number of parameters of the method implemented in the subclass must be the same as those implemented method is consistent.

Example:

getValue() . "\n";
  }
}

class ConcreteClass1 extends AbstractClass
{
  protected function getValue() {
    return "ConcreteClass1";
  }

  public function prefixValue($prefix) {
    return "{$prefix}ConcreteClass1";
  }
}

class ConcreteClass2 extends AbstractClass
{
 //访问方式可以更宽松
  public function getValue() {
    return "ConcreteClass2";
  }

  public function prefixValue($prefix) {
    return "{$prefix}ConcreteClass2";
  }
}

$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') ."\n";

$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') ."\n";
?>

prefixName("Pacman"), "\n";
echo $class->prefixName("Pacwoman"), "\n";
?>

final

If a method in the parent class is declared final, the subclass cannot override the method. If a class is declared final, it cannot be inherited.

This is easier to understand and I won’t go into details

static

Declaring a class attribute or method as static allows direct access without instantiating the class. Static properties cannot be accessed through an object of a class that has been instantiated (but static methods can).

In order to be compatible with PHP 4, if no access control is specified, properties and methods default to public.

Since static methods do not require an object to be called, the pseudo variable $this is not available in static methods.

Static properties cannot be accessed by objects through the -> operator.

Calling a non-static method statically will result in a E_STRICT level error.

Like all other PHP static variables, static properties can only be initialized to literals or constants, not expressions. So a static property can be initialized to an integer or an array, but it cannot be initialized to another variable or function return value, nor can it point to an object.

Since PHP 5.3.0, you can use a variable to dynamically call a class. But the value of this variable cannot be the keywords self, parent or static.

Summary:

• Static methods do not need to be instantiated and can be accessed directly;

• Objects instantiated by a class cannot access the class Static properties in static methods, but can access static methods;

• Pseudo variables$this are not available in static methods;

• Static properties cannot be accessed by the object through the -> operator;

• Calling a non-static method statically will result in an E_STRICT level error ;

• Static properties can only be initialized to literals or constants, expressions (function return values/rather than a variable/object) cannot be used;

• You can use a variable to dynamically call the class. But the value of this variable cannot be the keywords self, parent or static.

staticValue() . "\n";
print $foo->my_static . "\n";   // Undefined "Property" my_static 

print $foo::$my_static . "\n";
$classname = 'Foo';
print $classname::$my_static . "\n"; // As of PHP 5.3.0

print Bar::$my_static . "\n";
$bar = new Bar();
print $bar->fooStatic() . "\n";
?>
  
 

 
  
  

The above is the detailed content of Detailed explanation of the principles and usage of abstract, final and static in PHP. For more information, please follow other related articles on the PHP Chinese website!