¿Qué es una clase abstracta en PHP?

¿Qué es una clase abstracta en PHP?

¿Como puede ser usado?

Una clase abstracta es una clase que contiene al menos un método abstracto, que es un método sin ningún código real en él, solo el nombre y los parámetros, y que se ha marcado como "abstracto".

El propósito de esto es proporcionar una especie de plantilla para heredar y forzar a la clase heredera a implementar los métodos abstractos.

Por tanto, una clase abstracta es algo entre una clase regular y una interfaz pura. Además, las interfaces son un caso especial de clases abstractas donde TODOS los métodos son abstractos.

Consulte esta sección del manual de PHP para obtener más referencias.

Las clases abstractas son clases que contienen uno o más métodos abstractos. Un método abstracto es un método que se declara, pero no contiene implementación. Las clases abstractas no se pueden instanciar y requieren subclases para proporcionar implementaciones para los métodos abstractos.

1. No se pueden instanciar clases abstractas : las clases definidas como abstractas no pueden instanciarse, y cualquier clase que contenga al menos un método abstracto también debe ser abstracta.

Ejemplo a continuación:

abstract class AbstractClass
{

    abstract protected function getValue();
    abstract protected function prefixValue($prefix);


    public function printOut() {
        echo "Hello how are you?";
    }
}

$obj=new AbstractClass();
$obj->printOut();
//Fatal error: Cannot instantiate abstract class AbstractClass

2. Cualquier clase que contenga al menos un método abstracto también debe ser abstracta : la clase abstracta puede tener métodos abstractos y no abstractos, pero debe contener al menos un método abstracto. Si una clase tiene al menos un método abstracto, entonces la clase debe declararse abstracta.

Nota: Los rasgos apoyan el uso de métodos abstractos para imponer requisitos a la clase expositora.

Ejemplo a continuación:

class Non_Abstract_Class
{
   abstract protected function getValue();

    public function printOut() {
        echo "Hello how are you?";
    }
}

$obj=new Non_Abstract_Class();
$obj->printOut();
//Fatal error: Class Non_Abstract_Class contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (Non_Abstract_Class::getValue)

3. Un método abstracto no puede contener cuerpo : los métodos definidos como abstractos simplemente declaran la firma del método; no pueden definir la implementación. Pero un método no abstracto puede definir la implementación.

abstract class AbstractClass
{
   abstract protected function getValue(){
   return "Hello how are you?";
   }

    public function printOut() {
        echo $this->getValue() . "\n";
    }
}

class ConcreteClass1 extends AbstractClass
{
    protected function getValue() {
        return "ConcreteClass1";
    }

    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass1";
    }
}

$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') ."\n";
//Fatal error: Abstract function AbstractClass::getValue() cannot contain body

4. Cuando se hereda de una clase abstracta, todos los métodos marcados como abstractos en la declaración de clase del padre deben ser definidos por el hijo : si hereda una clase abstracta, debe proporcionar implementaciones para todos los métodos abstractos en ella.

abstract class AbstractClass
{
    // Force Extending class to define this method
    abstract protected function getValue();

    // Common method
    public function printOut() {
        print $this->getValue() . "<br/>";
    }
}

class ConcreteClass1 extends AbstractClass
{
    public function printOut() {
        echo "dhairya";
    }

}
$class1 = new ConcreteClass1;
$class1->printOut();
//Fatal error: Class ConcreteClass1 contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (AbstractClass::getValue)

5. Visibilidad igual (o menos restringida) : cuando se hereda de una clase abstracta, todos los métodos marcados como abstractos en la declaración de clase del padre deben ser definidos por el hijo; además, estos métodos deben definirse con la misma (o menos restringida) visibilidad. Por ejemplo, si el método abstracto se define como protegido, la implementación de la función debe definirse como protegida o pública, pero no privada.

Tenga en cuenta que el método abstracto no debe ser privado.

abstract class AbstractClass
{

    abstract public function getValue();
    abstract protected function prefixValue($prefix);

        public function printOut() {
        print $this->getValue();
    }
}

class ConcreteClass1 extends AbstractClass
{
    protected function getValue() {
        return "ConcreteClass1";
    }

    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass1";
    }
}
$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') ."<br/>";
//Fatal error: Access level to ConcreteClass1::getValue() must be public (as in class AbstractClass)

6. Las firmas de los métodos abstractos deben coincidir : cuando se hereda de una clase abstracta, todos los métodos marcados como abstractos en la declaración de clase del padre deben ser definidos por el hijo; las firmas de los métodos deben coincidir, es decir, las sugerencias de tipo y el número de los argumentos deben ser los mismos. Por ejemplo, si la clase secundaria define un argumento opcional, donde la firma del método abstracto no lo hace, no hay conflicto en la firma.

abstract class AbstractClass
{

    abstract protected function prefixName($name);

}

class ConcreteClass extends AbstractClass
{


    public function prefixName($name, $separator = ".") {
        if ($name == "Pacman") {
            $prefix = "Mr";
        } elseif ($name == "Pacwoman") {
            $prefix = "Mrs";
        } else {
            $prefix = "";
        }
        return "{$prefix}{$separator} {$name}";
    }
}

$class = new ConcreteClass;
echo $class->prefixName("Pacman"), "<br/>";
echo $class->prefixName("Pacwoman"), "<br/>";
//output: Mr. Pacman
//        Mrs. Pacwoman

7. La clase abstracta no admite herencia múltiple : la clase abstracta puede extender otra clase abstracta, la clase abstracta puede proporcionar la implementación de la interfaz, pero no admite herencia múltiple.

interface MyInterface{
    public function foo();
    public function bar();
}

abstract class MyAbstract1{
    abstract public function baz();
}


abstract class MyAbstract2 extends MyAbstract1 implements MyInterface{
    public function foo(){ echo "foo"; }
    public function bar(){ echo "bar"; }
    public function baz(){ echo "baz"; }
}

class MyClass extends MyAbstract2{
}

$obj=new MyClass;
$obj->foo();
$obj->bar();
$obj->baz();
//output: foobarbaz

Nota: Tenga en cuenta que el orden o la ubicación de las clases en su código puede afectar al intérprete y puede causar un error fatal. Entonces, cuando use múltiples niveles de abstracción, tenga cuidado con el posicionamiento de las clases dentro del código fuente.

El siguiente ejemplo causará un error fatal: No se encontró la clase 'caballo'

class cart extends horse {
    public function get_breed() { return "Wood"; }
}

abstract class horse extends animal {
    public function get_breed() { return "Jersey"; }
}

abstract class animal {
    public abstract function get_breed();
}

$cart = new cart();
print($cart->get_breed());

Una clase abstracta es una clase que el programador implementa solo parcialmente. Puede contener uno o más métodos abstractos. Un método abstracto es simplemente una definición de función que sirve para decirle al programador que el método debe implementarse en una clase secundaria.

Hay una buena explicación de eso aquí .

Clase abstracta
1. Contiene un método abstracto
2. No se puede inicializar directamente
3. No se puede crear un objeto de clase abstracta
4. Solo se utiliza con fines de herencia

Método abstracto
1. No puede contener un cuerpo
2. No se puede definir como privado
3. Las clases secundarias deben definir los métodos declarados en la clase abstracta

Código de ejemplo:

abstract class A {
    public function test1() {
        echo 'Hello World';
    }
    abstract protected function f1();
    abstract public function f2();
    protected function test2(){
        echo 'Hello World test';
    }
}

class B extends A {
    public $a = 'India';
    public function f1() {
        echo "F1 Method Call";
    }
    public function f2() {
        echo "F2 Method Call";
    }
}

$b = new B();
echo $b->test1() . "<br/>";
echo $b->a . "<br/>";
echo $b->test2() . "<br/>";
echo $b->f1() . "<br/>";
echo $b->f2() . "<br/>";

Salida:

Hello World
India
Hello World test
F1 Method Call
F2 Method Call

• Abstract Class contiene solo declarar la firma del método, no pueden definir la implementación.
• Las clases de abstracción se definen utilizando la palabra clave abstract .
• La clase abstracta no es posible implementar la herencia múltiple .
• La última versión de PHP 5 ha introducido clases y métodos abstractos.
• Clases definidas como abstractas, no podemos crear el objeto (no se pueden crear instancias)

Las clases abstractas son aquellas clases que no se pueden inicializar directamente. O en otras palabras, podemos decir que las clases abstractas son aquellas clases cuyo objeto no se puede crear directamente. En PHP, las clases abstractas se desafían con la palabra clave abstract .

Además, para convertirse en una clase abstracta, hasta un método de la clase debe ser abstracto.

Para obtener más detalles sobre la clase abstracta, puede consultar mi blog sobre la clase abstracta en PHP .

Una clase abstracta es como la clase normal contiene variables contiene variables protegidas funciones contiene constructor solo una cosa es diferente contiene método abstracto.

El método abstracto significa un método vacío sin definición, por lo que solo una diferencia en la clase abstracta no podemos crear un objeto de clase abstracta

Abstract debe contener el método abstracto y esos métodos deben definirse en su clase heredada.