【PHP 面向对象】面向对象(OOP)编程知识点归纳总结（一）_飞道的博客

【PHP 面向对象】面向对象(OOP)编程知识点归纳总结（一）

2021-05-17 08:47 254人阅读评论(0)

一、面向对象的概念

面向对象编程（OOP)是我们编程的一项基本技能，PHP5对OOP提供了良好的支持。如何使用OOP的思想来进行PHP的高级编程，对于提高 PHP编程能力和规划好Web开发构架都是非常有意义的。下面我们就通过实例来说明使用PHP的OOP进行编程的实际意义和应用方法。

我们通常在做一个有数据库后台的网站的时候，都会考虑到程序需要适用于不同的应用环境。和其他编程语言有所不同的是，在PHP中，操作数据库的是一系列的具体功能函数（如果你不使用ODBC接口的话）。这样做虽然效率很高，但是封装却不够。如果有一个统一的数据库接口，那么我们就可以不对程序做任何修改而适用于多种数据库，从而使程序的移植性和跨平台能力都大大提高。

对象的基本组成

对象的组成元素:是对象的数据模型，用于描述对象的数据,又称为对象的属性，或者对象的成员变量.
对象的行为: 是对象的行为模型，用于描述对象能够做什么事情,又被称为对象的成员方法.

对象特点

每一个对象都是独一无二的
对象是一个特定的事物，他的职能是完成特定功能
对象是可以重复使用

类的概念

物以类聚，把具有相似特性的对象对垒到一个类中,类定义了这些相似对象拥有的相同的属性和方法
类是相似对象的描述，成为类的定义，是该类对象的蓝图或者原型
类的对象称为一个类的实例(Instance)
类的属性和方法统称为类成员

类的实例化

类的实例化：通过类定义创建一个类的对象
类的定义属性值都是空或默认值，而对象的属性都有具体的值

类的定义

类的定义以关键字class开始，后面跟着这个类的名称。类的命名通常每个单词的第一个字母大写，以中括号开始和结束
类的实例化为对象时使用关键字new，new之后紧跟类的名称和一对圆括号
对象中得成员属性和方法可以通过->符号来访问

二、OOP面向对象编程

面向对象编程（Object Oriented Programming，OOP）是一种编程思想，在很多现代编程语言中都有面向对象编程的概念。

面向对象编程的思想就是把具有相似特性的事物抽象成类，通过对类的属性和方法的定义实现代码共用。将实现某一特定功能的代码部分进行封装，这样可被多处调用，而且封装的粒度越细小被重用的概率越大。

而面向对象编程的继承性和多态性也提高了代码的重用率。总之，面向对象编程充分地体现了软件编程中的“高内聚，低耦合”的思想。

PHP 之所以能够成为 Web 开发领域的主流语言，对面向对象开发模式的支持也是重要原因之一。

1. PHP class：定义类

定义类

变量：实现数据的复用
函数：实现代码块的复用
类：具有相同属性(变量)和方法(函数)的对象集合
对象：复合数据类型，可以储存且有权利对储存在其中的变量进行操作的一组函数
oop：单位是对象，对象是类的实例化的结果 instance
实现类的自动加载前提必须满足psr-4规范：类文件名称和类同名

[修饰类的关键字] class 类名{
    类的成员属性和方法;
}

修饰类的关键字是一个可选参数，可以省略。我们通常使用下面这些关键字来修饰类：

abstract：抽象类或方法，被修饰为抽象类之后，类将不能被实例化，但可以被继承。如果类中有至少一个方法被声明为抽象的，那么这个类也必须声明为抽象的。继承一个抽象类的时候，子类必须重新定义父类中的所有抽象方法，而且这些方法的访问控制必须和父类中一样。
final：使用 final 修饰的类不能被继承，而使用 final 修饰的方法不能在子类中重新定义。
注意：一个类可以包含有属于自己的常量、变量（在类中称为“成员属性”或者“属性”）以及函数（在类中称为“成员方法”或者“方法”）。

访问权限

常用访问权限修饰符及其含义如下所示：

public：公共的，在类的内部、子类中或者类的外部都可以使用；（不受限制）
protected：受保护的，在类的内部和子类中可以使用，但是不能被对象访问，只能通过封装的方式让对象访问；（可以被继承，但外部不能访问）
private：私有的，只能在类的内部使用，在类的外部或子类中都无法使用。（既不能继承也不能外部访问）
static：静态成员，无需实例化对象，即可通过类名访问。

成员属性

在类中声明成员属性时，变量前面一定要使用一个关键字来修饰，例如 public、private，static 等，但这些关键字修饰的变量都具有一定的意义。如果不需要有特定意义的修饰，可以使用“var”关键字，一旦成员属性有其他的关键字修饰就需要去掉“var”。

【示例】创建一个 Students 类并在类中声明一些成员属性，代码如下所示：

<?php
    class Students{
   
    	// 成员属性 一定要有访问修饰符 public protected private static
        public $name = 'zhang';
        public $age = 18;
        private $sex; // 抽象属性 null
        protected static $school;
    }
?>

提示：权限修饰符可以和定义静态变量的关键字 static 混合在一起使用，如上面代码中所示。

成员方法

在类中定义的函数被称为成员方法。函数和成员方法唯一的区别就是，函数实现的是某个独立的功能，而成员方法是实现类中的一个行为，是类的一部分。

可以在类中声明多个成员方法，成员方法的声明和函数的声明完全一样，只不过在声明成员方法时可以在function关键字的前面加一些访问权限修饰符来控制访问权限，例如 public、private、protected 等。

【示例】在上面示例中创建的 Students 类中创建一些成员方法。

<?php
    class Students{
   
    // 成员属性 一定要有访问修饰符 public protected private static
        public $name = 'zhang';
        public $age = 18;
        private $sex; // 抽象属性 null
        protected static $school;
    	
    	// 成员实例方法
        public function Write(){
   
           echo '正在写字中……';
        }
        protected static function Read(){
   
			 echo '正在读书中……';
        }
        function Listen(){
   
            echo '正在听力中……';
        }
    }

?>

成员方法前面的权限修饰符可以省略，省略后默认权限为 public。在类中成员属性和成员方法的声明都是可选的，可以同时存在，也可以单独存在，具体可以根据实际情况而定。

在 PHP7 中，引入了类型声明，我们可以为成员方法的形参和返回值声明类型，格式如下所示：

[权限修饰符] function 方法名 (类型 参数1, 类型 参数2, ..., 类型 参数n) : 返回值类型 {
    ... ...
}

PHP7 中支持声明的参数类型包括整型、浮点型、字符串型和布尔类型。示例代码如下所示：

<?php
    class Students{
   
        var $name;
        public $age;
        private $sex;
        public static $school;
        public function Write(string $a, int $b):bool{
   
           
        }
        protected static function Read(string $str):int{
   

        }
        function Listen(int $num):bool{
   

        }
    }

?>

2. PHP new：实例化对象

实例化对象

将类实例化成对象非常容易，只需要使用 new 关键字并在后面加上一个和类名同名的方法即可。当然如果在实例化对象时不需要为对象传递参数，在 new 关键字后面直接用类名称即可，不需要再加上括号。

对象的实例化格式如下：

变量名 = new 类名(参数数列表); 或 变量名 = new 类名;

参数说明如下：

变量名：通过类所创建的一个对象的引用名称，可以通过这个名称来访问对象的成员；
new：关键字，表明要创建一个新的对象；
类名：表示新对象的类型；
参数列表：指定类的构造方法用于初始化对象的值，如果类中没存定义构造函数，PHP - 会自动创建一个不带参数的默认构造函数。（后面我们会详细介绍）。

【示例】创建一个类并将其实例化。

<?php
    class Students{
   
    }
    $person1 = new Students();
    $person2 = new Students;
    $person3 = new Students;
    var_dump($person1);
    echo '<br>';
    var_dump($person2);
    echo '<br>';
    var_dump($person3);
?>

一个类可以实例化出多个对象，每个对象都是独立的。在上面的代码中通过 Students 类实例化出三个对象 $p e r s o n 1 、$ person2 和 $person3，相当于在内存中开辟了三份空间用于存放每个对象。

使用同一个类声明的多个对象之间是没有联系的，只能说明他们都是同一个类型，每个对象内部都有类中声明的成员属性和成员方法。就像独立的三个人，都有自己的姓名，性别和年龄的属性，每个人都有说话、吃饭和走路的方法。

对象的访问

对象中包含成员属性和成员方法，访问对象中的成员和访问数组中的元素类似，只能通过对象的引用来访问对象中的成员。但还要使用一个特殊的运算符号->来完成对象成员的访问，访问对象中成员的语法格式如下所示：

变量名 = new 类名(参数);   //实例化一个类
变量名 -> 成员属性 = 值;   //为成员属性赋值
变量名 -> 成员属性;           //直接获取成员属性的值
变量名 -> 成员方法();        //访问对象中的成员方法

下面通过一个示例来演示一下：

<?php
    class Website{
   
        public $name, $url, $title;
        public function demo(){
   
            echo '成员方法 demo';
        }
    }

    $student = new Website();
    $student -> name = 'php中文网';
    $student -> url = 'http://php.cn';
    $student -> title = '实例化对象';
    echo $student -> name.'<br>';
    echo $student -> url.'<br>';
    echo $student -> title.'<br>';
    $student -> demo();
?>

$this当前对象

在 PHP 面向对象编程中，对象一旦被创建，在对象中的每个成员方法里面都会存在一个特殊的对象引用“ $t h i s ” 。成员方法属于哪个对象， “$ this”就代表哪个对象，与连接符->联合使用，专门用来完成对象内部成员之间的访问。如下所示：

$this -> 成员属性;$this -> 成员方法(参数列表);

比如在 Website 类中有一个 $name 属性，我们可以在类中使用如下方法来访问 $name 这个成员属性：

$this -> name;

需要注意的是，在使用 $t h i s 访问某个成员属性时，后面只需要跟属性的名称即可，不需要 ‘$ `符号。另外，$this 只能在对象中使用，其它地方不能使用 $this，而且不属于对象的东西 $this 也调用不了，可以说没有对象就没有 $this。

【示例】使用 $this 调用类中的属性和方法。

<?php
    class Website{
   
        public $name;
    
        public function __construct($name){
   
            $this -> name = $name;
            $this -> name();
        }
        public function name(){
   
            echo $this -> name.'<br>';
            $this -> url();
        }
        public function url(){
   
            echo 'http://php.cn<br>';
            $this -> title();
        }
        public function title(){
   
            echo 'PHP入门教程<br>';
        }
    }

    $object = new Website('PHP中文网');
?>

构造函数

魔术方法名称（双下划线开头）：由系统调用 __set 、__get、__call、__callStatic、__construct

__construct()：构造函数/方法(构造器)

对对的公共属性进行初始化赋值
记录当前类被实例化的次数

构造函数（constructor method，也称为构造器）是类中的一种特殊函数，当使用 new 关键字实例化一个对象时，构造函数将会自动调用。

构造函数就是当对象被创建时，类中被自动调用的第一个函数，并且一个类中只能存在一个构造函数。和普通函数类似构造函数也可以带有参数，如果构造函数有参数的话，那么在实例化也需要传入对应的参数，例如new Students($name, $age)，否则会报错。

<?php
    class Website{
   
        public $name, $url, $title;
    	private $price = 4900;
    	protected $num = 50;
        public function __construct($name, $url, $title){
   
            $this -> name  = $name;
            $this -> url   = $url;
            $this -> title = $title;
            $this -> read();
        }
        public function read(){
   
            echo $this -> name.'<br>';
            echo $this -> url.'<br>';
            echo $this -> title.'<br>';
            echo $this -> price.'<br>';
            echo $this -> num.'<br>';
        }
    }

    $object = new Website('PHP中文网','http://php.cn/','构造函数');
    /* 构造函数会在类实例化的时候，自动调用，所以我们的对象方法read也被调用了
    PHP中文网
    http://php.cn/
    构造函数
    4900
    50
    */
	$object-> name = '百度一下';
	$object-> url = 'http://baidu.com';
	// 私有成员只能在本类的内部访问 ，通过实例化对象访问会报错
	// $object-> price;
	// protected 可以在本类内部和子类内部访问，同样实例对象不能访问
	// $object-> num;
	$object-> read();

3. PHP 类的自动加载机制

在使用面向对象模式开发程序时，通常大家习惯为每个类都创建一个单独的文件。这样会很容易实现对类进行复用，同时将来维护时也很便利，这也是面向对象程序设计的基本思想之一。当需要使用一个类时，只需要直接使用 include 或 require 将其包含进来即可,然后通过客户端代码加载这个类，然后进行实例化等一系列后续操作。

注意：类文件的名称需要与类名相同，另外一个类文件中只能定义一个类

Player.php

<?php
class Player{
   
	// 成员属性 一定要有访问修饰符 public protected private static
	public $name = 'zhang';
	public $height;
	public $team;
    // 受保护成员，仅限本类及子类中访问
	protected $playerNum;
    // 私有成员，仅限本类中使用
    // 如何给私有成员赋值 1.可以通过构造函数 2.可以通过魔术方法
	private $weight;

	// 成员实例方法
	public function jog(){
   
		echo "{
     $this->name} is jogging";
	}

	// 魔术方法名称： 由系统调用
	// __set __get __call __callStatic __construct
	
	public function __construct($name,$height,$team){
   
		// 对对象的公共属性进行初始化赋值
		// 记录当前类被实例化的次数
		$this->name = $name;
		$this->height = $height;
		$this->team = $team;
	}
}
?>

client.php

<?php
    require './Player.php';
    require './Product.php';

    $np1 = new Player('kebe','206cm','Laker');
    echo $np1->name;
    $np1->height = '198cm';
    echo $np1->height;
    $np1->jog();
    // 私有成员只能在本类的内部访问 ，通过实例化对象访问会报错
    // $object-> playerNum;
    // protected 可以在本类内部和子类内部访问，同样实例对象不能访问
    // $object-> weight;
?>

spl_autoload_register() 函数

上述的方法虽然可以加载一个类，但如果一个页面需要使用多个类，就不得不在脚本页面开头编写一个长长的包含文件的列表。将本页面需要的类文件全部包含进来，这样处理不仅烦琐，而且容易出错。

__autoload() 是系统函数，名称是固定的，而且该函数没有方法体，需要我们自定义方法体。另外，该函数是自动调用的，当我们 new 一个类时，如果当前源文件中找不到这个类，PHP 则会自动调用 __autoload() 函数，并将类名传递给 __autoload() 函数。

autoload.php

<?php
    // 注册类的自动加载器
    spl_autoload_register(function ($class){
   
        // 加载当前文件夹下的类
        $file = './'.$class.'.php';
        require $file;
    });
    
    $james = new Player('james','198cm','Laker');
	echo $james->name."<br>";
	echo $james->team."<br>";
	echo $james->jog()."<br>";
    $mobile = new Product("Redmi note9 pro",1599);
    echo $mobile->show();
	
?>

Product.php

<?php
    class Product{
   
    	public $name;
    	public $price;
    	
    	public function __construct($name,$price){
   
            $this->name = $name;
            $this->price = $price;
        }
    
    	public function show(){
   
            return "{
     $this->name},￥{
     $this->price}";
        }
	}
?>

4. PHP static：类的静态成员

**声明类的静态成员或静态方法为 static ，就可以不实例化类而直接访问，**不能通过一个对象来访问其中的静态成员（静态方法除外）。静态成员属于类，不属于任何对象实例，但类的对象实例都能共享。

Static(静态)关键字

静态成员：定义时在访问控制关键字后添加static关键字即可（访问控制关键字：public. protected. private）

静态属性用于保存类的公有数据，可以在不同对象间共享
静态方法里面只能访问静态属性，不能访问非静态属性
静态成员不需要实例化对象就可以访问
类的内部可以通过 self:: 或 static:: 关键字访问自身静态成员，self::$属性 self::方法()
通过 parent:: 关键字访问父类的静态成员，也可以通过子类::父类静态成员
通过类名:: 的方式在类的外部访问静态成员

<?php
    // 类的静态成员 static
    class User{
   
        public static $name = 'zhang';
        protected $_config = ['auth_on' => true,'auth_type => 1'];
        // 认证方式 1 实时认证 2 登录认证

        public static $nation = 'China';
        private static $salary;
        private static $count = 0;

        public function __construct($name,$salary){
   
            // 静态成员与类的实例对象无关，不能用$this来访问，他指向实例对象
            // self::类的引用 访问静态成员
            self::$name = $name;
            self::$salary = $salary;
            static::$count++;
        }
        public static function getCount(){
   
            return sprintf("User类被实例化了%d次<br>",self::$count);
        }
    
    	public static function getConfig(){
   
            // 静态方法里面只能访问静态属性，不能访问非静态属性
            // 原因：不管是静态成员还是静态方法，都是类级别存在的，随着类的加载而加载，优先于对象存在
            // 非静态成员是对象级别的存在，静态方法中访问非静态成员属性，此时还不存在对象无法获取到
            // return vsprintf("认证开关：%s,<br>认证类型：%d",$this->_config);
            return vsprintf("认证开关：%s,<br>认证类型：%d",self::$_config);
        }
    
    	public function getConfig2(){
   
            return vsprintf("认证开关：%s,<br>认证类型：%d",$this->_config);
        }
    }
    // 静态成员无需实例化调用，直接使用类名::成员
    $user1 = new User('zhang',20000);
    $user2 = new User('shuai',8000);
    // 通过对象引用也可以访问静态成员方法，但不推荐这种写法
    echo $user1->getCount();
	// 但通过对象引用访问静态属性一定是不可以的，报错
	// echo $user1->name;
    // 直接使用类名::方法()调用
    echo User::getCount();
	// 静态属性可以在不同对象间共享 所以输出的是shuai
	echo User::$name;
   // echo User::getConfig();
	echo $user2->getConfig2();
?>

5. PHP extends：类的继承

面向对象编程（OOP）的一大好处就是，可以使用一个类继承另一个已有的类，被继承的类称为父类或基类，而继承这个父类的类称为子类。子类可以继承父类的方法和属性，因此通过继承可以提高代码的重用性，也可以提高软件的开发效率。

继承的好处:

父类里面定义的类成员可以不用在子类中重复定义，节约了编程的时间和代价;
同一个父类的子类拥有相同的父类定义的类成员，因此外部代码调用他们的时候可以一视同仁;
子类可以修改和调用父类定义的类成员我们称为重写（Overwrite）, 一旦子类修改了，就按照子类修改之后的功能执行;
父类中有部分相同的属性和方法，子类可以增加父类之外的新功能，因此也可以将子类称为父类的“扩展”

	public（默认）	private	protected
同一个类中访问	√	√	√
在子类中访问	√	×	√
在类的外部访问	√	×	×

子类：

子类可以通过$this访问父类的属性
子类的对象可以直接调用父类的方法和属性
PHP的单继承特性：类不允许同时继承多个父类（extends后面只能跟一个父类名称）

Product.php

<?php
    class Product{
   
    	public $name;
    	public $price;
    	
    	public function __construct($name,$price){
   
            $this->name = $name;
            $this->price = $price;
        }
    
    	public function show(){
   
            return "{
     $this->name},￥{
     $this->price}";
        }
	}
?>

Goods.php

// 子类Goods类继承父类Product
class Goods extends Product{
   
    // 属性扩展
    private $num;
    
    // 重写父类的构造器
    public function __construct($name,$price,$num){
   
        // parent::关键字调用父类的成员方法(构造方法)
        parent::__construct($name,$price);
        $this->num = $num;
    }
    
    // 重写父类的普通方法
    public function show():string{
   
        return parent::show().",数量：{
     $this->num} 个";
    }
    
    public function total(){
   
        return "{
     $this->name},总计：".$this->price * $this->num."元";
    }
}

client.php

<?php
 spl_autoload_register(function ($class){
   
       require './'.$class.'.php';
    });

	$good1 = new Goods('被子',266,8);
	$good2 = new Goods('被罩',99,3);
	
	echo $good1->show()."<br>";
	echo $good1->total()."<br>";

/* 被子,￥266,数量：8 个
   被子,总计：2128元 */
?>

数据访问总结

parent关键字可以可用于调用父类中被子类重写了的方法
self关键字可以用于访问类自身的成员方法，静态成员和类常量；不能用于访问类自身的属性！！！使用常量的时候不需要在常量const名称前面添加$符号
static::关键字用于访问类自身定义的静态成员，访问静态属性时需要在属性前面添加$符号。
常量属性const不能使用对象访问，仅能使用类访问，在类本体内可以使用“self::常量名”，在类本体外可以使用“类名::常量名”

6. PHP instanceof：判断对象是否属于某个类

<?php
 spl_autoload_register(function ($class){
   
       require './'.$class.'.php';
    });

	$good = new Goods('被子',266,8);
	$james = new Player('james','198cm','Laker');

//  instanceof 运算符，可以判断一个对象是否属于某一个类
echo "<pre>";
var_dump($good);
var_dump($james);
/*
object(Goods)#2 (3) {
  ["num":"Goods":private]=>
  int(8)
  ["name"]=>
  string(6) "被子"
  ["price"]=>
  int(266)
}
object(Player)#3 (5) {
  ["name"]=>
  string(5) "james"
  ["height"]=>
  string(5) "198cm"
  ["team"]=>
  string(5) "Laker"
  ["playerNum":protected]=>
  NULL
  ["weight":"Player":private]=>
  NULL
}
 */

var_export($good instanceof Goods); // true
var_export($james instanceof Goods); // false
var_export($james instanceof Player); // true
	
?>

作业回顾：

类(对象抽象化的结果)与对象 (类实例化结果)
构造方法 3. 对象成员之间的内部访问 $this
private仅限本类中使用 protected本类中,子类中使用
类的自动加载 spl_autoload_register
静态成员的访问类的引用self::
类的继承扩展父类方法(魔术方法,普通方法)的重写 parent:: 调用父类成员

<?php
    class Person{
   
    	public $name = 'zhangshuai';
  	    public $age = 20;
    	protected static $tel;
    
    	public function __construct($name,$age,$tel){
   
            $this->name = $name;
            $this->age = $age;
             self::$tel = $tel;
            echo "姓名：{
     $this->name},年龄：{
     $this->age},电话:". self::$tel;
        }
    
    	public static function _setTel($_tel){
   
            self::$tel = $_tel;
            echo static::_getTel();
        }
    	public static function _getTel(){
   
            return  self::$tel;
        }
	}
?>

<?php
    class Son extends Person{
   
    	private $sex;
    	public static $email = "2602138376@qq.com";
    	public function __construct($name,$age,$tel,$sex){
   
            $this->sex = $sex;
            parent::__construct($name,$age,$tel);
            echo ",性别：{
     $this->sex}";
        }
    
    	public function getSex(){
   
            return $this->sex;
        }
    
    	public static function _getTel(){
   
            echo "电话：".parent::_getTel();
            echo "邮箱：".self::$email;
        }
	}
?>

<?php
    spl_autoload_register(function ($class){
   
       require './'.$class.'.php';
    });

	$p1 = new Person("zhang",20,18949064166);
	echo $p1->name,$p1->age;
	echo Person::_getTel();
	Person::_setTel("15056825056");

	echo "<hr>";

	$s1 = new Son("孙小果",18,13096578824,"女");
	echo $s1->name,$s1->age;
	echo Son::_getTel();
	echo $s1->getSex();
	Son::$email = "admin@php.cn";
	echo Son::_getTel();
?>

转载：https://blog.csdn.net/weixin_43958049/article/details/116758437

查看评论

飞道的博客

飞道的博客

个人资料

文章分类

文章存档

阅读排行

评论排行

推荐文章