PHP学习5面向对象程序设计

PHP面向对象程序设计

定义和使用类

声明类

用class 关键字
class 类名
{
定义成员变量
定义成员函数
}
在类定义中，使用关键字var 定义一个成员变量，在定义成员变量时可以同时为它赋初值。
类的成员变量分为公有和私有，用public 和private来标识，访问方式与c++相同，公有函数和变量可以在类外访问，私有的不能在类外访问。

常使用$this来引用类中的成员变量。
使用方法 $this->变量名

构造函数

与c++很不同，c++中的构造函数与函数名同名，php中有一个固定的名称。—— ——construct(函数名以两个下划线开头）

class Mystring
{
   public $userName;
   private $pwd;
    function __construct()
    {
        $this->userName="Admin";
        $this->pwd="Admipwd";
    }

    function  output()
    {
        echo ($this->userName);
        
    }
}

在构造函数中，程序对共有变量$userName和私有变量 $pwd设置了初始值。可以在构造函数中使用参数，通常使用参数来设置成员变量特别是私有变量的值。

    function __construct($name,$pwd)
    {
        $this->userName=$name;
        $this->pwd=$pwd;
    }

析构函数

同样有一个固定格式_ _destruct()

function __destruct()
    {
        // TODO: Implement __destruct() method.
        echo "EXIT!";
    }

上面这个析构函数只是简单的打印个字符串。

定义类的对象

$mystr=new Mystring();
在定义对象时使用带参数的构造函数。
$mystr=new Mystring(‘admin’,‘pwd’);
访问公有变量和公共函数的方式。

<?php
class Mystring
{
   public $userName;
   private $pwd;
    function __construct($name,$pwd)
    {
        $this->userName=$name;
        $this->pwd=$pwd;
    }
    function __destruct()
    {
        // TODO: Implement __destruct() method.
        echo "EXIT!";
    }

    function  output()
    {
        echo ($this->userName);

    }
}
//声明对象
$mystr=new Mystring('admin','pwd');
//访问公有变量
echo($mystr->userName);
//访问成员函数
$mystr->output();

静态类成员

静态类成员与具体的对象没有关系，只属于定义它们的类。
例如：private static $count=0;
访问静态变量的方式： $self:: $ count 不能用$this访问了。

因为静态变量不属于任何对象，所以通常使用静态函数来访问静态变量。

<?php
class Users{
    public $username;
    static  private $online_count;

    function __construct($name="")
    {
        $this->username=$name;
        self::$online_count++;
    }
    function __destruct()
    {
        self::$online_count--;
        // TODO: Implement __destruct() method
    }
    static function  getCount()
    {
        Return self::$online_count;
    }

}
$my_use1=new Users('admin');
$my_use2=new Users('lee');
$my_use3=new Users('zhang');
echo (Users::getCount());

instanceof关键字

用于检查给定的对象是否属于（继承于）某个类。如果是返回TRUE，不是返回false

类的继承和多态

class B extends A{ }
从类B中可以访问到类A的成员变量和成员函数。

子类可以访问父类的公有变量和公共成员函数，不能访问父类的私有变量和私有函数。

<?php
class Users{
    public $username;


    function __construct($name="")
    {
        $this->username=$name;
      
    }
    public function dispUserName()
    {
        echo($this->username);
    }
}

class UserLogin extends Users{
    private $lastLoginTime;
    function __construct($name = "")
    {
        $this->username=$name;
        $cur_time=getdate();
        $this->lastLoginTime=$cur_time['year']."-".$cur_time['mon']."-".$cur_time['mday']." ".$cur_time['hours'].":".
            $cur_time['minutes'].":".$cur_time['seconds']."\n";
    }
    function disLoginTime(){
        echo("登录时间为：".$this->lastLoginTime."<br/>");
    }
}
//声明3个对象
$myuser_1=new UserLogin('admin');
$myuser_2=new UserLogin('lee');
$myuser_3=new UserLogin('zhang');
//分别调用父类和子类函数
$myuser_1->dispUserName();
$myuser_1->disLoginTime();
$myuser_2->dispUserName();
$myuser_2->disLoginTime();
$myuser_3->dispUserName();
$myuser_3->disLoginTime();

抽象类和多态

定义一个抽象类
abstract class 抽象类名称{
成员变量
abstract function 抽象函数
}
在继承抽象类的类中必须对抽象函数进行实现。
在不同的子类中，对抽象函数进行不同的实现。

复制对象

新对象名=原有对象名

通过函数参数复制对象

function drawCircle($circle)
{
    if($circle instanceof circle)
        $circle->draw();
}
$mycircle=new circle();
drawCircle($mycircle);

可以在参数列表使用抽象类的对象，它可以接受所有从抽象类派生的子类对象。这样就不需要为每一个子类都定义一个对象的函数了。

继承的多态的例子

<?php
//继承和多态的例子

abstract class Shape{
    public $color;
    abstract function draw();
}
class circle extends Shape{
    public $x,$y,$radius;
    function draw()
    {
        // TODO: Implement draw() method.
        echo("Draw Circle:color $this->color;($this->x,$this->y);Radius $this->radius\n");
    }

}
class line extends Shape{
    public $x1,$y1,$x2,$y2;
    function draw()
    {
        // TODO: Implement draw() method.
        echo("Draw line:color $this->color;($this->x1,$this->y1)=>($this->x2,$this->y2)\n");
    }
}
$mycircle=new circle();
$mycircle->x=100;
$mycircle->y=100;
$mycircle->radius=50;
$mycircle->color='red';
$mycircle->draw();

$myline=new line();
$myline->x1=100;
$myline->y1=100;
$myline->x2=200;
$myline->y2=200;
$myline->color='blue';
$myline->draw();

//通过函数参数复制对象
function drawCircle($circle){
    if($circle instanceof circle){
        $circle->draw();
    }
}
$mycircle=new circle();
$mycircle->x=100;
$mycircle->y=100;
$mycircle->radius=50;
$mycircle->color='red';
drawCircle($mycircle);

使用类Shape的子类对象作为参数，调用drawshape()函数,因为类shape是抽象类，它的draw（）函数没有具体的实现代码，如果以circle对象或line对象作为参数， 则可以指向这两个类中的draw函数。

function drawShape($shape){
    if($shape instanceof Shape){
        $shape->draw();
    }
}
$mycircle=new circle();
$mycircle->x=100;
$mycircle->y=100;
$mycircle->radius=50;
$mycircle->color='red';
drawShape($mycircle);

$myline=new line();
$myline->x1=100;
$myline->y1=100;
$myline->x2=200;
$myline->y2=200;
$myline->color='blue';
drawShape($myline);