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;