很多朋友可能分不清楚在php中静态变量与静态方法的用法与区别在哪里,下面我来根据自己的经验来介绍静态变量与静态方法一些理解。

在PHP中,静态变量的解释是存在于类作用域的变量,在第一次初始化时给变量赋值,以后类初始化时,静态变量将不会再被重新赋值,主要用于一个类具有多个实例时的变量共享.

使用静态变量

变量范围的另一个重要特性是静态变量(static variable),静态变量仅在局部函数域中存在,但当程序执行离开此作用域时,其值并不丢失,看看下面的例子：

演示需要静态变量的例子,代码如下:

1. <?php 
2. function Test () 
3. { 
4. $a = 0; 
5. echo $a; 
6. $a++; 
7. } 
8. ?> 

本函数没什么用处,因为每次调用时都会将 $a 的值设为 0 并输出 "0",将变量加一的 $a++ 没有作用,因为一旦退出本函数则变量 $a 就不存在了,要写一个不会丢失本次计数值的计数函数,要将变量 $a 定义为静态的：

使用静态变量的例子,代码如下:

1. <?php 
2. function Test() 
3. { 
4. static $a = 0; 
5. echo $a; 
6. $a++; 
7. } 
8. ?> 

现在,每次调用 Test() 函数都会输出 $a 的值并加一.

静态变量也提供了一种处理递归函数的方法。递归函数是一种调用自己的函数。写递归函数时要小心，因为可能会无穷递归下去。必须确保有充分的方法来中止递归。一下这个简单的函数递归计数到 10，使用静态变量 $count 来判断何时停止：

静态变量与递归函数,代码如下:

1. <?php 
2. function Test() 
3. { 
4. static $count = 0; 
5. $count++; 
6. echo $count; 
7. if ($count < 10) { 
8. Test (); 
9. } 
10. $count--; 
11. } 
12. ?> 

注:静态变量可以按照上面的例子声明,如果在声明中用表达式的结果对其赋值会导致解析错误。

声明静态变量,代码如下:

1. <?php 
2. function foo(){ 
3. static $int = 0; // correct 
4. static $int = 1+2; // wrong  (as it is an expression) 
5. static $int = sqrt(121); // wrong  (as it is an expression too) 
6. $int++; 
7. echo $int; 
8. } 
9. ?> 

静态方法,代码如下:

1. <?php 
2. class Fruit { 
3.  public static $category = "I'm fruit"; 
4.      
5.     static function find($class)  
6.  { 
7.      $vars = get_class_vars($class) ; 
8.        echo $vars['category'] ; 
9.     } 
10. } 
11. class Apple extends Fruit { 
12.      public static $category = "I'm Apple"; 
13. } 
14. Apple::find("Apple"); 
15. ?> 
16. //程序运行结果：1 I'm Apple 

Program List:重写基类方法,在派生类重写基类的方法,代码如下:

1. <?php 
2. class Fruit 
3. { 
4.  static function Foo ( $class = __CLASS__ ) 
5.     { 
6.         call_user_func(array($class, 'Color')); 
7.     } 
8. } 
9. class Apple extends Fruit 
10. { 
11.     static function Foo ( $class = __CLASS__ ) 
12.     { 
13.         parent::Foo($class); 
14.     } 
15.     static function Color() 
16.     { 
17.         echo "Apple's color is red"; 
18.     } 
19. } 
20. Apple::Foo(); // This time it works. 
21. ?> 
22. //程序运行结果：Apple's color is red 

Program List:静态数组的使用

静态和const作用域都可以用::操作符访问,如果你想使用::操作符访问数组,你需要事先将数组声明为静态,代码如下:

1. <?php 
2. class Fruit 
3. { 
4.    static $color = array('color1' => 'red', 'color2' => 'yellow'); 
5. } 
6. class Apple 
7. { 
8.    public function __construct() 
9.    { 
10.      var_dump(Fruit::$color); 
11.    } 
12. } 
13. class Banana 
14. { 
15.   public function __construct() 
16.   { 
17.     Fruit::$color = FALSE; 
18.   } 
19. } 
20. new Apple();    // prints array(2) { ["color1"]=> string(3) "red" ["color2"]=> string(6) "yellow" }  
21. echo '<br />'; 
22. new Banana(); 
23. new Apple();    // prints bool(false) 
24. ?> 

Program List:再来一个单例模式,Static真的很酷,下面的程序演示了如何获得一个已经存在的实例,代码如下:

1. <?php 
2. class Singleton { 
3.     private static $instance=null; 
4.     private $value=null; 
5.     private function __construct($value) { 
6.         $this->value = $value; 
7.     } 
8.     public static function getInstance() { 
9.         if ( self::$instance == null ) { 
10.             echo "<br>new<br>"; 
11.             self::$instance = new Singleton("values"); 
12.         }   
13.   else { 
14.             echo "<br>old<br>"; 
15.         } 
16.         return self::$instance; 
17.     } 
18. } 
19. $x = Singleton::getInstance(); 
20. var_dump($x); // returns the new object 
21. $y = Singleton::getInstance(); 
22. var_dump($y); // returns the existing object 
23. ?> 

例,静态变量与静态方法,代码如下:

1. class A { 
2.  static $i = 10; 
3.  public function set($n) 
4.  { 
5.   self::$i = $n; 
6.  } 
7.  public function get() 
8.  { 
9.   return self::$i; 
10.  } 
11. } 
12. $a = new A(); 
13. $a->set(11); 
14. $a1= new A(); 
15. echo $a1->get(); 

输出结果为11,可以看到类A在第二次实例化后,静态变量$i依然与上一次实例化时后设定的$i值是一致的,用java来解释,其实就是一个类的静态变量在多个实例中都使用了一个内存空间,我觉得这样解释更加便于理解,因为静态变量和静态方法不需要实例化就可以使用，因而在文件被加载后静态变量就会初始化,而静态方法则会被注册。这也就可以理解,为什么java类的入口会这样的了,代码如下:

public static void main(String[] args){}

我以前一直觉得由于静态方法不需要实例化就可以直接使用，节约了实例化的巨大开销，因而在使用一个类的方法时我更加倾向于直接静态调用而避免实例化。对于这个问题，我与同事已经争论过很多次，他不主张静态调用主要有以下想法：

1.实例化类更加符合面向对象编程的思想；

2.静态调用方法并不能在消耗上有较大的节约。

对于这个问题,我还是坚持自己的观点,但也并不是无论什么时候都使用静态调用,我主要有以下想法：

1.由于静态变量在文件被载入时就会被初始化,因此如果有多个类,并且类中存在多个静态变量与方法,势必在还未实例化时已消耗较多的内存（未验证）,所以对于访问不频繁或特殊需要,不建议将一个方法设为static；

2.对于调用较为频繁的类,我强烈建设使用static静态和静态方法,不仅可以共享内存空间,还可以共享数据。细心就会发现目前主流的PHP框架的基类都是使用的静态调用方法。