PHP object-oriented abstract classes, interfaces, final, class constants_PHP tutorial

The article introduces a basic tutorial on abstract classes, interfaces, finals, and class constants in PHP. Friends who need to know more can refer to it. php object-oriented

1. Abstract class (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:

The code is as follows

Copy code

abstract class class name{

代码如下	复制代码
abstract class 类名{         属性 $name;         方法(){}  //方法也可以为abstract 修饰符 function 方法名(){}     }

Attribute $name;

Method(){} //Method can also be abstract modifier function method name(){}
}

代码如下	复制代码
abstract class animal{         public $name;         public $age;         //抽象方法不能有方法体，主要是为了让子类去实现;         abstract public function cry();         //抽象类中可以包含抽象方法，同时也可以包含实例类方法         public function getname(){             echo $this->name;         }     }     class Cat{         public function cry(){             echo 'ok';         }     }

Example:  

The code is as follows	Copy code
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(); {} 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
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
                                                       

The code is as follows

Copy code

interface interface name{ //Properties, methods

代码如下	复制代码
interface 接口名{                 //属性、方法                 //接口中的方法都不能有方法体；             }             如何实现接口             class 类名 implements 接口名{               }

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

The code is as follows

Copy code

//Interface defines specifications and attributes. Usually starts with a lowercase i;

代码如下

复制代码

//接口是定义规范、属性的，一般以小写的i开头；         interface iUsb{             public function start();             public function stop();         }         //编写相机类，让它去实现接口         //当一个类实现了某个接口，那么该类就必须实现接口的所有方法         class Camera implements iUsb{             public function start(){                 echo 'Camera Start Work';             }             public function stop(){                 echo 'Camera Stop Work';             }         }         //编写一个手机类         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();

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 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 inheriting 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 want a method not to 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:

The code is as follows

Copy code

class A{

代码如下	复制代码
class A{                 final public function getrate($salary){                     return $salary*0.08;                 }             }             class B extens A{                 //这里父类的getrate方法使用了final，所以这里无法再重写getrate                 //public function getrate($salary){                 //    return $salary*0.01;                 //}             }

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:

} $a=new A();

The code is as follows

代码如下	复制代码
class A{     const TAX_RATE=0.08;     function paytax($salary){         return $salary*self::TAX_RATE;     } } $a=new A(); echo $a->paytax(100);

Copy code

class A{
const TAX_RATE=0.08;
Function paytax($salary){
          return $salary*self::TAX_RATE; }

echo $a->paytax(100);

Note: 1. Constants can be inherited by subclasses 2. Constants belong to a certain class, not to an object Although the implementation is very simple, as long as you have some basic knowledge, you can quickly and easily implement PHP object-oriented editing operations.

http://www.bkjia.com/PHPjc/629158.html

www.bkjia.com

truehttp: //www.bkjia.com/PHPjc/629158.htmlTechArticleThe article introduces a basic tutorial on abstract classes, interfaces, final, and class constants in PHP, for those who need to know more You can refer to it. php object-oriented 1. Abstract class (abstract) In our implementation...