###1、Static 静态声明
在前面的课件中，我们不是有多次提起过，在成员属性 和 成员函数定义时，带有修饰符的声明。

而 `static` (静态声明)关键字，就是修饰符中的一种。

其作用是，可以让Class在不实例化的情况下调用，

调用格式是，直接使用：`类名::方法名`的方式进行调用。

同时，静态属性不允许Class类使用 `->` 操作符访问，而是使用`self::`操作符代替访问。

案例代码如下：
```php
<?php
class Test {
 public static $HP = 100; // 血量
 public static $AD = 5; // 攻击力
 
 # 调用这个攻击
 public static function Battle() { 
 self::$HP = self::$HP - self::$AD;
 echo '受到攻击剩余血量为：'.self::$HP.' ';
 }

}

echo '初始血量是：'.Test::$HP.' ';
echo '初始攻击力是：'.Test::$AD.' ';
Test::Battle();
Test::Battle();
Test::Battle();
Test::Battle();
```
注意：

在使用了`static`修饰符的成员函数中，不能使用`$this->`操作符调用任何，

没有使用`static`修饰符的成员函数或者成员属性，否则PHP将会报错，

如下列代码：
```php
<?php
class Test {
 public $HP = 100; // 血量
 public static $AD = 5; // 攻击力
 
 # 调用这个攻击
 public static function Battle() { 
 $this->$HP = $this->$HP - self::$AD;
 echo '受到攻击剩余血量为：'.$this->$HP.' ';
 }

}
Test::Battle(); // 将会报错
```
###2、什么是父类、子类
在Class类中，我们可以实现类似于生孩子这样的特性。

例如下图：

![](https://xiuxian.junphp.com/public/kejian/v1-98.png)

Class中的父子类关系生成主要分成三种模式：
```
1、继承
2、接口
3、抽象
```
每一种模式之间，都有各自不同的要求和特点，我们在下面的课件中会对其进行一一讲解。

###3、类的继承
继承是面向对象程序设计中最常用的一个特性，

假设案例中的汽车是一个比较大的类，我们也可以称之为基类或父类，

除此之外，汽车还分为卡车、轿车、SUV、越野车等，

因为这些子类具有很多相同的属性和方法，可以采用继承汽车类来共享这些属性与方法，实现代码的复用性，同时也方便程序管理和升级。

PHP 使用 `extends` 关键字来继承一个类，，其语法格式如下：
```
class 本类名(子类) extends 继承的类名(父类) {}
```
下面，我们使用魔兽争霸3的游戏兵种，来进行一个Class继承的学习：
```
1、假设兵种是一个大类(父类)
2、那么所有兵种同有的属性肯定有：血量、攻击力、防御值。
3、所有兵种同有的方法肯定有：发起攻击
4、子类的工作应该是生产不同的兵种。
```
那么则可以使用继承的特性，编写以下代码：
```php
<?php
# 我是基类，定义一个兵种模糊的概念
class Arms {
 protected $Name; // 兵种名称
 protected $HP; // 血量
 protected $AD; // 攻击力
 protected $MD; // 防御力
 
 # 调用这个方法攻击
 public function Battle() { 
 $this->HP = $this->HP - $this->AD;
 echo $this->Name.'受到攻击剩余血量为：'.$this->HP.' ';
 }

}

# 我是子类，实体化一个步兵兵种
class Infantry extends Arms {
    # 初始化兵种属性
    public function __construct() {
        # 修改父类定义的成员属性
        $this->Name = '步兵'; // 兵种名称
        $this->HP = 120;      // 血量
        $this->AD = 2;        // 攻击力
        $this->MD = 5;        // 防御力
    }
}

# 我是子类，实体化一个远程兵种
class Remote extends Arms {
    # 初始化兵种属性
    public function __construct() {
        # 修改父类定义的成员属性
        $this->Name = '远程兵'; // 兵种名称
        $this->HP = 80;        // 血量
        $this->AD = 10;        // 攻击力
        $this->MD = 1;         // 防御力
    }
}

# 生产出一个步兵
$Infantry = new Infantry();
$Infantry->Battle();
# 生产出一个远程兵
$Infantry = new Remote();
$Infantry->Battle();
```
####A、重写父类方法
很多时候，父类的方法没办法满足子类的要求，

那么这时候我们就可以用同名函数的方式，重写父类的方法。

例如下列案例代码：
```php
<?php
# 父类
class Test {
 # 注意这里，我是私有权限
 private function Demo() { echo '我想要发起进攻'; }
}
# 子类
class Test2 extends Test {
 # 功能不对，我要重写父类的方法(同时改为公有权限)
 public function Demo() { echo '我想改为撤退防御'; }
}
# 使用demo如下：
$obj = new Test2();
$obj->Demo();
```
####B、构造函数的先后调用
正确情况下，如果父子类同时定义了构造函数，那么只会执行最后一个子类的构造函数，
而其上所有父类的构造函数都不会被执行（可以理解为被重写了）。

而如果我们想让父类的构造函数先执行，可以在子类的构造函数中，用`parent::关键字`先调用一下父类的构造函数，

`parent::关键字`，代表访问调用父类的成员属性（静态声明过的成员属性）和方法（构造函数、析构函数、静态声明过的成员函数）。

其案例代码如下：
```php
<?php
# 父类
class Test {
 public function __construct() { echo '我是父Test类的构造函数 '; }
}
# 子类
class Test2 extends Test {
 public function __construct() {
 # 让父类的构造函数先执行
 parent::__construct();
 echo '我是子Test2类的构造函数'; 
 }
}
# 使用demo如下：
$obj = new Test2();
```
####C、调用父类的Static成员属性 和 成员函数
在子类调用父类的静态成员属性和函数，不能使用`self::关键字`， 而是使用`parent::关键字`进行代替，这一点同学们需要注意一下：
```php
<?php
# 父类
class Test {
 public static $HP = 100; // 血量 
 public static function Demo() { echo '别用self::调用我'; }
}
# 子类
class Test2 extends Test {
 public function Demo2() {
 # 使用parent::关键字，调用父类的静态成员属性和方法
 echo '血量为：'.parent::$HP;
 parent::Demo();
 }
}
# 使用demo如下：
$obj = new Test2();
$obj->Demo2();
```
###4、类的接口
Class类的接口实现，也属于父子类中的一种，实现接口的声明并不需要使用class关键字，
而是使用`interface`关键字，同时接口中的方法不需要使用{}符号概括具体的逻辑内容。

其语法格式如下：
```
interface 接口类名 {
    控制权限 修饰符 function 方法();
}
```
接口类创建完后是不能直接`new`实例化的，而是需要使用`implements`关键字创建对应的子类，并且该子类必须实现父类中定义的所有方法，否则将会报一个致命错误。

其语法格式如下：
```
class 子类名 implements 接口父类名 {
 # 必须实现父类所定义的所有方法
}
```
下面我们来看下接口类的具体实现代码：
```php
<?php
# 接口父类
interface Api {
 /**
 * 攻击
 * @param int $AD 攻击力
 */
 public function Attack($AD);

/**
     * 防御
     */
    public function Defense();
}

# 子类
class V1 implements Api {
    /**
     * 攻击
     * @param int $AD 攻击力
     */
    public function Attack($AD) { echo '我要攻击'; }

/**
     * 防御
     */
    public function Defense() { echo '我要防御'; }
}
# 使用demo如下：
$obj = new V1();
$obj->Attack(1);
$obj->Defense();
```
接口的使用是便于版本管理，当我们有些业务流程是固定不变的，

那么为了规范代码的编程流程和升级维护，我们就可以使用接口定义，

把这些固定的流程声明在父类中，下一次升级版本的时候只需要新建一个子类，就能重新开发，

同时还能保存旧版本的代码，如果新版本的代码出现bug，就可以通过将new V2切换为V1，就能回退版本。

所以，接口类可以总结为是一套子类必须100%执行的规范。

###5、类的抽象
Class类的抽象实现，也属于父子类中的一种，

抽象是介于基础类和接口类的一个升级版，

接口类中父类不能具体化成员函数内容，只能定义一些函数框架，然后让子类去实现。

而基础类中，父类不能强迫子类一定要重写某些成员函数。

而抽象类就是为了解决这两种情况，并将其融合在了一起，

同样的，被声明为抽象类的Class，不能直接被new实例化，而是需要使用`extends`关键字创建对应的子类。

其语法格式如下：
```
abstract class 抽象类名 {
    abstract 控制权限 修饰符 function 方法名();
    控制权限 修饰符 function 方法名() {}
}
```
当我们class基础类中，只要有一个成员函数使用了`abstract`关键字，该类就表示为抽象类，同时class关键字前面也需要加上`abstract`关键字。

具体案例代码如下：
```php
<?php
# 抽象父类
abstract class Test {
 # 要求子类必须实现这些方法
 abstract public function Get();
 abstract public function Post($str);

# 普通方法（非抽象方法）
    public function Dump() { echo '不强迫子类重写'; }
}

# 子类
class Demo extends Test {
    # 具体化父抽象强迫实现的方法
    public function Get() { echo '粑粑我实现了'; }
    public function Post($str) { echo '粑粑我实现了'; }
}

# Demo
$obj = new Demo();
```
###6、final 唯一声明
在实际开发中，我们可能会创建很多层父类，然后各种继承，但当定义的成员函数多了之后（可能会高达上百个），

这时候就很难避免一些不想被子类重写的方法，但又无法监听到，这时候class就提供了一个`final`关键字，

用于声明该成员函数是唯一的，不能被子类重写。

同时`final`关键字还可以作用在class上，让该类不允许被继承。

其语法格式如下：
```php
final class 类名 {}
class 类名 {
    final 控制权限 修饰符 function 方法名() {}
}
```
###7、类与类之间的实例传递
之前很多同学可能会有疑惑，案例中魔兽争霸3游戏代码里，怎么那些步兵，远程兵攻击的逻辑都是打自己呢？

这是因为之前的Class学习中，都没有学习到关于Class与Class间的实例传递使用的知识。

当我们学会如果一个类传递给另一个类，就能够编写出正常的攻击逻辑了。

下面我们来看一段简单的案例代码，从中学会如何将class实例相互传递（为了代码量少，案例不使用继承，有兴趣的同学可以自行修改学习）：
```php
<?php
# 生产商
class Produce {
 public $obj; // 传递过来的实例
 /**
 * 将实例传递给我们
 * @param object $obj 实例
 */
 public function Demo($obj) {
 $this->obj = $obj;
 echo '我需要生产一辆：'.$this->obj->Name;;
 }
}

# 保时捷零件批发商
class Porsche {
    public $Name = '保时捷';
}

# 使用demo如下：
$Porsche = new Porsche();
$obj = new Produce();
$obj->Demo($Porsche);
```
上面的案例基本讲述了如果将实例化传递到另一个类中，但这时候出现了一个问题，
就是如果上面的代码，如果我不传递保时捷这个类过去，随便传递一个别的类，那`Demo()`方法不是有可能输出别的内容，

例如：我需要生产一辆雨伞？

为了避免出现这种低级错误，Class提供了一个实例引用规避的方法，就是在成员方法中传递参数时，声明一下对应的类，

这样传递给该传递的类实例，就一定要是这个声明的类或是该类继承下的子类。

其语法格式如下：
```php
class 类名 {
 控制权限 修饰符 function 方法名(声明类名 参数A, ...) {}
}
```
详细用法可以参考下列案例代码：
```php
<?php
# 生产商
class Produce {
 public $obj; // 传递过来的实例
 /**
 * 将实例传递给我们
 * @param object $obj 实例，声明这个参数只能传递Porsche类或者其子类的实例
 */
 public function Demo(Porsche $obj) {
 $this->obj = $obj;
 echo '我需要生产一辆：'.$this->obj->Name;;
 }
}

# 保时捷零件批发商
class Porsche {
    public $Name = '保时捷';
}

# 雨伞批发商
class Umbrella {
    public $Name = '樱桃小雨伞';
}

# 使用demo如下：
$Porsche = new Porsche();
$obj = new Produce();
$obj->Demo($Porsche);
# 下面我们传递雨伞的实例过去，看看会不会报错
$Umbrella = new Umbrella();
$obj->Demo($Umbrella);
```
###8、练习题
模仿魔兽争霸3游戏：

使用Class继承的概念，还有类实例传递的概念，实现真正意义上的攻击逻辑。

实现的具体兵种为：步兵、远程兵；

兵种带有的属性为：
```
1、兵种名称
2、血量
3、攻击力
4、防御力
```
通过传递兵种实例，调用一个成员方法：

根据当前兵种的攻击力 减去 被攻击兵种的防御力 再减去 被攻击者的血量，并输出当前血量还剩余多少。

答案：[下载](https://blog.junphp.com/cangjingge/php/12.zip "下载")

已有0条评论

添加新评论☺

如果认为本文对您有所帮助请赞助本站

支付宝扫一扫赞助

已有0条评论

添加新评论☺