• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    迪恩网络公众号
登陆 注册
描述文字

php面向对象

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

面向对象的基本概念，面向对象编程，oop，面向对象，面向对象的分析，面向对象的设计，面向对象的编程，什么是类。

类，属性和方法，类，对象，面向对象编程的三大特点。特点，封装性，继承性，多态性。

封装性，也可以称为信息隐藏。
继承性就是派生类（子类）自动继承一个或多个基类（父类）中的属性与方法，并可以重写或添加新的属性或方法。
多态性是指同一个类的不同对象，使用同一个方法可以获得不同的结果，这种技术称为多态性。

类的定义，成员方法，类的实例化，成员变量，类常量，构造方法和析构方法，继承和多态的实现，数据的隐藏，静态变量。

类的定义：

<?php
class SpoObject{            //定义类
    //…
}
?>

成员方法：

<?php
    class SportObject{
        function beatBasketball()($name,$height,$avoirdupois,$age,$sex){    //声明成员方法
            echo "姓名：".$name;   //方法实现的功能
    
        }
    }
?>

类的实例化:

对象名 -> 成员方法

成员变量
类中的变量，也称为成员变量

关键字 成员变量名
对象名 -> 成员变量

类常量
常量就是不会改变的量，是一个恒值。
定义常量使用关键字const
输出格式：

类名::常量名

构造方法和析构方法

void __construct([mixed args [,…]])
void __destruct ( void )

示例：

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>成员变量</title>
<style type="text/css">
<!--
body,td,th {
    font-size: 12px;
}
body {
    margin-left: 10px;
    margin-top: 10px;
    margin-right: 10px;
    margin-bottom: 10px;
}
-->
</style></head>
<body>
<?php
class SportObject{
    public $name;                               //定义成员变量
    public $height;                             //定义成员变量
    public $avoirdupois;                        //定义成员变量
    
    public function bootFootBall($name,$height,$avoirdupois){               //声明成员方法
        $this->name=$name;
        $this->height=$height;
        $this->avoirdupois=$avoirdupois;
        if($this->height<185 and $this->avoirdupois<85){
            return $this->name."，符合踢足球的要求!";            //方法实现的功能
        }else{
            return $this->name."，不符合踢足球的要求!";           //方法实现的功能
        }
    }
}
$sport=new SportObject();           //实例化类，并传递参数
echo $sport->bootFootBall('1','185','80');                              //执行类中的方法
?>

</body>
</html>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>成员方法</title>
<style type="text/css">
<!--
body,td,th {
    font-size: 12px;
}
body {
    margin-left: 10px;
    margin-top: 10px;
    margin-right: 10px;
    margin-bottom: 10px;
}
-->
</style></head>
<body>
<?php
    class SportObject{
        function beatBasketball($name,$height,$avoirdupois,$age,$sex){              //声明成员方法
            if($height>180 and $avoirdupois<=100){
                return $name."，符合打篮球的要求!";          //方法实现的功能
            }else{
                return $name."，不符合打篮球的要求!";         //方法实现的功能
            }
        }
    }
    $sport=new SportObject();
    echo $sport->beatBasketball('1','185','80','20周岁','男');
?>
</body>
</html>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>常量</title>
<style type="text/css">
<!--
body,td,th {
    font-size: 12px;
}
body {
    margin-left: 10px;
    margin-top: 10px;
    margin-right: 10px;
    margin-bottom: 10px;
}
-->
</style></head>
<body>
<?php
class SportObject{
    const BOOK_TYPE = '计算机图书';
    public $object_name;                        //图书名称
    function setObjectName($name){              //声明方法setObjectName()
        $this -> object_name = $name;           //设置成员变量值
    }
    function getObjectName(){                   //声明方法getObjectName()
        return $this -> object_name;
    }
}
$c_book = new SportObject();                        //实例化对象
$c_book -> setObjectName("PHP类");               //调用方法setObjectName
echo SportObject::BOOK_TYPE."->";                   //输出常量BOOK_TYPE
echo $c_book -> getObjectName();                //调用方法getObjectName
?>
</body>
</html>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>构造方法</title>
<style type="text/css">
<!--
body,td,th {
    font-size: 12px;
}
body {
    margin-left: 10px;
    margin-top: 10px;
    margin-right: 10px;
    margin-bottom: 10px;
}
-->
</style></head>
<body>
<?php
class SportObject{
    public $name;                               //定义成员变量
    public $height;                             //定义成员变量
    public $avoirdupois;                        //定义成员变量
    public $age;                                //定义成员变量
    public $sex;                                //定义成员变量
    public function __construct($name,$height,$avoirdupois,$age,$sex){              //定义构造方法
        $this->name=$name;                      //为成员变量赋值
        $this->height=$height;                  //为成员变量赋值
        $this->avoirdupois=$avoirdupois;        //为成员变量赋值
        $this->age=$age;                        //为成员变量赋值
        $this->sex=$sex;                        //为成员变量赋值
    }
    public function bootFootBall(){             //声明成员方法
        if($this->height<185 and $this->avoirdupois<85){
            return $this->name."，符合踢足球的要求!";            //方法实现的功能
        }else{
            return $this->name."，不符合踢足球的要求!";           //方法实现的功能
        }
    }
}
$sport=new SportObject('1','185','80','20','男');            //实例化类，并传递参数
echo $sport->bootFootBall();                                //执行类中的方法

?>

</body>
</html>

析构方法，是对象被销毁时被调用的，作用是释放内存。

void __destruct ( void )
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>析构方法</title>
</head>
<body>
<?php
class SportObject{
    public $name;                               //定义成员变量
    public $height;                             //定义成员变量
    public $avoirdupois;                        //定义成员变量
    public $age;                                //定义成员变量
    public $sex;                                //定义成员变量
    public function __construct($name,$height,$avoirdupois,$age,$sex){              //定义构造方法
        $this->name=$name;                      //为成员变量赋值
        $this->height=$height;                  //为成员变量赋值
        $this->avoirdupois=$avoirdupois;        //为成员变量赋值
        $this->age=$age;                        //为成员变量赋值
        $this->sex=$sex;                        //为成员变量赋值
    }
    public function bootFootBall(){             //声明成员方法
        if($this->height<185 and $this->avoirdupois<85){
            return $this->name."，符合踢足球的要求!";            //方法实现的功能
        }else{
            return $this->name."，不符合踢足球的要求!";           //方法实现的功能
        }
    }
    function __destruct(){
        echo "<p><b>对象被销毁，调用析构函数。</b></p>";
    }
}
$sport=new SportObject('1','185','80','20','男');            //实例化类，并传递参数
//unset($sport);    

?>
</body>
</html>

继承和多态的实现

所有成员变量和方法
构造函数
先调用子类中的方法
去调用父类中的构造方法

class subClass extends superClass{
…
}

多态存在两种形式：覆盖和重载。

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>继承的实现</title>
<style type="text/css">
</head>
<body>
<?php
/*  父类  */
class SportObject{
    public $name;                               //定义姓名成员变量
    public $age;                                //定义年龄成员变量
    public $avoirdupois;                        //定义体重成员变量
    public $sex;                                //定义性别成员变量
    public function __construct($name,$age,$avoirdupois,$sex){              //定义构造方法
        $this->name=$name;                      //为成员变量赋值
        $this->age=$age;                        //为成员变量赋值
        $this->avoirdupois=$avoirdupois;        //为成员变量赋值
        $this->sex=$sex;                        //为成员变量赋值
    }
    function showMe(){                          //定义方法
        echo '这句话不会显示。';
    }
}
/*  子类BeatBasketBall  */
class BeatBasketBall extends SportObject{               //定义子类，继承父类
    public $height;                                     //定义身高成员变量
    function __construct($name,$height){                //定义构造方法
        $this -> height = $height;                      //为成员变量赋值
        $this -> name = $name;                          //为成员变量赋值
    }
    function showMe(){                                  //定义方法
        if($this->height>185){
            return $this->name."，符合打篮球的要求!";            //方法实现的功能
        }else{
            return $this->name."，不符合打篮球的要求!";           //方法实现的功能
        }
    }
}
/*  子类WeightLifting  */
class WeightLifting extends SportObject{                        //继承父类
    function showMe(){                                          //定义方法
        if($this->avoirdupois<85){
            return $this->name."，符合举重的要求!";             //方法实现的功能
        }else{
            return $this->name."，不符合举重的要求!";            //方法实现的功能
        }
    }
}


//实例化对象
$beatbasketball = new BeatBasketBall('','190');             //实例化子类
$weightlifting = new WeightLifting('','185','80','20','男');
echo $beatbasketball->showMe()."<br>";                          //输出结果
echo $weightlifting->showMe()."<br>";
?>
</body>
</html>

继承的实现

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>继承的实现</title>
<style type="text/css">
</head>
<body>
<?php
/*  父类  */
class SportObject{
    public $name;                               //定义姓名成员变量
    public $age;                                //定义年龄成员变量
    public $avoirdupois;                        //定义体重成员变量
    public $sex;                                //定义性别成员变量
    public function __construct($name,$age,$avoirdupois,$sex){              //定义构造方法
        $this->name=$name;                      //为成员变量赋值
        $this->age=$age;                        //为成员变量赋值
        $this->avoirdupois=$avoirdupois;        //为成员变量赋值
        $this->sex=$sex;                        //为成员变量赋值
    }
    function showMe(){                          //定义方法
        echo '这句话不会显示。';
    }
}
/*  子类BeatBasketBall  */
class BeatBasketBall extends SportObject{               //定义子类，继承父类
    public $height;                                     //定义身高成员变量
    function __construct($name,$height){                //定义构造方法
        $this -> height = $height;                      //为成员变量赋值
        $this -> name = $name;                          //为成员变量赋值
    }
    function showMe(){                                  //定义方法
        if($this->height>185){
            return $this->name."，符合打篮球的要求!";            //方法实现的功能
        }else{
            return $this->name."，不符合打篮球的要求!";           //方法实现的功能
        }
    }
}
/*  子类WeightLifting  */
class WeightLifting extends SportObject{                        //继承父类
    function showMe(){                                          //定义方法
        if($this->avoirdupois<85){
            return $this->name."，符合举重的要求!";             //方法实现的功能
        }else{
            return $this->name."，不符合举重的要求!";            //方法实现的功能
        }
    }
}


//实例化对象
$beatbasketball = new BeatBasketBall('','190');             //实例化子类
$weightlifting = new WeightLifting('','185','80','20','男');
echo $beatbasketball->showMe()."<br>";                          //输出结果
echo $weightlifting->showMe()."<br>";
?>
</body>
</html>

重载:
传递的参数个数不同，调用不同的方法，返回不同的值。

<?php 
    class C{
        function __call($name,$num){        //调用不存在的方法
        echo "方法名称：" . $name . "<p>";       //输出方法名
        echo "参数存在个数：" . count($num) . "<p>";   //输出参数个数
            if (count($num) == 1){  //根据参数个数调用不同的方法
                echo $this->list1($a);  
            }
            if (count($num) == 2){  //根据参数个数调用不同的方法
                echo $this->list2($a,$b);
            }
        }
        public function list1($a){      //定义方法
            return "这是list1函数";
        }
        public function list2($a,$b){   //定义方法
            return "这是list2函数";
        }
    }
$a = new C;                 //类的实例化
$a->listshow(1,2);              //调用方法，传递参数
?>
关键字::变量名/常量名/方法名
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>伪变量$this</title>
</head>
<body>
<?php
    class example{
        function exam(){
            if(isset($this)){
                echo '$this的值为：'.get_class($this);
            }else{
                echo '$this未定义';
            }
        }
    }
    $class_name = new example();
    $class_name->exam();
?>
</body>
</html>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>“::”操作符</title>
</head>
<body>
<?php
class Book{
    const NAME = 'computer';                            //常量NAME
    function __construct(){                             //构造方法
        echo '本月图书类冠军为：'.Book::NAME.' ';        //输出默认值
    }
}
class l_book extends Book{                              //Book类的子类
    const NAME = 'foreign language';                    //声明常量
    function __construct(){                             //子类的构造方法
        parent::__construct();                          //调用父类的构造方法
        echo '本月图书类冠军为：'.self::NAME.' ';        //输出本类中的默认值
    }
}
$obj = new l_book();                                    //实例化对象
?>
</body>
</html>

parent: 可以调用父类中的成员变量，成员方法和常量。

self:可以调用当前类中的静态成员和常量。

类名:可以调用本类中的变量，常量和方法。

数据隐藏

public（公共成员）
private（私有成员）
protected（保护成员）

public, private, protected, static, final

静态变量（方法）

关键字::静态成员
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>private关键字</title>
</head>
<body>
<?php
class Book{
    private $name = 'computer';                         //声明私有变量$name
    public function setName($name){                     //设置私有变量
        $this -> name = $name;
    }
    public function getName(){                          //读取私有变量
        return $this -> name;
    }
}
class LBook extends Book{                               //Book类的子类  
}
$lbook = new LBook();                                   //实例化对象
echo '正确操作私有变量的方法：';
$lbook -> setName("PHP");                   //对私有变量进行操作
echo $lbook -> getName();
echo '<br>直接操作私有变量的结果：';                    //对私有变量进行操作
echo Book::$name;
?>
</body>
</html>

private只能在所属类的内部被调和修改，不可以在类外被访问。

protected修饰的类成员，可以在本类和子类中被调用，其他地方不可以被调用。

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>protected关键字</title>
</head>
<body>
<?php
class Book{
    protected $name = 'computer';                       //声明保护变量$name
}
class LBook extends Book{                               //Book类的子类
    public function showMe(){
        echo '对于protected修饰的变量，在子类中是可以直接调用的。如：$name = '.$this -> name;
    }
}
$lbook = new LBook();                                   //实例化对象
$lbook -> showMe();
echo '<p>但在其他的地方是不可以调用的，否则：';           //对私有变量进行操作
$lbook -> name = 'history';
?>
</body>
</html>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>protected关键字</title>
</head>
<body>
<?php
class Book{
    protected $name = 'computer';                       //声明保护变量$name
}
class LBook extends Book{                               //Book类的子类
    public function showMe(){
        echo '对于protected修饰的变量，在子类中是可以直接调用的。如：$name = '.$this -> name;
    }
}
$lbook = new LBook();                                   //实例化对象
$lbook -> showMe();
echo '<p>但在其他的地方是不可以调用的，否则：';           //对私有变量进行操作
$lbook -> name = '会报错，这里就错了';
?>
</body>
</html>

静态变量：

关键字::静态成员

self，在类内部调用 静态成员所使用

在静态方法中，只能调用静态变量，不能调用普通变量，而普通方法可以调用静态变量。

对象被销毁后，仍然保存被修改的静态数据。

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>静态变量的使用</title>
</head>
<body>
<?php
class Book{                                     //Book类
    static $num = 0;                            //声明一个静态变量$num，初值为0
    public function showMe(){                   //申明一个方法
        echo '您是第'.self::$num.'位访客';        //输出静态变量
        self::$num++;                           //将静态变量加1
    }
}
$book1 = new Book();                            //实例化对象$book1
$book1 -> showMe();                             //调用showMe()方法
echo "<br>";
$book2 = new Book();                            //实例化对象$book2;
$book2 -> showMe();                             //再次调用showMe()方法
echo "<br>";
echo '您是第'.Book::$num.'为访客';                //直接使用类名调用静态变量
?>
</body>
</html>

运行效果是：

您是第0位访客
您是第1位访客
您是第2位访客

对象的高级应用

final关键字，抽象类，接口的使用，克隆对象，对象比较，对象类型检测，魔术方法。

不可以被继承，不能有子类
final class class_name{
//…
}

final function method_name() 不可以重写和覆盖
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>final类</title>
></head>
<body>
<?php
    final class SportObject{
        function  __construct(){
            echo '不能被继承，不能有子类';
        }
    }
    class MyBook extends SportObject{
        static function exam(){
            echo "会报错的";
        }
    }
    MyBook::exam();
?>
</body>
</html><

鲜花
握手
雷人
路过
鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
More+
上一篇：
{php变量}发布时间：2022-07-10
下一篇：
从php到浏览器的缓存机制发布时间：2022-07-10
热门推荐
More+
热门话题
More+
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服
地址：深圳市南山区西丽大学城创智工业园
电邮：jeky_zhao#qq.com
移动电话：139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap