面向对象

1.0 类名首字母要大写

class A{

   类成员;

}

2.0 类成员

类成员可以赋予初值。一般成员都需要关键字的说明，会有 public、private和static属性，但是如果没有特别的说明要用 var 关键字 说明，一旦有其他的关键字修饰时可以替换var关键字。

3.0 类的实例化

$a = newclasname();

4.0  $this指针

在对象内部 $this 指针指的是对象。可以用$this指向内部的成员

classPerson{

   var$name;

   var$num;

   var$sex;

  

function__construct(){

   $this->name ="小红";

   $this->num ="2011";

   $this->sex ='man';

}

}

用$this->num;不用$this->$num;

5.0 构造函数和析构函数

1.在构造函数中php5.0版本以前使用与类名相同的名称。Php5.0之后的版本就用__construct名称。省去在改变类名的时候，同时改变构造函数名称。

Function_construct(参数列表){

}

为了向下兼容，如果没有_construct名称，默认寻找与类名相同的构造函数。

2. __destruct(),析构函数不加任何的参数。析构函数是在php5.0以后的版本中添加的，析构函数是在对象被销毁时自动调用的。

在php中有一种垃圾回收机制。当对象不能被访问时就会自动的启动垃圾回收机制。回收对象在堆栈中的空间。析构函数就是在回收对象之前调用的。

6.0  php面向对象的讨论

一般来说，面向对象中应该要有封装性，就是不允许在类外直接可以调用成员。Public的成员是可以的。但是private的成员是不行的。所以会在类中为成员都设置一个赋值和读取的函数。Php中为了减少繁琐性就设置了__set()函数。可以直接在外部为私有成员赋值。

<?php

Class Wo {

   private $name;

   public $num;

   public $sex;

   function __construct(){

       $this->name = "wp";

       $this->sex = "wo";

       $this->num = "we";            

    }

   

      function __set($stringname,$value){

       $this->$stringname = $value;

   }   

   function  put(){

       echo "名字".$this->name."座号为".$this->num."性别为".$this->sex;

       

    }

   

    }

    $person = new Wo;

   $person->name = "xiao"; //为私有成员赋值

   

   $person->put();

   

?>

Function __get();获取私有成员值

<?php

class Person{

    private $name;

       var $num;

       var $sex;

      

function__construct(){

       $this->name = "小红";

       $this->num = "2011";

       $this->sex = 'man';

}

 

function__get($propertyName){

       if($propertyName =='name')  return $this->$propertyName;

}

 

}

$xiao = newPerson;

echo$xiao->name;

?>

魔法函数__isset(){}用于判断是否变量是否存在

Function__isset(){

Return isset(变量名称)

}

魔法函数__unset(){}用于删除私有成员。利用unset()函数

Function__unset($varname){

 

Unset($varname)

}

Unset($varname)

7.0 子类调用父类中被重载的方法 parent::

一般来说重载父类函数的时候，父类的函数功能就被子类的函数重写。而类似于__construct()这样的构造函数，如果子类中需要对子类中的成员进行赋值的话。会把父类中的构造函数进行重写，从而父类的成员就不会被付初值。继而用parent：：调用父类的成员到子类的成员中。这样让子类对父类中的成员也可以一并赋初值。

<?php

class Person{

   var $nam;

   var $sex;

   function __construct(){

       $this->nam = "小红";

       $this->sex = "男";

    }

   function say(){

   echo $this->nam.$this->sex;

    }

}

class Student extends Person{

   var $num;

   function __construct(){

        $this->num = 2011;

        parent::__construct();   

    }

   function say(){

       parent::say();

       echo $this->num;

   }  

    }

 

 $person = new Person;

 $person->say();

 echo"<br>";

 $student = new Student;

 $student->say();

?>

实验结果：

小红男

小红男2011

8.0使用final关键字标识的类不会被子类所继承。被标识的成员方法不会被重写。

使用static静态成员属性标识的成员方法和成员。是不需要实例化对象调用的。因为它属于类不属于对象。所以不能用$this指针来引用他。需要用self关键字;

<?php

 

class P{

   static $count;

   function __construct(){

       self::$count++;

       

    }

   function getcount(){

       echo self::$count;

    }

   

    }

   p::$count = 0;

   $wo = new P();

   $wo1 = new P();

   $wo2 = new P();

   $wo3 = new P();

   echo p::$count;

   echo "<br>";

   echo $wo3->getcount();

?>

9.0 单态设计模式

保证在面向对象的过程中。一个类只有一个实例化对象，在建立目录和数据库连接可能都会用到这个函数。

Const 标识（定义为常量）和static的用法大致一致，功能不同。但是变量标识不同

Const var=”常量”;在类的内部用self：：进行调用。

Instanceof关键字用于判断是否为类的实例化对象

10.0 克隆对象clone

有时需要对象做实验，避免重新new实例化一个对象，可以克隆一个对象。克隆对象后的对象也会拥有同母体一样的方法和成员。

$person = new Person();

$person2 = clone $person ;

此时的$person 和 $person1 是相同的。但是又不是同一个对象。如果需要对克隆的对象重新初始化。需要在母体中申明__clone()魔法方法。无需定义__clone()的参数。用$this（子） 和$that（母体）指针来为__clone（）做赋值操作;

11.0 类中的通用方法__toString()

通常是快速获取对象字符串表示的方法。已知 $per = new Person(); 而$per为一个指针；指向内存地址。所以echo $per 是错误的。但是__toString()能获取对象字符串表示。所以魔术方法__toString(){

Return something;

}

<?php

 

class P{

   var  $count;

   function __construct(){

       $this->count = 'w';

    }

   function getcount(){

       echo  $this->count;

    }

   function __toString(){

       return  $this->count;

    }

}

   $wo = new P;

   echo $wo;

?>

12.0 __call()方法的应用

如果调用类中不存在的函数、或者不存在的参数的话。程序会出现错误。那么__call()方法就会为这种情况作出处理好让程序继续往下执行。同时返回不存在的函数及其参数列表。

Function __call()有俩个固定参数，一个用于调用的函数名，一个用于被调用函数的参数列表。

<?php

class P{

   var $name;

   function __construct(){

       $this->name= 'wo';

    }

   function __call($functionname,$arry){

       echo '你输入的'.$functionname.'不存在';

       echo '<br>他的参数为';

       print_r($arry);

   } 

   }

$p1 = new P();

$p1->name(1,2.3);

?>

注意：数组的array（

        “key” =>”value”，

        “key” =>”value”，

“key” =>”value”，

）先是键然后是值。Array是个系统函数。

Strtolower()变为小写；

基于__call()的连贯操作：就是在用到__call(){}的位置都会返回调用该方法的对象：return $this;

<?php

class P{

   private $name = array(

       "where"=>"",

       "select"=>"",

       "from"=>"",

   );

   function __call($functionname,$arry){

        $functionname = strtolower($functionname);

      if(array_key_exists($functionname,$this->name)){

           $this->name[$functionname]= $arry[0];

      }else{

          echo '不存在此函数';

      }

      return $this;

    }

   function say(){

       echo$this->name['select'].$this->name['from'].$this->name['where'];

    }

   }

$p1 = new P();

//连贯操作

$p1->select("select * from")

  ->from("table")

  ->where("where name='wo'")

  ->say();

?>

13.0  自动加载类__autoload(){ }

在设计面向对象程序时，通常会为一个类设计一个php源文件。如果需要调用多个类的话需要加载多个文件。Include就会有很长的文件。会比较繁琐。和容易出错。Php提供自动加载类。在文件中参数定义为类名.所以在定义文件时要统一：例如Person.Class.php

<?php

function __autoload($classname){

   include("strtolower($classname).class.php");

    }

   $p = new Person();

   $p1 = new Student();

?>

14.0 对象的串行化：serialize();将对象串行化保存起来待下次用到用unserialize();

$preson = new Person();

$string = serialize( $preson );

File_put_contents(‘file_.txt’,$string);

 

获取：

$stringFile=_get_contents(‘file_.txt’);

$person = unserialize($stringFlie);

__Sleep() 和__wakeup();是用在与串行化/反串行化一起用的__sleep()是在串行化时默认的保存的成员。__wakeup()是反串行化时输出的一些操作和成员

15.0 抽象类和抽象方法abstract

抽象类无法实例化，用抽象类的好处在于规定了一个模板。子类一定要实现抽象类中的抽象方法。否则子类也为抽象类无法实现实例化

Abstract class Pres{

 

Abstract function  say();

}

16.0 Interface接口

一般来说类单继承设计。即一个类只有一个父类。但是可以拥有多个接口。

接口和抽象类有点类似。他所定义的方法全部默认为抽象类

Interface P{

Function say();

}

Say()为抽象类

 

17.0 多态性

在php中多态性指的就是方法的重写，可以用interface来表达的话

<?php

interface Usb{

   function run();

   } 

class Myphone implements  Usb{

       function run(){

           echo '手机的接口';

       }

    }

class Myu implements Usb{

   function run(){

       echo 'u盘的接口';

    }

}        

class P{

   function runfuction($interface){

       $interface->run(); 

   }  

}

$p1 = new P();

$p1->runfuction(new Myphone());

$p1 ->runfuction(new Myu);

?>