English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Programação orientada a objetos (em inglês: Object-Programação orientada a objetos (abreviação: OOP) em que um objeto é um todo composto por uma descrição de informações e do processamento dessas informações, é uma abstração do mundo real.
No mundo real, todas as coisas que enfrentamos são objetos, como computadores, televisores, bicicletas, etc.
Principais três características do objeto:
Comportamento do objeto: Operações que podem ser aplicadas ao objeto, acender e desligar são comportamentos.
Forma do objeto: Quando aplicamos esses métodos, como o objeto responde, cor, tamanho, forma.
Representação do objeto: A representação do objeto é equivalente a um cartão de identidade, a diferença específica está em o que é diferente em termos de comportamento e estado.
Por exemplo, Animal (animal) é uma classe abstrata, podemos nos especificar um cão e um cordeiro, e o cão e o cordeiro são objetos específicos, eles têm propriedades de cor, podem escrever, podem correr e outros estados de comportamento.
Classe − Define as características abstratas de uma coisa. A definição da classe inclui a forma dos dados e as operações sobre os dados.
Objeto − É uma instância da classe.
Variável membro − Definido dentro da classe, é uma variável cujo valor é invisível do exterior, mas pode ser acessado através de funções membro. Após a classe ser instanciada como um objeto, essa variável pode ser chamada de atributo do objeto.
Função membro − Definido dentro da classe, pode ser usado para acessar os dados do objeto.
herança − A herança é o mecanismo de que a subclasse compartilha automaticamente a estrutura de dados e métodos da classe pai, que é um tipo de relação entre classes. Ao definir e implementar uma classe, é possível fazer isso com base em uma classe já existente, usando o conteúdo definido pela classe existente como seu próprio conteúdo e adicionando alguns novos conteúdos.
Classe pai − Uma classe que é herdada por outra classe pode ser chamada de classe pai, ou classe base, ou classe super.
Subclasse − Uma classe que herda de outra classe é chamada de subclasse, também conhecida como classe derivada.
Polimorfismo − A polimorfismo é a característica de funções ou métodos idênticos que podem atuar em diferentes tipos de objetos e obter resultados diferentes. Diferentes objetos, ao receberem a mesma mensagem, podem gerar resultados diferentes, este fenômeno é chamado de polimorfismo.
Sobrecarga − Em termos simples, é a situação em que funções ou métodos têm o mesmo nome, mas listas de parâmetros diferentes. Tais funções ou métodos com nomes idênticos e parâmetros diferentes são chamados de sobrecarga de funções ou métodos.
Abstração − A abstração é a característica de abstrair objetos que possuem a mesma estrutura de dados (propriedades) e comportamento (operações) em classes. Uma classe é assim uma abstração que reflete propriedades importantes relacionadas ao aplicativo, ignorando outros conteúdos irrelevantes. A divisão de qualquer classe é subjetiva, mas deve estar relacionada ao aplicativo específico.
Encapsulamento − Encapsulamento é o ato de ligar as propriedades e comportamentos de um objeto existente no mundo real em um único bloco lógico.
Construtor − É usado principalmente para inicializar objetos ao criar, ou seja, atribuir valores iniciais às variáveis membro do objeto, geralmente usado em conjunto com o operador new em instruções de criação de objetos.
Destrutor − Função destrutora (destructor) é o oposto do construtor, quando o objeto termina sua vida útil (por exemplo, quando a função onde o objeto está localizado é chamada), o sistema executa automaticamente a função destrutora. A função destrutora geralmente é usada para "limpar e fechar" (por exemplo, ao usar new para abrir um espaço de memória ao criar um objeto, deve ser liberado com delete antes de sair).
Na figura a seguir, criamos três objetos através da classe Car: Mercedes, Bmw e Audi.
$mercedes = new Car(); $bmw = new Car(); $audi = new Car();
A definição de classe PHP geralmente tem a seguinte forma:
<?php
class phpClass {
var $var1;
var $var2 = 'string constante';
function myfunc($arg1, $arg2) {
[..]
}
[..]
}
?>Análise a seguir:
Classe usa class com a palavra-chave seguida pelo nome da classe.
Pode definir variáveis e métodos dentro de um par de chaves {} após o nome da classe.
As variáveis da classe usam var para declarar, as variáveis também podem ser inicializadas com valores.
Definição de função é semelhante à definição de função PHP, mas a função pode apenas ser acessada através da classe e dos objetos exemplificados.
<?php
class Site {
/* Variável membro */
var $url;
var $title;
/* Função membro */
function setUrl($par){
$this->url = $par;
}
function getUrl(){
echo $this->url . PHP_EOL;
}
function setTitle($par){
$this->title = $par;
}
function getTitle(){
echo $this->title . PHP_EOL;
}
}
?>Variável $this Representa o objeto próprio.
PHP_EOL Para quebra de linha.
Após a criação da classe, podemos usar new Operador para exemplificar o objeto da classe:
$w3codebox = new Site; $taobao = new Site; $google = new Site;
O código acima criou três objetos, três objetos são independentes um do outro, vamos ver como acessar métodos e variáveis membros.
Após a criação do objeto, podemos usar o objeto para chamar métodos membros, os métodos membros podem apenas operar variáveis membros do objeto:
// Chamar função membro, configurar título e URL
$w3codebox->setTitle( "Base Tutorial Site" );
$taobao->setTitle('淘宝');
$google->setTitle( "Google Busca" );
$w3codebox->setUrl( 'www.w3>setUrl( 'www.codebox.com' );
$taobao->setUrl('www.taobao.com');
$google->setUrl( 'www.google.com' );
// Chama funções membros para obter o título e a URL
$w3codebox->getTitle();
$taobao->getTitle();
$google->getTitle();
$w3codebox->getUrl();
$taobao->getUrl();
$google->getUrl();Código completo a seguir:
<?php
class Site {
/* Variável membro */
var $url;
var $title;
/* Função membro */
function setUrl($par){
$this->url = $par;
}
function getUrl(){
echo $this->url . PHP_EOL;
}
function setTitle($par){
$this->title = $par;
}
function getTitle(){
echo $this->title . PHP_EOL;
}
}
$w3codebox = new Site;
$taobao = new Site;
$google = new Site;
// Chamar função membro, configurar título e URL
$w3codebox->setTitle( "Base Tutorial Site" );
$taobao->setTitle( "Tmall Loja" );
$google->setTitle( "Google Busca" );
$w3codebox->setUrl( 'www.w3>setUrl( 'www.codebox.com' );
$taobao->setUrl( 'www.tmall.com' );
$google->setUrl( 'www.google.com' );
// Chama funções membros para obter o título e a URL
$w3codebox->getTitle();
$taobao->getTitle();
$google->getTitle();
$w3codebox->getUrl();
$taobao->getUrl();
$google->getUrl();
?>Ao executar o código acima, o resultado da saída será:
Base Tutorial Site Tmall Loja Google Busca pt.oldtoolbag.com www.tmall.com www.google.com
O construtor é um método especial. Principalmente usado para inicializar um objeto ao criar um objeto, ou seja, atribuir valores iniciais aos membros do objeto, usado juntamente com o operador new na declaração de criação de objetos.
PHP 5 Permite que o desenvolvedor defina um método como construtor em uma classe, com a seguinte forma gramatical:
void __construct ([ mixed $args [, $... ]]] )
No exemplo acima, podemos inicializar as variáveis $url e $title através do método construtor:
function __construct( $par1, $par2 ) {
$this->url = $par1;
$this->title = $par2;
}Agora não precisamos mais chamar os métodos setTitle e setUrl:
$w3codebox = new Site('pt.oldtoolbag.com', 'Base Tutorial Site');
$tmall = new Site('www.tmall.com', 'Tmall Loja');
$google = new Site('www.google.com', 'Google Busca');
// Chama funções membros para obter o título e a URL
$w3codebox->getTitle();
$tmall->getTitle();
$google->getTitle();
$w3codebox->getUrl();
$tmall->getUrl();
$google->getUrl();O destrutor (destructor) é o oposto do construtor, é executado automaticamente pelo sistema quando o objeto termina sua vida útil (por exemplo, quando a função onde o objeto está localizado é chamada)
PHP 5 Introdução ao conceito de destrutor, semelhante a outras linguagens orientadas a objetos, com a seguinte forma gramatical:
void __destruct ( void )
<?php
class MyDestructableClass {
function __construct() {
print "构造函数\n";
$this->name = "MyDestructableClass";
}
function __destruct() {
print "Destruição " . $this->name . "\n";
}
}
$obj = new MyDestructableClass();
?>Ao executar o código acima, o resultado da saída será:
Construtor Destruição de MyDestructableClass
O PHP usa a palavra-chave extends Para herdar uma classe, o PHP não suporta herança múltipla, o formato é o seguinte:
class Child extends Parent {
// Parte do código
}No exemplo, a classe Child_Site herda a classe Site e expande suas funcionalidades:
<?php
// A subclassa Child_Site expande a categoria de site
class Child_Site extends Site {
var $category;
function setCate($par){
$this->category = $par;
}
function getCate(){
echo $this->category . PHP_EOL;
}
}Se o método herdado da classe pai não atender às necessidades da classe filha, pode-se reescrevê-lo, este processo é chamado de sobrescrita de método (override) ou reescrita de método.
No exemplo, os métodos getUrl e getTitle foram sobrescritos:
function getUrl() {
echo $this->url . PHP_EOL;
return $this->url;
}
function getTitle(){
echo $this->title . PHP_EOL;
return $this->title;
}O PHP realiza o controle de acesso de propriedades ou métodos adicionando as palavras-chave public (pública), protected (protegida) ou private (privada) no início.
public (pública):Os membros de classe públicos podem ser acessados em qualquer lugar.
protected (protegido):Os membros de classe protegidos podem ser acessados por si mesmos, suas subclasses e classes pais.
private (privado):Os membros de classe privados só podem ser acessados pelo próprio tipo de classe onde estão definidos.
As propriedades de classe devem ser definidas como pública, protegida, privada. Se definida com var, é considerada pública.
<?php
/**
* Definir MyClass
*/
class MyClass
{
public $public = 'Public';
protected $protected = 'Protected';
private $private = 'Private';
function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj = new MyClass();
echo $obj->public; // Essa linha pode ser executada normalmente
echo $obj->protected; // Essa linha gerará um erro fatal
echo $obj->private; // Esta linha também gerará um erro fatal
$obj->printHello(); // Output Public, Protected e Private
/**
*Definir MyClass2
*/
class MyClass2 extends MyClass
{
// É possível redefinir public e protected, mas não private
protected $protected = 'Protected'2';
function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj2 = new MyClass2();
echo $obj2->public; // Essa linha pode ser executada normalmente
echo $obj2->private; // Não definido private
echo $obj2->protected; // Essa linha gerará um erro fatal
$obj2->printHello(); // Emitir Public, Protected2 e Undefined
?>Os métodos da classe podem ser definidos como públicos, privados ou protegidos. Se não forem definidos esses termos, o método é considerado público por padrão.
<?php
/**
* Definir MyClass
*/
class MyClass
{
// Declarar um construtor público
public function __construct() { }
// Declarar um método público
public function MyPublic() { }
// Declarar um método protegido
protected function MyProtected() { }
// Declarar um método privado
private function MyPrivate() { }
// Este método é público
function Foo()
{
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate();
}
}
$myclass = new MyClass;
$myclass->MyPublic(); // Essa linha pode ser executada normalmente
$myclass->MyProtected(); // Essa linha gerará um erro fatal
$myclass->MyPrivate(); // Essa linha gerará um erro fatal
$myclass->Foo(); // Públicos, protegidos e privados podem ser executados
/**
* Definir MyClass2
*/
class MyClass2 extends MyClass
{
// Este método é público
function Foo2();
{
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate(); // Essa linha gerará um erro fatal
}
}
$myclass2 = new MyClass2;
$myclass2->MyPublic(); // Essa linha pode ser executada normalmente
$myclass2->Foo2(); // Os públicos e protegidos podem ser executados, mas não os privados
class Bar
{
public function test() {
$this->testPrivate();
$this->testPublic();
}
public function testPublic() {
echo "Bar::testPublic\n";
}
private function testPrivate() {
echo "Bar::testPrivate\n";
}
}
class Foo extends Bar
{
public function testPublic() {
echo "Foo::testPublic\n";
}
private function testPrivate() {
echo "Foo::testPrivate\n";
}
}
$myFoo = new foo();
$myFoo->test(); // Bar::testPrivate
// Foo::testPublic
?>Usando a interface (interface), é possível especificar que uma classe deve implementar quais métodos, mas não é necessário definir o conteúdo específico desses métodos.
A interface é definida por interface definidos por palavras-chave, como se definisse uma classe padrão, mas todas as métodos definidos dentro dela são vazios.
Todos os métodos definidos na interface devem ser públicos, essa é uma característica da interface.
Para implementar uma interface, usar implements O operador. A classe deve implementar todos os métodos definidos na interface, senão será lançado um erro fatal. Uma classe pode implementar várias interfaces, separando os nomes das interfaces por vírgulas.
<?php
// Declarar uma interface 'iTemplate'
interface iTemplate
{
public function setVariable($name, $var);
public function getHtml($template);
}
// Implementar interface
class Template implements iTemplate
{
private $vars = array();
public function setVariable($name, $var)
{
$this-$this->vars[$name] = $var;
}
public function getHtml($template)
{
foreach($this-foreach($this->vars as $name => $value) {
$template = str_replace('{'. $name .'}', $value, $template);
}
return $template;
}
}Os valores que sempre permanecem inalterados em uma classe podem ser definidos como constantes. Não é necessário usar o símbolo $ ao definir e usar constantes.
O valor da constante deve ser um valor fixo, não pode ser uma variável, atributo de classe, resultado de uma operação matemática ou chamada de função.
Desde o PHP 5.3. A partir de 0, é possível usar uma variável para chamar dinamicamente a classe. Mas o valor dessa variável não pode ser um nome reservado (como self, parent ou static).
<?php
class MyClass
{
const constant = '常量值';
function showConstant() {
echo self::constant . PHP_EOL;
}
}
echo MyClass::constant . PHP_EOL;
$classname = "MyClass";
echo $classname::constant . PHP_EOL; // desde 5.3.0 começando
$class = new MyClass();
$class->showConstant();
echo $class::constant . PHP_EOL; // desde PHP 5.3.0 começando
?>Qualquer classe que contenha pelo menos um método declarado como abstrato deve ser declarada como abstrata.
As classes declaradas como abstratas não podem ser instanciadas.
Os métodos declarados como abstratos apenas declaram a forma de chamada (parâmetros), não podem definir a implementação específica.
Quando se herda uma classe abstrata, a subclasse deve definir todos os métodos abstratos da classe pai; além disso, o controle de acesso desses métodos deve ser o mesmo que na classe pai (ou mais liberal). Por exemplo, se um método abstrato for declarado como protegido, o método implementado na subclasse deve ser declarado como protegido ou público, e não como privado.
<?php
abstract class AbstractClass
{
// Obriga a definição de métodos nestes subclasses
abstract protected function getValue();
abstract protected function prefixValue($prefix);
// Método comum (não abstrato)
public function printOut() {
print $this->getValue() . PHP_EOL;
}
}
class ConcreteClass1 extends AbstractClass
{
protected function getValue() {
return "ConcreteClass1";
}
public function prefixValue($prefix) {
return "{$prefix}ConcreteClass1";
}
}
class ConcreteClass2 extends AbstractClass
{
public function getValue() {
return "ConcreteClass2";
}
public function prefixValue($prefix) {
return "{$prefix}ConcreteClass2";
}
}
$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') . PHP_EOL;
$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') . PHP_EOL;
?>Ao executar o código acima, o resultado da saída será:
ConcreteClass1 FOO_ConcreteClass1 ConcreteClass2 FOO_ConcreteClass2
Além disso, o método da subclasse pode conter parâmetros opcionais que não existem no método abstrato da classe pai.
Por exemplo, se a subclasse define um parâmetro opcional, enquanto a declaração do método abstrato da classe pai não o faz, ele também pode ser executado normalmente.
<?php
abstract class AbstractClass
{
// Nossos métodos abstratos precisam apenas definir os parâmetros necessários.
abstract protected function prefixName($name);
}
class ConcreteClass extends AbstractClass
{
// Nossa subclasse pode definir parâmetros opcionais que não existem na assinatura do pai.
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"), "\n";
echo $class->prefixName("Pacwoman"), "\n";
?>O resultado da saída é:
Mr. Pacman Mrs. Pacwoman
Declarar uma propriedade ou método da classe como static (estático) permite acessá-lo diretamente sem exemplificar a classe.
As propriedades estáticas não podem ser acessadas por meio de um objeto que já exemplificou a classe (mas os métodos estáticos podem).
Como os métodos estáticos podem ser chamados sem passar por um objeto, o pseudo-variável $this não está disponível nos métodos estáticos.
As propriedades estáticas não podem ser acessadas por meio de um objeto. -> operador para acessar.
Desde o PHP 5.3. A partir de 0, é possível chamar dinamicamente uma classe com uma variável. Mas o valor dessa variável não pode ser o nome de palavra-chave self, parent ou static.
<?php
class Foo {
public static $my_static = 'foo';
public function staticValue() {
return self::$my_static;
}
}
print Foo::$my_static . PHP_EOL;
$foo = new Foo();
print $foo->staticValue() . PHP_EOL;
?>Executar o programa acima, o resultado de saída será:
foo foo
PHP 5 Adicionou uma palavra-chave final. Se um método da classe pai for declarado como final, a classe filha não pode sobrescrever esse método. Se uma classe for declarada como final, não pode ser herdada.
A execução do seguinte código gerará um erro: }}
<?php
class BaseClass {
public function test() {
echo "BaseClass::test() called" . PHP_EOL;
}
final public function moreTesting() {
echo "BaseClass::moreTesting() called" . PHP_EOL;
}
}
class ChildClass extends BaseClass {
public function moreTesting() {
echo "ChildClass::moreTesting() called" . PHP_EOL;
}
}
// Mensagem de erro fatal: Cannot override final method BaseClass::moreTesting()
?>O PHP não chama automaticamente o método construtor da classe pai no método construtor da subclasse. Para chamar o método construtor da classe pai, é necessário chamá-lo no método construtor da subclasse parent::__construct() .
<?php
class BaseClass {
function __construct() {
print "BaseClass classe com método construtor" . PHP_EOL;
}
}
class SubClass extends BaseClass {
function __construct() {
parent::__construct(); // O método construtor da subclasse não pode chamar automaticamente o método construtor da classe pai
print "SubClass classe com método construtor" . PHP_EOL;
}
}
class OtherSubClass extends BaseClass {
// Herança do método construtor de BaseClass
}
// Chamada do método construtor de BaseClass
$obj = new BaseClass();
// Chamada dos métodos construtores de BaseClass e SubClass
$obj = new SubClass();
// Chamada do método construtor de BaseClass
$obj = new OtherSubClass();
?>Executar o programa acima, o resultado de saída será:
BaseClass classe com método construtor BaseClass classe com método construtor SubClass classe com método construtor BaseClass classe com método construtor