PHP 面向对象编程（OOP）
自编程语言创建以来，计算机科学家一直致力于开发多种编程计算机的方法。最终，随着越来越多的开发编程语言的出现，人们用来编写程序的方式也发生了变化。方法论，算法，概念化，它们不断发展多年。目前，面向对象编程是一种用于编程任何应用程序的流行方法。
必须以非常特定的方式设计特定的编程语言，以便可以遵循特定的方法。就PHP而言，它是一种面向对象的编程语言。在本节中，我们将看到PHP中支持或使其成为面向对象编程语言的功能。首先，让我们试着理解什么是面向对象编程？（或OOP）及其概念。
什么是面向对象编程？
面向对象编程是一种编程风格，它与类，对象和围绕这两者的各种其他概念相关联，如继承(Inheritance)，多态(Polymorphism)，抽象(Abstraction)，封装(Encapsulation )等。
OOP的设计方式是在编程时应该关注对象而不是程序。对象可以是我们在我们周围看到的任何东西。它可以是一个人（有一些属性，如 : 姓名，地址，出生日期等），一把椅子（大小，材料，成本等），一所学校（按地点，学生数量，结果）等
面向对象编程使编程接近现实生活，因为我们总是处理一个对象，对它执行操作，使用它的方法和变量等。
OOP的概念
让我们通过一个简单的例子来尝试理解所有这些。人类是生物形式，大致分为男性和女性两种类型。对？这是真的。每个人（男性或女性）都有两条腿，两只手，两只眼睛，一只鼻子，一只心脏等。有男性和女性常见的身体部位，但是男性身上有一些特定的身体部位。女性不存在，女性存在一些身体部位但男性不存在。
所有人类都会走路，吃饭，看，说，听，等等。现在，男性和女性都会执行一些共同的功能，但两者都有一些细节，对另一个则无效。例如：A女性可以分娩，而男性则不能分娩，所以这只适用于女性。
人体解剖学很有意思，不是吗？但是让我们看看这一切是如何与PHP和OOPS相关的。在这里，我们将尝试通过此示例解释所有OOPS概念，在下面一个教程中，我们将为所有这些提供技术定义
类(Class)
在这里，我们可以将人类视为一个阶级。类是任何定义其属性及其功能的功能实体的蓝图。像人类一样，拥有身体部位，并执行各种行动。
继承(Inheritance)
考虑HumanBeing一个具有手，腿，眼睛等属性的类，以及像走(walk)，说(talk)，吃(eat)，看(see)等功能Male，Female也是类，但大多数属性和函数都包含在内HumanBeing，因此它们可以继承类中的所有内容HumanBeing使用继承的概念。
对象(Objects)
我的名字是SKY8G，我是班级的实例/对象男人。当我们说人类，男性或女性，我们只是意味着一种，你，你的朋友，我，我们是这些类的形式。而类只是一个逻辑定义。我们有物理存在的，而存在的这个物体被称为是对象。
抽象(Abstraction)
抽象意味着，在隐藏细节的同时向外界展示所需的东西。继续我们的例子，人类可以说话，走路，听，吃，但细节隐藏在外面的世界。在我们的案例中，我们可以将皮肤作为抽象因子，隐藏内部机制。
封装(Encapsulation)
用我们的例子解释这个概念有点棘手。我们的腿是绑定的，以帮助我们走路。我们的手，帮助我们抓住东西。这些属性与函数的绑定称为Encapsulation。
多态性(Polymorphism)
多态性是一个概念，它允许我们通过改变它的完成方式或通过改变使用它的部分来重新定义某些东西的工作方式。两种方式都有不同的术语。
PHP 中的类（OOP）
PHP是一种面向对象的编程语言，允许在开发任何软件或应用程序时创建类和对象以遵循面向对象的编程范例。
类是一个用户定义的数据类型，其包括局部变量和局部方法。
虽然对象是类的一个实例，它保存带有赋值的局部变量，并且我们可以在其上调用类中定义的本地方法。
在本教程中，我们将学习如何在PHP中定义类以及如何创建其对象。
在PHP中定义一个类
当我们在PHP中定义一个类时，就像任何变量一样，我们必须给我们的类命名，并且在用PHP命名我们的类时必须遵循一些规则，它们是：
- 类名应以字母开头。
- 类名不应该是保留的PHP关键字。
- 类名不应包含任何空格。
现在我们知道了与PHP命名约定相关的规则，让我们创建一个名为Person的简单类。
PHP中定义类的语法
在PHP中定义类的语法非常简单，我们使用关键字class后跟类的名称，然后我们将类的代码括在花括号{}中，就像函数/方法一样。
以下是课程代码Person：
| 1 2 3 4 5 6 7 | <?php class Person { // class variables and methods comes here... } ?> |
因此，我们将Person在Person.php文件中保存该类的上述代码。
现在让我们在我们的类中添加一个变量来存储一个人的名字。当我们在类中创建变量时，它被称为属性。
| 1 2 3 4 5 6 7 | <?php class Person { // 存储人名 var $name; } ?> |
var是在类中定义变量/属性的关键字，是变量$name的名称。
是时候在我们的类中添加方法/函数了。函数在类中定义时称为方法。
在类中，方法被定义为对类变量（属性）执行某些操作或对类执行一些其他操作，例如打印所有变量的值，或者可以将数据存储到数据库等。
当我们定义获取类变量值的方法并设置类变量的值时，这些方法称为Getter和Setter函数。
这些通常被命名为get_NAME-OF-VARIABLE()和set_NAME-OF-VARIABLE()。
所以，对于变量$name，让我们添加get_name()和set_name()功能。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | <?php class Person { // to store name of person var $name; // print name function get_name() { return $this->name; } function set_name($new_name) { $this->name = $new_name; } } ?> |
当我们学习如何创建类的对象时，我们将更多地讨论为什么我们需要getter和setter函数。
我们可以定义一个没有任何变量的类吗？
是的，一个简单的类不需要任何变量。我们可以简单地介绍一些方法。这些类通常是辅助类，其中包含一些有用的常用方法。
让我们用两个方法创建一个名为Human的简单类：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | <?php class Human { // for male function male() { echo "This human is a male"; } function female() { echo "This human is a female"; } } ?> |
对于上面的类，所有对象都是相似的，因为没有变量。
当我们在类中有变量时，我们可以使用类变量的不同值创建该类的多个对象。
所以到现在为止，我们希望您已经理解了类是什么，它只是用户定义的数据类型，它具有属性/变量和类方法。在下面一个教程中，我们将学习如何创建类对象。
什么是对象？
正如在上一个教程中所讨论的，类只是蓝图或用户定义的数据类型，可以通过创建其对象来使用。
类是一个逻辑实体，而它的对象是真实的。一个类一般包括局部变量和局部方法。
而一个对象是持有与分配和使用对象，我们可以调用类中定义的本地方法值局部变量的类的实例。
在本教程中，我们将学习如何在PHP中初始化任何类的对象。
在PHP中创建一个类的对象，要创建类的对象，我们使用new关键字。
让我们快速举例说明我们将为一个简单的PHP类创建对象。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | <?php class Sky8g { // to store name of person var $url = "sky8g.com"; // simple class method function desc() { echo "Sky8g helps you learn Coding."; } } // creating class object $obj = new Sky8g(); ?> |
如您所见，我们new在最后一行使用了关键字来创建Sky8g类的对象并将其分配给变量$obj。
一旦我们有了任何类的对象，我们就可以使用它来使用->操作符号访问类方法和变量。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | <?php class Sky8g { // variable with a default value var $url = "sky8g.com"; // simple class method function desc() { echo "Sky8g 帮助您学习编码。"; } } // creating class object $obj = new Sky8g(); // accessing class variable echo $obj->url . "<br/>"; // calling class method $obj->desc(); ?> |
输出：
| 1 | sky8g.com Sky8g帮助您学习编码。 |
访问类变量和方法
要使用类的对象访问类变量和方法，我们使用->运算符，后跟变量名称或方法名称。
我们已经在上面的例子中展示了这个，但是让我们有另一个例子，有一个更复杂的类。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | <?php class Person { // first name of person var $fname; // last name of person var $lname; function showName() { echo "My name is: " . $this->fname . "" . $this->lname; } } // creating class object $john = new Person(); // assigning values to variables $john->fname = "sky8g"; $john->lname = ".com"; // calling the method function $john->showName(); ?> |
输出：
| 1 | My name is: sky8g.com |
在上面的类中，在showName()我们使用$this关键字的方法内部，它用于引用调用对象。我们将在即将到来的教程中了解更多相关信息。
类似地，我们可以创建一个类的多个对象，其中不同的值分配给本地类变量。我们这样做，
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | <?php class Person { // first name of person var $fname; // last name of person var $lname; function showName() { echo "My name is: " . $this->fname . "" . $this->lname; } } // creating class object $john = new Person(); // assigning values to variables $john->fname = "sky8g"; $john->lname = ".com"; // calling the method function $john->showName(); echo "<br/>"; // creating class object $james = new Person(); // assigning values to variables $james->fname = "www.sky8g"; $james->lname = ".com/"; // calling the method function $james->showName(); ?> |
输出：
| 1 2 | My name is: sky8g.com My name is: www.sky8g.com/ |
类变量fname和lname，两者都可以作为对象单独副本$john和$james，在这里我们可以给它们赋值，然后使用它们。
PHP 访问修饰符
要设置类方法和变量的访问权限，我们使用访问修饰符，它们只是PHP关键字。我们甚至可以将一些访问修饰符分配给类本身，以使类以特殊方式运行。
以下是PHP 关键字，它们用作访问修饰符及其含义：
public：当我们将类成员定义为public时，可以从任何地方访问它们，甚至可以从类范围外部访问它们。private：当我们将类成员定义为私有时，只能从类本身中访问它们。protected：这与private相同，但有一个例外，仍然可以从其子类访问定义为protected的类成员（我们将在学习继承时了解子类）。abstract：此关键字仅用于PHP类及其成员函数。final：定义为final的类方法不能被任何子类更改或覆盖。
何时使用哪个访问修饰符
我们不能将所有可用的访问修饰符与类的变量和方法一起使用。在下表中，我们已指定将哪个访问说明符应用于以下内容：
| Access Modifer | classes | functions | variables |
| public | 不适用 | 适用 | 适用 |
| private | 不适用 | 适用 | 适用 |
| protected | 不适用 | 适用 | 适用 |
| abstract | 适用 | 适用 | 不适用 |
| final | 适用 | 适用 | 不适用 |
public 访问修饰符
如果我们不指定任何访问修饰符，则public默认情况下会将所有类及其成员视为。
如表中上面提到的，public，private或protected访问修饰符不能与类使用。让我们看看如果我们这样做会发生什么
| 1 2 3 4 5 | <?php public class Sky8g { ... } ?> |
输出
| 1 | Parse error: syntax error, unexpected 'public' (T_PUBLIC) in ... |
我们将得到上述错误。但是对于类方法和变量，我们应该指定访问说明符，尽管默认情况下它们被视为公共。
这是PHP类的一个简单示例：
| 1 2 3 4 5 6 7 8 9 10 11 | <?php class Sky8g { // to store name of person var $url = "sky8g.com"; // simple class method function desc() { echo "Sky8g helps you learn Coding."; } } ?> |
在上面的代码中，我们var在类变量之前使用了关键字。如果我们不使用var，我们将得到一个解析错误。var修饰符既是public修饰符。
但是代替使用var我们也可以在类变量之前使用access modifier关键字，例如：
| 1 2 3 4 5 6 7 8 9 10 11 | <?php class Sky8g { // to store name of person public $url = "sky8g.com"; // simple class method function desc() { echo "Sky8g helps you learn Coding."; } } ?> |
这就是我们应该如何创建PHP类，在类变量和方法中指定访问修饰符是一种很好的编程习惯。
private 访问修饰符
我们可以将private访问修饰符用于类变量和方法，但不能用于PHP类。当一个类成员变量或一个函数被声明为时，private它不能使用该类的对象直接访问。例如：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | <?php class Person { // first name of person private $fname; // last name of person private $lname; // public function to set value for fname public function setFName($fname) { $this->fname = $fname; } // public function to set value for lname public function setLName($lname) { $this->lname = $lname; } // public function to public function showName() { echo "My name is: " . $this->fname . "" . $this->lname; } } // <span>创建类对象</span> $john = new Person(); // <span>试图访问私有类变量</span> $john->fname = "sky8g"; // invalid $john->lname = ".com"; // invalid // <span>调用公共函数来设置fname和lname</span> $john->setFName("sky8g"); $john->setLName(".com"); ?> |
在上面的代码中，$fname并且$lname是私有类变量，因此我们不能使用类对象直接访问它们。
我们将得到一个致命的PHP错误：
输出:
| 1 | Fatal error: Cannot access private property Person::$fname in ... |
但是我们可以通过在类中定义公共函数来轻松访问类的私有变量。我们可以创建单独的函数来将值设置为私有变量并获取它们的值。这些函数称为Getters和Setters。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | <?php class Person { // first name of person private $name; // public function to set value for name (setter method) public function setName($name) { $this->name = $name; } // public function to get value of name (getter method) public function getName() { return $this->name; } } // creating class object $john = new Person(); // calling the public function to set fname $john->setName("sky8g.com"); // getting the value of the name variable echo "My name is " . $john->getName(); ?> |
输出：
| 1 | My name is sky8g.com |
我们应该为类中的所有私有变量设置getter和setter方法。
protected 访问修饰符
就像private访问修饰符一样，访问修饰符protected也限制了类外变量和类方法的访问。但是protected类变量和函数可以在类内部和子类内部（继承该类的类）中访问。
我们将在接下来的教程中学习如何创建子类以及有关继承的概念。
我们来看一个简单快速的例子：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 | <?php class Human { // protected variable protected $genders = array("Male", "Female", "Other"); // protected function for humans features protected function getFeatures($gender) { if($gender == "Male") { echo "Men will be Men"; } else if($gender == "Female") { echo "Women's mind is a maze."; } else if($gender == "Other") { echo "All are born equal."; } } } // subclass of the above class class Male extends Human { protected $gender = "Male"; // public function to print Male features public function getMaleFeatures() { // calling the protected getFeatures() method of class Human $this->getFeatures($this->gender); } } // object of Human class $human = new Human(); // object of Male class $male = new Male(); /* accessing protected variables and methods */ echo $human->genders; // INVALID $human->getFeatures("Male"); // INVALID echo $male->gender; // INVALID /* but we can call getMaleFeatures method, in which we are calling a protected method of Human class */ $male->getMaleFeatures(); ?> |
在上面的程序中，我们定义了两个类，Human和Male。该类Male是该类的子Human类。
在Human类中，所有类变量和方法都是protected，因此它们不能从类外部访问，但可以在类的子类中访问它们Human。
如果由于继承的概念看起来令人困惑，请不要担心，当我们学习继承时，我们将再次重新访问它。
abstract 访问修饰符
该abstract访问修饰符是使用PHP类的功能。它不能用于类变量。
如果一个类甚至有一个abstract方法。那么这个类也必须定义为abstract。
此外，PHP不允许实例化抽象类，即您不能创建abstract类的对象，尽管这些类可以继承。
当我们将介绍Abstract类和接口时，我们将详细了解这个访问修饰符。
final 访问修饰符
当我们final使用此访问修饰符声明一个类时，该类不能被继承。
类似地，当我们将类函数定义为时final，PHP限制该类的子类覆盖声明为的该函数final。
同样，当我们学习继承时，我们将借助示例解释这一点。
PHP $this关键字
如果您从一开始就学习本教程，或者从OOPS概念开始，您必须注意到$this某些代码片段的用法。
$this关键字在类中使用，通常使用成员函数来访问当前对象的类（变量或函数）的非静态成员。
让我们举个例子来理解它的用法$this。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | <?php class Person { // first name of person private $name; // public function to set value for name (setter method) public function setName($name) { $this->name = $name; } // public function to get value of name (getter method) public function getName() { return $this->name; } } // creating class object $john = new Person(); // calling the public function to set fname $john->setName("sky8g.com"); // getting the value of the name variable echo "My name is " . $john->getName(); ?> |
输出：
| 1 | My name is sky8g.com |
在上面的程序中，我们private在类中创建了一个带有名称的变量$name，我们有两个public方法，setName()并getName()为$name变量分配一个新值并分别获取它的值。
每当我们想要从成员函数内部调用类的任何变量时，我们就会使用$this指向保存变量的当前对象。
我们还可以使用$this在另一个成员函数内调用类的一个成员函数。
static类成员使用self
相反的$this，对于static类成员（变量或函数），我们使用self，连同范围解析操作符 ::。我们举一个例子。
| 1 2 3 4 5 6 7 8 9 10 11 12 | <?php class Person { // first name of person public static $name; // public function to get value of name (getter method) public static function getName() { return self::$name; // using self here } } ?> |
PHP self与PHP的区别this
让我们理解self和之间的一些区别this：
self | this |
self 关键字前面没有任何符号。 | this关键字前面应加一个$符号。 |
要使用self关键字访问类变量和方法，我们使用范围解析运算符 :: | 如果是$this操作，我们使用->符号。 |
它用于引用static静态类的成员。 | 它用于访问类的非static静态成员。 |
PHP self指的是类成员，但不指任何特定对象。这是因为static成员（变量或函数）是类的所有对象共享的类成员。 | $this会引用特定实例的成员变量和函数。 |
让我们以一个代码示例来更好地理解这一点：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 | <?php class Job { // opening for position public $name; // description for the job; public $desc; // company name - as the company name stays the same public static $company; // public function to get job name public function getName() { return $this->name; } // public function to get job description public function getDesc() { return $this->desc; } // static function to get the company name public static function getCompany() { return self::$company; } // non-static function to get the company name public function getCompany_nonStatic() { return self::getCompany(); } } $objJob = new Job(); // setting values to non-static variables $objJob->name = "Data Scientist"; $objJob->desc = "You must know Data Science"; /* setting value for static variable. done using the class name */ Job::$company = "Sky8g"; // calling the methods echo "Job Name: " .$objJob->getName()."<br/>"; echo "Job Description: " .$objJob->getDesc()."<br/>"; echo "Company Name: " .Job::getCompany_nonStatic(); ?> |
输出
| 1 2 3 | Job Name: Data Scientist Job Description: You must know Data Science Company Name: Sky8g |
在上面的代码片段中，我们有一些非静态static变量和一个静态static变量。
因为static成员与类本身相关联而不是类的对象，因此我们使用类名称来调用它们。
此外，static成员函数可以在其中使用static变量，而如果非静态方法在其中使用static变量，那么也使用类名调用它，就像static方法一样。
如果你还想阅读下篇文章请看： PHP 高级教程-面向对象编程(OOP)[第二章]