PHP面向对象(三)

一、继承概念

　　继承性也是面向对象程序设计中的重要特性之一。它是指建立一个新的派生类，从一个先前定义的类中继承数据和函数，而且可以重新定义新的数据类型和函数，从而建立累的层次或等级关系。

　　格式：
　　　　[修饰符] class 子类名 extends 父类名
　　　　{
　　　　　　...
　　　　}

　　假如B类继承A类，那么
　　　　从内存上来讲：B继承了A中所有的属性和方法；但是父类中的private部分不能直接访问
　　　　从使用上来讲：B继承了A中所有非私有的属性和方法
　　　　其中Ａ叫父类（基类）。　Ｂ叫子类（派生类）

　　PHP只支持单继承，不允许多重继承。一个子类只能有一个父类，不允许一个类直接继承多个类，但一个类可以被多个类继承。可以有多层继承，即一个类可以继承某一个类的子类，如类B继承了类A，类C又继承了类B，那么类C也间接继承了类A。

class A
{
}
class B extends A
{
}
class C extends B
{
}

注意：

　　子类继承父类的所有内容，但父类中的private部分不能直接访问
　　子类中新增加的属性和方法是对父类的扩展
　　子类中定义的与父类同名的属性是对父类属性的覆盖，同名的方法也是对父类方法的覆盖

　　　　　　public(公有) 　　 protected(受保护) 　　 private(私有)
===========================================================
在本类中　　 Y 　　　　　　　　　　 Y 　　　　　　　　 Y
在子类中 　　Y 　　　　　　　　　　 Y　　　　　　　　  N
在类外边　　 Y 　　　　　　　　　　 N 　　　　　　　　 N

 

<?php 

    class A
    {    
        public $x=10;            
        protected $y=200;        
        private $z=3000;

        public function fun1()
        {
            echo "class A fun1....<br>";
        }
    
        protected function fun2()
        {
            echo "class A fun2....<br>";
        }
        
        private function fun3()
        {
            echo "class A fun3....<br>";
        }
            
    }
    //类B继承类A
    class B extends A 
    {

    }
    $b=new B();
    var_dump($b);    
    /*
        object(B)[1]                         //B继承了A的所有属性
              public 'x' => int 10           //公有的还是共有的
              protected 'y' => int 200       //受保护的还是受保护的
              private 'z' (A) => int 3000    //私有的可以看到任然属于类A
      */
    echo $b->x;        　//输出公有属性    10
    //echo $b->y;        //尝试输出受保护的失败    Fatal error: Cannot access protected property B::$y 
    //echo $b->z;        //尝试输出私有属性失败    Notice: Undefined property: B::$z 
 ?>

 

二、继承中的使用(易维护，易扩展)

　　在子类里面允许重写（覆盖）父类的方法 在子类中，使用parent访问父类中的被覆盖的属性和方法 parent::__construce(); parent::fun();

<?php
//类的继承使用(parent的使用)

class Person
{
    private $name;
    private $age;
    
    public function __construct($name,$age)
    {
        $this->name = $name;
        $this->age = $age;
    }
    
    public function getInfo()
    {
        return " 姓名：".$this->name." 年龄：".$this->age;
    }
}

class Stu extends Person
{
    private $classid;
    
    public function __construct($name,$age,$classid)
    {
        parent::__construct($name,$age);
        $this->classid = $classid;
    }
    
    public function getInfo()       //重写（覆盖）父类方法，达到不修改只添加，易维护
    {
        return parent::getInfo()." 班级：".$this->classid;
    }
    public function say()           //添加父类没有的方法，达到扩展功能，易扩展
    {
        echo "hello world!<br>";
    }
}


$s = new Stu("wangwu",26,"lamp149");
echo $s->getInfo()."<br>";
$s->say();

$p = new Person("zhangsan",22);
echo $p->getInfo()."<br/>";
?>

 

三、final关键字

　　在PHP5中新增加了final关键字，它只能用来修饰类和方法，不能使用final这个关键字来修饰成员属性，因为final是常量的意思，我们在PHP里定义常量使用的是define()函数和const关键字，所以不能使用final来定义成员属性。

　　 final的特性：

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

　　　　使用final关键字标识的方法不能被子类覆盖（重写），是最终版本；

　　目的：一是为了安全，二是没有必要

<?php
//类中final关键字的使用：
//final关键字可修饰类和方法，被修饰的类不可有子类，修饰的方法不可被子类覆盖。

//final修饰的类不可有子类。
final class A
{ 
    //使用final关键字修饰的方法不可以被子类覆盖
    public final function fun1()
    {
        echo "aaaaaaaaaaaaa<br/>";
    }
    
    public final function max($a,$b)    //这种方法是没有必要重写的
    {
        return $a>$b?$a:$b;
    }
}

/*
class B extends A       //类A带有final修饰，不能被继承
{
    
    public function fun1()      //如果类A没有被final修饰但是由于fun1有关键字final修饰不能被重写（覆盖）
    {
        echo "bbbbbbbbbbbb<br/>";
    }
}
*/
?>

四、static关键字　

　　表示静态的意思: 用于修饰类的属性和方法
　　static关键字修饰方法称为静态方法，可以不用new（实例化）就可以直接使用方法：如 类名::方法名
　　注意：静态方法在实例化后的对象也可以访问 //$对象名->静态方法名

　　static关键字修饰属性称为静态属性，可以不用new（实例化）就可以直接访问属性：如 类名::属性名
　　注意：静态属性在实例化后的对象不可以访问； //$对象名->静态属性名

　　注意：　静态属性是共享的。也就是new很多对象也是共用一个属性
　　　　　　在静态方法中不可以使用非静态的内容。就是不让使用$this
　　　　　　在类的方法中可以使用其他静态属性和静态方法，不过要使用self关键字：
　　　　　　如 【self::静态属性名】或【self::静态方法名】
　　　　　　(>PHP5.3)在一个类的方法中若没有出现$this的调用，默认此方法为静态方法。

　　类中的静态属性和静态方法不用实例化(new)就可以直接使用类名访问。

　　　　格式： 　　类::$静态属性 　　类::静态方法

　　在类的方法中，不能用this来引用静态变量或静态方法，而需要用self来引用。

　　　　格式：　　 self::$静态属性　　 self::静态方法

<?php
//static静态关键字使用

class A
{
    //使用static关键字修饰的属性称静态属性，特点是不用实例化就可直接通过类名::调用
    public static $name="lisi";
    
    //使用static关键字修饰的方法称静态方法，特点是不用实例化就可直接通过类名::调用
    public static function max($a,$b)
    {
        
        return $a>$b?$a:$b;
    }
    
    public static function add($x,$y)
    {
        return $x+$y;
    }
    
    public function demo()
    {
        //在类中调用其他静态属性和方法使用关键字self
        echo self::$name;
        echo self::add(30,40);
        
    }
    
}

echo A::max(10,20); //20
echo A::add(10,20); //30
echo A::$name; //获取静态属性

A::$name = "wangwu";

echo "<hr/>";
$a = new A();
$a->demo();
?>

 

单例（单态）模式

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

　　要点：1.构造方法私有化

　　　　　2.定义私有静态的对象属性

　　　　　3.提供公有静态的实例化当前类对象的方法，内部判断

<?php
//PHP手册单例模式例子
class Example
{
    // 2.保存类实例在此属性中
    private static $instance;
    
       // 1.构造方法声明为private，防止直接创建对象
    private function __construct() 
    {
        echo 'I am constructed';
    }

    // 3.singleton 方法
    public static function singleton() 
    {
        if (!isset(self::$instance)) {
            $c = __CLASS__;
            self::$instance = new $c;
        }

        return self::$instance;
    }
    
    // Example类中的普通方法
    public function bark()
    {
        echo 'Woof!';
    }

    //4.阻止用户复制对象实例
    public function __clone()
    {
        trigger_error('Clone is not allowed.', E_USER_ERROR);
    }

}

?> 

 

五、const关键字

　　在类中修饰成员属性，将其定义成常量（不可修改的），一般要求常量名都是大写的,没有“$”符 没有其他修饰符（public）

　　定义格式:  const 成员常量名="值"; 

　　使用：

　　　　在类的方法中： 　　echo self::成员常量名;

　　　　在类的外部：　　 　 echo 类名::成员常量名;

<?php
//类中常量定义
define("PI",3.14);
const WTO = "世贸组织";


class Game
{
    const UP=37;
    const RIGHT=38;
    const DOWN=39;
    const LEFT=40;
    
    public function move($m)
    {
        switch($m){
            case 37: echo "向上移动...<br/>"; break;
            case 38: echo "向右移动...<br/>"; break;
            case 39: echo "向下移动...<br/>"; break;
            case 40: echo "向左移动...<br/>"; break;
        }
        
    }
}

$g = new Game();
$g->move(38);
$g->move(37);
$g->move(Game::LEFT); //使用类中常量提高代码的可读性。
$g->move(Game::DOWN);
?>

 

六、instanceof

　　用于确定一个 PHP 变量是否属于某一类 class 的实例（亲自鉴定）

<?php
//instanceof类型运算符

class A{}

class B extends A{}

class C{}

$a = new A();
$b = new B();
$c = new C();

var_dump($a instanceof A); //bool(true)
var_dump($b instanceof A); //bool(true)
var_dump($b instanceof B); //bool(true)
var_dump($c instanceof C); //bool(true)
echo "<hr/>";
var_dump($c instanceof A); //bool(false)
var_dump($c instanceof B); //bool(false)
?>