📌  相关文章
📜  PHP | OOP中的常用术语

📅  最后修改于: 2022-05-13 01:54:11.525000             🧑  作者: Mango

PHP | OOP中的常用术语

面向对象编程是程序员解决实际问题的一个非常重要的概念。本文解释了面向对象编程的概念及其特点。

  • 物体：这个世界上的一切都被物体包围着。桌子、椅子、显示器、手机一切都是物体。为了解决现实生活中的问题，要记住一个对象中有两件事。一个是属性，一个是行为。如果我们谈论显示器......型号，屏幕尺寸所有这些都是属性。另一方面，音量增大或音量减小等功能是显示器的行为。在编程中，变量是属性，函数是行为。

    例子： 

    volume++;
    }
      
    function volumeDown() {
        $this->volume--;
    }
}
  
// Create new object
$tv_one = new TV;
  
// Calling member function
$tv_one->volumeUp();
echo $tv_one->volume;
  
?>
    输出： 
    2

    在上述例子中，产生类电视和执行函数的一个目的$ tv_one表示对象的行为。最初 $tv_one->volume 为 1。调用其函数， volume 已增加并显示更新的结果。 $this 指的是特定的或当前的对象。您可以创建多个对象并显示其行为。实现此代码将具有代码可重用性的好处，并且将来代码将易于管理。

  • 构造函数：构造函数是一个特殊的函数，它不需要像之前创建对象后那样调用函数。

    例子： 

    volume++;
    }
      
    function volumeDown() {
        $this->volume--;
    }
    function __construct($m, $v) {
     $this->model = $m; 
     $this->volume= $v;
   }
}
  
// Create new object
$tv = new TV('xyz', 2);
   
echo $tv->model;
  
?>
    输出： 

    xyz

    在上面的例子中，我们在创建对象时分配了模型和体积的值。这是使用构造函数的好处。您无需为您将要制作的每个项目更改型号。所需要做的就是包含此文件，当您需要创建 TV 对象并为其赋值时，您可以在创建其对象时立即执行此操作。

  • 继承：简单来说，继承意味着从一个类继承属性或功能到另一个类。型号和音量可以在各种电视中找到，但假设您需要添加额外的功能计时器。定时器不能包含在所有的电视中。因此，它将为该电视使用继承，其中包括计时器属性。使用 'extends' 关键字来实现继承。

    例子： 

    volume++;
    }
      
    function volumeDown() {
        $this->volume--;
    }
      
    function __construct($m, $v) {
        $this->model = $m; 
        $this->volume= $v;
    }
}
  
class TvWithTimer extends TV {
    public $timer = true;
}
  
// Create new object
$tv = new TvWithTimer('xyz', 2);
  
echo $tv->model;
  
?>
    输出： 
    xyz

    这里，TVWithTimer 类是 TV 类的子类，而 TV 类是父类。 TVWithTimer 类继承了其父类的所有变量和函数，因此 TV 类中的所有变量和函数都将在 TvWithTimer 中可用。所以创建多个类并从 TV 类继承属性。另一个重要的事情是方法覆盖。如果在继承父类的所有属性后在子类中定义构造函数，那么优先级将被赋予子类构造函数而不是父类。 

    class plazmaTv extends TV {
     function __construct {
           
      }  
}
  
$plazma = new plazmaTv;
  
echo $plazma->model;

    在这里，不会显示任何输出并且屏幕将是空白的，因为正在调用子类构造函数并且它已经覆盖了父类构造函数。相同的逻辑也适用于变量，您也可以覆盖子类中的变量。

  • 封装：封装就是将数据和方法包装在一个单元中。面向对象编程设置成员函数或变量的访问级别。这意味着从哪里需要访问它。存在三种访问级别或访问说明符。
    1. 公共：公共函数或变量只能从任何地方访问。在上面所有的例子中，我们都可以访问类外的公共函数和变量，每个人都可以调用它。
    2. 私有：私有函数或变量只能由创建它的类访问。

      例子： 

      volume++;
    }
      
    function volumeDown() {
        $this->volume--;
    }
      
    function __construct($m, $v) {
        $this->model = $m; 
        $this->volume= $v;
    }
}
  
// Create new object
$tv = new TV('xyz', 2);
  
echo $tv->model;
  
?>

      输出： 

      Cannot access private property TV::$model in /home/65af96133e297a6da6c1ad3d75c9ff46.php:28

      执行上述代码后会显示错误。这意味着不能在类外访问该函数或变量。

    3. 受保护：受保护的函数或变量只能被创建的类使用，它的子类是指继承父类属性的所有具有受保护方法或变量的类。

      例子： 

      volume++;
    }
      
    function volumeDown() {
        $this->volume--;
    }
      
    function getModel() {
        return $this->model;
    }
      
    function __construct($m, $v) {
        $this->model = $m; 
        $this->volume= $v;
    }
}
  
class plazma extends TV {
    function getModel() {
        return $this->model;
    }
}
  
// Create new object
$tv = new plazma('xyz', 1);
  
echo $tv->getModel();
  
?>
      输出： 
      xyz
  • 抽象类：就像关键字所说的那样，抽象意味着未完成。抽象类是那些声明了函数但没有实现的类。

    例子：



    xyz();
  
?>
    输出： 
    Welcome to GeeksforGeeks

    在这里，我们创建了一个具有一个抽象方法的抽象类，但我们还没有在 ABC 基类中实现该方法。所有将扩展 ABC 类的类都将具有函数XYZ 的实现。在这里你不能为 ABC 类制作对象。 ABC 类作为其所有子类的基类，并且将为子类完成实现或对象创建。声明一个抽象类是强制你不想为那个类创建一个直接对象。

    例子： 

    firstname. " " .$this->lastname;
    }
      
    public abstract function getMonthlySalary();
      
    public function __construct($f, $l) {
        $this->firstname = $f;
        $this->lastname = $l;
    }
}
  
class FullTimeEmployee extends BaseEmployee {
      
    protected $annualSalary;
      
    public function getMonthlySalary() {
    return $this->annualSalary / 12;
    }
}
  
class ContractEmployee extends BaseEmployee {
    protected $hourlyRate;
    protected $totalHours;
  
    public function getMonthlySalary() {
        return $this->hourlyRate * $this->totalHours;
    }
}
  
$fulltime = new FullTimeEmployee('fulltime', 'Employee');
$contract = new ContractEmployee('Contract', 'Employee');
  
echo $fulltime->getFullName();
echo $contract->getFullName();
  
echo $fulltime->getMonthlySalary();
echo $contract->getMonthlySalary();
  
?>
    输出： 
    fulltime EmployeeContract Employee00
  • 接口： PHP中的继承有一个限制，即您不能扩展多个类。通过接口可以实现多重继承属性。接口也像抽象类一样工作。 'implements' 关键字用于接口。抽象类和接口类之间存在差异。在抽象类中定义变量，但在接口中，类不能定义变量。它也不能在接口中创建构造函数。它不能声明私有或受保护的函数。

    例子： 

    abc();
$obj->xyz();
  
?>
    输出： 
    GeeksforGeeks A computer science portal
  • 静态成员：静态变量或静态函数与类直接相关。它可以直接使用类名访问静态变量或函数。使用 'static' 关键字来声明静态函数或静态变量。

    例子：
    输出： 
    GeeksforGeeks A computer science portal

    示例：此示例计算我们为一个类创建了多少个对象。
    输出： 

    4

    注意：如果每次使用静态函数或变量创建对象而不是静态，则输出将为1。因此静态变量或关键字与类相关而不是对象。

  • 后期静态绑定：在PHP 5.3 中引入了后期静态绑定的概念。

    例子： 

    select();
  
?>
    输出： 
    SELECT * FROM basetable

    在这里，类 DB 扩展了类 abc，但是在编译期间运行此代码时，它从 abc 类中获取表名，而不是 DB。在编译期间， PHP解释器立即从父类分配值。为了从子级获取变量，类解释器需要在运行时而不是在上面的示例中发生的编译时分配值。 

    echo 'SELECT * FROM' .self::$table;

    或者

    echo 'INSERT INTO' .self::$table;

    在这里，当解释器收到请求时，它不会在编译期间分配值。它将等待运行时。它将在运行时分配值，输出将为SELECT * FROM abc

  • 多态性：多态性意味着多种类型或多种形式。这意味着假设您已经创建了一个接口以及将实现该接口类的类。这些类将具有不同的功能，它们都将共享这个通用接口。

    在 LoggerInterface 中创建一个具有 LoggerInterface 名称的接口。 PHP文件。

    现在创建一个文件 EmailLogger。 PHP将实现这个接口。

    创建另一个文件 FileLogger。 PHP并实现接口类。

    另一个文件是 DBLogger。 PHP

    现在，创建一个用户配置文件。 PHP文件，其中通过仅使用类型提示定义接口名称来调用所有这些文件。不需要为调用文件中创建的每个类定义类名。 

    logger->log("User Created");
    }
      
    public function updateUser() {
        echo "updating user";
        $this->logger->log("User Updated");
    }
      
    public function deleteUser() {
        echo "deleting user";
        $this->logger->log("Deleting User");
    }
      
    public function __construct(LoggerInterface $logger) 
    {
        $this->logger = $logger;
    }
  
}
  
?>

    现在，创建一个文件索引。 PHP



    createUser();
   
?>

    输出： 

    Creating User. Logging message to DB: User Created

    所以，从这个例子中创建多个文件并定义它们的功能。所有都需要实现接口类，并且只在类型提示名称中给出接口名称，就像我在 UserProfile 中定义的那样。 PHP文件。

  • 特性：特性是在 PHP5.4 中引入的。它是单继承语言中代码重用的机制。 'trait' 关键字用于定义它。

    例子： 

    test2();
  
?>
    输出： 
    test2 method of test trait

    在这里，使用类 abc 及其在所有子类中的功能。所以在所有子类中访问 abc 类的属性。现在考虑一个场景，我们只需要在类 1 和类 2 中访问另一个函数，而不需要在其余类中访问。如果您将在同一个类 abc 中定义该函数，它将在所有扩展类 abc 的类中可用。所以解决方案是我们可以在 trait 中定义该方法。
    Trait 也类似于类。在这里，在 trait test 中定义 test2函数，并通过在子类中使用 'use' 关键字来使用这个 trait。所以我们只在第一类和第二类中使用了这个特性，因为我们需要在第一类和第二类中访问这个方法。

  • 特性中的方法覆盖：如果定义在类和特性中实现的相同方法，则优先考虑特性类方法的实现。这意味着 trait 类方法将覆盖父类方法。

    例子： 

    abc();
  
?>

    输出： 

    ABC method from test trait

    所以，优先顺序是子类方法 > trait 类方法 > 父类方法。

  • 特征中的访问级别：您可以更改子类中特征的访问级别。

    例子： 

    abcXyz();
   
?>
    输出： 
    xyz method from trait abc
  • 命名空间：在PHP，类不能被重新声明。这意味着一个类不能被多次声明。它将显示一条错误消息。为了解决这个问题，使用了命名空间的概念。

    例子：

    输出： 

    XYZ from DEF namespace

    默认情况下，所有类都是全局命名空间的一部分。仅使用关键字“namespace”声明的全局命名空间（无需定义命名空间的名称）。不能在命名空间之外声明代码。此外，如果您在其中声明一个类，命名空间应该是代码中的第一行。
    还有另一种方法可以从 def 类调用函数。创建对象时，只需替换如下代码即可。 

    use def\xyz as def;
$obj = new def();

    输出将是相同的。您还可以为命名空间创建子命名空间。当您声明它位于线下方时，您只需要做的就是。 

    namespace def\ghi
  • 类型提示：在PHP，不需要定义你声明的变量的数据类型。它在创建变量时自动定义数据类型，但有时当您接收一个变量时，您需要定义您接收的变量类型。

    例子： 

     $v) {
        echo $k . "  " . $v . "\n";
    }
}
  
// Declare an array
$array = ['abc'=>'ABC', 'xyz'=>'XYZ'];
  
// Function call
test($array);
  
?>
    输出： 
    abc  ABC
xyz  XYZ

    所以，当接收到变量并定义它应该是一个数组类型时。如果您将解析字符串类型数据 $array ='abcdefgh' 那么您将收到致命错误并且代码不会执行。您还可以对类名和接口进行类型提示。