php面向对象中构造 析构 封装性

//创建一个人类  
class Person  
{  
    //下面是人的成员属性  
    var $name;  //人的名子  
    var $sex;    //人的性别  
    var $age;    //人的年龄  
 
    //定义一个构造方法参数为姓名$name、性别$sex和年龄$age  
    function __construct($name, $sex, $age)  
    {  
        //通过构造方法传进来的$name给成员属性$this->name赋初使值  
        $this->name=$name;  
        //通过构造方法传进来的$sex给成员属性$this->sex赋初使值  
        $this->sex=$sex;  
        //通过构造方法传进来的$age给成员属性$this->age赋初使值  
        $this->age=$age;  
    }  
 
    //这个人的说话方法  
    function say()  
    {  
        echo "我的名子叫：".$this->name." 性别：".$this->sex." 我的年龄是：".$this->age."";  
    }  
}  
 
//通过构造方法创建3个对象$p1、p2、$p3,分别传入三个不同的实参为姓名、性别和年龄  
$p1=new Person("张三","男", 20);  
$p2=new Person("李四","女", 30);  
$p3=new Person("王五","男", 40);  
 
//下面访问$p1对象中的说话方法  
$p1->say();  
//下面访问$p2对象中的说话方法  
$p2->say();  
//下面访问$p3对象中的说话方法  
$p3->say();  
 
输出结果为：  
我的名子叫：张三 性别：男 我的年龄是：20  
我的名子叫：李四 性别：女 我的年龄是：30  
我的名子叫：王五 性别：男 我的年龄是：40 

//创建一个人类
class Person
{
    //下面是人的成员属性
    var $name;  //人的名子
    var $sex;    //人的性别
    var $age;    //人的年龄

    //定义一个构造方法参数为姓名$name、性别$sex和年龄$age
    function __construct($name, $sex, $age)
    {
        //通过构造方法传进来的$name给成员属性$this->name赋初使值
        $this->name=$name;
        //通过构造方法传进来的$sex给成员属性$this->sex赋初使值
        $this->sex=$sex;
        //通过构造方法传进来的$age给成员属性$this->age赋初使值
        $this->age=$age;
    }

    //这个人的说话方法
    function say()
    {
        echo "我的名子叫：".$this->name." 性别：".$this->sex." 我的年龄是：".$this->age."";
    }
}

//通过构造方法创建3个对象$p1、p2、$p3,分别传入三个不同的实参为姓名、性别和年龄
$p1=new Person("张三","男", 20);
$p2=new Person("李四","女", 30);
$p3=new Person("王五","男", 40);

//下面访问$p1对象中的说话方法
$p1->say();
//下面访问$p2对象中的说话方法
$p2->say();
//下面访问$p3对象中的说话方法
$p3->say();

输出结果为：
我的名子叫：张三 性别：男 我的年龄是：20
我的名子叫：李四 性别：女 我的年龄是：30
我的名子叫：王五 性别：男 我的年龄是：40

//使用private这个关键字来对属性和方法进行封装：  
//原来的成员:  
var $name;          //声明人的姓名  
var $sex;           //声明人的性别  
var $age;           //声明人的年龄  
function run(){…….}  
 
//改成封装的形式：  
private $name;          //把人的姓名使用private关键字进行封装  
private $sex;           //把人的性别使用private关键字进行封装  
private $age;           //把人的年龄使用private关键字进行封装  
private function run(){……}  //把人的走路方法使用private关键字进行封装 

//使用private这个关键字来对属性和方法进行封装：
//原来的成员:
var $name;   //声明人的姓名
var $sex;   //声明人的性别
var $age;   //声明人的年龄
function run(){…….}

//改成封装的形式：
private $name;    //把人的姓名使用private关键字进行封装
private $sex;   //把人的性别使用private关键字进行封装
private $age;   //把人的年龄使用private关键字进行封装
private function run(){……} //把人的走路方法使用private关键字进行封装注意：只要是成员属性前面有其它的关键字就要去掉原有的关键字”var”. 通过private就可以把人的成员（成员属性和成员方法）封装上了。封装上的成员就不能被类外面直接访问了，只有对象内部自己可以访问；下面的代码会产生错误：

class Person  
{  
    //下面是人的成员属性  
    private $name;  //人的名子，被private封装上了  
    private $sex;    //人的性别, 被private封装上了  
    private $age;    //人的年龄, 被private封装上了  
 
    //这个人可以说话的方法  
    function say()  
    {  
        echo "我的名子叫：".$this->name." 性别：".$this->sex." 我的年龄是：".$this->age."";  
    }         
 
    //这个人可以走路的方法, 被private封装上了  
    private function run()  
    {  
        echo "这个人在走路";  
    }  
}  
//实例化一个人的实例对象  
$p1=new Person();  
 
//试图去给私有的属性赋值， 结果会发生错误  
$p1->name="张三";  
$p1->sex="男";  
$p1->age=20;  
 
//试图去打印私有的属性， 结果会发生错误  
echo $p1->name."";  
echo $p1->sex."";  
echo $p1->age."" 
 
//试图去打印私有的成员方法， 结果会发生错误  
$p1->run();  
 
输出结果为：  
Fatal error: Cannot access private property Person::$name 
Fatal error: Cannot access private property Person::$sex 
Fatal error: Cannot access private property Person::$age 
Fatal error: Cannot access private property Person::$name 
Fatal error: Call to private method Person::run() from context '' 

class Person
{
    //下面是人的成员属性
    private $name;  //人的名子，被private封装上了
    private $sex;    //人的性别, 被private封装上了
    private $age;    //人的年龄, 被private封装上了

    //这个人可以说话的方法
    function say()
    {
        echo "我的名子叫：".$this->name." 性别：".$this->sex." 我的年龄是：".$this->age."";
    }  

    //这个人可以走路的方法, 被private封装上了
    private function run()
    {
        echo "这个人在走路";
    }
}
//实例化一个人的实例对象
$p1=new Person();

//试图去给私有的属性赋值， 结果会发生错误
$p1->name="张三";
$p1->sex="男";
$p1->age=20;

//试图去打印私有的属性， 结果会发生错误
echo $p1->name."";
echo $p1->sex."";
echo $p1->age.""

//试图去打印私有的成员方法， 结果会发生错误
$p1->run();

输出结果为：
Fatal error: Cannot access private property Person::$name
Fatal error: Cannot access private property Person::$sex
Fatal error: Cannot access private property Person::$age
Fatal error: Cannot access private property Person::$name
Fatal error: Call to private method Person::run() from context ''

function say()  
{  
    echo "我的名子叫：".$this->name." 性别：".$this->sex." 我的年龄是：".$this->age." 
";  
    //在这里也可以访问私有方法  
    //$this->run();  
} 

//这个人可以说话的方法, 说出自己的私有属性，在这里也可以访问私有方法
function say()
{
 echo "我的名子叫：".$this->name." 性别：".$this->sex." 我的年龄是：".$this->age."
";
 //在这里也可以访问私有方法
 //$this->run();
}因为成员方法say()是公有的， 所以我们在类的外部调用say()方法是可以的，改变上面的代码；

class Person  
{  
    //下面是人的成员属性  
    private $name;  //人的名子，被private封装上了  
    private $sex;    //人的性别, 被private封装上了  
    private $age;    //人的年龄, 被private封装上了  
 
    //定义一个构造方法参数为私有的属性姓名$name、性别$sex和年龄$age进行赋值  
    function __construct($name, $sex, $age)  
    {  
        //通过构造方法传进来的$name给私有成员属性$this->name赋初使值  
        $this->name=$name;  
        //通过构造方法传进来的$sex给私有成员属性$this->sex赋初使值  
        $this->sex=$sex;  
        //通过构造方法传进来的$age给私有成员属性$this->age赋初使值  
        $this->age=$age;  
    }  
 
    //这个人可以说话的方法, 说出自己的私有属性，在这里也可以访问私有方法  
    function say()  
    {  
        echo "我的名子叫：".$this->name." 性别：".$this->sex." 我的年龄是：".$this->age." 
";  
    }  
}  
 
//通过构造方法创建3个对象$p1、p2、$p3,分别传入三个不同的实参为姓名、性别和年龄  
$p1=new Person("张三"，"男", 20);  
$p2=new Person("李四"，"女", 30);  
$p3=new Person("王五"，"男", 40);  
 
//下面访问$p1对象中的说话方法  
$p1->say();  
//下面访问$p2对象中的说话方法  
$p2->say();  
//下面访问$p3对象中的说话方法  
$p3->say();  
 
输出结果为：  
我的名子叫：张三 性别：男 我的年龄是：20  
我的名子叫：李四 性别：女 我的年龄是：30  
我的名子叫：王五 性别：男 我的年龄是：40 

class Person
{
    //下面是人的成员属性
    private $name;  //人的名子，被private封装上了
    private $sex;    //人的性别, 被private封装上了
    private $age;    //人的年龄, 被private封装上了

    //定义一个构造方法参数为私有的属性姓名$name、性别$sex和年龄$age进行赋值
    function __construct($name, $sex, $age)
    {
        //通过构造方法传进来的$name给私有成员属性$this->name赋初使值
        $this->name=$name;
        //通过构造方法传进来的$sex给私有成员属性$this->sex赋初使值
        $this->sex=$sex;
        //通过构造方法传进来的$age给私有成员属性$this->age赋初使值
        $this->age=$age;
    }

    //这个人可以说话的方法, 说出自己的私有属性，在这里也可以访问私有方法
    function say()
    {
        echo "我的名子叫：".$this->name." 性别：".$this->sex." 我的年龄是：".$this->age."
";
    }
}

//通过构造方法创建3个对象$p1、p2、$p3,分别传入三个不同的实参为姓名、性别和年龄
$p1=new Person("张三"，"男", 20);
$p2=new Person("李四"，"女", 30);
$p3=new Person("王五"，"男", 40);

//下面访问$p1对象中的说话方法
$p1->say();
//下面访问$p2对象中的说话方法
$p2->say();
//下面访问$p3对象中的说话方法
$p3->say();

//私有的属性年龄  
prvate $age;  
 
//为外部提供一个公有设置年龄的方法  
function setAge($age)  
{  
    //在给属性赋值的时候，为了避免非法值设置给属性  
    if($age<0 || $age>130)  
        return;  
    $this->age=$age;  
}  
 
//为外部提供一个公有获取年龄的方法  
function getAge()  
{  
    return($this->age);  
} 

//私有的属性年龄
prvate $age;

//为外部提供一个公有设置年龄的方法
function setAge($age)
{
 //在给属性赋值的时候，为了避免非法值设置给属性
 if($age<0 || $age>130)
  return;
 $this->age=$age;
}

//为外部提供一个公有获取年龄的方法
function getAge()
{
 return($this->age);
}上

<?php
// 删除文件夹，及其其下所有文件

function deldir($dir) {

  $dh=opendir($dir);
  
  while ($file=readdir($dh)) {
  
    if($file!="." && $file!="..") {
    
    $fullpath=$dir."/".$file;
    
      if(!is_dir($fullpath)) {
      
        unlink($fullpath);
      
      } else {
      
        deldir($fullpath);
      
      }
    
    }
  
  }
  
  closedir($dh);
  
  if(rmdir($dir)) {
  
    return true;
  
  } else {
  
    return false;
  
  }

}
?>

//__get()方法用来获取私有属性  
function __get($property_name)  
{  
    if(isset($this->$property_name)) {  
        return($this->$property_name);  
    }else {  
        return(NULL);  
    }  
}   
 
//__set()方法用来设置私有属性  
function __set($property_name, $value)  
{  
    $this->$property_name = $value;  
} 

//__get()方法用来获取私有属性
function __get($property_name)
{
    if(isset($this->$property_name)) {
        return($this->$property_name);
    }else {
        return(NULL);
    }
}

//__set()方法用来设置私有属性
function __set($property_name, $value)
{
 $this->$property_name = $value;
}__

class Person  
{  
    //下面是人的成员属性， 都是封装的私有成员  
    private $name;  //人的名子  
    private $sex;    //人的性别  
    private $age;    //人的年龄  
 
    //__get()方法用来获取私有属性  
    function __get($property_name)  
    {  
        echo "在直接获取私有属性值的时候，自动调用了这个__get()方法<br>";  
        if(isset($this->$property_name)) {  
            return($this->$property_name);  
        }else {  
            return(NULL);  
        }  
    }   
 
    //__set()方法用来设置私有属性  
    function __set($property_name, $value)  
    {  
        echo "在直接设置私有属性值的时候，自动调用了这个__set()方法为私有属性赋值<br>";  
        $this->$property_name = $value;  
    }  
}  
 
$p1=new Person();  
 
//直接为私有属性赋值的操作， 会自动调用__set()方法进行赋值  
$p1->name="张三";  
$p1->sex="男";  
$p1->age=20;  
 
//直接获取私有属性的值， 会自动调用__get()方法，返回成员属性的值  
echo "姓名：".$p1->name."<br>";  
echo "性别：".$p1->sex."<br>";  
echo "年龄：".$p1->age."<br>"; 

class Person
{
    //下面是人的成员属性， 都是封装的私有成员
    private $name;  //人的名子
    private $sex;    //人的性别
    private $age;    //人的年龄

    //__get()方法用来获取私有属性
    function __get($property_name)
    {
        echo "在直接获取私有属性值的时候，自动调用了这个__get()方法<br>";
        if(isset($this->$property_name)) {
            return($this->$property_name);
        }else {
            return(NULL);
        }
 }

    //__set()方法用来设置私有属性
    function __set($property_name, $value)
    {
        echo "在直接设置私有属性值的时候，自动调用了这个__set()方法为私有属性赋值<br>";
        $this->$property_name = $value;
    }
}

$p1=new Person();

//直接为私有属性赋值的操作， 会自动调用__set()方法进行赋值
$p1->name="张三";
$p1->sex="男";
$p1->age=20;

//直接获取私有属性的值， 会自动调用__get()方法，返回成员属性的值
echo "姓名：".$p1->name."<br>";
echo "性别：".$p1->sex."<br>";
echo "年龄：".$p1->age."<br>";

private function __isset($nm)  
{  
    echo "当在类外部使用isset()函数测定私有成员$nm时，自动调用";  
    return isset($this->$nm);  
} 

private function __isset($nm)
{
 echo "当在类外部使用isset()函数测定私有成员$nm时，自动调用";
 return isset($this->$nm);
}

private function __unset($nm)  
{  
    echo "当在类外部使用unset()函数来删除私有成员时自动调用的";  
    unset($this->$nm);  
} 

private function __unset($nm)
{
 echo "当在类外部使用unset()函数来删除私有成员时自动调用的";
 unset($this->$nm);
}我们来看一个完整的实例：

class Person  
{  
    // 下面是人的成员属性  
    private $name; // 人的名字  
    private $sex; // 人的性别  
    private $age; // 人的年龄  
    //__get()方法用来获取私有属性  
    private function __get($property_name)  
    {  
        if (isset($this->$property_name)) {  
            return($this->$property_name);  
        } else {  
            return(NULL);  
        }  
    }  
    // __set()方法用来设置私有属性  
    private function __set($property_name, $value)  
    {  
        $this->$property_name = $value;  
    }  
    // __isset()方法  
    private function __isset($nm)  
    {  
        echo "isset()函数测定私有成员时，自动调用";  
        return isset($this->$nm);  
    }  
    // __unset()方法  
    private function __unset($nm)  
    {  
        echo "当在类外部使用unset()函数来删除私有成员时自动调用的";  
        unset($this->$nm);  
    }  
}  
$p1 = new Person();  
$p1->name = "this is a person name";  
// 在使用isset()函数测定私有成员时，自动调用__isset()方法帮我们完成，返回结果为true  
echo var_dump(isset($p1->name)) . "";  
echo $p1->name . "";  
// 在使用unset()函数删除私有成员时，自动调用__unset()方法帮我们完成，删除name私有属性  
unset($p1->name);  
// 已经被删除了， 所这行不会有输出  
echo $p1->name; 

class Person
{
 // 下面是人的成员属性
 private $name; // 人的名字
 private $sex; // 人的性别
 private $age; // 人的年龄
 //__get()方法用来获取私有属性
 private function __get($property_name)
 {
  if (isset($this->$property_name)) {
   return($this->$property_name);
  } else {
   return(NULL);
  }
 }
 // __set()方法用来设置私有属性
 private function __set($property_name, $value)
 {
  $this->$property_name = $value;
 }
 // __isset()方法
 private function __isset($nm)
 {
  echo "isset()函数测定私有成员时，自动调用";
  return isset($this->$nm);
 }
 // __unset()方法
 private function __unset($nm)
 {
  echo "当在类外部使用unset()函数来删除私有成员时自动调用的";
  unset($this->$nm);
 }
}
$p1 = new Person();
$p1->name = "this is a person name";
// 在使用isset()函数测定私有成员时，自动调用__isset()方法帮我们完成，返回结果为true
echo var_dump(isset($p1->name)) . "";
echo $p1->name . "";
// 在使用unset()函数删除私有成员时，自动调用__unset()方法帮我们完成，删除name私有属性
unset($p1->name);
// 已经被删除了， 所这行不会有输出
echo $p1->name;输出结果为：

isset()函数测定私有成员时，自动调用  
bool(true)  
this is a person name 

isset()函数测定私有成员时，自动调用
bool(true)
this is a person name当在类外部使用unset()函数来删除私有成员时自动调用的 __set()、__get()、__isset()、__unset()

//定义一个“人”类做为父类
class Person
{
    //下面是人的成员属性
    var $name;  //人的名子
    var $sex;    //人的性别
    var $age;    //人的年龄

    //定义一个构造方法参数为属性姓名$name、性别$sex和年龄$age进行赋值
    function __construct($name, $sex, $age)
    {
        $this-&gt;name=$name;
        $this-&gt;sex=$sex;
        $this-&gt;age=$age;
    }

    //这个人可以说话的方法, 说出自己的属性
    function say()
    {
        echo "我的名子叫：".$this-&gt;name." 性别：".$this-&gt;sex." 我的年龄是：".$this-&gt;age."&lt;br&gt;";
    }
}

class Student extends Person
{
    var $school;  //学生所在学校的属性

    //这个学生学习的方法
    function study()
    {
        echo "我的名子叫：".$this-&gt;name." 我正在”.$this-&gt;school.” 学习&lt;br&gt;";
    }

    //这个学性可以说话的方法, 说出自己所有的属性，覆盖了父类的同名方法
    function say()
    {
        echo "我的名子叫：".$this-&gt;name." 性别：".$this-&gt;sex." 我的年龄是：".$this-&gt;age."我在".$this-&gt;school."上学.&lt;br&gt;";
    }
}

class Student extends Person
{
    var $school;  //学生所在学校的属性

    //这个学生学习的方法
    function study()
    {
        echo "我的名子叫：".$this-&gt;name." 我正在”.$this-&gt;school.” 学习&lt;br&gt;";
    }

    //这个学性可以说话的方法, 说出自己所有的属性，覆盖了父类的同名方法
    function say()
    {
        //使用父类的“类名：：“来调用父类中被覆盖的方法；
        //Person::say();

        //或者使用“parent：：”的方试来调用父类中被覆盖的方法；
        parent::say();

        //加上一点自己的功能
        echo “我的年龄是：".$this-&gt;age."我在".$this-&gt;school."上学.&lt;br&gt;";
    }
}

class Student extends Person
{
    var $school;  //学生所在学校的属性

    function __construct($name, $sex, $age, $school)
    {
        //使用父类中的方法为原有的属性赋值
        parent::__construct($name, $sex, $age);
        $this-&gt;school=$school;
    }

    //这个学生学习的方法
    function study()
    {
        echo "我的名子叫：".$this-&gt;name." 我正在”.$this-&gt;school.” 学习&lt;br&gt;";
    }

    //这个人可以说话的方法, 说出自己的属性
    function say()
    {
        parent::say();
        //加上一点自己的功能
        echo “我的年龄是：".$this-&gt;age."我在".$this-&gt;school."上学.&lt;br&gt;";
    }
}

//定义一个“人”类做为父类
class Person
{
    //下面是人的成员属性
    var $name;  //人的名子
    var $sex;    //人的性别
    var $age;    //人的年龄

    //定义一个构造方法参数为属性姓名$name、性别$sex和年龄$age进行赋值
    function __construct($name, $sex, $age)
    {
        $this-&gt;name=$name;
        $this-&gt;sex=$sex;
        $this-&gt;age=$age;
    }

    //这个人可以说话的方法, 说出自己的属性
    function say()
    {
        echo "我的名子叫：".$this-&gt;name." 性别：".$this-&gt;sex." 我的年龄是：".$this-&gt;age."&lt;br&gt;";
    }
}

//定义一个“学生类”类做为父类
class Student
{
    //下面是人的成员属性
    var $name;  //人的名子
    var $sex;    //人的性别
    var $age;    //人的年龄
    var $school;  //学生所在学校的属性

    //定义一个构造方法参数为属性姓名$name、性别$sex和年龄$age进行赋值
    function __construct($name="", $sex="", $age="", $school="")
    {
        $this-&gt;name=$name;
        $this-&gt;sex=$sex;
        $this-&gt;age=$age;
        $this-&gt;school=$school;
    }

    //这个人可以说话的方法, 说出自己的属性
    function say()
    {
        echo "我的名子叫：".$this-&gt;name." 性别：".$this-&gt;sex." 我的年龄是：".$this-&gt;age."&lt;br&gt;";
    }  

    //这个学生学习的方法
    function study()
    {
        echo "我的名子叫：".$this-&gt;name." 我正在".$this-&gt;school." 学习&lt;br&gt;";
    }
}

//定义一个子类“学生类“使用”extends”关键字来继承”人”类  
class Student extends Person  
{  
    //学生所在学校的属性  
    var $school;    
 
    //这个学生学习的方法  
    function study()  
    {  
        echo "我的名子叫：".$this->name." 我正在".$this->school." 学习<br>";  
    }  
} 

class Person
    {
    //下面是人的静态成员属性
    public static $myCountry="中国";
    // var $name;  //人的名子

    //这是人的静态成员方法
    public static function say()
    {
        echo "我是中国人
";
    }
}

//输出静态属性
echo Person::$myCountry;

//访问静态方法
Person::say();

//重新给静态属性赋值
Person::$myCountry="美国";
echo Person::$myCountry;

class Person  
    {  
    //下面是人的静态成员属性  
    public static $myCountry="中国";  
    // var $name;  //人的名子  
 
    //这是人的静态成员方法  
    public static function say()  
    {  
        echo "我是中国人 
";  
    }  
}  
 
//输出静态属性  
echo Person::$myCountry;  
 
//访问静态方法  
Person::say();  
 
//重新给静态属性赋值  
Person::$myCountry="美国";  
echo Person::$myCountry; 

class Person
    {
    //下面是人的静态成员属性
    public static $myCountry="中国";
    // var $name;  //人的名子

    //这是人的静态成员方法
    public static function say()
    {
        echo "我是中国人
";
    }
}

//输出静态属性
echo Person::$myCountry;

//访问静态方法
Person::say();

//重新给静态属性赋值
Person::$myCountry="美国";

class Person
{
    //下面是人的静态成员属性
    public static $myCountry="中国";

    //这是人的静态成员方法, 通过self访问其它静态成员
    public static function say()
    {
        echo "我是".self::$myCountry."";
    }
}
//访问静态方法
Person::say();

class MyClass
{
    //定义一个常量constant
    const constant = 'constant value';

    function showConstant() {
        echo  self::constant . "n";  //使用self访问，不要加”$”
    }
}

echo MyClass::constant . "n";  //使用类名来访问,也不加”$”

$class = new MyClass();
$class->showConstant();
//echo $class::constant;  是不允许的

final class Person
{
}

class Student extends Person
{
} 

//会出现下面错误:
Fatal error: Class Student may not inherit from final class (Person)

使用final关键标记的方法不能被子类覆盖，是最终版本；

class Person
{
 final function say() {}
}

class Student extends Person
{
 function say() {}
}

//会出现下面错误:
Fatal error: Cannot override final method Person::say()