Advanced learning of PHP object-oriented_PHP tutorial

Learning content: abstract classes, interfaces, final, class constants

1. Abstract
In our actual development process, some classes do not need to be instantiated. For example, some parent classes learned earlier are mainly inherited by subclasses, which can improve code reusability
Grammar structure:
abstract class class name {
Attribute $name;
Method(){} //Method can also be abstract modifier function method name(){}
}
Example:
abstract class animal{
         public $name;
        public $age;
​​​​ //Abstract methods cannot have method bodies, mainly for subclasses to implement;
         abstract public function cry();
//Abstract classes can contain abstract methods and instance class methods
          public function getname(){
echo $this->name;
}
}
class Cat{
        public function cry(){
echo 'ok';
}
}

Understanding: Animal class is actually an abstract concept, which stipulates some common attributes and behaviors of some animals, but in fact it does not have those attributes and behaviors itself. Another example: transportation, plants, etc.

Note:
1. If a class is modified with abstract, then the class is an abstract class. If a method is modified with abstract, then the method is an abstract method. An abstract method cannot have a method body => abstract function cry(); Connect {} cannot have
either 2. Abstract classes must not be instantiated. Abstract classes do not need abstract methods, but if a class contains any abstract method, the class must be declared as an abstract class;
3. If a class inherits another abstract class, the subclass must implement all abstract methods in the abstract class (unless it itself is also declared as an abstract class);

2. Interface
The interface is to encapsulate some unimplemented methods together. When a certain class needs to use them, these methods can be written out according to the specific situation;
Grammatical structure
               interface interface name {
//Properties, methods
                             //Methods in the interface cannot have a method body;
            }
How to implement the interface
class class name implements interface name {

            }
Understanding: An interface is a more abstract abstract class. Methods in abstract classes can have method bodies, but methods in interfaces must not have method bodies. The interface realizes the polymorphism of programming and the design ideas of high cohesion and low coupling;

Example:
​​​​ //Interfaces define specifications and attributes, usually starting with a lowercase i;
interface iUsb{
              public function start();
              public function stop();
}
​​​​ //Write the camera class and let it implement the interface
​​​​ //When a class implements an interface, then the class must implement all methods of the interface
class Camera implements iUsb{
              public function start(){
echo 'Camera Start Work';
            }
              public function stop(){
echo 'Camera Stop Work';
            }
}
//Write a mobile phone class www.2cto.com
class Phone implements iUsb{
              public function start(){
echo 'Phone Satrt Work';
            }
              public function stop(){
echo 'Phone Stop Work';
            }
}
          $c=new Camera();
           $c->start();
           $p=new Phone();
           $p->start();

When to use interface:
​ ​ 1. Set specifications and let other programmers implement them
​ ​ 2. When multiple classes of the same level need to implement a certain function, but the implementation methods are different;

Summary:
​ ​ 1. The interface cannot be instantiated, and all methods in the interface cannot have a body;
​​​​ 2. A class can implement multiple interfaces, separated by commas (,) class demo implements if1,if2,if3{}
3. There can be attributes in the interface, but they must be constants. Constants cannot have modifiers (the default is public modifier) ​​
For example: interface iUsb{
                           const A=90;
                 }
echo iUsb::A;
​ ​ 4. All methods in the interface must be public, and the default is public;
​ ​ 5. An interface cannot inherit other classes, but it can inherit other interfaces. An interface can inherit multiple other interfaces
For example: interface interface name extends if1,if2{}
​ ​ 6. A class can inherit other interfaces while inheriting the parent class
For example: class test extends testbase implements test1,test2{}

Implementing interfaces VS inherited classes
The inheritance of PHP is single inheritance, that is, a class can only inherit one parent class, which has a certain impact on the expansion of the functions of subclasses. Implementing interfaces can be seen as a supplement to inherited classes. Inheritance is a hierarchical relationship and is not very flexible, while implementing interfaces is a horizontal relationship. Implementing interfaces can extend a certain function without breaking the inheritance relationship, which is very flexible.

3. Final

1. If we want a certain class not to be inherited by other classes (for example, for security reasons, etc.), then we can consider using final
Grammar:
               final class A{}
2. If we hope that a certain method will not be overridden by subclasses, we can consider using final to modify it. The method modified by final can still be inherited, because the inheritance rights of the method depend on the public modification
For example: class A{
final public function getrate($salary){
                         return $salary*0.08;
                }
            }
class B extens A{
//The getrate method of the parent class here uses final, so getrate
cannot be overridden here. //public function getrate($salary){
// Return $ salary*0.01;
                        //}
            }
3. Final cannot be used to modify attributes

4. Class constant (const)

In some cases, there may be such a requirement: when you do not want a member variable to be modified and want the value of the variable to be fixed, you can use const constants (const names should be in all uppercase letters and without $ Symbols and constants cannot be modified)
Syntax:
​​​​ const constant name=constant value; //An initial value must be assigned because constants cannot be modified
Call:
Class name::constant name [self::constant name is available inside this class] or interface name::constant name //Only constants can be used in the interface, variables cannot be used

Such as:

class A{
const TAX_RATE=0.08;
Function paytax($salary){
          return $salary*self::TAX_RATE;
}
}
$a=new A();
echo $a->paytax(100);

Note:
1. Constants can be inherited by subclasses
2. Constants belong to a certain class, not to an object