php面向对象类中的$this，static，final，const，self及双冒号 :: 这几个关键字使用方法。

<?php
<span style="color:#ff0000;">// this是指向当前对象的指针</span>
class test_this{private $content; //定义变量function __construct($content){ //定义构造函数$this->content= $content;}function __destruct(){}//定义析构函数function printContent(){//定义打印函数echo $this->content.'<br />';}
}
$test=new test_this('北京欢迎你！'); //实例化对象
$test->printContent();//北京欢迎你！
$test=new test_this('新年新气象！');//再一次实例化对象
$test->printContent();//新年新气象！
echo '<br />';
<span style="color:#ff0000;">//self是指向类的本身，只跟类有关，跟任何对象实例无关</span>
class test_self{private static $first_count; //定义静态变量private $last_count;function __construct(){$this->last_count=++self::$first_count;//直接用self调用变量的值赋值给另一个变量}function __destruct(){}function print_self(){print($this->last_count);}
}
$abc=new test_self();//实例化对象
$abc->print_self();//1
echo '<br />';
<span style="color:#ff0000;">//parent是指向父类的指针</span>
class test_parent{ //基类public $name;  //定义姓名  父类成员需要定义为public，才能够在继承类中直接使用 this来调用。function __construct($name){$this->name=$name;}
}
class test_son extends test_parent{ //派生类  继承test_parentpublic $gender;//定义性别public $age;    //定义年龄function __construct($gender,$age){ //继承类的构造函数parent::__construct('nostop');//使用parent调用父类的构造函数,来进行对父类的实例化$this->gender=$gender;$this->age=$age;}function __destruct(){}function print_info(){echo $this->name.'是个'.$this->gender.'，今年'.$this->age.'岁'.'<br />';}
}
$nostop=new test_son('女性','22');//实例化test_son对象
$nostop->print_info();//执行输出函数  nostop是个女性，今年23岁
?>

$this

<span style="font-size:14px;"><?php
class MyClass{private $name;public  function __construct($name){$this->name=$name;}public function getname(){return $this->name;}public  function printName(){echo $this->getname();}
}
$myclass= new MyClass("I Like PHP");
$myclass->printName();//输出：I Like PHP
?></span>

static

<?php
class MyObject{public static $myStaticVar=0;function myMethod(){self::$myStaticVar+=2;echo self::$myStaticVar;}
}
$instance1=new MyObject();
$instance1->myMethod();
$instance2=new MyObject();
$instance2->myMethod();
//结果将分别打印2、4

<?php
class Book{static $num=0;public function showMe(){echo"您是滴".self::$num."位访客";self::$num++;}
}
$book1=new Book();
$book1->showMe();
echo"<br>";
$book2=new Book();
$book2->showMe();
echo"<br>";
echo"您是滴".Book::$num."位访客";
?>

final

<?php
final class MyClass{//此类将不允许被继承final function fun1(){......}//此方法将不允许被重写
}

const

<?php
class clss_a{private static $name="static class_a"; const PI=3.14; public $value; public static function getName(){ return self::$name; } //这种写法有误，静态方法不能访问非静态属性 public static function getName2(){ return self::$value; } public function getPI(){ return self::PI; }
}

self

PHP中 :: 、-> 、self 、$this操作符的区别

<?php
class Fruit {const CONST_VALUE = 'Fruit Color';
}
$classname = 'Fruit';
echo $classname::CONST_VALUE; // As of PHP 5.3.0
echo Fruit::CONST_VALUE;
?>

<?php
class Fruit {const CONST_VALUE = 'Fruit Color';
}
class Apple extends Fruit
{public static $color = 'Red';public static function doubleColon() {echo parent::CONST_VALUE . "\n";echo self::$color . "\n";}
}

<?php
class Fruit
{protected function showColor() {echo "Fruit::showColor()\n";}
}
class Apple extends Fruit
{// Override parent's definitionpublic function showColor(){// But still call the parent functionparent::showColor();echo "Apple::showColor()\n";}
}
$apple = new Apple();
$apple->showColor();
?>

  
<?phpclass Apple{public function showColor(){return $this->color;}}class Banana{public $color;public function __construct(){$this->color = "Banana is yellow";}public function GetColor(){return Apple::showColor();}}$banana = new Banana;echo $banana->GetColor();
?>

    
<?php
class Fruit
{static function color(){return "color";}static function showColor(){echo "show " . self::color();}
}
class Apple extends Fruit
{static function color(){return "red";}
}
Apple::showColor();
// output is "show color"!
?>