<?php
class person{   
 
 var $abc='god name ';  //属性可以不声明的但声明是一个好习惯，属性可以给一个默认值但不能是表达式
 public $name ;   //公共的
 private $kk;     //私有
 protected  $gg;  //保护
 const TYPE_CASH=1;  //类的常量不能改变，而且一定要大写
 static $go=23;   //静态类属性  调用时用类名而不是对象名。
  
 function __get($pro){ //当调用一个没定义的属性类自动使用__get和__set函数
  print("get for $pro");
  if ($pro == 'bio') {
   $a ="long text";
   return $a;
  }
 }
 
 function __set($pro,$val){
  if ($pro=='bio'){
   print("set Hello, you tried to put $val in $pro\n");

  }
 }
 
function __call($name,$arguments) {   //当你试图访问类中一个不存在的变量或方法时，__call()就会被自动调用:
    print("'Did you call me?  I'm $name {$arguments[0]}! \n");
  } 
 
 function ger_name (){    //系统类方法名用__开头的自定义的方法不要用
  return $this->name;
 }
 
 static function t($name){    //这是一个静态类方法，在这个方法里$this无效， 调用时用类名而不是对象名。
  echo self::$go; //类里调用静态属性的方法
  echo "  $name\n" ;
 }
 
 final function get_name(){  //最终的子类无法覆写这个方法
  return $this->name;
 }
}

$obj = new person;  //这里要注意不能用单引号'' $obj =new 'person'是错的

$pro='person';     //不过使用变量指定是可以的。
$obj1 = new $pro;

$a = $obj1 ;   //指向同一个地址，这两个对象是一致的

$b = clone $obj1 ; //复制clone一个类 ,是类不是对象

$obj->name = " hello world" ;
//  $obj->kk='error';   //错误内部属性不能外部访问只能在类中访问
// $obj->gg='error';   //错误保护属性不能外部访问只能在类和子类中访问
echo "{$obj->ger_name ()}\n";
echo  person::t('the is static');
echo person::$go;  //静态类方法\属性的调用办法

$obj1->name = "hehehe";
echo "{$obj1->ger_name()}\n" ;

echo "{$a->ger_name()}\n";

$b->name= 'ddd';
echo "{$b->ger_name()}\n" ;

$b->meiyou  ;   //属性meiyou是没定义的将直接用get
echo "\n";
echo $b->bio ;
echo "\n";

$b->bio="ddd";  //属性bio没定义将调用set

$b->kkkk('mmm');  //这个方法不存在所以直接调用了call

class eperson extends  person {
 var $newname ;
 
 function ger_name (){
  print "zhe is subclass \n";
 }
 
 function f_name(){
  print parent::ger_name();  //访问父类的方法
 }
}

$suba = new eperson;
$suba->ger_name();    //子类中的方法如果和父类相同，那将覆写

$suba->name = 'test sub';
$suba->f_name();

 

 

 

 

class foo {
  private $x;  //私有的

  public function public_foo() {
    print("I'm public \n");
  }

  protected function protected_foo() {  //保护的
    $this->private_foo(); //Ok 在内部使用私有的没问题
    print("I'm protected \n");
  }

  private function private_foo() {   //私有的
    $this->x = 3;       //内部可以使用私有属性
    print("I'm private $this->x \n");
  }
}

class foo2 extends foo {
  public function display() {
    $this->protected_foo();  //ok 继承使用保护的
    $this->public_foo();
    // $this->private_foo();  // 错误 继承不能使用私有的
  }
}

$x = new foo();
$x->public_foo();
//$x->protected_foo();  //错误不是在外面使用保护的
//$x->private_foo();    //更错私有的还能出门吗？

$x2 = new foo2();
$x2->display();

 

 

 

 

interface face1 {   //接口定义了类的规则，知道接口就知道实现的类的功能
 function get_facename();
}

interface face2{
 function get_name();
}

class impface implements face1,face2 {
 function get_facename(){
  print "the is interface implements ;\n";
 }
 
 function get_name(){
  print "the is interface2 name\n";
 }
}

$kk = new impface ;
$kk->get_facename();
$kk->get_name();

abstract class comp {  //抽象类，他和接口不同的地方是接口单纯只有个定义什么也没有，而抽象类是超类只能在子类中实现
 protected $x ;
 abstract function printout();   //抽象方法什么也没有只有个接口
 function setx($a){
  $this->x=$a ;
 }
}

class imagecomp extends comp{
 function printout(){  //实现抽象方法
  self::setx('kkkkk');  //继承抽象类的属性和方法 self是子类的
  print "abstrace class $this->x \n";
 }
}

$ss = new imagecomp;
$ss->printout();

class foo1 {
  function abc(){
   print "foo \n";
  }
}

class bar {
  public function process_a_foo(foo1 $fooa) {  //类型指示
   $fooa->abc();
  }
}

$b = new bar();
$f = new foo1();
$b->process_a_foo($f);

 

 

 

 

class person1 {
 var $name;
 var $age;
 function __construct($name,$age){  //构造函数
  $this->name=$name;
  $this->age=$age;
 }
   
 function __destruct(){  //析构函数
  echo " byebye \n";
 }
}

class experson1 extends person1 {
 var $posid,$sal;
 function experson1($name,$age,$posid,$sal){   //建立构造函数的另一种方法就是建一个和类同名的函数
  $this->__construct($name,$age);  //构造函数在子类实例化的时候不会自动调用的必须手动
  $this->posid=$posid;
  $this->sal=$sal;
 }
}

$ak =new person1('ggg',34);
echo "$ak->name    $ak->age\n";

$aka =new experson1('dfdf',33,'ki',34);
echo "$aka->name , $aka->name,$aka->posid,$aka->sal\n" ;

 

 

 

 

 

 

 

class food {
  function divide($x,$y) {
    if($y==0) throw new Exception("cannot divide by zero\n");  //php的异常类
    return $x/$y;
  }
}

$x = new food();

try {    //捕捉异常有对应的异常就跳到相应的catch语句中都没有就到最后的catch中
  echo "\n {$x->divide(3,0)}";  
} catch (Exception $e) {
    echo $e->getMessage();
    echo "\n<br />\n";
    // Some catastrophic measure here
}

 

 

 

class MyException extends Exception            //自定义的异常类
{
    public function __construct($message, $code = 0) {  // 重定义构造器使 message 变为必须被指定的属性
        // 自定义的代码  // 确保所有变量都被正确赋值
        parent::__construct($message, $code);
    }

    public function __toString() {      // 只有这个能覆写  自定义字符串输出的样式
        return __CLASS__ . ": [{$this->code}]: {$this->message}\n";
    }

    public function customFunction() {
        echo "A Custom function for this type of exception\n";
    }
}

class TestException  //创建一个用于测试异常处理机制的类
{
    public $var;

    const THROW_NONE    = 0;
    const THROW_CUSTOM  = 1;
    const THROW_DEFAULT = 2;

    function __construct($avalue = self::THROW_NONE) {
        switch ($avalue) {
            case self::THROW_CUSTOM:
                // 抛出自定义异常
                throw new MyException('1 is an invalid parameter', 5);
                break;

            case self::THROW_DEFAULT:
                // 抛出默认的异常
                throw new Exception('2 isnt allowed as a parameter', 6);
                break;
            default:
                // 没有异常的情况下，创建一个对象
                $this->var = $avalue;
                break;
        }
    }
}

try {             // 例子 1
    $o = new TestException(TestException::THROW_CUSTOM);
} catch (MyException $e) {      // 捕获异常
    echo "Caught my exception\n", $e;
    $e->customFunction();
} catch (Exception $e) {        // 被忽略
    echo "Caught Default Exception\n", $e;
}

try {   // 例子 2
    $o = new TestException(TestException::THROW_DEFAULT);
} catch (MyException $e) {      // 不能匹配异常的种类，被忽略
    echo "Caught my exception\n", $e;
    $e->customFunction();
} catch (Exception $e) {        // 捕获异常
    echo "Caught Default Exception\n", $e;
}

try {    // 例子 3
    $o = new TestException(TestException::THROW_CUSTOM);
} catch (Exception $e) {        // 捕获异常
    echo "Default Exception caught\n", $e;
}

try { // 例子 4
    $o = new TestException();
} catch (Exception $e) {        // 没有异常，被忽略
    echo "Default Exception caught\n", $e;
}

 

 

 

 

$yes_no = class_exists(foo) ;
echo "$yes_no \n";  //检查类是否存在

$classes = get_declared_classes();  //取出已经定义的类，返回一个数组

$clsss='person';
get_class_methods(person);   //得到类的方法；
get_class_methods('person');
get_class_methods($classs);

get_class_vars($clsss);  //得到类的属性包括父类 不过只能得出已默认值的属性，名字为键，值为值

$acb=get_parent_class(eperson); //得到父类的名字,参数可以是对象名或类名
echo "$acb \n" ;

foreach ($classes as $class){
 echo "showing class info about $class <br / \n>";
 
}
$yn1 = is_object($b);  //是否对象
echo "$yn1\n";
echo  get_class($b);   //取出对象的类名

$yn=method_exists($b,'process_a_foo'); //检查方法是否存在

$yn = var_export($b,'foo') ; //检查属性是否存在
$ff=get_object_vars($b);   //返回有默认值的对象属性

?>


对象串行化 序列化

<?php
//对象的串行化  序列化
class log{                 //php的对象只存在在页面里，页面结束就释放这就是脚本语言的特征 所以需要串行化
 var  $filename ;      //php的串行化基本是自动的但类对象必须先定义否则只处理stdClass
 var  $fp;                   //所以串行化先要调用对象的定义
 
 
 function log($filename){
  $this->filename=$filename ;
  $this->open ();
 }
 
 function open(){
  $this->fp=fopen($this->filename,'a') or die ("Can't open {$this->filename}");
  }
  
 function write($note){
  fwrite($this->fp,"$note\n");
 }
 
 function read(){
  return join(' ',file($this->filename));
 }
 
 function __wakeup(){              //wakeup钩子的作用就是一个对象在字节流中被创建时立即调用以完成一些必须的操作
  $this->open();
 }
 
 function __sleep(){    //sleep钩子的作用是对象被串行化前自动被调用，以完成一些指定的必要操作如关数据库连接
  fclose($this->fp);
  return array('filename');
 }
}
?>

调用的程序
<?php
include_once( 'log.inc');
session_start();

?>

<html><head><title>front page </title></head>
<body>
<?php
 $now=strftime("%c");
 if ( !session_is_registered('l')) {
  $l=new log("/persistent_log");
  session_register('l');
  $l->write("Created $now");
  echo ("Create session and persistent log object .<p>");
 }
 
 $l->write("viewed first page $now");
 echo  "the log contains:<p>";
 echo nl2br($l->read());
?>

<a href="next.php">Move to the next page</a>
</body>

</html>