O que é uma classe abstrata em PHP?

O que é uma classe abstrata em PHP?

Como pode ser usado?

Uma classe abstrata é uma classe que contém pelo menos um método abstrato, que é um método sem nenhum código real, apenas o nome e os parâmetros, e que foi marcado como "abstrato".

O objetivo disso é fornecer um tipo de modelo para herdar e forçar a classe herdada a implementar os métodos abstratos.

Uma classe abstrata é, portanto, algo entre uma classe regular e uma interface pura. As interfaces também são um caso especial de classes abstratas, onde TODOS os métodos são abstratos.

Veja esta seção do manual do PHP para referência adicional.

Classes abstratas são classes que contêm um ou mais métodos abstratos. Um método abstrato é um método declarado, mas não contém implementação. As classes abstratas podem não ser instanciadas e requerem subclasses para fornecer implementações para os métodos abstratos.

1. Não é possível instanciar a classe abstrata : as classes definidas como abstratas não podem ser instanciadas, e qualquer classe que contenha pelo menos um método abstrato também deve ser abstrata.

Exemplo abaixo:

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. Qualquer classe que contenha pelo menos um método abstrato também deve ser abstrata : A classe abstrata pode ter métodos abstratos e não abstratos, mas deve conter pelo menos um método abstrato. Se uma classe tiver pelo menos um método abstrato, ela deverá ser declarada abstrata.

Nota: As características suportam o uso de métodos abstratos para impor requisitos à classe expositora.

Exemplo abaixo:

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. Um método abstrato não pode conter corpo : Os métodos definidos como abstratos simplesmente declaram a assinatura do método - eles não podem definir a implementação. Mas um método não abstrato pode definir a implementação.

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. Ao herdar de uma classe abstrata, todos os métodos marcados como abstratos na declaração de classe dos pais devem ser definidos pelo filho : Se você herdar uma classe abstrata, precisará fornecer implementações para todos os métodos abstratos nela.

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. Mesma visibilidade (ou menos restrita) : Ao herdar de uma classe abstrata, todos os métodos marcados como abstratos na declaração de classe do pai devem ser definidos pelo filho; Além disso, esses métodos devem ser definidos com a mesma visibilidade (ou menos restrita). Por exemplo, se o método abstrato for definido como protegido, a implementação da função deverá ser definida como protegida ou pública, mas não privada.

Observe que o método abstrato não deve 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. As assinaturas dos métodos abstratos devem corresponder : Ao herdar de uma classe abstrata, todos os métodos marcados como abstratos na declaração de classe dos pais devem ser definidos pelo filho; as assinaturas dos métodos devem corresponder, ou seja, as dicas de tipo e o número de solicitações necessárias. argumentos devem ser os mesmos. Por exemplo, se a classe filho definir um argumento opcional, onde a assinatura do método abstrato não, não haverá conflito na assinatura.

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. A classe abstrata não suporta herança múltipla : A classe abstrata pode estender outra classe abstrata, a classe abstrata pode fornecer a implementação da interface. Mas ela não suporta herança múltipla.

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: Observe que a ordem ou o posicionamento das classes no seu código pode afetar o intérprete e causar um erro fatal. Portanto, ao usar vários níveis de abstração, tenha cuidado com o posicionamento das classes no código-fonte.

O exemplo abaixo causará erro fatal: Classe 'cavalo' não encontrada

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());

Uma classe abstrata é uma classe que é implementada apenas parcialmente pelo programador. Pode conter um ou mais métodos abstratos. Um método abstrato é simplesmente uma definição de função que serve para informar ao programador que o método deve ser implementado em uma classe filho.

Há uma boa explicação disso aqui .

Classe abstrata
1. Contém um método abstrato
2. Não pode ser inicializado diretamente
3. Não é possível criar um objeto da classe abstrata
4. Usado apenas para fins de herança

Resumo Método
1. Não pode conter um corpo
2. Não pode ser definido como privado
3. As classes filhas devem definir os métodos declarados na classe abstrata

Código de exemplo:

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/>";

Resultado:

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

• Abstract Class contém apenas declarar a assinatura do método, eles não podem definir a implementação.
• A classe de abstração é definida usando a palavra-chave abstract .
• Classe abstrata não é possível implementar herança múltipla .
• A versão mais recente do PHP 5 apresenta classes e métodos abstratos.
• Classes definidas como abstratas, não podemos criar o objeto (pode não ser instanciado)

Classes abstratas são aquelas que não podem ser inicializadas diretamente. Ou, em outras palavras, podemos dizer que classes abstratas são aquelas classes cujo objeto não pode ser criado diretamente. No PHP, as classes abstratas são desafiadas com a palavra-chave abstract .

Também para se tornar um resumo de uma classe, pelo menos, um método da classe deve ser abstrato.

Para os detalhes da classe abstrata, você pode consultar o meu blog sobre Classes Abstratas em PHP .

Uma classe abstrata é como a classe normal; ela contém variáveis; contém variáveis ​​protegidas; funções; contém construtor; apenas uma coisa é diferente; contém o método abstrato.

O método abstrato significa um método vazio sem definição, portanto, apenas uma diferença na classe abstrata, não podemos criar um objeto da classe abstrata

O resumo deve conter o método abstrato e esses métodos devem ser definidos em sua classe de herança.