Home / Questions / 98873
Accepted
A. Cedano
Asked: 2020-09-01 06:59:55 +0800 CST 2020-09-01 06:59:55 +0800 CST

你能谈谈 PHP 中的 OOP 吗？

  • 772

这是我很久以来的一个问题。

我想问这个问题很久了，我发布这个问题是希望它不会被关闭，因为它是基于意见的......如果发生这种情况，它可能是我的答案：不。

我的问题是，我们是否可以在严格意义上谈论 PHP 中的面向对象编程 (OOP)，或者相反，是否只能在 PHP 中应用一些 OOP 原则。

我希望得到基于文件和证据的答案（如果有的话）。

当我看到有关它的 PHP 手册的示例或所谓的魔法方法时，它给人的印象是违反了基本的 OOP 概念，就像创建setters 公共访问的情况一样。

具体问题如下：我们可以说使用 PHP 可以进行严格意义上的 OOP 吗？为什么？

php

2 Answers

  1. Best Answer

    PHP 是严格的 OOP 吗？：

    要回答这个问题，让我们检查几点：

    1）引用PHP文档：

    自 PHP 5 起，对象模型已被重写，以提供更好的性能和更多的功能。这是 PHP 4 的一个重大变化。PHP 5 有一个完整的对象模型。

    根据文档，从 PHP 5 开始，我们有一个完整的对象模型：

    • 可见性：公开、私有和受保护。
    • 课程
    • 对象和属性。
    • 公共和私有方法。
    • 类和静态属性的定义。
    • 魔术方法如：
      • __get()
      • __set()
      • __call()
      • __construct()

    PHP POO ESTRICTO + 1;

    2）OOP基础知识及其在PHP中的作用：

    在 OOP 中，我们可以找到将语言视为 OO 的基本特征，其中包括：

    1)抽象

    2)继承

    3)封装

    3) 隐藏

    4) 多态性

    5) 模块化

    6）垃圾收集

    Lei 表示，OOP 理论家将 3 个要点（粗体部分）作为 OOP 的基础。

    现在，让我们检查一下 PHP 是否满足基本要求：

    在 PHP 中使用 OOP 的基础知识：

    // Declarar la clase es *encapsulamiento*
// Al usar extends estamos usando "herencia"
Class Entidad extends EntidadMayor
{
    public $atributo;
    //Ocultar las funciones del exterior es *ocultamiento*
    public function obtenerAtributo(){
        return $this->atributo;
    };
}
// Al crear una instancia estamos *abstrayendo*
$objeto = new Entidad();
$objeto->atributo = "valor";
$objeto->obtenerAtributo();

    OOP 的 3 个基本原理得到了满足。

    PHP POO ESTRICTO + 1;

    3）魔术方法VS类方法

    要访问类的属性，我们有两种方法，经典方法和魔术方法：

    经典方法：在这个方法中，我们定义了自己的gettersandsetters：

    Class Entidad
{
    public $atributo;
    public function obtenerAtributo() {
        return $this->atributo;
    }
    public function cambiarAtributo($dato) { 
        $this->atributo = $dato;
    }
}
$objeto = new Entidad();
$objeto->atributo = "valor";
$objeto->cambiarAtributo("nuevoValor");
$objeto->obtenerAtributo(); // nuevoValor

    魔术方法：在这个方法中我们使用了 PHP 带来的魔术方法，例如__get()and__set()：

    Class Entidad
{
    public $atributo;
    public function __get($property) {
        if (property_exists($this, $property)) {
            return $this->$property;
        }
    }
    public function __set($property, $value) {
        if (property_exists($this, $property)) {
            $this->$property = $value;
        }
    }
}
$objeto = new Entidad();
$objeto->set($atributo,"valor");
$objeto->get($atributo); // valor

    我什么时候使用什么样的方法？：

    答案可在 PHP 官方文档的“重载”部分找到。

    但首先让我们了解一些基本概念：

    什么是超载？：

    在面向对象编程中，重载是指具有两个或多个同名但功能不同的函数的可能性，也就是说，它们根据参数的不同数量和/或类型执行不同的操作。

    那么PHP中有重载吗？：

    不，让我们记住 PHP 没有输入：

    $entero = 4; // Entero.
$entero = "4"; // String.
$string = array(); // Array.

    因此，在 PHP 中没有参数类型的重载。

    此外，我们无法控制传递给函数的参数数量，例如 Javascript，使用 arguments[]，因此没有参数数量的重载。

    但是 PHP 并没有失控，因为它创建了： “魔术方法”，并与此一起进行了重载模拟。（有人说这个 PHP 属性命名错误）

    引用： http: //php.net/manual/en/language.oop5.overloading.php

    PHP 中的重载提供了动态创建属性和方法的方法。

    当与尚未声明或在活动范围内不可见的属性或方法交互时，将调用重载方法。

    PHP 对“重载”的解释不同于大多数面向对象的语言。 重载传统上提供了拥有多个具有相同名称但具有不同类型或参数数量的方法的能力。

    因此，如果 PHP 中不存在重载：魔术方法扮演什么角色来模拟它？

    什么是神奇的方法？：

    • 它们是允许通过实现某些方法来更改类的内部功能的函数。
    • PHP 在某些事件上自动调用它们。
    • 所以它允许我们在这些事件发生时执行代码。
    • 由于它具有修改类的能力，我们现在可以定制接收的参数、类型以及类的操作方式、实例和获取/设置方法。

    那么我们可以这样说：

    创建魔术方法是为了能够模拟重载。所以这些函数不是用来违背 OOP 的基础，而是为了让 PHP 更像 OOP，通过修改类的访问器方法的交互方式，使其无类型语言适应检查数据类型的能力。

    注意： 应该注意的是，我们对这些魔术方法所做的就是能够修改它们以覆盖（遮蔽）它们在类中的默认函数。

    让我们看一个使用魔术方法重载的示例：

    <?php
class MiClase
{
    public function __construct()
    {

        // Almacenamos los argumentos ingresados.
        $parametros= func_get_args();

        // Retornamos el número de argumentos ingresados.
        $numeroParametros = func_num_args();

        // Creamos el constructor con el numero de parametros.
        $constructor ='__construct'.$numeroParametros;

        // Buscamos el metodo dentro de nuestra clase.
        if (method_exists($this,$constructor)) {
            call_user_func_array(array($this,$constructor),$parametros);
        }
    }
    public function __construct0() {
        echo "Cero argumento";
    }
    public function __construct1($x) {
        echo "Una argumento: $x";
    }
    public function __construct2($x, $y) {
        echo "Dos argumentos: $x y $y";
    }
}
$objeto0 = new MiClase("0"); // llamará a construct0
$objeto1 = new MiClase("1"); // llamará a construct1
$objeto2 = new MiClase("1","2"); // llamará a construct2

    使用魔术方法__construct()，我们重载构造函数以根据传递的参数做出反应，调用相同的方法。

    现在让我们使用另一种方法，例如__call()：

    __call() 有什么功能？

    - 允许您捕获不存在的方法的调用。

    • 可以重新定义此方法以满足系统的需要，或者在这种情况下提供重载。

    • 利用这个功能，我们可以控制我们正在调用的函数并重定向到我们所指的特定函数。

    让我们看一个例子：

    class Ejemplo {

  // Ejecutaremos Prueba el CUAL NO EXISTE pero gracias a __call lo creamos verificando
  // que este exista en un array.
  // Call lo usamos con este formato: __call($nombreDelMetodo, $argumentos)

  function __call($nombreMetodo, $argumentos) {
    $metodosAceptados = array("Pruebas");
    if(!in_array($nombreMetodo, $metodosAceptados)) {
      echo "$nombreMetodo no existe en los métodos disponibles";
    }
    $numeroArgumentos = count($argumentos);
    if($numeroArgumentos == 0) {
      $this->Pruebas1();
    } else if($numeroArgumentos == 1) {
      $this->Pruebas2($argumentos[0]);
    } else if($numeroArgumentos == 2) {
      $this->Pruebas3($argumentos[0], $argumentos[1]);
    } else if($numeroArgumentos == 3) {
      $this->Pruebas4($argumentos[0], $argumentos[1], $argumentos[2]);
    } else {
      return false;
    }
  }
  function Pruebas1() {
    echo "Hola pasaste cero argumentos<br>";
  }
  function Pruebas2($nombre){
    echo "Hola $nombre, pasaste 1 argumento<br>";
  }
  function Pruebas3($primerNombre, $segundoNombre){
    echo "Hola $primerNombre $segundoNombre, pasaste dos argumentos<br>";
  }
  function Pruebas4($primerNombre, $segundoNombre, $edad){
    echo "Hola $primerNombre $segundoNombre, ya tienes $edad años, pasaste tres argumentos<br>";
  }
}
$objeto = new Ejemplo();
$objeto->Pruebas();
$objeto->Pruebas("John");
$objeto->Pruebas("John", "Smith");
$objeto->Pruebas("John", "Smith", 60);

    在这个例子中，我们用不同数量的参数和不同的类型重载了我们的类。总之，可以在 PHP 中重载（模拟）。

    PHP POO ESTRICTO + 1;

    WAIT：那么多态性和重载不一样吗？为什么，如果是这样，你是在做多态性而不是重载吗？：

    不，多态是指一组具有相同名称和相同数量的参数和类型的方法，但是定义在不同的类中，之前我们传递了不同的数据类型。

    让我们看一个多态的例子：

    // Definimos las clases
class Poligono
{
    function calculo() {
        echo 'El area depende del tipo de polígono';
    }
}
class Cuadrado extends Poligono
{
    function calculo()  {
        echo 'area de un cuadrado : a=l*l<br>';
    }
}
class Rectangulo extends Poligono
{
    function calculo()  {
        echo 'area de un rectangulo : a=b*h<br>';
    }
}
class Triangulo extends Poligono
{
    function calculo()  {
        echo 'area de un triangulo : a=(b*h)/2<br>';
    }
}

// Definimos la funcion que hara la llamada polimórfica al método cuadrado
// Es decir adaptaremos la función definida a cualquiera de las clases.

// NOTA: En la definición de la función definimos el tipo parámetro que pasamos por referencia, esto no es obligatorio en PHP, pero nos ayuda a entender el concepto y así poder aplicarlo en otros lenguajes más estrictos.

// Pasamos un objeto de la clase Poligono
function area(Poligono $objeto) {
    $objeto->calculo();
}
// Creamos los objetos necesarios
$cuadrado = new Cuadrado;
$rectangulo = new Rectangulo;
$triangulo = new Triangulo;

// Ejecutamos la función encargada de realizar la llamada polimórfica
area($cuadrado);
area($rectangulo);
area($triangulo);

// La función `area()` nos muestra la fórmula correcta en cada una de sus ejecuciones para cada tipo de figura geometrica, sea este Cuadrado, Rectangulo, Triangulo, pese a que en su definicion inicial hayamos especificado que el objeto es del tipo "Poligono" haciendo referencia a la clase base de cada objeto.

    PHP POO ESTRICTO +1;

    4）我们感兴趣的神奇方法：

    __set()在将数据写入不可访问的属性时执行。

    __get()用于从不可访问的属性中查询数据。

    引用 PHP 重载文档，我们发现：

    Se invoca a los métodos de sobrecarga cuando se interactúa con propiedades o métodos que no se han declarado o que no son visibles en el ámbito activo.

    Tenemos dos puntos de interés: Ámbito Activo y Propiedades Inaccesibles

    Ambito activo:

    El ámbito de una variable es el contexto dentro del que la variable está definida.

    Propiedades innacesibles: Son aquellas propiedades que bien estan ocultas, o no estan definidas.

    Citando lo anterior, como la sobrecarga usa los metodos magicos, y estos debes de poder acceder a propiedades innacesibles.

    Se fundamenta la razón de ser métodos públicos, ya que, te deben permiten obtener valores que no están en tu ámbito, ademas de crearlos dinamicamente si NO existen, cumpliendo su rol, interactuar con métodos/propiedades innacesibles.

    Veamos el ejemplo en una clase:

    Class Entidad
{
    // defino $atributo como privado.
    private $atributo;
    public function obtenerAtributo() {
        return $this->atributo;
    }
    public function cambiarAtributo($dato) { 
        $this->atributo = $dato;
    }
}

$objeto = new Entidad();
$objeto->atributo = "valor";
$objeto->cambiarAtributo("nuevoValor");
$objeto->obtenerAtributo(); // nuevoValor
$objeto->otroAtributo = "valor";

    En este caso al usar obtenerAtributo( ) o cambiarAtributo( ) estamos trabajando bajo atributos que están definidos dentro de la clase. Pero en el último llamado de otroAtributo estamos definiendo un valor que no existe.

    Aqui entra el papel de __set y __get, los cuales nos permiten trabajar bajo propiedades o métodos inexistentes:

    1) Si los quisiera redifinir para controlar como obtener y cambiar variables usaría:

    public function __set($propiedad,$valor) {
            //
        }
public function __get($propiedad) {
            //
        }
public function __call($metodo, $argumentos) {
           //
}

    2) Estos métodos nos permiten controlar el acceso o el cambio de propiedades.

    3) No son sustitutos de los getters/setters, ya que, nos permiten trabajar en modos que de la forma clásica daría error, más que todo son para manejo de errores, ejemplo obteniendo/cambiando atributos que no existen, comparando con JavaScript podrían usarse como si quisiéramos evitar que se crearan objetos sin new.

    4) Podría definirse a los métodos mágicos como los Object Watchers de Javascript, ya que estos crean propiedades inexistentes para funcionar, pero claro esta golpea en el rendimiento del código.

    Entonces sabiendo cuando usarlos, ¿Cual es mas eficiente?

    Ocurre un problema, son públicos y pueden acceder a mis propiedades privadas, ¿que hago?:

    Como es fácil violar la encapsulación en PHP:

    Veamos un ejemplo:

    class Produccion
{
}
$objeto = new Produccion();
$objeto->hackeado = 'boom';

    Tendremos dos soluciones:

    1) Si trabajas con mas personas: Documentar.

    2) Si no queremos documentar, para evitar usar dichos metodos, haremos lo siguiente, re-declarar los métodos mágicos:

    class Produccion
{
    public function __set($name,$value){
        throw new Exception ('No');
    }
    public function __get($name){
        throw new Exception ('No de nuevo');
    }
    public function __call($name, $arguments) {
        throw new Exception ('Stop');
    }
}
$objeto = new Produccion();
$objeto->hackeado  = 'boom'; //  Uncaught Exception: No
$objeto->hackeado; //  Uncaught Exception: No de nuevo.
$objeto->hackeado(); //  Uncaught Exception: Stop.

    A pesar de que estos métodos "crean" propiedades y métodos dinámicos, en ninguno de los casos funcionan como se esperaba porque los redefinimos, así podemos evitar esos posibles "fallos" de encapsulamiento.

    ¿Y si quiero utilizar mis propios metodos get/set?:

    Sencillamente agregamos nuestros propios métodos privados:

        class Produccion
    {
    private $atributo = 4;
        public function __set($name,$value){
            throw new Exception ('No');
        }
        public function __get($name){
            throw new Exception ('No de nuevo');
        }
        public function __call($metodo, $argumentos) {
            $metodosAceptados = array("tus","metodos","get","set");
            if(!in_array($metodo, $metodosAceptados)) {
                 throw new Exception ('Stop');
        }
    }
    private function get(){
        return $this->atributo;
    }
    private function set($valor){
        return $this->atributo = $valor;
    }
}
$objeto = new Produccion();

// Si queremos usar el get y set privados totalmente, los des-habilitamos en el __call, para evitar que los llamen sino queremos que sea así
$objeto->get(); // 4
$objeto->set(60);
$objeto->get(); // 60

    Entonces, podemos observar que aunque si pueden generar aberturas de seguridad en el encapsulamiento de PHP, podemos proteger las propiedades, por su misma capacidad de servir (los metodos magicos) como administradores de propiedades y metodos mas adaptables a las necesidades.

    PHP POO ESTRICTO + 1;

    En conclusión: PHP: SI ES POO ESTRICTO.

    1) Cumple con los fundamentos de la POO:

    • Herencia.

    • Abstracción.

    • Encapsulamiento.

    2)Tiene los elementos básicos como son:

    • Objetos, clases y métodos.

    • Visibilidad privada, protegida y pública

    • Metodos privados y públicos

    • Puede emplear propiedades estáticas

    • Sobrecargar sus métodos.

    3) Puede ademas tener polimorfismo y sobrecarga (gracias a los métodos mágicos):

    4) Tiene métodos mágicos con los que:

    • Ampliar las capacidades de PHP como POO.

    • Administrar los errores en PHP, y permiten redefinir las propiedades accesoras del objeto (aumentado así la encapsulación).

    • Los métodos mágicos se pueden opacar (shadowing).

    • 23

  2. 根据维基百科，PHP 范例是：

    多范式：命令式、函数式、面向对象、过程式、反射式。

    OOP范式的定义是：

    面向对象编程（POO，或根据其英文首字母缩略词的 OOP）是一种编程范式，它在交互中使用对象来设计应用程序和计算机程序。它基于各种技术，包括继承、内聚、抽象、多态、耦合和封装。

    是的，您可以在严格意义上进行 OOP，但您还必须看到，我们这些刚开始使用 OOP 的人通常会混合不同的范式。在我的项目中，我不断发现一种范式和另一种范式之间的跳跃，尤其是在小规模上。当你在 C 中工作时，一切都是命令式的并且易于阅读，所以有时你会按照这种范式用 Java 或 PHP 编写代码。但实际上如果是OO。我在 Python 中也发生了同样的事情。最初，它没有使用自己的类，它用函数来做所有事情，更不用说继承或抽象了。

    随着时间的推移，你会在一种或另一种范式中获得更多的练习。在这种情况下，它并不太依赖于 PHP，而是取决于您真正了解范式的程度以及您知道如何应用它的程度。尽管在后者中会有不同的人。

    更新

    关于神奇的方法。在 python 中，一切都可以被覆盖并从任何地方访问。没有私人的，也没有公共的。它们存在，但它们提到了代码的格式。例如，不应从类外部访问 _VAR 变量。它们是达成的约定。这称为隐藏，它是 OOP 的特征之一。JAVA 在这个意义上是非常严格的，因为它是为团队合作而设计的。领导者、Jr 开发人员等。Python 不，它更自由。相信程序员的良好实践。然后 PHP 在这些想法中有它的家务活。无论如何，当您在 OOP 中开发项目时，您最不希望的是必须访问其他类的方法并覆盖它们。制造混乱。就个人而言，我只对 get 和 set 及其描述的结果感兴趣。访问魔术方法有一些我不想要的复杂性。

    • 3