面向过程、面向对象
面向过程：从开始到结束自己独立完成
面向对象：将一个事物划分为单体来各自实现区域性的功能，最后通过调用组合完成
类、对象
类：某一些具有共同特征的物体
对象：指某一种具体的物体，属于某一个类
类成员（成员属性，成员方法）
类里面只包括属性和方法
使用属性的格式为:$对象->属性名（属性名前不加$符号）
方法直接在类里面定义
静态属性、静态方法
在定义属性的时候，前面加上static就是静态属性，只属于类本身
静态属性的使用：类 :: $静态属性名（::双冒号）
静态方法也是只属于类，不属于具体对象
静态方法中不能掉用非静态方法
静态方法的使用：类名 :: $静态方法名（::双冒号）
如果通过类名来调用静态方法，不能出现$this关键字
构造__construct()、析构方法__destruct()
插入一个对象的同时，也给这个对象赋值，然后本身就会有属性值，可以在本类内调用
例：
class Teacher{
public $name="匿名";
public $age="未知";
public $eduction="未知";
function _ _construct($name,$age,$eduction){
$this->name=$name;
$this->age=$age;
$this->eduction=$eduction;
}
function showAllInfo(){
echo"<br/>hi,大家好，我叫".$this->name;
echo"<br/>今年".$this->age."岁";
echo "<br/>学历:".$this->eduction;
}
}
$teacher1=new Teacher("张三",22,"本科");
$teacher2=new Teacher("李四",23,"研究生");
$teacher1->showAllInfo();
echo "<br>";
$teacher2->showAllInfo();
1，该方法名字是固定的，为：_ _construct();注意：两个下划线
2，该方法必须是普通方法（不能是静态方法）
3，通常该方法应该是public
4，通常该方法中使用$this这个关键字来对属性进行赋值
5，当new 类名()的时候，其实是在调用该构造方法
6，在一个类中有构造方法，那么在本类的方法中就会调用构造方法中的值
构造 方法是“创建”对象的时候会自动调用。
析构 方法是“销毁”对象的时候会自动调用。
说明：
１，析构方法通常不太需要去定义。
２，析构方法不能调用。
３，析构方法不能有形参。
４，析构方法中可以用于清理一些在php代码结束后不能清理的数据，如生成的文件。
对象销毁的几个情形：
脚本程序运行结束，自动销毁；
明确地unset()一个对象变量，则被销毁；
改变对象变量的值，被销毁；
$this、self、parent
$this：$this是一个“伪对象”，代表当前所属类的当前对象。
Self:含义：代表当前类
只能在某个类的方法里代表该类的名称
Class S{
Public $v=1;
Static funcation new(){
Return new self;//self代表当前类
//new self 代表当前类的一个对象
}
}
$obj = S::new(); //通过s的静态方法得到当前类的一个新对象
Var_dump($obj);
Parent:代表父类
一般用于子类调用父类内容时使用，通常使用父类的静态类
class C{
public $p1 = 1;
function showMe(){
echo "<br />我是父类，数据有：";
echo "<br />C中p1=" . $this->p1;
}
function _ _construct($p1){
$this->p1 = $p1;
}
}
class D extends C{
public $p2 = 2;
function __construct($p1,$p2){
//经典用法
parent::__construct($p1);//调用父类的构造函数来初始化p1
$this->p2 = $p2; //初始化p2
}
function showMe2(){
echo "<br />我是子类，数据有：";
//基本用法：
parent::showMe();//调用父类的showMe方法， 使用静态方法调用
echo "<br />D中p2=" . $this->p2;
}
}
$d1 = new D(10,20); //此时就需要尊照构造函数的参数结构来使用
$d1->showMe2();
public、protected、private、static
public：公共的（只要在文档中都可以用）一般用于设置变量
protected：受保护的（可以在当前类或当前类的上下级具有继承关系的类中访问）
private：私有的（只能在当前类中使用）
extends ：继承 （子类继续父类）
Static：静态
重写、重载__set()__get()__isset()__unset()
所谓属性重载，就是在面对上述4种情形的属性使用场景中，该对象如果来“应对”的问题。
如果某属性不存在，但在语法中使用如下情形，则会发生：
都称之为：魔术方法“”
取值：$v1 = 对象->属性； ===>自动调用类中的__get()方法
赋值：对象->属性 = XX值； ===>自动调用类中的__set()方法
判断是否存在：isset(对象->属性;) ===>自动调用类中的__isset()方法
销毁：unset(对象->属性;) ===>自动调用类中的__unset()方法
重写关键字：override
例子：
class C{
function show1($para1){
echo "<br />父类的show1方法：para1 = " . $para1;
}
}
class D extends C{
function show1($para, $para2){//参数不一致
echo "<br />子类的show1方法";
}
}
在继承关系中使用，可以节约代码
重载方法
在一个类中，有多个同名的方法，每个方法的参数不同而已。这种现象就称为“重载”
参数不同可以是：数量个数不同，或类型不同，或顺序不同
例子
class A{
int function f1(int x){......}
int function f1(int x, int y){.....}
int function f1(string s int m){....}
}
在PHP中重载只是一个概念
__call() __callStatic() __clone()
方法重载关键字：__call
例子：
Function f1（）{
Echo ：”f1被调用”
}
Function f2（$x,$y）{
echo ：”f2被调用”;
return $x+$y;
}
Class a{
Public $p1=1;
Function __call($x,$arr){
$c=count($array);
If($c==0){
F1();
}else if(){
Return f2($arr[0],$arr[1]);
}
}
}
$d=new a();
$d->f1();
$v1=$d->f1(1,2)//f1不存在两个参数
echo "<br />d1里面的p1=" . $d1->p1;
echo "<br />结果v1=" . $v1;
执行结果
f1被调用
f1被调用
o1里面的p1=1
结果v1=3
一个对象还可以使用clone运算符进行克隆，则就也会“生成”新对象。
当使用一个对象（类）调用一个不存在的静态方法的时候，会自动去调用预先定义好的＂＿＿callStatic＂方法。（该方法必须带２个参数）
extends、abstract
Extends：子类继承父类
Abstract：抽象类
在正常定义类的前面，加上关键字：abstract，那就构成抽象类。
abstract class 类名{.....类的定义.....}
接口interface
单例：
1、私有属性（值是对象）
2、私有构造方法（不能new）
3、提供获取对象的方法（这里面判断是否存在）
4、私有克隆
面向对象三大特性：封装、继承、多态
工厂模式
class factory{
//Instance表示“实例”，“对象”
static function getInstance($className){
if(file_exists('./class/' . $className . ".class.php")){
$obj1 = new $className();
return $obj1;
}else{
return null;//也可以die();
}
}
}
$obj1 = factory::getInstance("A");//获取类A的一个对象
$obj2 = factory::getInstance("B");//获取类B的一个对象
$obj3 = factory::getInstance("A");//再获取类A的一个对象
优点：只需要指定对象就可以创建
最终类final class：
通常，一个类，没有特别声明的话，则“别人”就可以随意拿过来使用并对之进行“扩展”——继承。
但是：
如果某个类不希望对其进行扩展，则可以将其声明为“最终类”。
形式：
final class 类名{ 。。。。类定义。。。。}
最终方法final method
通常，一个方法，如果没有特别声明，则下级类就可以对其进行“覆盖”（重写）。
但是：
如果某个方法不希望被下级类覆盖，就可以对其生命为“最终方法”。
形式：
final function 方法名(){。。。。方法定义。。。。}
