php类和对象的学习(二)

static关键字

1)声明类成员或者方法为static,就可以不实例化类而直接访问,不能通过一个对象来访问其中的静态成员（静态方法除外）。

2)为了兼容PHP4，如果没有指定“可见性”，属性和方法默认为public。

3)由于静态方法不需要通过对象即可调用，所以伪变量$this在静态方法中不可用。

4)静态属性不可以由对象通过->操作符来访问

<?php
class baseStaticClass{
   public static $foo="foo";
   public function staticValue(){
      return self::$foo;//静态成员内部的调用方法
   }
   public static function staticMeth(){
      echo "调用了静态方法<br>";
   }
}
class secondStaic extends baseStaticClass{
   public function secondStaticValue(){
     return parent::$foo;
   }
} 
//调用静态成员的属性,类名.属性名
echo baseStaticClass::$foo,"<br>";//调用静态属性前面要加$
echo baseStaticClass::staticMeth();//调用静态方法不用加$
$baseClass=new baseStaticClass();
echo $baseClass->staticValue(),"<br>";
//echo $baseClass->$foo,"<br>";// Undefined variable: foo 
echo $baseClass::$foo,"<br>";//????
?>

抽象类

释义:PHP5支持抽象类和抽象方法。抽象类不能直接被实例化，你必须先继承该抽象类，然后再实例化子类。抽象类中至少要包含一个抽象方法。如果类方法被声明为抽象的，那么其中就不能包括具体的功能实现。

继承一个抽象类的时候，子类必须实现抽象类中的所有抽象方法；另外，这些方法的可见性必须和抽象类中一样（或者更为宽松）。

<?php
abstract class AbstractClass{
   // 强制要求子类定义这些方法
    abstract protected function getValue();
    abstract protected function crawValue($prefix);
    // 普通方法（非抽象方法）
    public function printOut() {
        print $this->getValue() . "<br>";
    }
}
class realizeClass extends AbstractClass{
    //private-->protected-->public  访问权限依次加大
    //实现类的访问权限要大于抽象类中的,可以是protected,也可以是public
    public function getValue(){//声明为protected时Call to protected method realizeClass::getValue()
        echo get_class($this)." 实现了抽象类的方法getValue<br>";
    }
    public function crawValue($prefix){
        echo get_class($this)." 实现了抽象类的方法crawValue,传入的值是{$prefix}<br>";
    }
}
$a=new realizeClass();
$a->getValue();
$a->crawValue('yxkong');
$a->printOut();
?>

接口

使用接口（interface），你可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。

1)通过interface来定义一个接口，就像定义一个标准的类一样，

2)其中定义所有的方法都是空的。

3)接口中定义的所有方法都必须是public，这是接口的特性。

4)接口即可以继承,也可以被implements

<?php
//声明一个接口
interface baseFace{
    public function setVariable($name, $var);
    public function getHtml($template);
}
class realizeBaseFace implements baseFace{
    private $arr=array();
    public function setVariable($name, $var){
        echo "输入的name值是{$name},输入的var值是{$var}<br>";
        $this->arr[$name]=$var;
    }
    public function getHtml($template){
        foreach($this->arr as $name => $value) {
            //mixed str_replace ( mixed $search , mixed $replace , mixed $subject [, int &$count ] ),将$subject中的$search全部替换为$replace
            //将$template中的包含{$name}值全部换成$value的值
            $template = str_replace('{' . $name . '}', $value, $template);
        }
        return $template;
 
    }
}
$b=new realizeBaseFace();
echo $b->setVariable("title","yxkong博客"),"<br>";
echo $b->getHtml('<博客的标题是:{title},再次说明博客的标题是:{title}>'),"<br>";
?>

对象迭代

对象迭代是将类中的属性和值组成key-value的形式输出的,外部只能访问public方法

<?php
class MyClass
{
    public $var1 = '值1';
    public $var2 = '值2';
    public $var3 = '值3';
 
    protected $protected = 'protected 值';
    private   $private   = 'private 值';
 
    function iterateVisible() {
       echo "MyClass::iterateVisible:\n";
       foreach($this as $key => $value) {
           print "$key => $value<br>";
       }
    }
}
$class = new MyClass();
foreach($class as $key => $value) {
    print "$key => $value<br>";
}
$class->iterateVisible();
?>

设计模式

使用设计模式是促进最佳实践和良好设计的好办法。设计模式可以提供针对常见的编程问题的灵活的解决方案。

工厂模式

工厂模式（Factory）允许你在代码执行时实例化对象。它之所以被称为工厂模式是因为它负责“生产”对象。工厂方法的参数是你要生成的对象对应的类名称。

<?php
class FactoryExample
{
    // 
    public static function factory($type)
    {
        if (include_once 'Drivers/' . $type . '.php') {
            $classname = 'Driver_' . $type;
            return new $classname;
        } else {
            throw new Exception ('Driver not found');
        }
    }
}
//根据需求加载mysql的驱动
$mysql=FactoryExample::factory('MySql');
?>

单例模式

单例模式（Singleton）用于为一个类生成一个唯一的对象。最常用的地方是数据库连接。使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。

1)单例的构造方法是私有的,不允许实例化的

2)单例里实现方法是静态的,只在调用的时候执行一次(在java中只在编译的时候执行一次,加载到内存以后就不动了)

<?php
class SingletonExample
{
    // 保存类实例在此属性中
    private static $instance;
       // 构造方法声明为private，防止直接创建对象
    private function __construct() 
    {
        echo 'SingletonExample 的构造方法';
    }
    // singleton 方法
    public static function singleton() 
    {
        if (!isset(self::$instance)) {
            $c = __CLASS__;
            self::$instance = new $c;
        }
        return self::$instance;
    }    
    // Example类中的普通方法
    public function bark()
    {
        echo 'aaa!';
    }
    // 阻止用户复制对象实例
    public function __clone()
    {
        trigger_error('Clone 是不被允许的', E_USER_ERROR);
    }
}
?> 
<?php
    // 这个写法会出错，因为构造方法被声明为private
  //  $test = new SingletonExample();
    // 下面将得到Example类的单例对象
    $test = SingletonExample::singleton();
    $test->bark();
 
    // 复制对象将导致一个E_USER_ERROR.
    $test_clone = clone $test;
?>

Final关键字

PHP 5 新增了一个 final 关键字。(注,java中的Final关键字可以作用在属性上,定义一个常量)

1)如果父类中的方法被声明为final，则子类无法覆盖该方法；

2)如果一个类被声明为final，则不能被继承。