PHP Classes Abstratas

As classes abstratas do PHP fornecem uma maneira de definir uma classe base que não pode ser instanciada por conta própria, mas pode ser estendida por outras classes.

Este artigo fornecerá uma visão abrangente das classes abstratas do PHP . Aqui vamos aprender como definir classes e métodos abstratos, bem como usá-los em nossos projetos de codificação.

As classes abstratas são uma parte essencial da programação orientada a objetos , permitindo que você escreva um código mais flexível e sustentável.

A classe abstrata do PHP é caracterizada pelo fato de que não pode ser instanciada diretamente em um ambiente de programação orientada a objetos (OOP), mas serve como um modelo do qual outras classes podem herdar sua funcionalidade.

A classe abstrata consiste em métodos abstratos que não possuem nenhuma implementação própria e devem ser implementados por qualquer subclasse concreta herdada da classe abstrata.

Índice-

Classes e métodos abstratos do PHP

A classe abstrata e os métodos são aqueles em que uma classe pai possui um método nomeado, mas esse método precisa ser preenchido pela(s) classe(s) filha(s).

A classe abstrata é definida como a classe que contém pelo menos um método abstrato. Métodos declarados de forma abstrata não serão codificados; em vez disso, eles serão declarados, mas não implementados.

Usando a palavra-chave abstract , uma classe ou método pode ser definido como abstrato:

Sintaxe:

<?php
abstract class MainClass {
abstract public function method1();
abstract public function method2($name, $color);
}
?>

Ao herdar de uma classe abstrata com um nome de método igual ao da classe pai, o método da classe filha deve ter um modificador de acesso menos restrito ou o mesmo modificador de acesso da classe pai.

Em outras palavras, se o método abstrato da classe pai for definido como protegido, o método da classe filha deverá ser definido como protegido ou público. Também é necessário que o tipo de argumento e o número de argumentos necessários sejam os mesmos.

Além de suas classes pai, as classes filhas podem receber argumentos opcionais.

Portanto, quando uma classe filha herda de uma classe abstrata, as seguintes regras devem ser seguidas:

  • Os métodos da classe filha devem ser implementados com o mesmo nome do método da classe pai, que deve ser redeclarado.
  • Esse método deve ter o mesmo ou um modificador de acesso menos restritivo que o método da classe pai.
  • Deve haver o mesmo número de argumentos necessários para cada método. Além dos argumentos obrigatórios, a classe filha também pode aceitar argumentos opcionais

Para entender melhor esse conceito, vejamos um exemplo:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
<?php
// Parent class
abstract class Shape
{
public $name;
public function __construct($name)
{
$this->name = $name;
}
abstract public function message();
}
// Child classes
class Rectangle extends Shape
{
public function message()
{
return "This is a $this->name shape!";
}
}
class Triangle extends Shape
{
public function message()
{
return "This is a $this->name shape!";
}
}
class Circle extends Shape
{
public function message()
{
return "This is a $this->name shape!";
}
}
// Create objects from the child classes
$rect = new Rectangle("Rectangle");
echo $rect->message();
echo "<br>";
$triangle = new Triangle("Triangle");
echo $triangle->message();
echo "<br>";
$circle = new Circle("Circle");
echo $circle->message();
?>
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Exemplo de Explicação

A classe Shape é a classe pai das classes Rectangle , Triangle e Circle , todas herdadas dela.

Ao herdar a propriedade pública $name e o método público __construct() da classe Shape, é possível que as classes Rectangle, Triangle e Circle usem a propriedade pública $name e o método público __construct() da classe Shape.

Apesar disso, message() é um método abstrato e deve ser definido em todas as classes filhas também, e elas devem retornar uma string quando chamadas.

No exemplo a seguir, demonstraremos uma situação em que há um argumento fornecido para um método abstrato:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
<?php
//Parent Classes
abstract class Person {
public $name;
public function __construct($name) {
$this->name = $name;
}
abstract public function greeting();
}
// Child classes
class Programmer extends Person {
public function greeting(){
return "Hello world from programmer and my name is " . $this -> name;
}
}
class Student extends Person {
public function greeting(){
return "Hello! from a student and my name is $this->name!";
}
}
class Employee extends Person {
public function greeting() {
return "Hello! from an employee and my name is $this->name! ";
}
}
// create instances of the child classes
$programmer = new Programmer("Denis");
echo $programmer->greeting();
echo "<br>";
$student = new Student("John");
echo $student->greeting();
echo "<br>";
$employee = new Employee("Alex");
echo $employee->greeting();
?>
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Outro exemplo é onde temos um método abstrato em uma classe pai que possui um argumento e, em seguida, temos um método abstrato em uma classe filha que possui argumentos opcionais que não são definidos no método abstrato da classe pai:

Example: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
<?php
//Parent Classes
abstract class Person {
public $name;
abstract public function greeting($name);
}
// Child classes
class Programmer extends Person {
public function greeting($name, $language = "PHP"){
return "Hello world from programmer and my name is $name and working as $language developer";
}
}
class Student extends Person {
public function greeting($name, $class = "8th"){
return "Hello! from a student and my name is $name! and i am studying in $class class";
}
}
class Employee extends Person {
public function greeting($name, $yearOfExp = 5) {
return "Hello! from a employee and my name is $name! and i have $yearOfExp year of experience";
}
}
// create instances of the child classes
$programmer = new Programmer();
echo $programmer->greeting("Denis");
echo "<br>";
$student = new Student();
echo $student->greeting("John");
echo "<br>";
$employee = new Employee();
echo $employee->greeting("Alex");
?>
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Por que usar classes abstratas do PHP?

Classes abstratas são úteis em PHP por vários motivos:

  • As classes abstratas do PHP fornecem uma maneira de definir funcionalidades comuns que podem ser reutilizadas em várias subclasses.
  • As classes abstratas nos permitem criar uma hierarquia de classes relacionadas, tornando mais fácil escrever código que funcione com vários objetos relacionados.
  • As classes abstratas fornecem uma maneira de encapsular detalhes de implementação em uma classe base, reduzindo a duplicação de código e melhorando a capacidade de manutenção.
  • As classes abstratas do PHP podem ser estendidas por outras classes para adicionar funcionalidade adicional, tornando o código mais flexível e adaptável às mudanças nos requisitos.
Nós valorizamos o seu feedback.
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
Assine a nossa newsletter
Digite seu e-mail para receber um resumo semanal de nossos melhores posts. Saber mais!
ícone
Ao assinar, você concorda com nossa política de privacidade e nossos termos de serviço.