PHP class variables and members, and issues to be aware of during inheritance, access, and rewriting

PHP class variables and members, and issues to be aware of during inheritance, access, and rewriting

Class Myclass { Public $ prop = 123; } $ Obj = new Myclass (); ?> The member attributes of a class (the attribute name is relative to the "method") include class constants and class variables. class constants cannot be empty during definition, if a class attribute is assigned a value during definition, it can only use scalar and array, and cannot be an expression. because the class attribute is initialized during compilation, PHP does not execute expressions during compilation. 1. access control for members:Public: it can be inherited and can be accessed outside the class's methods, such as $ obj-> prop; protected: it can be inherited. private cannot be accessed outside the class's methods: it cannot be inherited or accessed outside the class's methods. PHP 4 uses var to declare the attributes of the class, which is no longer used after PHP5. it is warned before PHP5.3, and PHP5.3 can be used before public or separately as the public alias. These three access control keywords can also be used to modify constructors. when private and protected modifier class constructors, you can only call constructors through a publice static method to instantiate objects, this is because the function cannot be accessed outside the class. for example, the implementation of a 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 be cloned '); Return self: getInstance (); } } // New Singleton (); // Error $ In = Singleton: getInstance (); ?> 2. Inheritance prohibited: Final keyword, used only for modifying methods of classes or classes If a class is modified by final, this class cannot be inherited. if a method is modified by final, this method cannot be overwritten ). Class Myclass { Public $ prop = 123; Final public static function methodA () {// public static method that cannot be inherited Return 'This is a final method '; } } ?> 3. abstract classes and abstract methods: Abstract is only used for classes and methods. abstract classes cannot be directly used to instantiate objects and can only be used to generate subclasses. Abstract class Myclass { Public $ prop = 123; Abstract public function methodA (); // The abstract method does not implement the function body. } ?> 4. class constants and their access: The class constant cannot use the access restriction modifier. it is public, can be inherited, can be overwritten by the quilt class, and the constant of the category class must use double colons ::, you can use an instance of the class name or class to access the instance. 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 (); ?> A constant of a class is a value. During code compilation, the constant name is replaced with the corresponding value and cannot be modified at runtime. Therefore, the constant of a class is related to the class itself, the object already exists before it is instantiated, so the 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 inherits from the parent class and replaces it with the self: m value during compilation. Note that the self :: m Echo $ s-& gt; getPConst (); // 100 ?> 5. static member and access of the class Static can be used to modify the attributes and methods of a class. the static modified member belongs to the class but does not belong to the class instance. the static member must use the class name and double colon: for access, because the static state member exists before the object is instantiated, in the static method, the pseudo variable $ this pointing to the instance itself is prohibited (or commonly referred to as the $ this pointer ), you can use the keyword self to replace the CLASS name (equivalent to the magic constant _ CLASS _ of the CLASS __). Static cannot be used to modify the constructor of a class, nor to modify the methods declared by an interface. Class Myclass { Public static $ x = 99; Public function getX (){ Return self: $ x; } } Echo Myclass: x; // 99 ?> Static members can be inherited and overwritten by modifying the access control keyword. Note that if a subclass inherits the static method of the parent class (this method is not overwritten ), the subclass actually calls the static method of the parent class. Because the static member owner is a class not an object, multiple instances of the class share the same static property. modifying the static property in one instance affects the static property in another instance: Class { Public static $ a1 = 11; Public $ a2 = 22; Public static function showStatic (){ Return self: $ a1; } Public function getStatic (){ Return self: $ a1; } Public function getClassStatic (){ $ ClassName = get_called_class (); Return $ className: $ a1; } Public function getProp (){ Return $ this-> a2; } } Class B extends { Public static $ a1 = 88; Public $ a2 = 99; } $ Obj1 = new (); $ Obj2 = new B (); Echo A: showStatic (); // 11 Echo $ obj1-> getStatic (); // 11 Echo $ obj1-> getClassStatic (); // 11 Echo $ obj1-> getProp (); // 22 Echo B: showStatic (); // 11 calls the method of the parent class and accesses the static member of the parent class. Echo $ obj2-> getStatic (); // 11 calls the method of the parent class, and the self in the method points to the class holding the static method. Echo $ obj2-> getClassStatic (); // 88 Echo $ obj2-> getProp (); // 99 ?> Static binding in the later stage: to prevent the subclass from overwriting static attributes, the inherited method still accesses the static attributes of the parent class, PHP5.3 adds a new syntax: static binding in the later stage, use the static keyword to replace the self keyword so that static points to the same class returned by get_called_class (), that is, the class of the object that currently calls the static method, this keyword is also valid for access to static methods. Public function getClassStatic (){ $ ClassName = get_called_class (); Return $ className: $ a1; } // It can be written as follows: Public function getClassStatic (){ Return static: $ a1; } // Used for static methods // In Class: Public static function testStatic (){ Echo" TestStatic of "; } Public function callStatic (){ Static: testStatic (); } // Class B: Public static function testStatic (){ Echo" TestStatic of B "; } // Class B inherits the callStatic method of Class A and can correctly access the testStatic method of each class. ?> 6. Several keywords pointing to a class or instance in the class method$ This-> propName $ this points to the instance parent: xxx parent of the class pointing to the parent class. you can access the static constants and static attributes (parent: $ xxx) of the parent class ), you cannot access non-static attributes of the parent class. you can call the 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 static members and the constant static: xxx accesses the class that instantiates the instance that calls the current method, used to access static members and tired constants. The difference between them and self is that static members are accessed using "Static binding later ". 7. rewriting in class inheritance:The access control degree of the rewritten members cannot be reduced. for example, a public member cannot be rewritten to a protected non-static member, or a static member cannot be rewritten to a non-static member. 8. the method defined in the interface must be public.Class when implementing interface methods, these methods must also be public, specific implementation (cannot be abstract ). An interface can also define an interface constant. its usage is exactly the same as that of a class constant, but the interface cannot define non-function members. Interfaces can be inherited from each other. interfaces can be inherited from each other by commas (,). a class can implement multiple interfaces, separated by commas Interface Ix extends Iy, Iz { Public function (); } Class A implements Iy, Iz { ....... } ?> 9. type constraints PHP functions (or class methods) can set the parameter type in the declaration time limit, but can only be limited to array or object (class/interface). if it is limited to string type, PHP considers it to be a string-type object parameter. If the type is limited to an interface, the input parameter must be an instance of the class that implements the interface. When the interface implementation and subclass override the parent class method, the specified parameter type cannot be modified. When calling a method or function, if data of different parameter types is input, an error is returned, but the null parameter is acceptable. Interface Im { Public function a (classm $ m ); } Class A implements Im { Public function a ($ x) {// error. the parameter $ x must be set to the classm type to define the matching interface. Var_dump ($ x ); } } ?>