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