quelle est la classe abstraite en php?

Question

Qu'est-ce qu'une classe abstraite en php? Où peut-il être utilisé?

Answer 1

Une classe abstraite est une classe qui contient au moins une méthode abstraite, qui est une méthode sans aucun code réel, juste le nom et les paramètres, et qui a été marqué comme "abstrait".

Le but de ceci est de fournir un type de modèle à hériter de et à forcer la classe héritière à implémenter les méthodes abstraites.

Une classe abstraite est donc quelque chose entre une classe régulière et une interface pure. Les interfaces sont également un cas particulier de classes abstraites où toutes les méthodes sont abstraites.

Voir this section du manuel PHP pour référence ultérieure.

Answer 2

An abstract class is a class that is only partially implemented by the programmer. It may contain one or more abstract methods. An abstract method is simply a function definition that serves to tell the programmer that the method must be implemented in a child class.

Il y a une bonne explication de cette here.

Answer 3

Lien: Abstract Class in Php and oops

• classe abstraite contient déclarer que la signature de la méthode, ils ne peuvent pas définir la mise en œuvre.
• La classe d'abstraction est définie à l'aide du mot-clé abstract.
• La classe abstraite ne peut pas être implémentée héritage multiple.
• La dernière version de PHP 5 a introduit des classes et des méthodes abstraites.
• classes définies comme abstraite, nous sommes incapables de créer l'objet (non instanciés)

http://www.codingslover.com/2015/07/abstract-class-in-php.html

Answer 4

Abstract classes are classes that contain one or more abstract methods. An abstract method is a method that is declared, but contains no implementation. Abstract classes may not be instantiated, and require subclasses to provide implementations for the abstract methods.

1. instanciation classe abstraite: Les classes définies comme abstraite ne peut pas être instancié, et toute classe qui contient au moins une méthode abstraite doit également être abstraite.

Exemple ci-dessous:

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. Toute classe qui contient au moins une méthode abstraite doit aussi être abstraite: classe abstraite peut avoir des méthodes abstraites et non abstraites, mais il doit contenir au moins un méthode abstraite Si une classe a au moins une méthode abstraite, alors la classe doit être déclarée abstraite.

Note: Traits support the use of abstract methods in order to impose requirements upon the exhibiting class.

Exemple ci-dessous:

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. Une méthode abstraite ne peut pas contenir corps: Les méthodes définies comme abstraite il faut simplement déclarer la signature de la méthode - ils ne peuvent pas définir la mise en œuvre. Mais une méthode non abstraite peut définir l'implémentation.

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. Lorsque héritant d'une classe abstraite, toutes les méthodes marquées comme abstraites dans la déclaration de classe du parent doit être défini par l'enfant: Si vous héritez d'une classe abstraite, vous devez fournir des implémentations à toutes les méthodes abstraites dedans.

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. Idem (ou moins restreint) visibilité: Lorsque héritant d'une classe abstraite, toutes les méthodes marquées comme abstraites dans la déclaration de classe du parent doit être défini par l'enfant; de plus, ces méthodes doivent être définies avec la même visibilité (ou moins restreinte). Par exemple, si la méthode abstraite est définie comme protégée, l'implémentation de la fonction doit être définie comme protégée ou publique, mais pas comme privée.

Note that abstract method should not be private.

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. Signatures des méthodes abstraites doivent correspondre: Quand héritant d'une classe abstraite, toutes les méthodes marquées comme abstraites dans la déclaration de classe du parent doit être défini par l'enfant, les signatures des méthodes doit correspondre, c'est-à-dire que les indications de type et le nombre d'arguments requis doivent être identiques. Par exemple, si la classe enfant définit un argument facultatif, ce qui n'est pas le cas de la signature de la méthode abstraite, il n'y a pas de conflit dans la signature.

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. Classe abstraite ne supporte pas l'héritage multiple: peut Résumé de la classe étend une autre classe abstraite, classe abstraite peut fournir la mise en œuvre de interface.But il ne supporte pas l'héritage multiple.

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 

Note: Please note order or positioning of the classes in your code can affect the interpreter and can cause a Fatal error. So, when using multiple levels of abstraction, be careful of the positioning of the classes within the source code.

exemple ci-dessous provoquera Erreur fatale: de cheval 'Classe pas trouvé

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

Answer 5

classe abstraite
1. Contient une méthode abstraite
2. Ne peut pas être directement initialisé
3. Impossible de créer un objet de la classe abstraite
4. Utilisé uniquement à des fins d'héritage

Résumé Méthode
1. Ne peut pas contenir un corps
2. Ne peut pas être défini comme privé
3. Les classes enfant doivent définir les méthodes déclarées dans la classe abstraite

Exemple de code:

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

Sortie:

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