php面向对象抽象方法和抽象类 __call 克隆对象详细教程

本文章介绍了关于php中面向对象的抽象方法和抽象类 __call 克隆对象用法，有需要发解的朋友可以学学。

抽象方法和抽象类

在OOP语言中，一个类可以有一个或多个子类，而每个类都有至少一个公有方法做为外部代码访问其的接口。而抽象方法就是为了方便继承而引入的,我们先来看一下抽象类和抽象方法的定义再说明它的用途。

什么是抽象方法？我们在类里面定义的没有方法体的方法就是抽象方法，所谓的没有方法体指的是，在方法声明的时候没有大括号以及其中的内容，而是直接在声明时在方法名后加上分号结束，另外在声明抽象方法时还要加一个关键字“abstract”来修饰；例如：

代码如下	复制代码
abstract function fun1(); abstract function fun2();

上例是就是“abstract”修饰的没有方法体的抽象方法“fun1()”和“fun2()”,不要忘记抽象方法后面还要有一个分号；那么什么是抽象类呢？只要一个类里面有一个方法是抽象方法，那么这个类就要定义为抽象类，抽象类也要使用“abstract”关键字来修饰；在抽象类里面可以有不是抽象的方法和成员属性，但只要有一个方法是抽象的方法，这个类就必须声明为抽象类，使用”abstract”来修饰。例如：

代码如下	复制代码
abstract class Demo {     var $test;     abstract function fun1();     abstract function fun2();     function fun3()     {         ... ...     } }

上例中定义了一个抽象类“Demo”使用了”abstract”来修饰， 在这个类里面定义了一个成员属性“$test”,和两个抽象方法“fun1”和“fun2”还有一个非抽象的方法fun3();那么抽象类我们怎么使用呢？最重要的一点就是抽象类不能产生实例对象，所以也不能直接使用，前面我们多次提到过类不能直接使用，我们使用的是通过类实例化出来的对象，那么抽象类不能产生实例对象我们声明抽象类有什么用呢？我们是将抽象方法是做为子类重载的模板使用的，定义抽象类就相当于定义了一种规范，这种规范要求子类去遵守，子类继函抽象类之后，把抽象类里面的抽象方法按照子类的需要实现。子类必须把父类中的抽象方法全部都实现，否则子类中还存在抽象方法，那么子类还是抽象类，还是不能实例化对;为什么我们非要从抽象类中继承呢？因为有的时候我们要实现一些功能就必须从抽象类中继承，否则这些功能你就实现不了，如果继承了抽象类，就要实现类其中的抽象方法；

代码如下	复制代码
abstract class Demo     {     var $test;     abstract function fun1();     abstract function fun2();     function fun3()     {         ... ...     } }

//抽象类为能产生实例对象，所以这样做是错的,实例化对象交给子类

代码如下	复制代码
$demo=new Demo(); class Test extends Demo {     function fun1()     {         ... ...     }     function fun2()     {         ... ...     } }

//子类可以实例化对象，因为实现了父类中所有抽象方法

代码如下	复制代码
$test=new Test();

__call处理调用错误

在程序开发中，如果在使用对象调用对象内部方法时候，调用的这个方法不存在那么程序就会出错，然后程序退出不能继续执行。那么可不可以在程序调用对象内部不存在的方法时，提示我们调用的方法及使用的参数不存在，但程序还可以继续执行，这个时候我们就要使用在调用不存在的方法时自动调用的方法”__call()”。

代码如下	复制代码
//这是一个测试的类，里面没有属性和方法 class Test { } //产生一个Test类的对象 $test=new Test(); //调用对象里不存在的方法 $test->demo("one", "two", "three"); //程序不会执行到这里 echo "this is a test";

上例出现如下错误，程序通出不能继续执行；
Fatal error: Call to undefined method Test::demo()

下面我们加上“__call()”方法，这个方法有2个参数，第一个参数为调用不存在的方法过程中,自动调用__call()方法时，把这个不存在的方法的方法名传给第一个参数，第二个参数则是把这个方法的多个参数以数组的形式传进来。

代码如下	复制代码
//这是一个测试的类，里面没有属性和方法 class Test {     //调用不存的方法时自动调用的方法，第一个参数为方法名，第二个参数是数组参数     function __call($function_name, $args)     {         print "你所调用的函数：$function_name(参数：";         print_r($args);         print ")不存在！n";     } } //产生一个Test类的对象 $test=new Test(); //调用对象里不存在的方法 $test->demo("one", "two", "three"); //程序不会退出可以执行到这里 echo "this is a test";

上例输出结果为：
你所调用的函数： demo(参数：Array ( [0] => one [1] => two [2] => three ) )不存在！ this is a test.

克隆对象

有的时候我们需要在一个项目里面，使用两个或多个一样的对象，如果你使用“new”关键字重新创建对象的话，再赋值上相同的属性，这样做比较烦琐而且也容易出错，所以要根据一个对象完全克隆出一个一模一样的对象，是非常有必要的，而且克隆以后，两个对象互不干扰。

在PHP5中我们使用”clone”这个关键字克隆对象；

代码如下

复制代码

class Person {     //下面是人的成员属性     var $name;  //人的名子     var $sex;    //人的性别     var $age;    //人的年龄     //定义一个构造方法参数为属性姓名$name、性别$sex和年龄$age进行赋值     function __construct($name="", $sex="", $age="")     {         $this->name=$name;         $this->sex=$sex;         $this->age=$age;     }     //这个人可以说话的方法, 说出自己的属性     function say()     {         echo "我的名子叫：".$this->name." 性别：".$this->sex." 我的年龄是：".$this->age."";     } } $p1=new Person("张三", "男", 20); //使用“clone”克隆新对象p2，和p1对象具有相同的属性和方法。 $p2=clone $p1; $p2->say();

PHP5定义了一个特殊的方法名“__clone()”方法，是在对象克隆时自动调用的方法，用“__clone()”方法将建立一个与原对象拥有相同属性和方法的对象,如果想在克隆后改变原对象的内容，需要在__clone()中重写原本的属性和方法, ”__clone()”方法可以没有参数，它自动包含$this和$that两个指针，$this指向复本，而$that指向原本；

代码如下

复制代码

class Person {     //下面是人的成员属性     var $name;  //人的名子     var $sex;    //人的性别     var $age;    //人的年龄     //定义一个构造方法参数为属性姓名$name、性别$sex和年龄$age进行赋值     function __construct($name="", $sex="", $age="")     {         $this->name=$name;         $this->sex=$sex;         $this->age=$age;     }     //这个人可以说话的方法, 说出自己的属性     function say()     {         echo "我的名子叫：".$this->name." 性别：".$this->sex." 我的年龄是：".$this->age."";     }     //对象克隆时自动调用的方法, 如果想在克隆后改变原对象的内容，需要在__clone()中重写原本的属性和方法     function __clone()     {         //$this指的复本p2, 而$that是指向原本p1，这样就在本方法里，改变了复本的属性。         $this->name="我是假的$that->name";         $this->age=30;     } } $p1=new Person("张三", "男", 20); $p2=clone $p1; $p1->say(); $p2->say(); 上例输出：

我的名子叫：张三 性别：男 我的年龄是：20
我的名子叫：我是假的张三 性别：男 我的年龄是：30

Static关键字是在类中描述成员属性和成员方法是静态的,final 关键字的应用 这个关键字只能用来定义类和定义方法， 不能使用final这个关键字来定义成员属性，因为final是常量的意思，我们在PHP里定义常量使用的是define()函数，所以不能使用final来定义成员属性

Static关键字是在类中描述成员属性和成员方法是静态的；静态的成员好处在那里呢？前面我们声明了“Person”的人类，在”Person”这个类里如果我们加上一个“人所属国家”的属性，这样用”Person”这个类实例化出几百个或者更多个实例对象，每个对象里面就都有“所属国家”的属性了，如果开发的项目就是为中国人而开发的，那么每个对象里面就都有一个国家的属性是“中国“其它的属性是不同的，如果我们把“国家”的属性做成静态的成员，这样国家的属性在内存中就只有一个，而让这几百个或更多的对象共用这一个属性，static成员能够限制外部的访问，因为static的成员是属于类的，是不属于任何对象实例，是在类第一次被加载的时候分配的空间，其他类是无法访问的，只对类的实例共享，能一定程度对类该成员形成保护。

从内存的角度我们来分析一下，内存从逻辑上被分为四段，其中对象是放在“堆内存”里面，对象的引用被放到了“栈内存“里，而静态成员则放到了“初始化静态段”，在类第一次被加载的时候放入的，可以让堆内存里面的每个对象所共享,如下图;

 

类的静态变量，非常类似全局变量，能够被所有类的实例共享，类的静态方法也是一样的，类似于全局函数。

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

"PHP5面向对象详解(高洛峰)" 这教程写得很不错，对于PHP菜鸟还是老鸟来说，貌似都是值得一看的，附上word文档php5面向对象详解。

static 和 const 关键字的使用
Static关键字是在类中描述成员属性和成员方法是静态的；静态的成员好处在那里呢？前面我们声明了“Person”的人类，在”Person”这个类里如果我们加上一个“人所属国家”的属性，这样用”Person”这个类实例化出几百个或者更多个实例对象，每个对象里面就都有“所属国家”的属性了，如果开发的项目就是为中国人而开发的，那么每个对象里面就都有一个国家的属性是“中国“其它的属性是不同的，如果我们把“国家”的属性做成静态的成员，这样国家的属性在内存中就只有一个，而让这几百个或更多的对象共用这一个属性，static成员能够限制外部的访问，因为static的成员是属于类的，是不属于任何对象实例，是在类第一次被加载的时候分配的空间，其他类是无法访问的，只对类的实例共享，能一定程度对类该成员形成保护。

从内存的角度我们来分析一下，内存从逻辑上被分为四段，其中对象是放在“堆内存”里面，对象的引用被放到了“栈内存“里，而静态成员则放到了“初始化静态段”，在类第一次被加载的时候放入的，可以让堆内存里面的每个对象所共享,如下图;

 

类的静态变量，非常类似全局变量，能够被所有类的实例共享，类的静态方法也是一样的，类似于全局函数。

 

代码如下

复制代码

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;因为静态成员是在类第一次加载的时候就创建的，所以在类的外部不需要对象而使用类名就可以访问的到静态的成员；上面说过,静态成员被这个类的每个实例对象所共享，那么我们使用对象可不可以访问类中的静态成员呢？从上图中我们可以看到，静态的成员不是在每个对象内部存在的，但是每个对象都可以共享，所以我们如果使用对象访问成员的话就会出现没有这个属性定义，使用对象访问不到静态成员的，在其它的面向对象的语言中，比如Java是可以使用对象的方式访问静态成员的，如果PHP中可以使用对象访问静态成员的话，我们也尽量不要去使用，因为静态的成员我们在做项目的时候目的就是使用类名去访问。

类里面的静态方法只能访问类的静态的属性，在类里面的静态方法是不能访问类的非静态成员的，原因很简单，我们要想在本类的方法中访问本类的其它成员，我们需要使用$this这个引用，而$this这个引用指针是代表调用此方法的对象，我们说了静态的方法是不用对象调用的，而是使用类名来访问，所以根本就没有对象存在，也就没有$this这个引用了，没有了$this这个引用就不能访问类里面的非静态成员，又因为类里面的静态成员是可以不用对象来访问的，所以类里面的静态方法只能访问类的静态的属性，即然$this不存在，在静态方法中访其它静态成员我们使用的是一个特殊的类”self”; self和$this相似，只不过self是代表这个静态方法所在的类。所以在静态方法里，可以使用这个方法所在的类的“类名“，也可以使用“self“来访问其它静态成员,如果没有特殊情况的话，我们通常使用后者，即 "self::成员属性"的方式。

代码如下	复制代码
class Person {     //下面是人的静态成员属性     public static $myCountry="中国";     //这是人的静态成员方法, 通过self访问其它静态成员     public static function say()     {         echo "我是".self::$myCountry."";     } } //访问静态方法 Person::say();

在非静态方法里可不可以访问静态成员呢，当然也是可以的了，但是也不能使用”$this”引用也要使用类名或是”self::成员属性的形式”。 const是一个定义常量的关键字，在PHP中定义常量使用的是”define()”这个函数，但是在类里面定义常量使用的是”const”这个关键字，类似于C中的#define如果在程序中改变了它的值，那么会出现错误，用”const”修饰的成员属性的访问方式和”static”修饰的成员访问的方式差不多，也是使用”类名”，在方法里面使用”self”关键字。但是不用使用”$”符号，也不能使用对象来访问。

代码如下	复制代码
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 关键字的应用
这个关键字只能用来定义类和定义方法， 不能使用final这个关键字来定义成员属性，因为final是常量的意思，我们在PHP里定义常量使用的是define()函数，所以不能使用final来定义成员属性。

使用final关键标记的类不能被继承；

代码如下	复制代码
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()

PHP 5也支持接口的概念，并为之引入了interface和implements关键字。和Java一样，PHP 5使用接口也实现类似于“多重继承”的效果。

PHP5接口语法如下：
声明一个类的时候我们使用的关键字是”class”，而接口一种特殊的类，使用的关键字是“interface”;

类的定义：class 类名{ … }，接口的声明：interface 接口名{ …}

具体PHP5抽象类的代码如下：

代码如下	复制代码
abstract class AbstractClass {         abstract public function test();      }           class ImplementedClass extends AbstractClass {         public function test() {             echo "ImplementedClass::test() called. ";         }      }           $o = new ImplementedClass;      $o->test();

实例二

代码如下	复制代码
interface displayable {        function display();      }      interface printable {        function doprint();      }           class foo implements displayable,printable {        function display() {          // code        }   function doprint() {          // code        }      }

抽象类和PHP5接口的引入使PHP成了一个完全面向对象的语
//定义一个接口使用interface关键字，“One”为接口名称

代码如下	复制代码
interface One {     //定义一个常量     const constant = 'constant value';     //定义了一个抽象方法”fun1”     public function fun1();     //定义了抽象方法”fun2”     public function fun2(); }

上例中定义了一个接口”one”，里面声明了两个抽象方法“fun1”和”fun2”，因为接口里面所有的方法都是抽象方法，所以在声明抽象方法的时候就不用像抽象类那样使用”abstract”这个关键字了，默认的已经加上这个关键字，另外在接口里边的”public”这个访问权限也可以去掉，因为默认就是public的，因为接口里所有成员都要是公有的，所在对于接口里面的成员我们就不能使用“private”的和”protected”的权限了，都要用public或是默认的。另外在接口里面我们也声明了一个常量“constant“， 因为在接口里面不能用变量成员，所以我们要使用const这个关键字声明。

因为接口是一种特殊的抽象类，里面所有的方法都是抽象方法，所以接口也不能产生实例对象; 它也做为一种规范，所有抽象方法需要子类去实现。

我们可以使用”extends”关键字让一个接口去继承另一个接口;

代码如下	复制代码
//使用”extends”继承另外一个接口 interface Two extends One {     function fun3();     function fun4(); }

而我们定义一接口的子类去实现接口中全部抽象方法使用的关键字是”implements”，而不是我们前面所说的”extends”;

//使用“implements”这个关键字去实现接口中的抽象方法

代码如下	复制代码
class Three implements One {     function fun1()     {         … …     }     function fun2()     {         … …     } }

//实现了全部方法，我们去可以使用子类去实例化对象了

代码如下	复制代码
$three=new Three();

我们也可以使用抽象类，去实现接口中的部分抽象方法，但要想实例化对象，这个抽象类还要有子类把它所有的抽象方法都实现才行；

在前面我们说过，PHP是单继承的，一个类只能有一父类，但是一个类可以实现多个接口，就相当于一个类要遵守多个规范，就像我们不仅要遵守国家的法律，如果是在学校的话，还要遵守学校的校规一样；

代码如下	复制代码
//使用implements实现多个接口 class Four implemtns 接口一，接口二，…… {     //必须把所有接口中的方法都要实现才可以实例化对象。 }

PHP中不仅一个类可以实现多个接口，也可以在继承一个类的同时实现多个接口，一定要先继承类再去实现接口；

代码如下	复制代码
//使用extends继承一个类，使用implements实现多个接口 class Four extends 类名一 implemtns 接口一，接口二，…… {     //所有接口中的方法都要实现才可以实例化对象     ……… }

讲了这么多最后看看一个实例

VideoCard.php 接口文件（显卡的功能接口定义）

代码如下	复制代码
<?php interface VideoCardInter{ function Display(); function getName(); } ?>

Dmeng.php 实现接口（帝盟的厂家实现了这些接口，怎么实现的，主板厂家不用管）

代码如下	复制代码
<?php include_once("VideoCard.php"); class Dmeng implements VideoCardInter { function Display(){ echo "Display"; } function getName(){ return "Dmeng VideoCard"; } } ?>

Mainboard.php  应用接口（把显卡插到主板上，主板只要用这些接口就行了，也可以不用）

代码如下	复制代码
<?php include_once("VideoCard.php"); include_once("Dmeng.php"); class Mainboard{ var $vc; function run(VideoCardInter $vc){  //定义VideoCardInter接口类型参数，这时并不知道是谁来实现。 $this->vc=$vc; $this->vc->Display(); echo "主板运行！"; } } $conputer=new Mainboard(); $conputer->run(new Dmeng);

//用的时候把实现接口类的名称写进来，（现在是帝盟的显卡，也可以换成别的场家的，只要他们都实现了接口）
?>上面是转自的，然后自己试着写了点东西：把自己的思想总结一下
这里我想是分成4个方面

1，静态链接数据库类（基本的链接数据库，查询记录数，返回结果集等等）

2，每个模块的接口（例如新闻类接口  NewsInterface）

3，实现接口的类(新闻实现类  NewsInterfaceImpl 这里面写一些页面中用到的方法，然后new这个对象 调用这里么的方法)

4，模块类(新闻类  News)

本文章详细的介绍了在php学习中的最基础的内容包括了基本数据类型、变量类型、操作符等入门都会要接触到的东西。

php支持的基本数据类型：
Integer:整数
Float(Double，双精度值):浮点数，表示所有实数
String:字符串
Boolean:布尔值，true/false
Array:保存具有相同类型的多个数据项
Object:对象，保存类的实例
NULL:没有被赋值、已经被重置或被赋值为特殊值NULL的变量
特定的内置函数（例如数据库函数）将返回resource类型的变量

四种标量类型：

string（字符串）
integer（整型）
float（浮点型，也作 double ）
boolean（布尔型）
两种复合类型：

array（数组）
object（对象）
两种特殊类型：

resource（资源）
NULL（空）
查看变量类型
通过 gettype() 函数可以方便的查看某个变量的类型：

代码如下	复制代码
<?php $var_bool = TRUE;     // a boolean $var_str  = "foo";     // a string $var_int  = 12;      // an integer echo gettype($var_bool);    // 输出 boolean echo gettype($var_str);     // 输出 string echo gettype($var_int);     // 输出 integer ?>

提示
由于历史原因，如果是 float 类型数据，gettype() 函数返回的是 double，而不是 float 。
如果想查看某个表达式的值和类型，请使用用 var_dump() 函数。
判断变量类型
如果想通过判断变量类型来确定下一步逻辑动作，不要使用 gettype() ，而使用 is_type 系列函数：

代码如下	复制代码
<?php $var_int  = 12; // 如果 $var_int 是 int 类型，这进行加法 if (is_int($var_int)) {     $var_int = $var_int+4; } echo $var_int;  // 输出 16 ?>

NULL和resource都代表外部资源，例如数据库连接
基本上不能直接操作一个resource变量，但是通常它们都将被函数返回，而且必须作为参数传递给其他函数。

在php中，变量的类型是由赋给变量的值确定的。（动态类型语言）
PHP可以在任何时间根据保存在变量中的值来确定变量的类型，也就是具有在任何时间透明地改变变量类型的功能。
PHP将“自动地”获得输入的数据类型，一旦从变量中检索变量值，它将返回具有相同数据类型的数据。
养成习惯：常量名称都是由大写字母组成的。这样容易区分变量和常量。
常量和变量之间的一个重要不同点在于引用一个常量的时候，它前面并没有$符号。
常量和变量的另一个差异在于常量只可以保存布尔值、整数、浮点数或字符串数据，这些类型都是标量数据。

变量类型变化(juggling)
PHP不需要（或者说不支持）在声名变量明确他的变量类型；一个变量的类型是由这个变量被使用的前后关系来决定的，也就是说，如果你给一个变量var赋了 一个字符串的值，var就变成了字符串变量。如果你再将一个整数赋值给var,他又变成了一个整数型变量。 一个PHP自动转化变量类型的例子是加法的操作符’+’。如果任何一个操作数都是双精度数，那么所有的操作数被当作双精度数求值，并且结果也是双精度数。 否则，操作数将被认为是整数，结果也将会是整数。注意这并不影响每个操作数本身的变量类型，唯一的变化就是操作数在计算的过程中被如何处理。 $foo  =  "0";  //  $foo  是一个字符串  ，值是“0”(ASCII  48)

PHP代码

代码如下	复制代码
$foo  =  "0";  //  $foo  是一个字符串  ，值是“0”(ASCII  48)      $foo++;  //  $foo  是一个字符串，值是“1”(ASCII  49)      $foo  +=  1;  //  $foo  现在是一个整数（2）了      $foo  =  $foo  +  1.3;  //  $foo  现在是一个双精度数(3.3)了      $foo  =  5  +  "10  Little  Piggies";  //  $foo  是一个整数  (15)      $foo  =  5  +  "10  Small  Pigs";  //  $foo  是一个整数  (15)

如果你觉得上面例子中最后两个表达式看起来有点奇怪的话，请看 “字符串的转化”部分。 如果你希望强制一个变量被当作某种固定的类型来计算，请看 “类型强制(casting)” 一节。如果你希望转变一个变量的类型，请看函数“settype()”的说明。
 确定一个变量的类型
因为PHP自己决定变量的类型并且一般按照需要转化他们，一个特定的变量的类型不是在任何时间都非常明显。PHP包括一些函数可以找出这个变量的类型。这 些函数是gettype(), is_long(), is_double(), is_string(), is_array(), 和 is_object().
类型强制（type casting）
在PHP中类型强制同在C语言中大抵相似：将需要的类型的种类写在要强制的变量的前面的圆括号中。
 

PHP代码

代码如下	复制代码
$foo  =  10;  //  $foo  是一个整数     $bar  =  (double)  $foo;  //  $bar  是一个双精度数

以下的强制方式是允许的： (int), (integer) – 强制成整数 (real), (double), (float) – 强制成双精度数 (string) – 强制成字符串 (array) – 强制成数组 (object) – 强制成对象 注意在圆括号中允许制表符(tabs)和空格(spaces) ，因此下面的语句是等价的： $foo = (int) $bar; $foo = ( int ) $bar;
字符串转化
当一个字符串被当作数字型的值来计算时，他的结果和类型如下面所述的决定。 如果这个字符串含有字符’.’,’e’,或者’E’，则被当作双精度类型变量来处理，否则当作是整数。 这个字符串的值由词首部分决定。如果这个字符串以任何有效的数字的数据开始，那么这个数字数据就是这个字符串参加运算的值。否则，值为零(zero)。有 效的数字数据是遵循下面的这些标记的，跟随在一个或多个数字后面（可以包含小数点），跟随在一个可选的指数后面。指数是由一个或多个数字跟在’e’或 ’E’后面构成的。
 

PHP代码

代码如下	复制代码
$foo  =  1  +  "10.5";  //  $foo  是双精度数  (11.5)      $foo  =  1  +  "-1.3e3";  //  $foo  是双精度数(-1299)      $foo  =  1  +  "bob-1.3e3";  //  $foo  是整数  (1)      $foo  =  1  +  "bob3";  //  $foo  是整数  (1)      $foo  =  1  +  "10  Small  Pigs";  //  $foo  是整数  (11)    $foo  =  1  +  "10  Little  Piggies";  //  $foo  是整数  (11);      //  这个字符串包括字符'e'

标识符

操作符：
1)赋值操作符：=

2)算术操作符：+，-，*，/，%（取模）

3)连接操作符：. ，无论操作数是什么，都当成String，结果返回String

4)合计赋值操作符(Combined Assignment Operators)：+=，*=，/=，-=，%=，.=

5)自动增减操作符(Automatically Incrementing and Decrementing)：

（1）$variable+=1 ⇔$variable++；$variable-=1 ⇔$variable-,跟c语言一样，先做其他操作，后++或-

（2）++$variable，-$variable，先++或-，再做其他操作

6)比较操作符：

= =（左边等于右边），！=（左边不等于右边），
= = =（左边等于右边，且数据类型相同），
>=，>，<，<=

7)逻辑操作符：|| or，&& and，xor(当左右两边有且只有一个是true，返回true)，!

一个参考表

运算符（Arithmetic Operators）

Operator 符号	Description 描述	Example 案例	Result 结果
+	Addition 加号	x=2 x+2	4
-	Subtraction 减号	x=2 5-x	3
*	Multiplication 乘号	x=4 x*5	20
/	Division 除号	15/5 5/2	3 2.5
%	Modulus (division remainder) 求模（余数）	5%2 10%8 10%2	1 2 0
++	Increment 自加	x=5 x++	x=6
--	Decrement 自减	x=5 x--	x=4

Assignment Operators
分配符（Assignment Operators）

Operator 符号	Example 案例	Is The Same As 等同于
=	x=y	x=y
+=	x+=y	x=x+y
-=	x-=y	x=x-y
*=	x*=y	x=x*y
/=	x/=y	x=x/y
%=	x%=y	x=x%y

Comparison Operators
比较符（Comparison Operators）

Operator 符号	Description 具体描述	Example 案例
==	is equal to 等于	5==8 返回 false
!=	is not equal 不等于	5!=8 返回  true
>	is greater than 大于	5>8 返回  false
<	is less than 小于	5<8 返回  true
>=	is greater than or equal to 大于等于	5>=8 返回  false
<=	is less than or equal to 小于等于	5<=8 返回  true

Logical Operators
逻辑判断符（Logical Operators）

Operator 符号	Description 描述	Example 案例
&&	and 与	x=6 y=3 (x < 10 && y > 1) 返回 true
||	or 或	x=6 y=3 (x==5 || y==5) 返回 false
!	not 非	x=6 y=3 !(x==y)返回true

其他操作符：

三元操作符、错误抑制操作符、执行操作符、数组操作符、类型操作符

运算符"?"前的表达式

如果一个包含二元运算符的表达式出现在三元运算符" ? : "的"?"之前，那么应该给表达式添上一对圆括号。例如：
(x >= 0) ? x : -x;

下面我们来看一个简单的？号表达式实例

代码如下	复制代码
<? $a=1; echo $a?'true':'false'; 输出结果为 trur; 再看 if( $a ) {    echo 'true'; } else {    echo 'false'; }

以前很少这么详细的给大家介绍php中的变量、常量以及魔术常量的用法以及参考表，这文章对于初学者有不小的帮助有需要了解的朋友可以参考一下。

变量：

变量用于存储值，比如数字、文本字符串或数组。

一旦设置了某个变量，我们就可以在脚本中重复地使用它。

PHP 中的所有变量都是以 $ 符号开始的。

在 PHP 中设置变量的正确方法是：

代码如下	复制代码
$var_name = value;

PHP 的入门者往往会忘记在变量的前面的 $ 符号。如果那样做的话，变量将是无效的。

让我们试着创建一个存有字符串的变量，和一个存有数值的变量：

代码如下	复制代码
<?php $txt = "Hello World!"; $number = 16; ?>

 

1.如何定义变量，它和C# 等语言有什么不同呢？
   PHP 中的变量用一个美元符号后面跟变量名来表示。变量名是区分大小写的。例如:

代码如下	复制代码
<?php  $var='Jim';   $VAR='Kimi;   echo "$var,$VAR";//输出“Jim,Kimi"

 ?>你可能还关心变量的命名，其实和大多数语言一样。
2. 变量区分大小写吗？
   如 1里说的，区分大小写。
  注意，需要说明的一点是自PHP4以来，引入了引用赋值的概念，其实和多数语言的引用类似，不过我觉得最类似的是C/C++.因为它也用到了"&"符号。例如： 

代码如下	复制代码
1 <?php 2 $foo = 'Bob';              // 赋值'Bob'给foo 3 $bar = &$foo;              // 通过$bar引用.注意&符号 4 $bar = "My name is $bar";  // 修改 $bar 5 echo $bar; 6 echo $foo;                // $foo 也修改了. 7 ?>

和其他语言一样，只能对有变量名的变量才可以引用。

好了现在大家对变量应该有一个大概的了解了，现在我们看看变量的间接引用和字符串连接。

①变量的间接引用： 先看个例子吧

代码如下	复制代码
<?  $a = "b";  $$a = "123";  echo $b; ?>

 

上面的输出结果是123

我们可以看到在第二行代码中多了一个$，并通过指定的名称访问变量，指定的名字存储在$a("b")中，并把这个变量$b的值更改为123。因此，这样的$b的变量被创建和赋值。

通过在变量的前面增加附加的$标记，你可以任意增加引用的次数。

 ②字符串连接： 先看个例子吧

代码如下	复制代码
<? $a = "PHP 4" ; $b = "功能强大" ; echo $a.$b; ?>

 

需要注意的是 在PHP 4.2.0 以及后续版本中，PHP 指令 register_globals 的默认值为 off。这是 PHP 的一个主要变化。让 register_globals 的值为 off 将影响到预定义变量集在全局范围内的有效性。例如，为了得到 DOCUMENT_ROOT 的值，将必须使用 $_SERVER['DOCUMENT_ROOT'] 代替 $DOCUMENT_ROOT，又如，使用 $_GET['id'] 来代替 $id 从 URL http://www.example.com/test.php?id=3 中获取 id 值，亦或使用 $_ENV['HOME'] 来代替 $HOME 获取环境变量 HOME 的值

我们看到代码的第三行，英文的（句）号，它可以将字符串连接起来，变成合并的新字符串。

 

超全局变量	描述
$GLOBALS	包含一个引用指向每个当前脚本的全局范围内有效的变量。该数组的键名为全局变量的名称。从 PHP 3 开始存在 $GLOBALS 数组。
$_SERVER	变量由 web 服务器设定或者直接与当前脚本的执行环境相关联。类似于旧数组 $HTTP_SERVER_VARS 数组（依然有效，但反对使用）。
$_GET	经由 URL 请求提交至脚本的变量。类似于旧数组 $HTTP_GET_VARS 数组（依然有效，但反对使用）。
$_POST	经由 HTTP POST 方法提交至脚本的变量。类似于旧数组 $HTTP_POST_VARS 数组（依然有效，但反对使用）。
$_COOKIE	经由 HTTP Cookies 方法提交至脚本的变量。类似于旧数组 $HTTP_COOKIE_VARS 数组（依然有效，但反对使用）。
$_FILES	经由 HTTP POST 文件上传而提交至脚本的变量。类似于旧数组 $HTTP_POST_FILES 数组（依然有效，但反对使用）
$_ENV	执行环境提交至脚本的变量。类似于旧数组 $HTTP_ENV_VARS 数组（依然有效，但反对使用）。
$_REQUEST	经由 GET，POST 和 COOKIE 机制提交至脚本的变量，因此该数组并不值得信任。所有包含在该数组中的变量的存在与否以及变量的顺序均按照 php.ini 中的 variables_order 配置指示来定义。此数组在 PHP 4.1.0 之前没有直接对应的版本。参见 import_request_variables()。
$_SESSION	当前注册给脚本会话的变量。类似于旧数组 $HTTP_SESSION_VARS 数组（依然有效，但反对使用)

 

常量：

常量是一个简单值的标识符（名字）。如同其名称所暗示的，在脚本执行期间该值不能改变（除了所谓的魔术常量，它们其实不是常量）。常量默认为大小写敏感。通常常量标识符总是大写的。

常量名和其它任何 PHP 标签遵循同样的命名规则。合法的常量名以字母或下划线开始，后面跟着任何字母，数字或下划线。用正则表达式是这样表达的：[a-zA-Z_x7f-xff][a-zA-Z0-9_x7f-xff]*

 

①是在程序执行期间无法改变的数据，常量的作用域是全局的。

②常量的命名与与变量相似，只是不带美元符号“$”。一个有效的常量名由字母或者下划线开头，后面跟报上任意数量的字母、数字或者下划线。

③一般在PHP中常量都为大写字母而且又分为系统常量和自定义常量。

 

系统常量我们就大概说了 ，这个在后面的知识会介绍到。

1、__FILE__    默认常量，是指PHP程序文件名及路径；
2、__LINE__    默认常量，是指PHP程序的行数；
3、__CLASS__    类的名称；

自定义常量：通过define()函数来定义一个常量的，

其语法格式为：bool define ( string $name, mixed $value [, bool case_$insensitive] )

name：指定常量的名称。
value：指定常量的值。
insensitive：指定常量名称是否区分大小写。如果设置为true则不区分大小写；如果设置为false则区分大小写。如果没有设置该参数，则取默认值false。

<?php

// 合法的常量名
define("FOO",     "something");
define("FOO2",    "something else");
define("FOO_BAR", "something more");

// 非法的常量名
define("2FOO",    "something");

// 下面的定义是合法的，但应该避免这样做：(自定义常量不要以__开头)
// 也许将来有一天PHP会定义一个__FOO__的魔术常量
// 这样就会与你的代码相冲突
define("__FOO__", "something");

?>

几个 PHP 的“魔术常量”

名称	说明
__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__	当前命名空间的名称（大小写敏感）。这个常量是在编译时定义的（PHP 5.3.0 新增）