面向过程、面向对象

　　面向过程：从开始到结束自己独立完成

　　面向对象：将一个事物划分为单体来各自实现区域性的功能，最后通过调用组合完成

类、对象

　　类：某一些具有共同特征的物体

　　对象：指某一种具体的物体，属于某一个类

类成员（成员属性，成员方法）

　　类里面只包括属性和方法

　　使用属性的格式为:$对象->属性名（属性名前不加$符号）

　　方法直接在类里面定义

静态属性、静态方法

　　在定义属性的时候，前面加上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  方法名(){。。。。方法定义。。。。}