PHP class variables and members, and their inheritance, access and rewrite issues to be aware of

Class myclass{ Public $prop = 123; } $obj = new Myclass (); ?> Copy Code The member property of a class (the salutation of a property is relative to the "method") includes class constants and class variables, where class constants are not nullable when defined, the properties of a class are assigned when defined, can only use scalar and array, and cannot be an expression, because class properties are initialized at compile time, and PHP does not execute an expression at compile time. 1. Member's access control : Public: Can inherit, can be accessed outside of the method of the class, such as $obj->prop;protected: can inherit, cannot be accessed outside the method of the class private: Can not inherit, Can not be accessed outside of the method of the class PHP 4 uses Var to declare the properties of a class, is no longer used after PHP5, PHP5.3 is warned before use, and PHP5.3 can be used before public or as an alias for public. These three access control keywords can also be decorated with constructors, and when private and protected decorate the constructor of a class, you can only invoke the constructor to instantiate the object through a static method of Publice static, because it is sufficient that the function cannot be accessed outside the class, for example, Implementation of the Singleton class: Class Singleton { private static $instance =null; Public $k = 88; Private Function __construct () { } public static function getinstance () { if (self:: $instance ==null) { Self:: $instance = new self (); } Return self:: $instance; } Public Function __clone () {//pretend clone Oprationg Throw (' Singleton class can not is cloned '); return Self::getinstance (); } } New Singleton (); Error $in = Singleton::getinstance (); ?> Copy Code 2. Inheritance prohibition : final keyword, only methods for decorating classes or classes If a class is final decorated, the class cannot be inherited, and if a method is final decorated, the method cannot be overridden by a quilt class (override). Class myclass{ Public $prop = 123; Final public static function MethodA () {//non-inheritable, publicly-available method Return ' This is a final method '; } } ?> Copy Code 3. Abstract classes and abstract methods : Abstract is only used for classes and methods, which cannot be used directly for instantiating objects only to produce subclasses Abstract class myclass{ Public $prop = 123; Abstract public Function MethodA (); Abstract method does not implement function body } ?> Copy Code 4, class constants and their access : Class constants cannot use the access restriction modifier, he is public, inheritable, can be overridden by the quilt class, access to the class's constants must use double colons::, you can use the class name or instance of the class to access. Class myclass{ Public $prop = 123; const x = 999; public static function MethodA () { Return ' This is a final method '; } Public Function Getconst () { return self::x; or $this:: x; } } $instance = new Myclass (); Echo myclass::x; echo $instance:: x; echo $instance->getconst (); ?> Copy Code A constant of a class is a value that is replaced with the corresponding value during the code compile period, is not modifiable at run time, so the class's constants are related to the class itself and exist before the object is instantiated, so constants of the class can be accessed directly using the class name. Class p{ Const m = 100; Const n = self::m; } Class S extends p{ Const M=200; Public Function Getpconst () { return parent::n; } } $p = new P (); $s = new S (); echo $p:: N; 100 echo $s:: n; 200 The constant name is inherited from the parent class, replaced with the self::m value at compile time, and note that the method of distinguishing classes is used Self::m echo $s->getpconst (); 100 ?> Copy Code 5. Static members of the class and access Static can be used to modify the properties and methods of a class, a member of the static adornment belongs to a class rather than an instance of a class, and a statically member must be accessed by using the class name plus double colons::, because the static member exists before instantiating the object, so the pseudo-variable pointing to the instance itself is forbidden in the static method $this (or habitually referred to as $this pointer), you can use the keyword self instead of the class name (equivalent to the magic constant __class__ of the class). Static cannot be used to decorate the constructor of a class, nor can it be used to decorate the method of an interface declaration. Class myclass{ public static $x = 99; Public Function GetX () { Return self:: $x; } } Echo myclass::x; 99 ?> Copy Code Static members can be decorated with access control keywords, can be inherited and overridden, and it is important to note that if a subclass inherits the static method of the parent class (without overriding the method), then the subclass invocation is actually a static method of the parent class. Because static member holders are classes that are not objects, multiple instances of a class share the same static property, and modifying a static property in one instance affects the static property in another instance: Class a{ public static $a 1 = 11; Public $a 2 = 22; public static function Showstatic () { Return self:: $a 1; } Public Function getstatic () { Return self:: $a 1; } Public Function getclassstatic () { $className = Get_called_class (); Return $className:: $a 1; } Public Function Getprop () { return $this->a2; } } Class B extends a{ public static $a 1 = 88; Public $a 2 = 99; } $obj 1 = new A (); $obj 2 = new B (); Echo A::showstatic (); 11 echo $obj 1->getstatic (); 11 echo $obj 1->getclassstatic (); 11 echo $obj 1->getprop (); 22 Echo B::showstatic (); 11 calls a method of the parent class to access the static members of the parent class echo $obj 2->getstatic (); 11 calls the method of the parent class, and the self in the method points to the class that holds the static method echo $obj 2->getclassstatic (); 88 echo $obj 2->getprop (); 99 ?> Copy Code Late static binding: In order to avoid subclasses overriding static properties, using inherited methods still accesses the static properties of the parent class, PHP5.3 adds a new syntax: late static binding, replacing the Self keyword with the static keyword, so that static points to the Get_called_ Class () returns the same class that the object that is currently calling the static method belongs to, which is equally valid for access to the static method. Public Function getclassstatic () { $className = Get_called_class (); Return $className:: $a 1; } Can be written as: Public Function getclassstatic () { Return static:: $a 1; } For static methods In Class A: public static function Teststatic () { echo " Teststatic of A "; } Public Function callstatic () { Static::teststatic (); } In class B: public static function Teststatic () { echo " Teststatic of B "; } Class B inherits the Callstatic method of Class A, which can correctly access the Teststatic method of the respective class. ?> Copy Code 6. The methods of the class that point to a class or instance of the keyword $this->propname $this to an instance of the class Parent::xxx parent points to the parents class, you can access the static constant of the parent class, the static property (parent:: $xxx), You cannot access a non-static property of a parent class, you can call a method of the parent class (not the private method, whether static or not) Self::xxx self points to the class that defines the currently called method, and is used to access the constants of static members and classes STATIC::XXX Access instantiates the class that invokes the instance of the current method, used to access static members and tired constants, and the difference between him and self is that "late static binding" is used when accessing static members. 7. Overriding problem in Inheritance of class: the degree of access control of an overridden member cannot be reduced, for example, a member of public cannot be overridden as a static member of a protected non-static member, nor can a static member be overridden as a non-static member 8, the method defined in the interface must be the public class in the implementation of the interface method, these methods must also be public, concrete implementation (cannot be abstract). Interfaces can also define interface constants, which are exactly the same as class constants, but interfaces cannot define non-function members. Interfaces can inherit between interfaces, inheritance of interfaces can be multiple inheritance, separated by commas (the inheritance of the word class and the parent class is single-inheritance) a class can implement multiple interfaces, separated by commas Interface Ix extends iy,iz{ Public function A (); } Class A implements iy,iz{ ....... } ?> Copy Code 9. Type constraints PHP's functions (or methods of a class) can qualify the type of the parameter at declaration time, but only the array or object (Class/interface), and if it is qualified as a string, PHP will consider it to be an object parameter qualified as a string class. If the type is limited to an interface, the passed-in parameter must be an instance of the class that implements the interface. You cannot modify an already qualified parameter type when an interface implementation or subclass overrides a parent class method. In a method, a function call, if you pass in data that is different from a qualified parameter type, you will get an error, but you can accept the null parameter. Interface im{ Public function A (CLASSM $m); } Class A implements im{ Public function A ($x) {//error, parameter $x must be limited to CLASSM type to match the definition of the interface Var_dump ($x); } } ?> Copy Code

