PHP 面向对象，构造函数，析构函数，继承，方法的重写，接口抽象类，static，final，this，parent，self的异同和作用
- PHP 面向对象
- 1.构造函数
- 2.析构函数
- 3.继承
- 4.方法重写
- 5.访问控制
- 6.接口
- 7.抽象类
- 8.静态static
- 9.final
- 10. this ,self ,parent
- (1) this
- (2) self
- (3) parent
PHP 面向对象
面向对象编程的三个主要特性：
- 封装（Encapsulation）：指将对象的属性和方法封装在一起，使得外部无法直接访问和修改对象的内部状态。通过使用访问控制修饰符（public、private、protected）来限制属性和方法的访问权限，从而实现封装。
- 继承（Inheritance）：指可以创建一个新的类，该类继承了父类的属性和方法，并且可以添加自己的属性和方法。通过继承，可以避免重复编写相似的代码，并且可以实现代码的重用。
- 多态（Polymorphism）：指可以使用一个父类类型的变量来引用不同子类类型的对象，从而实现对不同对象的统一操作。多态可以使得代码更加灵活，具有更好的可扩展性和可维护性。在 PHP 中，多态可以通过实现接口（interface）和使用抽象类（abstract class）来实现。
1.构造函数
构造函数(construct)是一种特殊的方法。主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，在创建对象的语句中与 new 运算符一起使用。
<?php
class Cat{
// 成员变量
public $name;
public $age;
// 构造函数
public function __construct($name, $age)
{
$this->name = $name;
$this->age = $age;
}
// 成员方法
public function details(){
echo '姓名：'.$this->name.'年龄：'.$this->age;
}
}
$animal = new Cat('小白',10);
$animal->details(); // 姓名：小白年龄：10
echo "<hr>";
注意：php不像java那样，可以提供多个构造器，只能提供一个构造器，若提供了有参构造函数，则必须在new时传入相应的初始化参数。
2.析构函数
析构函数(destructor) 与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统自动执行析构函数。
<?php
class Plane{
public function __destruct()
{
echo '析构方法,对象结束生命周期时执行或者当前php脚本执行完毕时执行';
}
}
$p = new Plane();
echo '~~~~天气晴'.'<br>';
3.继承
PHP 使用关键字 extends 来继承一个类，PHP 不支持多继承，且使用final修饰的类无法再被继承。
<?php
final class Person{
public $name = '人类';
}
// 报错，提示final修饰的类无法被继承
class Student extends Person{
}
4.方法重写
如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
<?php
class Person{
public $name = '人类';
public function showInfo(){
echo '我的名字是'.$this->name.'<br>';
}
}
class Student extends Person{
public $name = '学生';
public $cid = '小学一年级';
public function showInfo()
{
parent::showInfo();
echo '我的年级是:'.$this->cid;
}
}
$st1 = new Student();
$st1->showInfo();
// 我的名字是学生
// 我的年级是:小学一年级
$this,指向当前实例对象的内容。
parent::showInfo() 或者 parent::xxxx(),代表当前的子类调用从父类继承的方法，和Java中的super.()类似.
5.访问控制
PHP 对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的。
- public（公有）：公有的类成员可以在任何地方被访问。
- protected（受保护）：受保护的类成员则可以被其自身以及其子类和父类访问。
- private（私有）：私有的类成员则只能被其定义所在的类访问。
6.接口
使用接口（interface），可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。
接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。
接口中定义的所有方法都必须是公有，这是接口的特性。
要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。
<?php
interface ComInterface{
public function connect();
public function transfer();
public function disconnect();
}
class MobilePhone implements ComInterface{
public function connect()
{
echo '连接开始'.'<br>';
}
public function transfer()
{
echo '连接传输'.'<br>';
}
public function disconnect()
{
echo '连接关闭'.'<br>';
}
}
$phone1 = new MobilePhone();
$phone1->connect();
$phone1->transfer();
$phone1->disconnect();
//连接开始
//连接传输
//连接关闭
<?php
interface behavior{
public function say();
public function jump();
}
interface behavior2{
public function eat();
}
class Superman implements behavior,behavior2 {
public function say()
{
echo '超人说:我在执行任务'.'<br>';
}
public function jump()
{
echo '超人，嗖的一下跳了出去！'.'<br>';
}
public function eat()
{
echo '超人:我不需要吃东西'.'<br>';
}
}
class Duck implements behavior,behavior2 {
public function say()
{
echo '鸭子:嘎嘎嘎'.'<br>';
}
public function jump()
{
echo '鸭子:左右摇摆的跳进了水里'.'<br>';
}
public function eat()
{
echo '鸭子吃食物'.'<br>';
}
}
$sp = new Superman();
$sp->say();
$sp->jump();
$sp->eat();
echo '<hr>';
$dk = new Duck();
$dk->say();
$dk->jump();
$dk->eat();
7.抽象类
任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象(abstract)的。
定义为抽象的类不能被实例化。
被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。
继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。例如某个抽象方法被声明为受保护的，那么子类中实现的方法就应该声明为受保护的或者公有的，而不能定义为私有的。
<?php
abstract class sport{
public abstract function status();
}
class Run extends sport{
public function status()
{
echo 'Run Run Run';
}
}
$runners = new Run();
$runners->status();// Run Run Run
8.静态static
声明类属性或方法为 static(静态)，就可以不实例化类而直接访问。
静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。
由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用。
静态属性不可以由对象通过 -> 操作符来访问。
<?php
class Superman{
// 静态变量，通过类来访问
public static $name = '超人';
// 普通成员变量
public $address = '华盛顿';
// 静态方法，通过类来访问
public static function action(){
echo '镭射眼~~~~~~';
}
// 普通方法
public function showInfo(){
// 使用static 修饰的类变量或者方法时，需要通过 类名::xxx 的形式来访问
echo '姓名:'.Superman::$name.'<br>地址:'.$this->address;
}
}
// static 修饰的，无需实例化即可通过类名来调用
echo Superman::$name;
Superman::action();
echo '<hr>';
// 实例化对象，通过对象调用非static修饰的
$sp = new Superman();
$sp->showInfo();
9.final
final修饰的类，无法被继承，final修饰的方法无法被重写。
10. this ,self ,parent
this,self,parent三个关键字之间的区别，从字面上比较好理解,分别是指这、自己、父亲。
在类里面调用当前类的属性和方法有三种方法，分别是self、parent、$this，这三个关键字的区别是self用来指向当前的类；parent用于指向当前类的父类，可以使用该关键字调用父类的属性和方法；$this用来在类体内调用自身的属性和方法。
(1) this
$this表示当前实例，在类的内部方法访问未声明为const及static的属性时，使用$this->value='phpernote';的形式。
常见用法如：
$this->属性
$this->方法
// 在get,set方法中，this频繁的使用，用来指定当前的实例的属性或者方法
class Man {
public $name ;
public $age;
public function __construct($name, $age)
{
$this->name = $name;
$this->age = $age;
}
public function getName()
{
return $this->name;
}
public function setName($name): void
{
$this->name = $name;
}
public function setAge($age): void
{
$this->age = $age;
}
public function getAge()
{
return $this->age;
}
}
(2) self
self用来指向当前的类
<?php
class Person{
function name(){
echo '类名'.get_class($this).'<br>';
}
}
class Man extends Person {
function name(){
echo '类名'.get_class($this).'<br>';
}
function nameSelf(){
self::name();
}
}
$m1 = new Man();
$m1->name();
$m1->nameSelf();
echo '<hr>';
$p = new Person();
$p->name();
(3) parent
parent用于指向当前类的父类，可以使用该关键字调用父类的属性和方法
<?php
class Person{
function say(){
echo 'hi'.'<br>';
}
}
class Man extends Person {
function saySomething(){
parent::say();
self::say();
}
function say()
{
echo 'hello'.'<br>';
}
}
$m1 = new Man();
$m1->saySomething();
// hi
// hello
