PHP系列(四)PHP面向对象程序设计-阿里云开发者社区

开发者社区> 开发与运维> 正文

PHP系列(四)PHP面向对象程序设计

简介:

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,我的性别:我的学校是:上海交通大学

 

 

7Php常见的关键字

 

Instanceof 操作符用于检测当前对象实例是否属于某一个类的类型

If($p instanceof Person){

         Echo“这个$pPerson类的对象”;

}else{

         Echo“对象不属于这个类”;

}

 

Final 用于类方法名前、不能修饰成员属性

1final可以修饰类、这个类不能扩展、不能有子类、这个类是最终类

2final可以修饰方法、这个方法、就不能在子类中覆盖、不能让子类来改这个方法、或扩展这个方法、这个方法也是最终方法。

 

Static  可以修饰属性和方法、不能修饰类

1)使用static修饰成员属性、存在内存的初始化表态段

2)可以被所有同一个类的对象共用

3)第一个用到类、类在加载到内存时、就已经将静态的成员加到了内存

对象->成员

类::成员

4)静态的成员一定要使用类来访问(静态成员不可以由对象通过->操作符来访问)

5self可以在类中的方法中、代表自已类的($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

 

8php魔术方法

__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 “串行化nameage”;

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

                   }

         }

 

9php抽象方法和抽象类

 

抽象方法:

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

 本文转自 sswqzx 51CTO博客,原文链接:http://blog.51cto.com/sswqzx/1964711







版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:
开发与运维
使用钉钉扫一扫加入圈子
+ 订阅

集结各类场景实战经验,助你开发运维畅行无忧

其他文章