Quando vamos desenvolver um programa, o certo não é pensar no projeto como um todo. A melhor forma de desenvolver é pensando e desenvolvendo em partes. Além de manter a sanidade do desevolvedor, a estrutura do código fica bem organizada. Para criar uma estrutura bem feita é necessário abstrair seu desenvolvimento.

Abstrair significa separar mentalmente, considerar isoladamente, simplificar. Assim nosso sistema deve ser separado de forma lógica com o objetivo de simplificar.

1. Classes abstratas

Sendo assim existem classes que chamamos de classes estruturais. Elas são responsáveis por manter uma estrutura padrão para seus filhos, indepentende do seu número. Ou seja, essas classes nunca serão instanciadas, pois somente seus filhos serão usados.

Com isso nosso exemplo anterior, deveríamos ter criado uma classe chamada Cheque, que seria a estrutura padrão para as classes ChequeComum e ChequeEspecial, onde essas duas ultimas herdariam Cheque e adicionariam ou sobrescreveriam apenas o que fosse relevante e a classe Cheque seria abstrata.

Para dizermos que uma classe é abstrata basta informarmos a palavra chave abstract.

<?php
abstract class Cheque
{
	private $valor;

	// ... outros métodos da classe

	public function setValor( $valor )
	{
		$this->valor = $valor;
	}

	public function getValor()
	{
		return $this->valor;
	}

	public function calculaJuros()
	{
		return $this->valor; // não há juros
	}
}

class ChequeComum extends Cheque
{
	public function calculaJuros()
	{
		return $this->valor * 1.25; // calcula 25% em cima do valor;
	}
}

class ChequeEspecial extends Cheque
{
	public function calculaJuros()
	{
		return $this->valor * 1.10; // calcula 10% em cima do valor;
	}
}

/*
* Tentando instanciar a classe Cheque.
* Isto vai causar um Fatal Error, pois ela é abstrata e não pode ser instanciada.
*/
$cheque = new Cheque();
?>

2. Classes finais

Há também casos em que não queremos que uma classe seja estendida por mais nenhuma outra. Para fazermos isso definimos a classe como final utilizando a palavra chave com o mesmo nome, final. Vamos supor que a classe ContaEspecial não pode ser estendida, porém alguém tentou de qualquer forma fazer isso:

<?php
final class ChequeEspecial extends Cheque
{
	public function calculaJuros()
	{
		return $this->valor * 1.10; // calcula 10% em cima do valor;
	}
}

/**
       * Ao ver que estamos tentando herdar uma classe final,  
       * o PHP lança um Fatal Error e para a execução do código  
       */  
class ChequeContaUniversitaria extends ChequeEspecial
{
	public function calculaJuros()
	{
		return $this->valor * 1.01; // calcula 1% em cima do valor;
	}
}

// Este código não chega a ser executado
$cheque = new ChequeContaUniversitaria();
?>

3. Métodos abstratos

Assim como classes, os métodos abstratos também são criados apenas para estruturação das classes filhas. Às vezes queremos que as classes derivadas de uma classe pai tenham obrigatóriamente um método específico, para garantir que não haja conflito em outros métodos que dependem desse primeiro.

<?php
abstract class Cheque
{
	// outros métodos

	abstract function calculaJuros();
}

class ChequeContaUniversitaria extends Cheque
{
	/**
           * Esta classe não precisa de calculo de juros.  
           * Mas se este método não for definido o PHP dispara um Fatal Error,  
           * pois na classe pai esse método está como abstrato.  
           */  
	public function calculaJuros()
	{
		return $this->valor; // não há juros;
	}
}
?>

Note que na classe Cheque o método calculaJuros() não é escrito, ele possui apenas sua assinatura. Isso é perfeitamente possível no caso de métodos abstratos.

4. Métodos finais

Quando um método é dito como final ele não pode ser sobrescrito ou seja, a classe filha continua tento acesso a ele, mas não pode mudá-lo.

<?php
abstract class Cheque
{
	final function calculaTotal()
	{
		// ...
	}
}

class ChequeContaUniversitaria extends Cheque
{
	/**
           * Isto retorna um Fatal Error  
           */  
	public function calculaTotal()
	{
		return 0.0;
	}
}
?>