php面向对象程序设计
面向对象的优势：可读性、可重用性、稳定性、维护性、可测试性
简单格式：
［修饰符］class 类名{
[成员属性]
[成员方法]
}
完整格式：
［修饰符］class 类名 [extends 父类] [implements 接口 ] {
[成员属性]
[成员方法]
}
成员方法格式：
[修饰符] function 方法名(参数){
[方法体]
[return返回值]
}
修饰符：public protected private static abstract final
$对象名称=new 类名称();
$引用名=new 类名(构造函数)
$引用名->成员属性=赋值
$引用名->成员方法(参数)
class student{
public$name = "ssw";
public$age = "20";
publicfunction study($num,$yum){
return"学习成功";
}
}
$s = new student();
echo $s->name;
echo $s->age;
$s->study();
1、特殊的对象引用 $this(代表对象的一个引用)
class Person{
public $name;
public $sex;
public function say(){
echo "我的名子：".$this->name."性别：".$this->sex;
}
}
$p = new Person();
$p -> name = ssw;
$p -> sex =male;
$p -> say();
显示为：我的名子：ssw性别：male
2、构造方法
（1）是对象创建完成以后、第一个自动调用的方法
（2）方法名比较特殊、可以和类名相同名的方法名、
（3）作用：给对象中的成员属性赋初值
class Person{
public$name;
public$sex;
public$age;
publicfunction Person($n,$s,$a="25"){
$this->name=$n;
$this->sex=$s;
$this->age=$a;
}
publicfunction say(){
echo"我的名子：".$this->name."性别：".$this->sex."年龄：".$this->age;
}
}
$p = new Person(ssw,male,22);
$p1 = new Person(ssw,male);
$p -> say();
显示为：我的名子：ssw性别：male年龄：22
classPerson{
public $name;
public $sex;
public $age;
/*
public functionPerson($n,$s,$a="25"){
$this->name=$n;
$this->sex=$s;
$this->age=$a;
}
*/
public function__construct($n,$s,$a="25"){
$this->name=$n;
$this->sex=$s;
$this->age=$a;
}
public function say(){
echo "我的名子：".$this->name."性别：".$this->sex."年龄：".$this->age;
}
}
$p= new Person(ssw,male,22);
$p1= new Person(ssw,male);
$p-> say();
显示为：我的名子：ssw性别：male年龄：22
3、析构函数
对象释放前调用、没有参数、__destruct
classPerson{
public $name;
public $sex;
public $age;
public function__construct($n,$s,$a="25"){
$this->name=$n;
$this->sex=$s;
$this->age=$a;
}
public function say(){
echo "我的名子：".$this->name."性别：".$this->sex."年龄：".$this->age;
}
function __destruct(){
echo "{$this->name}再见！<br>";
}
}
$p= new Person(ssw,male,22);
$p1= new Person(qzx,male);
显示为：（$p在内存中存储为栈。New Person()在内中存储为堆）
qzx再见！
ssw再见！
封装继承多态
4、类的封装性
方法的封装：
（1）、Public（）公共的：能在程序的任意地方引用！类内类外都可以引用！
（2）、Protected（）保护的：声明的类内能用，继承类能引用！
（3）、Private() 私有的：只能在本类内调用
classPerson{
private $name;
private $age;
private $sex;
function__construct($name="", $age=0, $sex="男"){
$this->name=$name;
$this->age=$age;
$this->sex=$sex;
}
function getAge(){
if($this->age < 20){
return$this->age;
}else if($this->age <30){
return $this->age- 5;
}else{
return 29;
}
}
function __destruct(){
echo "再见：".$this->name;
}
}
$p1= new Person("ssw", 80, "女");
echo$p1->getAge();
显示为：29再见：ssw
5、魔术方法
__get 获取类中私有属性值的时候、自动调用的方法
自动调用、是在直接访问私有成员时、自动调用
classPerson{
private $name;
private $age;
private $sex;
function__get($a){
echo $a."get";
}
}
$p1= new Person("ssw", 80, "女");
$p1->name."<br>";
$p1->age;
显示为：name####age####
classPerson{
private $name;
private $age;
private $sex;
function__construct($name="", $age=0, $sex="男"){
$this->name =$name;
$this->age =$age;
$this->sex =$sex;
}
function__get($a){
echo $this->$a."##";
}
}
$p1= new Person("ssw", 80, "女");
$p1->name;
$p1->age;
$p1->sex;
显示为：ssw##80##女##
__set 为类中私有属性赋值的时候、自动调用的方法
自动调用、是在直接设置私有属性值时、二个参数
class Person{
private $name;
private $age;
private $sex;
function__construct($name="", $age=0, $sex="男"){
$this->name = $name;
$this->age = $age;
$this->sex = $sex;
}
function __set($n,$v){
echo $n."=".$v;
echo "<br>";
echo $this->$n=$v;
}
}
$p1 = newPerson("ssw", 80, "女");
$p1->name="王子";
显示为：name=王子王子
class Person{
private $name;
private $age;
private $sex;
function__construct($name="", $age=0, $sex="男"){
$this->name = $name;
$this->age = $age;
$this->sex = $sex;
}
function __set($n,$v){
if($n=="age"){
if($v < 0 or $v > 100)
return;
}
$this->$n = $v;
}
function __get($pre){
return $this->$pre;
}
}
$p1 = newPerson("ssw", 80, "女");
$p1->name="王子";
$p1->age=109;
$p1->sex="女";
echo $p1->name;
echo $p1->sex;
echo $p1->age;//echo $p1->__get("age");__get不是私有的、外部可以通过对象来调用
显示为：王子女80
__isset() 判断类中私有属性是否存在时、自动调用的方法
isset()在使用isset判断一个私有属性是否存在时、自动调用__isset()魔术方法、参数则是属性名称
class Person{
private$name;
private$age;
private$sex;
function__construct($name="",$age=0,$sex="男"){
$this->name=$name;
$this->age=$age;
$this->sex=$sex;
}
function__isset($Pro){
if($Pro=="age")
returnfalse;
returnisset($this->$Pro);
}
}
$p = new Person("ssw",29,"男");
if(isset($p->name)){
echo"这个对象中的name是存在的属性";
}else{
echo"对象p中不存在name值";
}
显示为：这个对象中的name是存在的属性
__unset 销毁类中私有成员时、自动调用的方法
class Person{
private$name;
private$age;
private$sex;
function__construct($name="",$age=0,$sex="男"){
$this->name=$name;
$this->age=$age;
$this->sex=$sex;
}
function__isset($Pro){
if($Pro=="age")
returnfalse;
returnisset($this->$Pro);
}
function__unset($Pro){
if($Pro!="age"){
unset($this->$Pro);
}
}
}
$p = new Person("ssw",29,"男");
unset($p->name);
if(isset($p->name)){
echo"这个对象中的name是存在的属性";
}else{
echo"对象p中不存在name值";
}
显示为：对象p中不存在name值
6、类的继承性
类的继承访问控制：
（1）、子类使用extends继承父类、子类可以将父类中所有的内容都继承过来
（2）、private 私有的权限、只能自已类里用、不能在别的类中用、包括自已的子类
（3）、protected 保护的权限、只能是自已类和自已子类中使用、不能在类外面使用
（4）、public 公有的权限、所有都可以、自已、子类、类外部都可以使用
class Person{
public$name;
protected$age;
private$sex;
function__construct($name, $age, $sex){
$this->name= $name;
$this->age= $age;
$this->sex= $sex;
}
publicfunction say(){
echo"我的性别:{$this->sex}";
}
publicfunction eat(){
}
}
class Student extends Person{
var$school;
functionstudy(){
}
}
class Teacher extends Student{
var$gz;
functionjiao(){
echo"我的年龄是：".$this->age;
}
}
$t = new Teacher("ssw",30,"男");
echo $t -> name;
$t -> jiao();
$t -> say();
显示为：ssw我的年龄是：30我的性别:男
继承中的重载（覆盖）--在子类中可以重写父类同名的方法（方法也可以拓展）
对象->成员
类::成员
Parent::成员 使用用parent::访问父类中被覆盖的方法
重要：只要是子类的构造方法、去覆盖父类中的构造方法、一定要在子类的最上面调用一下父类被覆盖的方法
权限问题：子类只能大于或等于父类的权限、不能小于
class Person{ //使用用parent::访问父类中被覆盖的方法
public$name;
protected$age;
protected$sex;
function__construct($name, $age, $sex){
$this->name= $name;
$this->age= $age;
$this->sex= $sex;
}
publicfunction say(){
echo"我的名子：{$this->name},我的年龄是：{$this->age},我的性别:{$this->sex} <br>";
}
}
class Student extends Person{
var$school="jtuniverty!";
functionsay(){
// echo"我的名子：{$this->name},我的年龄是：{$this->age},我的性别:{$this->sex} <br>";
// Person::say();
parent::say();//这三个是一样的！
echo"我的学校是：{$this->school}";
}
}
$p = new Student("ssw", 28,"男");
$p -> say();
显示为：我的名子：ssw,我的年龄是：28,我的性别:男我的学校是：jtuniverty!
class Person{ //子类的构造方法、去覆盖父类中的构造方法
public$name;
protected$age;
protected$sex;
function__construct($name, $age, $sex){
$this->name= $name;
$this->age= $age;
$this->sex= $sex;
}
publicfunction say(){
echo"我的名子：{$this->name},我的年龄是：{$this->age},我的性别:{$this->sex} ";
}
}
class Student extends Person{
var$school;
function__construct($name, $age, $sex, $school){
parent::__construct($name,$age, $sex);
$this->school= $school;
}
functionsay(){
parent::say();//这三个是一样的！
echo"我的学校是：{$this->school}";
}
}
$p = new Student("ssw", 28,"男", "上海交通大学");
$p -> say();
显示为：我的名子：ssw,我的年龄是：28,我的性别:男我的学校是：上海交通大学
7、Php常见的关键字
Instanceof 操作符用于检测当前对象实例是否属于某一个类的类型
If($p instanceof Person){
Echo“这个$p是Person类的对象”;
}else{
Echo“对象不属于这个类”;
}
Final 用于类方法名前、不能修饰成员属性
（1）final可以修饰类、这个类不能扩展、不能有子类、这个类是最终类
（2）final可以修饰方法、这个方法、就不能在子类中覆盖、不能让子类来改这个方法、或扩展这个方法、这个方法也是最终方法。
Static 可以修饰属性和方法、不能修饰类
（1）使用static修饰成员属性、存在内存的初始化表态段
（2）可以被所有同一个类的对象共用
（3）第一个用到类、类在加载到内存时、就已经将静态的成员加到了内存
对象->成员
类：：成员
（4）静态的成员一定要使用类来访问（静态成员不可以由对象通过->操作符来访问）
（5）self可以在类中的方法中、代表自已类的（$this）。子类用parent::静态名
（6）静态成员一但被加载、只有脚本结束才释放
（7）在静态的方法中、是不能访问非静态的成员的
（8）只要是能使用静态的环境下声明方法、就最好使用静态方法（效率）
class Foo
{
public static $my_static = ‘foo‘;
public function staticValue() {
return self::$my_static;
}
}
class Bar extends Foo
{
public function fooStatic() {
return parent::$my_static;
}
}
print Foo::$my_static . "\n";
$foo = new Foo();
print $foo->staticValue() ."\n";
//print $foo->my_static ."\n"; // Undefined"Property" my_static
//print $foo::$my_static . "\n";
//$classname = ‘Foo‘;
//print $classname::$my_static ."\n"; // PHP 5.3.0之后可以动态调用
print Bar::$my_static . "\n";
$bar = new Bar();
print $bar->fooStatic() ."\n";
显示为：foofoo foo foo
单态设计模式
单态（单例、单件）
（1）如果想让一个类、只能有一个对象、就要先让这个类、不能创建对象、将构造方法private
（2）可以在类的内存使用一个方法、来创建对象
class Person{
static $obj = null;
static function getObj(){
//如果第一次调用时、没有对象则创建、以后调用时、直接使用第一次创建的对象
if(is_null(self::$obj)){
self::$obj = newself;
}
return self::$obj;
}
function __destruct(){
echo "####";
}
function say(){
echo "say";
}
}
$p =Person::getObj();
$p ->say();
显示为：say####
Const（类常量）修饰的成员属性为常量、只能修饰成员属性
类中：
（1）常量建议用大写、不能使用$
（2）常量一定要在声明时就给好初值
（3）常量的访问方式和static的访问方式相同、但只能读
在类外部使用类名：：常量名
在类内部使用 self：：常量名
class MyClass
{
const constant = ‘cv‘;
function showConstant() {
echo self::constant . "\n";
}
}
echoMyClass::constant . "\n";
//$classname ="MyClass";
//echo$classname::constant . "\n"; // PHP 5.3.0之后
$class = newMyClass();
$class->showConstant();
//echo$class::constant."\n"; // PHP 5.3.0之后
显示为：cv cv
8、php魔术方法
__construct() __destruct() __set() __get() __isset() __unset()
__tostring()
（1）直接使用 echo print printf输出一个对象引用时、自动调用这个方法
（2）将对象的基本信息放在__toString()方法内部、形成字符串返回
（3）__toString()方法中、不能有参数、而且必须返回一个字符串
class test{
private $foo;
public function __construct($foo){
$this->foo = $foo;
}
public function __toString(){
return $this->foo;
}
}
$p = newtest("ssw");
echo $p;
显示为：ssw
克隆对象__clone()方法
克隆对象：
（1）使用clone这个关键字复制一个对象
__clone()魔术方法：
（1）是在克隆对象时、自动调用的方法
（2）作用：和构造方法一样、是对新克隆的对象进行初使化
（3）在这个__clone()方法中$this代表的是副本、所以就可以给所有副本的成员初始化
class Person{
public $name;
public $age;
public $sex;
function __construct($name,$age,$sex){
$this->name = $name;
$this->age = $age;
$this->sex = $sex;
}
function say(){
echo "名子：{$this->name},年龄：{$this->age},性别：{$this->sex}";
}
function __destruct(){
}
function __clone(){
$this->name="克隆的";
$this->age=2;
}
}
$p = newPerson("ssw", 22, "男");
$p->say();
echo"<br>";
$p2=clone $p;
$p2->name="www";
$p2->say();
显示为：
名子：ssw,年龄：22,性别：男
名子：www,年龄：2,性别：男
__call()魔术方法：
（1）在调用一个对象中不存的方法时、自动调用__call方法
（2）有二个参数、第一个参数是、调用的不存在的方法的方法名、第二个参数、调用这个不存在的方法名的方法参数、
（3）作用：可以写提示、但这个不是主要的功能、将方法的功能相似、但方法名不同的、就可以用这个方式来完成
class Person{
public $name;
public $age;
public $sex;
public $marr = array("say","run", "eat");
function __call($method,$args){
if(in_array($method,$this->marr)){
echo$args[‘0‘]."<br>";
}else{
echo "你调用的方法{$method}()不存在<br>";
}
}
function __construct($name,$age,$sex){
$this->name = $name;
$this->age = $age;
$this->sex = $sex;
}
}
$p = newPerson();
$p->say("sss");
$p->run("rrr");
$p->eat("eee");
$p->ww("www");
显示为：sss rrr eee你调用的方法ww()不存在
对象串行化
$p=newPerson();//声明一个对象
$str=serialize($p);//将对象串行化
File_put_contents(“objstr.txt”,$str);//将字符串保存在文件objstr.txt中
——————————
读出字符串从文件中、返串行化
$str=file_get_contents(“objstr.txt”);
$p =unserialize($str);
$p->say();
__sleep() 在串行化时自动调用方法
作用：可以设置需要串行化的对象属性
只要在这个方法中、返回一个数、在数组中声明了那个属性、那个属性就会被串行化、没有在这个数组中的就不被串行化、默认这个方法、全部属性都串行化、
__wakeup() 在返串行化时自动调用的方法
作用：对象串行化回来的对象、进行初始化，用的和下面二个方法作用相似
__construct()
__clone()
Function __sleep(){
Echo “串行化name和age”;
Return array(“name”,”age”);
}
Function __wakeup(){
Echo “返串行化时自动调用这个方法”;
$this->age=12;
}
数组串行化
Json_encode串行化
Json_decode返串行化
$arr =array("name"=>"ssw", "age"=>10,"sex"=>"男");
//串行化
$str =json_encode($arr);
//返串行化、第二个参数true返串行化为数组(无第二个参数为对象 )
$parr =json_decode($str, true);
echo$parr[‘name‘];
显示为：ssw
魔术方法__set_state()
(1)、eval()函数、检查并执行php代码
$arr ="echo ‘ss‘;";
echo $arr;
eval($arr);
显示为：echo ‘ss‘; ss
(2)var_export()返回传递给该函数的变量的结构信息(和var_dump类似)
返回合法的php代码、可以直接当作php代码赋值一个变量
$arr = array ( "apple" ,"banana" , "orange" );
var_export ( $arr );
显示为：array ( 0 => ‘apple‘, 1=> ‘banana‘, 2 => ‘orange‘, )
__set_state()方法、就是在使用var_export()方法时、导出一个类的信息时自动调用的方法
输出内容以该魔术方法的返回值为准。__set_state()必须的为静态（static）函数、参数必为数组。
class Person{
public $name;
public $age;
public $sex;
function __construct($name, $age,$sex){
$this->name = $name;
$this->age = $age;
$this->sex = $sex;
}
static function __set_state($arr){
print_r($arr);
echo"<br>";
$p = newPerson("李静", 20, "女");
return $p;
}
}
$p = newPerson("ss", 39, "女");
//$p ->name = "111";
//$p -> age= 30;
eval(‘$b=‘.var_export($p, true).";");
var_dump($b);
显示为：
Array( [name] => ss [age] => 39 [sex] => 女 )
object(Person)#2 (3) { ["name"]=> string(6) "李静"["age"]=> int(20) ["sex"]=> string(3) "女"}
class Person{
public $name;
public $age;
public $sex;
function __construct($name, $age,$sex){
$this->name = $name;
$this->age = $age;
$this->sex = $sex;
}
static function __set_state($arr){
//print_r($arr);
$p = newPerson("李静", 20, "女");
$p->name=$arr[‘name‘];
$p->age=$arr[‘age‘];
return $p;
}
}
$p = newPerson("ss", 39, "女");
$p -> name= "111";
$p -> age =30;
eval(‘$b=‘.var_export($p, true).";");
var_dump($b);
显示为：object(Person)#2 (3) {["name"]=> string(3) "111" ["age"]=>int(30) ["sex"]=> string(3) "女" }
Php5.3以后新的魔术方法
__invoke()在创建实例后、可以直接调用对象
class Person{
public $name;
public $age;
public $sex;
function __construct($name, $age,$sex){
$this->name = $name;
$this->age = $age;
$this->sex = $sex;
}
function __invoke($a,$b,$c){
echo "在对象引用后加上()调用时自动调用这个方法{$a}{$b}{$c}";
}
}
$p = newPerson("ss", 39, "女");
$p(1,2,3);
显示为：在对象引用后加上()调用时自动调用这个方法123
__callstatic()调用不存的在静态方法时、自动调用这个函数
class Person{
public $name;
public $age;
public $sex;
function __construct($name, $age,$sex){
$this->name = $name;
$this->age = $age;
$this->sex = $sex;
}
static function__callstatic($method, $args){
echo "你调用的静态方法 $method(".implode(".",$args).")不存在";
}
}
$p = newPerson("ss", 39, "女");
Person::hello(1,2,3);
显示为：你调用的静态方法 hello(1.2.3)不存在
__autoload 只要在这个脚本中、需要加载类的时候（必须用到类名）、就自动调用这个方法
function__autoload($classname){
echo $classname."<br>";
includestrtolower($classname).".class.php";
}
$t = newTest();
$t ->one();
显示为：Test ttt
类文件
test.class.php
class Test{
public $name;
public function one(){
echo "ttt";
}
}
9、php抽象方法和抽象类
抽象方法：
（1） 声明一个方法、没有方法体（就是不能有{}）、而且直接分号结束
（2） 如果是抽象方法、必须使用abstract（抽象关键词来修饰）
（3） 除了抽象类中可以有抽象方法、以外、和正常的类完全一样
抽象类：
（1） 如果类中有一个方法为抽象方法、这个类就是抽象类
（2） 如果声明一个抽象类、这个类必须要使用abstract关键字来修饰
（3） 抽象类不能创建对象、必须写这个类的子类、将抽象类中的抽象的方法覆盖（加上方法体）
（4） 子类必须全部实（覆盖重写）抽象方法、这个类才能创建对象、如果只实现部分、那么还有抽象方法、则类也就必须是抽象类
抽象方法作用：
抽象方法的作用就是规定了、子类必须有这个方法的实现、功能交给子类。
只写出来结构、而没有实现、实现交给具体的子类（按自已的功能）去实现。
抽象类的作用：
就是要求子类的结构规范、所以抽象类就是一个规范
abstract classAbstractClass
{
// 强制要求子类定义这些方法
abstract protected function getValue();
abstract protected functionprefixValue($prefix);
// 普通方法（非抽象方法）
public function printOut() {
print $this->getValue() ."\n";
}
}
classConcreteClass1 extends AbstractClass
{
protected function getValue() {
return "ConcreteClass1";
}
public function prefixValue($prefix) {
return"{$prefix}ConcreteClass1";
}
}
classConcreteClass2 extends AbstractClass
{
public function getValue() {
return "ConcreteClass2";
}
public function prefixValue($prefix) {
return"{$prefix}ConcreteClass2";
}
}
$class1 = newConcreteClass1;
$class1->printOut();
echo$class1->prefixValue(‘FOO_‘) ."\n";
$class2 = newConcreteClass2;
$class2->printOut();
echo$class2->prefixValue(‘FOO_‘) ."\n";
显示为：ConcreteClass1FOO_ConcreteClass1 ConcreteClass2 FOO_ConcreteClass2
10、PHP接口
抽象类是一种抽象的类、接口是一种特殊的抽象类、接口也是一种特殊特殊的类
（1） 抽象类和接口都有抽象方法
（2） 抽象类和接口都不能创建实例对象
（3） 抽象类和接口的使用意义也就是作用相同
接口和抽象类相比、特殊在哪里：
（1） 接口中的方法、必须全部是抽象方法（不能用不抽象的方法）所有在接口中的抽象方法不需要使用abstract、直接使用分号结束即可。
（2） 接口中的成员属性、必须是常量、（不能是变量）接口常量和类常量的使用完全相同，但是不能被子类或子接口所覆盖
（3） 所有的权限必须是公有的(public)
（4） 声明接口不使用class、而是使用interface
（5） 接口也可以继承、通过extends操作符
（6） 可以使用一个类来实现接口中的全部方法、也可以使用一个抽象类、来实现接口中的部分方法
（7） 类或抽象类实现一个接口用implements关键字操作。
// 声明一个‘iTemplate‘接口
interfaceiTemplate{
public function setVariable($name, $var);
public function getHtml($template);
}
// 实现接口
class Templateimplements iTemplate{
private $vars = array();
public function setVariable($name, $var){
$this->vars[$name] = $var;
}
public function getHtml($template) {
return $template;
}
}
//接口也可以继承、通过extends操作符
interface a{
public function foo();
}
interface bextends a{
public function baz(Baz $baz);
}
Class world {
Function test(){}
}
// 正确写法
class cextents world implements b{
public function foo(){
}
publicfunction baz(Baz $baz){
}
}
//接口继承多个接口、然后类来实现在
interface a{
public function foo();
}
interface b{
public function bar();
}
interfacec extends a, b{
public function baz();
}
class dimplements c{
public function foo(){
}
public function bar(){
}
public function baz(){
}
}
接口常量（和类常量用法一样）
interface a{
const b = ‘Interface constant‘;
}
// 输出接口常量
echo a::b;
显示为：Interface constant
PHP多态
interface USB {
const WIDTH = 12;
const HEIGHT = 3;
function load();
function run();
function stop();
}
class Cumputer {
function useUSB(USB $usb) {
$usb -> load();
$usb -> run();
$usb -> stop();
}
}
class Mouse implements USB{
function load() {
echo "加载鼠标成功!<br>";
}
function run() {
echo "运行鼠标功能!<br>";
}
function stop() {
echo "鼠标工作结束!<br>";
}
}
class KeyPress implements USB {
function load() {
echo "加载键盘成功!<br>";
}
function run() {
echo "运行键盘成功!<br>";
}
function stop() {
echo "停止键盘使用!<br>";
}
}
class Worker {
function work() {
$c = new Cumputer();
$m = new Mouse;
$k = new KeyPress;
$c->useUSB($k);
$c->useUSB($m);
}
}
$w = new Worker;
$w -> work();
显示为：
加载键盘成功!
运行键盘成功!
停止键盘使用!
加载鼠标成功!
运行鼠标功能!
鼠标工作结束!
与类有关的魔术常量和函数
|
__LINE__ |
文件中的当前行号。 |
|
__FILE__ |
文件的完整路径和文件名。如果用在被包含文件中，则返回被包含的文件名。自 PHP 4.0.2 起，__FILE__ 总是包含一个绝对路径（如果是符号连接，则是解析后的绝对路径），而在此之前的版本有时会包含一个相对路径。 |
|
__DIR__ |
文件所在的目录。如果用在被包括文件中，则返回被包括的文件所在的目录。它等价于 dirname(__FILE__)。除非是根目录，否则目录中名不包括末尾的斜杠。（PHP 5.3.0中新增） = |
|
__FUNCTION__ |
函数名称（PHP 4.3.0 新加）。自 PHP 5 起本常量返回该函数被定义时的名字（区分大小写）。在 PHP 4 中该值总是小写字母的。 |
|
__CLASS__ |
类的名称（PHP 4.3.0 新加）。自 PHP 5 起本常量返回该类被定义时的名字（区分大小写）。在 PHP 4 中该值总是小写字母的。 |
|
__METHOD__ |
类的方法名（PHP 5.0.0 新加）。返回该方法被定义时的名字（区分大小写）。 |
|
__NAMESPACE__ |
当前命名空间的名称（大小写敏感）。这个常量是在编译时定义的 |
class_alias— Creates an alias for a class
class_exists— 检查类是否已定义
get_called_class— the "Late Static Binding" class name
get_class_methods— 返回由类的方法名组成的数组
get_class_vars— 返回由类的默认属性组成的数组
get_class— 返回对象的类名
get_declared_classes— 返回由已定义类的名字所组成的数组
get_declared_interfaces— 返回一个数组包含所有已声明的接口
get_declared_traits— Returns an array of all declared traits
get_object_vars— 返回由对象属性组成的关联数组
get_parent_class— 返回对象或类的父类名
interface_exists— 检查接口是否已被定义
is_a— 如果对象属于该类或该类是此对象的父类则返回 TRUE
is_subclass_of— 如果此对象是该类的子类，则返回 TRUE
method_exists— 检查类的方法是否存在
property_exists— 检查对象或类是否具有该属性
11、命名空间
(1)、任意合法的php代码都可以包含在命名空间中、但只有三种类型的代码受命名空间的影响、类、函数、和常量。命令空间通过关键字 namespace 命名空间名来声明、必须要其它所有代码之前声明
（2）、定义多个名子空间、以最后一个为主
（3）、在实际编程实践中、非常不提倡在同一个文件中定义多个命名空间、不要在大括号外面加任何代码
Namespace myname{}
Namespace mn1;
Namespace hello\world;
Function demo(){
Echo “1111”;}
Demo();
\hello\world\demo();
Namespace\demo();
Echo__NAMESPACE__;
命名空间别名：
Namespacenet\lamp\www;
Use net\lamp\www as lamp;
Function demo(){
Echo “111”;
}
Lamp\demo();