【细说PHP学习】第十章 PHP面向对象的程序设计

最新推荐文章于 2021-12-06 15:41:50 发布
最新推荐文章于 2021-12-06 15:41:50 发布
阅读量1.2k 收藏 2
点赞数 1
分类专栏： PHP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012682145/article/details/47278743
版权

10.1 面向对象的介绍

10.1.1 类和对象之间的关系

1. 什么是类

在面向对象的编程语言中，类是一个独立的程序单位，是具有相同属性和服务的一组对象的集合。它为属于该类的所有对象提供了统一的抽象描述，其内部包括成员属性和服务的方法两个主要部分。

2. 什么是对象

10.1.2 面向对象的程序设计

10.2 如何抽象一个类

10.2.1 类的声明

[一些修饰类的关键字]class 类名{
    类中成员；
}

10.2.2 成员属性

下例中声明了一个Person类，在类中声明了三个成员属性：

class Person{
    var $name;
    var $age;
    var $sex;
}

在Personl类的声明中可以看到，变量前面多使用一个关键字“var”来声明。声明变量不需要任何关键字修饰，而在类中声明成员属性时，变量前面一定要使用一个关键字，例如public、private、static等关键词来修饰。如果不需要有特定意义的修饰，就是用“var”关键字，一旦成员属性有其他的关键字修饰就需要去掉”var”。

class Person{
    public $name;
    private $age;
    static $sex;
}

10.2.3 成员方法

在对象中需要声明一些可以操作本对象成员属性的一些方法，来完成对象的一些行为，在类中直接声明的函数就称为成员方法。成员方法的声明和函数的声明完全一样，只不过可以加一些关键字的修饰来控制成员方法的一些权限。但声明的成员方法必须和对象相关，不能是一些没有意义的操作。

class Person{
    function say(){
        //方法体
    }
    function eat($food){
        //方法体
    }
    private fucnction run(){
        //方法体
    }
}

10.3 通过类实例化对象

10.3.1 实例化对象

$变量名=new 类名称([参数数列表]);

或

$变量名=new 类名称;

如果类中没有定义构造函数，PHP会自动创建一个不带参数的默认构造函数。
例如，通过上一节中声明的“Person”和“Phone”两个类，分别实例化出几个对象。

<?php
    class Phone{
//类中成员
}
class Person{
//类中成员
}
$person1=new Person();
$person2=new Person();
$person3=new Person();

$phone1=new Phone();
$phone2=new Phone();
$phone3=new Phone();
?>

一个类可以实例化出多个对象，每个对象都是独立的。

10.3.2 对象类型在内存中的分配

1. 栈空间段

栈的特点是空间小但被CPU访问的速度快，是用户存放程序中临时创建的变量。由于栈的后进先出特点，所以栈特别方便用来保存和恢复调用现场，从这个意义上讲，我们可以把堆栈看成一个临时数据寄存、交换的内存区，用于存储占用空间长度不变并且占用空间小的数据类型的内存段。

2. 堆空间段

堆是 用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。用于存储数据长度可变或占用内存比较大的数据。

3. 数据段

数据段用来存放可执行文件中已初始化全局变量，换句话说就是存放程序静态分配的变量。

4. 代码段

代码段是用来存放可执行文件的操作指令，也就是说它是可执行程序在内存中的镜像。代码段需要防止在运行时被非法修改，所以只准许读取操作，而不允许写入（修改）操作。

10.3.3 对象中成员的访问

$引用名=new 类名称([参数数列表]);

$引用名->成员属性=值;
echo $引用名->成员属性;

$引用名->成员方法;

在下例中声明了一个Person类，其中包含三个成员属性和两个成员方法，并通过Person类实例化出三个对象，而且使用运算符“->”分别访问三个对象中的每个成员属性和成员方法。

<?php 
    class Person{
        var $name;
        var $sex;
        var $age;

        function say(){
            echo "这个人在说话<br>";
        }

        function run(){
            echo "这个人在走路<br>";
        }
    }

    $person1=new Person();

    $person1->name="张三";
    $person1->sex="男";
    $person1->age=20;

    //下面三行诗访问$person1对象中的成员属性
    echo "person1对象的名字是：".$person1->name."<br>";
    echo "person1对象的名字是：".$person1->sex."<br>";
    echo "person1对象的名字是：".$person1->age."<br>";

    //下面两行访问$person1对象中的方法
    $person1->say();
    $person1->run();

?>

10.3.4 特殊的对象引用“$this”

对象一旦被创建，在对象中的每个成员方法里面都会存在一个特殊的对象引用“$this”。成员方法属于哪个对象，$this引用就代表哪个对象，专门用来完成对象内部成员之间的访问。

<?php 
    class Person{
        var $name;
        var $sex;
        var $age;

        function say(){
            echo "我的名字：".$this->name."，性别：".$this->sex."，年龄：".$this->age."<br>";
        }

        function run(){
            echo $this->name."在走路<br>";
        }
    }

    $person1=new Person();

    $person1->name="张三";
    $person1->sex="男";
    $person1->age=20;

    $person1->say();
    $person1->run();

?>

10.3.5 构造方法与析构方法

1. 构造方法
void __construct ([ mixed $args [, $... ]] )

Note: 如果子类中定义了构造函数则不会隐式调用其父类的构造函数。要执行父类的构造函数，需要在子类的构造函数中调用 parent::__construct()。如果子类没有定义构造函数则会如同一个普通的类方法一样从父类继承（假如没有被定义为 private 的话）。

在PHP中，同一个类中只能声明一个构造方法，原因是构造方法名称是固定的，在PHP中不能声明同名的两个函数，所以也就没有构造方法重载。但可以在声明构造方法时使用默认参数，实现其他面向对象的编程语言中构造方法重载的功能。

<?php
class BaseClass {
   function __construct() {
       print "In BaseClass constructor\n";
   }
}

class SubClass extends BaseClass {
   function __construct() {
       parent::__construct();
       print "In SubClass constructor\n";
   }
}

class OtherSubClass extends BaseClass {
    // inherits BaseClass's constructor
}

// In BaseClass constructor
$obj = new BaseClass();

// In BaseClass constructor
// In SubClass constructor
$obj = new SubClass();

// In BaseClass constructor
$obj = new OtherSubClass();
?>

为了实现向后兼容性，如果 PHP 5 在类中找不到 __construct() 函数并且也没有从父类继承一个的话，它就会尝试寻找旧式的构造函数，也就是和类同名的函数。因此唯一会产生兼容性问题的情况是：类中已有一个名为 __construct() 的方法却被用于其它用途时。

与其它方法不同，当 __construct() 被与父类 __construct() 具有不同参数的方法覆盖时，PHP 不会产生一个 E_STRICT 错误信息。

自 PHP 5.3.3 起，在命名空间中，与类名同名的方法不再作为构造函数。这一改变不影响不在命名空间中的类。

<?php
namespace Foo;
class Bar {
    public function Bar() {
        // treated as constructor in PHP 5.3.0-5.3.2
        // treated as regular method as of PHP 5.3.3
    }
}
?>
2. 析构方法

与构造方法相对应的就是析构方法，PHP将在对象被销毁前自动调用这个歌方法。

void __destruct ( void )

PHP 5 引入了析构函数的概念，这类似于其它面向对象的语言，如 C++。析构函数会在到某个对象的所有引用都被删除或者当对象被显式销毁时执行。

<?php
class MyDestructableClass {
   function __construct() {
       print "In constructor\n";
       $this->name = "MyDestructableClass";
   }

   function __destruct() {
       print "Destroying " . $this->name . "\n";
   }
}

$obj = new MyDestructableClass();
?>

和构造函数一样，父类的析构函数不会被引擎暗中调用。要执行父类的析构函数，必须在子类的析构函数体中显式调用 parent::__destruct()。此外也和构造函数一样，子类如果自己没有定义析构函数则会继承父类的。

析构函数即使在使用 exit() 终止脚本运行时也会被调用。在析构函数中调用 exit() 将会中止其余关闭操作的运行。

Note:
析构函数在脚本关闭时调用，此时所有的 HTTP 头信息已经发出。脚本关闭时的工作目录有可能和在 SAPI（如 apache）中时不同。

Note:
试图在析构函数（在脚本终止时被调用）中抛出一个异常会导致致命错误。

10.4 封装性

封装性是面向对象编程中的三大特性之一，封装性就是把对象的成员属性和成员方法结合成一个独立的相同单位，并尽可能隐蔽对象的内部细节，包含如下两个含义：

把对象的全部成员属性和全部成员方法结合在一起，形成一个不可分割的独立单位（即对象）。
信息隐蔽，即尽可能隐蔽对象的内部细节，对外形成一个边界，只保留有限的对外接口使之与外部发生联系。

10.4.1 设置私有成员

只要在声明成员属性或成员方法时，使用private关键字修饰就实现了对成员的封装。封装后的成员在对象的外部不能被访问，但在对象内部的成员方法中可以访问到自己对象内部被封装的成员属性和被封装的成员方法。

<?php 
    class Person{
        private $name;
        private $sex;
        private $age;

        function __construct($name="",$sex="男",$age=1){
            $this->name=$name;
            $this->sex=$sex;
            $this->age=$age;
        }

        function run(){
            echo $this->name."在走路时".$this->leftLeg()."再".$this->rightLeg()."<br>";
        }

        private function leftLeg(){
            return "迈左腿";
        }

        private function rightLeg(){
            return "迈右腿";
        }
    }
    $person1=new Person();
    $person1->run();
    $person1->name="李四";
    echo $person1->age;
    $person1->leftLeg();
?>

这里写图片描述
在上面的程序中，使用Private关键字将成员属性和成员方法封装成私有属性之后，就不可以在对象的外部通过对象的引用直接访问了，试图去访问私有成员将发生错误。如果在成员属性前面使用了其他的关键词修饰，，就不要在使用“var”关键字修饰了。

补充内容：PHP访问控制（可见性）

类属性必须定义为公有，受保护，私有之一。如果用 var 定义，则被视为公有。

<?php
/**
 * Define MyClass
 */
class MyClass
{
    public $public = 'Public';
    protected $protected = 'Protected';
    private $private = 'Private';

    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}

$obj = new MyClass();
echo $obj->public; // 这行能被正常执行
echo $obj->protected; // 这行会产生一个致命错误
echo $obj->private; // 这行也会产生一个致命错误
$obj->printHello(); // 输出 Public、Protected 和 Private


/**
 * Define MyClass2
 */
class MyClass2 extends MyClass
{
    // 可以对 public 和 protected 进行重定义，但 private 而不能
    protected $protected = 'Protected2';

    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}

$obj2 = new MyClass2();
echo $obj2->public; // 这行能被正常执行
echo $obj2->private; // 未定义 private
echo $obj2->protected; // 这行会产生一个致命错误
$obj2->printHello(); // 输出 Public、Protected2 和 Undefined

?>

Note: 为了兼容性考虑，在 PHP 4 中使用 var 关键字对变量进行定义的方法在 PHP 5 中仍然有效（只是作为 public 关键字的一个别名）。在 PHP 5.1.3 之前的版本，该语法会产生一个 E_STRICT 警告。

类中的方法可以被定义为公有，私有或受保护。如果没有设置这些关键字，则该方法默认为公有。

<?php
/**
 * Define MyClass
 */
class MyClass
{
    // 声明一个公有的构造函数
    public function __construct() { }

    // 声明一个公有的方法
    public function MyPublic() { }

    // 声明一个受保护的方法
    protected function MyProtected() { }

    // 声明一个私有的方法
    private function MyPrivate() { }

    // 此方法为公有
    function Foo()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate();
    }
}

$myclass = new MyClass;
$myclass->MyPublic(); // 这行能被正常执行
$myclass->MyProtected(); // 这行会产生一个致命错误
$myclass->MyPrivate(); // 这行会产生一个致命错误
$myclass->Foo(); // 公有，受保护，私有都可以执行


/**
 * Define MyClass2
 */
class MyClass2 extends MyClass
{
    // 此方法为公有
    function Foo2()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate(); // 这行会产生一个致命错误
    }
}

$myclass2 = new MyClass2;
$myclass2->MyPublic(); // 这行能被正常执行
$myclass2->Foo2(); // 公有的和受保护的都可执行，但私有的不行

class Bar 
{
    public function test() {
        $this->testPrivate();
        $this->testPublic();
    }

    public function testPublic() {
        echo "Bar::testPublic\n";
    }

    private function testPrivate() {
        echo "Bar::testPrivate\n";
    }
}

class Foo extends Bar 
{
    public function testPublic() {
        echo "Foo::testPublic\n";
    }

    private function testPrivate() {
        echo "Foo::testPrivate\n";
    }
}

$myFoo = new foo();
$myFoo->test(); // Bar::testPrivate 
                // Foo::testPublic
?>

同一个类的对象即使不是同一个实例也可以互相访问对方的私有与受保护成员。这是由于在这些对象的内部具体实现的细节都是已知的。

<?php
class Test
{
    private $foo;

    public function __construct($foo)
    {
        $this->foo = $foo;
    }

    private function bar()
    {
        echo 'Accessed the private method.';
    }

    public function baz(Test $other)
    {
        // We can change the private property:
        $other->foo = 'hello';
        var_dump($other->foo);

        // We can also call the private method:
        $other->bar();
    }
}

$test = new Test('test');

$test->baz(new Test('other'));
?>

以上例程会输出：

string(5) "hello"
Accessed the private method.

10.4.2 私有成员的访问

对象中的成员属性一旦被private关键字封装成私有之后，就只能在对象内部的成员方法中使用，不能被对象外部直接赋值，也不能在对象外部直接获取私有属性的值。

<?php 
    class Person{
        private $name;
        private $sex;
        private $age;

        function __construct($name="",$sex="男",$age=1){
            $this->name=$name;
            $this->sex=$sex;
            $this->age=$age;
        }

        public function getName(){
            return $this->name;
        }

        public function setSex($sex){
            if(sex=="男"||$sex=="女")
                $this->sex=$sex;
        }

        public function setAge($age){
            if($age>150||$age<0)
                return;
            $this->age=$age;
        }

        public function getAge(){
            if($this->age>30)
                return $this->age-10;
            else
                return $this->age;
        }

        function say(){
            echo "我的名字：".$this->name."，性别：".$this->sex."，年龄：".$this->age."<br>";
        }
    }
    $person1=new Person("王五","男",40);
    echo $person1->getName()."<br>";
    $person1->setSex("女");
    $person1->setAge(200);
    echo $person1->getAge()."<br>";
    $person1->say();
?>

该程序运行后输出的结果为：

王五
30
我的名字：王五，性别：女，年龄：40

10.4.3 __set()、__get()、__isset()和__unset()四个方法

以下内容参照PHP官方文档

__construct()，__destruct()，__call()， __callStatic()， __get()， __set()，__isset()，__unset()，__sleep()， __wakeup()，__toString()，__invoke()，__set_state()，__clone() 和 __debugInfo()等方法在 PHP 中被称为”魔术方法”（Magic methods）。在命名自己的类方法时不能使用这些方法名，除非是想使用其魔术功能。

PHP 将所有以__（两个下划线）开头的类方法保留为魔术方法。所以在定义类方法时，除了上述魔术方法，建议不要以 __ 为前缀。

1. 魔术方法__set()
void __set(string name,mixed value)

该方法的作用是在程序运行过程中为私有的成员属性设置值，他不需要有任何返回值。但它需要两个参数，第一个参数需要传入在为私有属性设置值时的属性名，第二个参数则需要传入为属性设置的值。

<?php 
    class Person{
        private $name;
        private $sex;
        private $age;

        function __construct($name="", $sex="男", $age=1){
            $this->name=$name;
            $this->sex=$sex;
            $this->age=$age;
        }

        private function __set($propertyName, $propertyValue){
            if($propertyName=="sex"){
                if(!($propertyValue=="男"||$propertyValue=="女"))
                    return;
            }
            if($propertyName=="age"){
                if($propertyValue>150||$propertyValue<0)
                    return;
            }
            $this->$propertyName=$propertyValue;
        }       

        public function say(){
            echo "我的名字叫：".$this->name."，性别：",$this->sex."，年龄：".$this->age."<br>";
        }
    }
    $person1=new Person("张三","男",20);
    //下面三行自动调用了__set()函数，将属性名分别传给第一个参数，将属性值传给第二个参数
    $person1->name="李四";
    $person1->sex="女";
    $person1->age="80";

    $person1->sex="保密";    //“保密”是个非法值，所以这句给私有属性sex赋值失败
    $person1->age=800;//800是个非法值，这条语句私有属性age赋值失败

    $person1->say();
?>

这里写图片描述

2. 魔术方法：__get()

如果在类中声明了__get()方法，则直接在对象的外部获取私有属性的值时，会自动调用此方法，返回私有属性的值。

mixed __get(string name)

该方法的作用是在程序运行过程中，通过可以在对象的外部获取私有成员属性的值。

<?php 
    class Person{
        private $name;
        private $sex;
        private $age;

        function __construct($name="", $sex="男", $age=1){
            $this->name=$name;
            $this->sex=$sex;
            $this->age=$age;
        }

        private function __get($propertyName){
            if($propertyName=="sex"){
                return "保密";
            }
            else if($propertyName=="age"){
                if($this->age>30)
                    return $this->age-10;
                else
                    return $this->$propertyName;
            }else{
                return $this->$propertyName;
            }
        }       
    }
    $person1=new Person("张三","男",40);

    echo "姓名：".$person1->name."<br>";
    echo "性别：".$person1->sex."<br>";
    echo "年龄：".$person1->age."<br>";
?>

这里写图片描述

3. 魔术方法 __isset()和__unset()

但如果在对象中存在“__isset()”方法，当在类外部使用“isset()”函数来测定对象里面的私有属性时，就会自动调用类里面的__isset()方法帮助我们完成测定的操作。

bool __isset(string name)     //传入对象中的成员属性名作为参数，返回测定后的结果

如果类中添加此方法，在对象的外部使用isset方法测定对象中的成员时，就会自动调用对象中的__isset()方法，间接地帮助我们完成对对象中私有成员属性的测定。

unset()函数的作用是删除指定的变量，参数为要删除的变量名称，也可以使用这个函数在函数外部删除对象属性，但这个对象中的成员属性必须是公有的才可以直接删除。

void __unset(string name)    //传入对象中的成员属性名作为参数，可以将私有成员属性删除

如果没有在类中加入这个方法，就不能删除对象中任何的私有成员属性。

<?php 
    class Person{
        private $name;
        private $sex;
        private $age;

        function __construct($name="",$sex="男",$age=1){
            $this->name=$name;
            $this->sex=$sex;
            $this->age=$age;
        }

        private function __isset($propertyName){
            if($propertyName=="name"){
                return false;
            }
            return isset($this->$propertyName);
        }

        private function __unset($propertyName){
            if($propertyName=="name"){
                return;
            }
            unset($this->$propertyName);
        }

        public function say(){
            echo "我的名字：".$this->name."，性别：".$this->sex."，年龄：".$this->age."<br>";
        }
    }

    $person1=new Person("张三","男",30);

    var_dump(isset($person1->name));
    var_dump(isset($person1->sex));
    var_dump(isset($person1->age));
    var_dump(isset($person1->id));

    unset($person1->name);
    unset($person1->sex);
    unset($person1->age);
?>

10.5 继承性

在PHP和Java语言一样没有多继承，只能使用单继承模式。

10.5.1 类继承的应用

10.5.2 访问类型控制

1. 公有的访问修饰符public
2. 私有的访问修饰符private

当类中的成员被定义为private，对于同一类里的成员都没有访问权限，但对于该类的外部代码是不允许改变甚至是操作的。

<?php 
    class MyClass {
        private $var1=100;

        private function printHello(){
            echo "Hello<br>";
        }
    }
    class MyClass2 extends MyClass {
        function useProperty(){
            echo "输出从父类继承过来的成员属性值".$this->var1."<br>";
            $this->printHello();
        }
    }

    $subObj=new MyClass2();
    $subObj->useProperty();

?>

这里写图片描述

3. 保护的访问修饰符protected

被修饰为protected的成员，对于该类的子类及子类的子类都有访问权限，但不能被该类外部代码访问。

<?php 
    class MyClass{
        protected $var1=100;
        protected function printHello() {
            echo "hello<br>";
        }
    }

    class MyClass2 extends MyClass{
        function useProperty(){
            echo "输出从父类继承过来的成员属性：".$this->var1."<br>";
        }
    }

    $subObj=new MyClass2();
    $subObj->useProperty();
    echo $subObj->var1;

?>

这里写图片描述

10.5.3 子类中重载父类的方法

<?php 
    class Person {
        protected $name;
        protected $sex;
        protected $age;

        function __construct($name="",$sex="男",$age=1){
            $this->name=$name;
            $this->sex=$sex;
            $this->age=$age;
        }

        function say(){
            echo "我的名字：".$this->name."，性别：".$this->sex."，年龄：".$this->age."<br>";
        }
    }

    class Student extends Person{
        private $school;

        function __construct($name="",$sex="男",$age=1,$school=""){
            parent::__construct($name,$sex,$age);
            $this->school=$school;
        }

        function study(){
            echo $this->name."正在".$this->school."学习<br>";
        }

        function say()
        {
            parent::say();
            echo "在：".$this->school."学校上学<br>";
        }
    }

    $student=new Student("张三","男",20,"edu");
    $student->say();
?>

这里写图片描述

10.6 常见的关键字和魔术方法

10.6.1 final关键字的应用

final关键字的作用：
- 使用final标识的类，不能被继承
- 在类中使用final标识的成员方法，在类中不能被覆盖

10.6.2 static 关键字的使用

使用static关键字可以将类中的成员标识为静态的，既可以用来表示成员属性，也可以用来标识成员方法。

类名::静态成员属性;
类名::静态成员方法名();
self::静态成员属性名;
self::静态成员方法名();

10.6.3 单态设计模式

单态模式的主要作用是保证在面向对象编程中，一个类只能有一个实例对象存在。

<?php 
    class DB{
        private static $obj=null;

        private function __construct(){
            echo "连接数据库成功<br>";
        }

        static function getInstance(){
            if(is_null(self::$obj))
                self::$obj=new self();

            return self::$obj;
        }

        function query($sql){
            echo $sql;
        }
    }

    $db=DB::getInstance();

    $db->query("select * from user");
?>

10.6.4 const关键字

将类中的成员属性使用const关键字标识为常量，其访问的方式和静态成员一样，都是通过类名或在成员方法中使用self关键字访问，也不会出现错误。注意：使用const声明的变量名称前不要使用“$”符号，而且常量名称通常都是大写的。

10.6.5 instanceof关键字

使用这个关键字可以确定一个对象是类的实例、类的子类，还是实现了某个特定接口，并进行相应的操作。

$man=new Person();
...
if($man instanceof Person)
    echo '$man是Person类的实例对象';

这里需要注意亮点，一点是类名没有任何定界符（不适用引号），使用定界符将会导致语法错误；另外，如果比较失败，脚本将推出执行。

10.6.6 克隆对象

如果需要对克隆后的副本对象在克隆时重新为成员属性赋值，则可以在类中声明一个魔术方法“__clone()”。该方法是在对象克隆时自动调用的。

10.6.7 类中通用的方法__toString()

魔术方法__toString()是快速获取对象的字符串表示的最便捷的方式，它是在直接输出对象引用时自动调用的方法。

<?php 
    class TestClass{
        private $foo;

        function __construct($foo){
            $this->foo=$foo;
        }

        public function __toString(){
            return $this->foo;
        }
    }

    $obj=new TestClass('Hello');
    echo $obj;
?>

10.6.8 __call()方法作用的应用

在PHP中，可以在类中添加一个“魔术”方法__call()，则调用对象中不存在的方法时就会自动调用该方法，并且程序也可以继续向下执行。__call()方法需要两个参数：第一个参数是调用不存在的方法时，接收这个方法名字字符串；而参数列表则以数组的形式传递到__call()方法的第二个参数中。

10.6.9 自动加载类

当你尝试使用一个PHP没有组织到的类时，它会寻找一个__autoload()的全局函数，如果存在这个函数，PHP会用一个参数调用它，参数即类的名称。不管调用时是大写还是小写，PHP将返回名称的小写。所以做项目时候，需要按照一定规则命名，也可以加上统一的前缀或后缀形成文件名。

10.6.10 对象串行化

对象通过写出描述自己状态的数值来记录自己，这个过程称为对象的串行化。串行化就是把整个对象转化成二进制字符串。
- 对象需要在网络中传输时，将对象串行化成二进制串后在网络中传输
- 对象需要持久保存时，将对象串行化后写入文件或是数据库中。

这里需要补充，暂空

10.7 抽象类与接口

10.7.1 抽象类

使用抽象类就包含了继承关系，它是为它的子类定义公共接口，将它的操作交给子类去实现。就是将抽象类作为子类重载的模板使用，定义抽象类就相当于定义了一种规范，这种规范要求子类去遵循。

10.7.2 接口技术

因为PHP只支持单继承，也就是说每个类只能继承一个父类，当声明的新类继承抽象类实现模板以后，它就不能再有其他父类了。接口中声明的方法必须都是抽象方法，另外不能在接口中声明变量，只能使用const关键字声明为常量的成员属性，而且接口中所有成员都必须有public的访问权限。

interface 接口名称{
//常量成员
//抽象方法
}

接口所有方法都要求是抽象方法，所以就不需要再方法前使用abstract关键字标识了。

10.8 多态性的应用

10.9 面向对象版图形计算器

secret114
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java面向对面编程笔记总结
04-12
JavaSE中的很重要的部分，Java面向对象部分的笔记总结。适合刚刚接触Java编程对面向对象的深刻理解与掌握！
面向对面基础
weixin_50269109的博客
08-28 85
对象和类的关系（属性，方法） public class testLei { int id; int age; String name; //属性（成员变量） void iii() { System.out.println("早上好！"); } void ddd() { System.out.println("中午好！"); } void ccc() { System.out.println("晚上好！"); } //（方法） public static void main
什么是面向对象_什么是面向对象？
weixin_39620252的博客
12-11 285
目录面向对象编程类和对象类的成员变量访问修饰符构造与析构函数this指针一、什么是面向对象？所谓面向对象就是基于对象概念，以对象为中心，以类和继承为构造机制，来认识、理解、刻画客观世界和设计、构建相应的软件系统（模拟现实）。对象是由数据和容许的操作组成的封装体，与客观实体有直接对应关系面向对象不是某一种语言的特性，而是一种编程思想【通俗来讲】二、抽象和类1.抽象：从具体事物抽取共同的本质特征2.类...
php面向对面,【学习笔记】PHP面向对面思想 二
weixin_42480540的博客
03-12 66
四、接口1.接口的作用：定义一套规范，接口定义的方法在程序中必须全部实现。2.PHP中的接口和其他语言的区别在PHP中，只关心是否实现了接口的方法，但是不会关心接口语义是否正确，可以实现接口里不存在的方法。但是Java中认为接口就是一种类型，除了要实现接口的方法，也不允许调用接口中不存在的方法。3.对PHP接口的思考PHP接口相对于Java/C++，在“面向契约编程”中是不足的。在PHP中，接口更...
【学习笔记】PHP面向对面思想 二
weixin_34301132的博客
03-29 72
四、接口 1.接口的作用：定义一套规范，接口定义的方法在程序中必须全部实现。 2.PHP中的接口和其他语言的区别 在PHP中，只关心是否实现了接口的方法，但是不会关心接口语义是否正确，可以实现接口里不存在的方法。 但是Java中认为接口就是一种类型，除了要实现接口的方法，也不允许调用接口中不存在的方法。 3.对PHP接口的思考 PH...
PHP程序设计经典300例（配套资源）
12-04
《PHP程序设计经典300例》是一本深入实践的PHP编程教材，旨在通过丰富的实例帮助读者掌握PHP语言的核心概念和技术。这本书的配套资源包含了书中所提到的代码示例，以便读者可以亲自运行和学习。这里我们将详细探讨...
细说PHP第二版
09-21
细说PHP第二版，扫描版，PHP入门、而且面向对象设计讲的非常好，结合设计模式效果更加
细说php 4th 在线教育系统EDUPlayer源码
07-29
细说php 4th 在线教育系统EDUPlayer源码28章 项目源码
《细说PHP》
11-25
对于PHP应用开发的新手而言,《细说PHP》不失为一本好的入门教材,内容既实用又全面,辅以视频教程,使读者轻松掌握所学知识
细说PHP(第2版) - 高洛峰
04-04
内容涵盖了动态网站开发的前台技术（HTML+CSS）、PHP编程语言的语法、PHP的常用功能模块和实用技巧、MySQL数据库的设计与应用、PHP面向对象的程序设计思想、数据库抽象层PDO、Smarty模板技术、Web开发的设计模式、...
面向对象编程
xingyu19911016的博客
12-06 775
面向过程和面向对象 1 简介 面向过程和面向对象都是对软件分析、设计、开发的一种思想。 面向过程（Procedure-oriented）面向对象（Object-oriented） procedure [prəˈsiːdʒər] 步骤 oriented [ˈɔːrientɪd] 以……为方向的；重视……的 早期先有面向过程思想，随着软件规模的扩大，问题复杂性的提高，面向过程的弊端越来越明显的显示出来，出现了面向对象思想并成为目前主流的方式。两者都贯穿于软件分析、设计和开发各个阶段，对应面向对象就分别称为面向
实验06 PHP面向对象程序设计
xmingy254的博客
06-06 949
实验06 PHP面向对象程序设计 实验目的 (1)掌握PHP类定义和使用方法； (2)了解继承和组合各自的优点和缺点； (3)掌握PHP类的魔术方法； (4)了解 PHP写MVC程序的一般方法； 实验内容 一、完成教材P329~330实验6.1(文件命名为SY6_1.php)-- PHP类定义和使用 <!DOCTYPE html> <html> <head> <title>学生管理类</title> </head>
Javascript 面向对面写法的必要性？
一炮送你回车库的博客
10-22 140
现在Javascript面向对象的方式来写页面很流行，什么纯javascript的mvc框架都出来了：ember 这是javascript层的mvc框架哦,不是j2ee的mvc框架   我想说的是，javascript本来就不是一门面向对象的语言，用它写出来的面向对象的程序，本身就有些别扭，很多人提到js的面向对象首先提的是：复用性。那么我请问你写的js里有多少是可以复用的，用functi...
PHP面向对象-----（总体学习路线）
滴水穿石
08-05 1681
1.什么是面向对象？ 面向对象编程（Object Oriented Programming, OOP, 面向对象程序设计）是一种计算机编程架构，OOP的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成，OOP达到了软件工程的三 个目标：重用性、灵活性和扩展性。为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息。 2.什么是类，什么是对象，类和对象这间的关系
复习------php面向对象（1）
mfigods的博客
07-14 112
面向对象的优点 可读性 可重用性 扩展性 稳定性 维护性 可测试性 面向对象的三大特性 封装：封装是把对象属性和成员方法，加上访问修饰符，使其尽可能隐藏对象的内部细节，以达到对成员的访问控制（是访问的控制，而不是拒绝访问） 继承 把两个类或者多个类中的相同的部分可以提出来，父类（基类），子类（派生类）画图的时候箭头指向的是父类 对于php来说是单继承的。只能继承一个父类，但是一个父类可以有很...
php获取私有成员,php 面向对象封装之设置私有成员private
weixin_42126274的博客
04-10 132
php 面向对象封装之设置私有成员private封装性是面向对象编程中的三大特性之一，封装性就是把对象的属性和服务结合成一个 独立的相同单位，并尽可能隐蔽对象的内部细节，包含两个含义：1.把对象的全部属性和全 部服务结合在一起，形成一个不可分割的独立单位(即对象)。2.信息隐蔽，即尽可能隐蔽对 象的内部细节，对外形成一个边界〔或者说形成一道屏障〕，只保留有限的对外接口使之与外 部发生联系。封装的原...
php 魔术方法__get,PHP魔术方法之__set()和__get()
weixin_36138524的博客
03-09 393
先来看一段代码：class Article{//私有成员属性private $title = '标题';//受保护的成员属性protected $author = '作者';//公有成员属性public $introduce = '简介';}$article = new Article();var_dump($article -> title);var_dump($article ->...
PHP面向对象中的魔术方法
wwl012345的博客
04-23 357
1.什么是魔术方法？ 魔术方法指的是系统在特定的时机自动调用的方法。 2.访问权限 在介绍魔术方法之前，先介绍一下PHP中的访问权限： 在PHP中一般有三个权限修饰符，并且权限修饰符是可选项，常见的权限修饰符包括public、private、protected。创建类时，可以省略权限修饰符，此时默认的修饰符为public。public、private、protected三者区别...
请细说动手学深度学习7.1节的程序在做什么？
最新发布
05-31
动手学深度学习7.1节的程序实现了一个基于卷积神经网络的图像分类模型，用于对CIFAR-10数据集中的图像进行分类，将其分为10个类别。具体来说，程序主要分为以下几个部分： 1. 数据预处理：程序首先对CIFAR-10数据集...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值