PHP其它常用函数；<<<面向对象(OPP)的三大特性：封装、继承、加态：>>> <----面试题 ；构造方法、析构方法，魔术方法、set、get方法;静态；抽象类；接口

PHP其它常用函数:     赋值:$r->name = "元素";      取值: echo $r->name; 

count()   计算数组中的元素数目或对象中的属性个数  /  计算数组的长度

1.in_array(元素a,$attr)   判断元素a是否在数组$attr里面存在，存在返回一个true,反之false

2.array_reverse($attr)  将数组中的元素顺序翻转，创建新的数组并返回

3.array_unique($attr)   删除数组中重复的值并返回新的数组

4.array_merge($attr1,$attr)  合并数组

5.array_push($attr,元素a)   把元素a添加到数组$attr的末尾

6.unset($arr[0])   删除数组的某个元素或者变量，只在foreach遍历可以，其它语言不可以

7.array_values($arr)   按顺序重新排列$attr数组的索引

unset($attr)和array_values($attr) 一般一块用

面向对象：每一个对象都不一样，都是独立的个体; 关键词"this":"this"写在类里面是代表"该对象","该对象"谁用代表谁;

需要注意：构造对象始终存在，即使不写也是存在的 ;  构造方法的名 一般用"__construct" "__"为两个下划线 例：function __construct($n)  {}

访问修饰符：

1.public：代表公有的，在任何地方都可以访问

2.protected：代表受保护的，只能在该类或该类子类中访问

3.private：代表私有的，只能在该类中访问

OPP（面向对象）三大特性：封装，继承，多态     在PHP类里面不允许出现同名的方法

一、封装：关键字："construct" 如：function __construct($v) {}

封装的目的：为了让类更安全★★★★

封装的做法（原理）：★★★★

①所有成员变量全部要private

②使用成员方法来间接访问成员变量

③在该方法里面加限制条件

例：

class Ren
{
    private $name;
    private $sex;
    private $age;

　　function __construct($v)　　　　//构造方法 在new 新对象执行的时候就执行
    {
        $this->sex =$v;    
    }
    //魔术方法 __set 调用方法：$r->__set("age",20)或者 $r->age=20;
    function __set ($k,$v) 　　　　　　//可以给成员变量赋值 $k是成员变量的名称 $v为成员变量的值  在给成员变量赋值的时候，自动调用
    {
        if($k=="age")
        {    
            if($v>=18 && $v<=50)
            {
                $this->$k=$v;
            }
        }
        else　　　　　　　　　　　　　　//else 其它输出不变，没别的条件
        {
            $this->$k=$v;
        }
    }
    function __get($k)　　　　　//魔术方法 __get  调用方法：$r->__get("age")或者$r->age;
    {
        return $this->$k;    
    }

　　    function __destruct()　　//析构方法  自动执行 这个对象释放的时候自动执行
    {
        echo "这是一个析构方法";    
    }
    
    function __tostring()           //输出对象“echo $r;”时 可返回字符串“这个类是人类”的字符串
    {
        return "这个类是人类";   
    }
}

$r = new Ren("男");

二、继承：关键字 "extend"  如：class China extends Ren  {}  <-子类

1.做父类和子类的目的：让父类更好的控制子类，变量名和方法名必须统一

2.特点：

①单继承：一个子类只能有一个父类，一个父类可有派生出多个子类（所有父类的对象都是object）

②子类继承了父类的所有成员和功能方法，如果子类要另行添加成员和方法都可以

③方法重写：在子类里面对父类的方法进行重写，如果我要保留父类的功能，再拓展一个功能例：

class Ren

　　{

　　　　public $name;

　　　　function say()

　　　　　　{

　　　　　　　　echo $this->name."正在讲话";

　　　　　　}

}

class China extends Ren  　　//子类China 继承了父类Ren的所有的成员和功能
{                           　　　　 　　//如果要另行添加成员或者方法都可以
    
    
    public $dizhi;
    function  say()          　　　　//在子类里面对父类的方法进行重写  ,如果我要保留父类的功能，再拓展一个功能
    {
        parent ::say();       　　 //调用父类的say方法 ，在子类里调用父类的方法 ：如果我要保留父类的功能，再拓展一个功能
        echo "中国人说话";    
    }                
}

3.① override:是重写的意思，子类对父类方法的重写  ②overload:Ⅰ.函数重载 Ⅱ.编译多态

三、多态：分为运行多态和编译多态，一般用运行多态

1.概念：

当父类引用指向子类实例，由于子类里面面对父类的方法进行了重写，父类引用在调用该方法的时候表现出的不同状态

2.条件：

①必须发生在继承下

②子类必须重写父类方法

③父类引用调用该方法

3.注意：

如果一个方法需要一个父类的参数，可以给一个子类对象，例：怪兽吃人：不挑食，给父类可以，随便一个子类都可以吃

四、静态：关键字 static self   如： public static$v; 调用静态成员方法：(类名：：$v）

                  方法也可以使静态：static function show() { echo self::$v}  self在(类)里面代表该类

1。类成员分为静态成员和普通成员

2.普通成员属于对象

3.静态成员属于类，静态相对于普通说的，方法也可以做成静态的

4.self关键字：在类里面代表该类

5.在静态方法里面不能调用不同成员（没法造对象）

6.在普通方法里面可以调用静态成员

7.静态是为了方便于使用类名就可以调用类里的成员和方法

class FenBi
{
    public $length;
    public static $color;  　　　　　　//关键字 static 定义静态成员 它属于这个FenBi类
        
    static function show()　　　　　　　//方法也可以是静态
    {
        echo "粉笔的颜色是：".self::$color;　　//    "粉笔的颜色是：".FenBi::$color;也可以 ；  self在类里面代表该类
    }    
}

$v = new FenBi;　　　　　　//先造一个对象

$v->length;　　　　　　　　//要调用普通成员必须先有对象
FenBi::$color;                     //调用静态成员 ，要使用类名

五、抽象：（抽象类）关键字abstract   abstract class ***{}

1.把类进一步抽象：关键字abstrsct  如：abstract class ***  {}

2.特点：不能被实例化，只能被继承

3.目的：为了派生子类来使用，控制子类所有功能

例：
abstract class Dog
{
    public $name;   
    function Jiao()
    {
        echo "汪汪";
    }
}
class JinMao extends Dog
{   
}
$d = new Dog();

六、接口（面向对象的接口）：关键字一：interface、    如：interface IUSB {}  （interface 代替 class）

关键字二：implements（实现）：　class Mouse implements IUSB {}（ implements 代替extend）

归根结底就是一个抽象类，极度抽象的类，接口里面不能有成员变量，只能包含成员方法，成员方法可以没有函数体
接口关键字：interface(相当与类的class)
接口名称的规则：一般"I"开头 如 interface IUSB  {}
实现接口的类，必须实现接口里面所有方法
如
interface IUSB
{
    function read();        //必须要有读的方法
    function write();      //也必须要有写的方法
}
//鼠标驱动类
class Mouse implements IUSB  　　　　// implements 实现的意思
{
    function read()
    {
        echo "鼠标点击了";    
    }    
    function write()
    {
        echo "给鼠标一个指令";    
    }
}
$m = new Mouse();
$m->read();

七、设计模式

1、单例模式：目的是<只能>返回一个对象;类的计划生育；只能造一个对象出来

条件：

①让该类在外界无法造对象：用private 把类封闭起来

②让外界可以造一个对象，然后做一个静态方法来返回对象

③在类里面通过静态变量控制返回对象只能是一个

例：

class Dog
{
    static $dx;
    public $test;
    
    static function DuiXiang()
    {
        if(empty(self::$dx))
        {
            self::$dx = new Dog();    
        }
        return self::$dx;    
    }
}
$a = Dog::DuiXiang();
$b = Dog::DuiXiang();
$b->test="hello";
echo $b->test;
var_dump($a);

2、工厂模式：便于修改；做一个抽象类，派生出子类

//正常模式：
class YunSuan
{
    public $a;
    public $b;
    public function Jia()
    {
        return $this->a+$this->b;    
    }    
    public function Jian()
    {
        return $this->a-$this->b;    
    }
}

//工厂模式：
abstract class YunSuan
{
    public $a;
    public $b;
    
    function Suan()      //抽象类父类方法，为了供子类使用
    {
    }    
}
class Jia extends YunSuan
{
    function Suan()
    {
        return $this->a+$this->b;    
    }    
}
class Jian extends YunSuan
{
    function Suan()
    {
        return $this->a-$this->b;    
    }    
}
class Cheng extends YunSuan
{
    function Suan()
    {
        return $this->a*$this->b;    
    }    
}
$j = new Cheng;
$j = new Jian();
$j->a=5;
$j->b=10;
echo $j->Suan();

class GongChang
{
    static function ShengChan($v)
    {
        switch($v)
        {
            case "+":
                return new Jia();
                break;
            case "-":
                return new Jian();
                break;
            case "*":
                return new Cheng();
                break;    
        }    
    }    
}
$j = GongChang::ShengChan("*");
$j->a=10;
$j->b=5;
echo $j->Suan();

题外话：

1.函数重载：在类里面写多个同名方法来实现不同的功能

2.如何实现重载:

①.函数名必须相同

②.参数的个数不同或者参数个数相同的话，参数类型不同也可以

public static $color;