PHP系列（四）PHP面向对象程序设计-web开发-互联网-天达云

PHP系列（四）PHP面向对象程序设计
更新：HHH 时间：2023-1-7

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}再见！ ";

}

$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." ";

$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 " ";

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} ";

}

class Student extends Person{

var$school="jtuniverty!";

functionsay(){

// echo"我的名子：{$this->name},我的年龄是：{$this->age},我的性别:{$this->sex} ";

// 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" ";

$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']." ";

}else{

echo "你调用的方法{$method}()不存在 ";

}

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" ";

$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." ";

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 "加载鼠标成功! ";

}

function run() {

echo "运行鼠标功能! ";

}

function stop() {

echo "鼠标工作结束! ";

}

class KeyPress implements USB {

function load() {

echo "加载键盘成功! ";

}

function run() {

echo "运行键盘成功! ";

}

function stop() {

echo "停止键盘使用! ";

}

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();

微信扫一扫、关注公众号

不定时分享资料视频


返回web开发教程...

新手上路

产品管理

支付方式

关于我们