Na programação orientada a objetos (inglês: Programação orientada a objetos, abreviatura: OOP), um objeto é um todo composto de informações e uma descrição de como processar as informações, e é uma abstração do mundo real.
No mundo real, as coisas que enfrentamos são objetos, como computadores, televisões, bicicletas, etc.
Existem três características principais dos objetos:
O comportamento do objeto: Quais operações podem ser aplicadas ao objeto, acender e apagar a luz são comportamentos.
A forma do objeto: como o objeto responde quando esses métodos são aplicados, cor, tamanho, aparência.
Representação de objetos: A representação de objetos equivale a um cartão de identificação, distinguindo especificamente as diferenças no mesmo comportamento e status.
Por exemplo, Animal é uma classe abstrata. Podemos especificar um cachorro e uma ovelha, e cachorros e ovelhas são objetos concretos. Eles possuem atributos de cor, podem ser escritos, podem correr e outros estados comportamentais.
Class - define as características abstratas de uma coisa. A definição de uma classe inclui a forma dos dados e as operações nos dados.
Object - é uma instância de uma classe.
Membervariables - Variáveis definidas dentro de uma classe. O valor desta variável é invisível para o mundo exterior, mas pode ser acessado por meio de funções-membro. Depois que a classe é instanciada como um objeto, a variável pode ser chamada de atributo do objeto.
Funções de membro - são definidas dentro da classe e podem ser usadas para acessar os dados do objeto.
Inheritance - Herança é um mecanismo pelo qual as subclasses compartilham automaticamente as estruturas de dados e métodos de sua classe pai. Este é um relacionamento entre classes. Ao definir e implementar uma classe, você pode fazer isso com base em uma classe existente, pegar o conteúdo definido pela classe existente como seu próprio conteúdo e adicionar algum conteúdo novo.
Parent class - Uma classe que é herdada por outras classes pode ser chamada de classe pai, classe base ou superclasse.
Subclass - Uma classe que herda de outras classes é chamada de subclasse ou também pode ser chamada de classe derivada.
Polymorphism - Polimorfismo significa que a mesma função ou método pode operar em vários tipos de objetos e obter resultados diferentes. Objetos diferentes podem produzir resultados diferentes ao receber a mesma mensagem. Esse fenômeno é chamado de polimorfismo.
Overloading - Simplificando, é uma situação em que funções ou métodos têm o mesmo nome, mas listas de parâmetros diferentes. Essas funções ou métodos com o mesmo nome e parâmetros diferentes são chamados de funções ou métodos sobrecarregados.
Abstraction - Abstração refere-se à abstração de objetos com estruturas de dados (propriedades) e comportamentos (operações) consistentes em classes. Uma classe é uma abstração que reflete propriedades importantes relacionadas a um aplicativo, ignorando outros conteúdos irrelevantes. A divisão de qualquer classe é subjetiva, mas deve estar relacionada à aplicação específica.
Encapsulation - Encapsulamento refere-se a unir as propriedades e o comportamento de um objeto que existe no mundo real e colocá-lo dentro de uma unidade lógica.
Construtor - é utilizado principalmente para inicializar o objeto ao criá-lo, ou seja, atribuir valores iniciais às variáveis membro do objeto. É sempre utilizado junto com o operador new na instrução para criar o objeto.
Destructor - Destruidor (destruidor) Ao contrário do construtor, quando o objeto encerra seu ciclo de vida (por exemplo, a função na qual o objeto está localizado foi chamada), o sistema executa automaticamente o destruidor. Os destruidores costumam ser usados para fazer trabalhos de "limpeza" (por exemplo, ao criar um objeto, use new para abrir um espaço de memória, que deve ser liberado com delete no destruidor antes de sair).
Na figura abaixo, criamos três objetos através da classe Carro: Mercedes, BMW e Audi.
$mercedes = carro novo();$bmw = carro novo();$audi = carro novo();
O formato de sintaxe usual para definir classes em PHP é o seguinte:
<?phpclass phpClass { var $var1; var $var2 = "string constante"; function myfunc ($arg1, $arg2) { [..] } [..]}?>A análise é a seguinte:
As classes são definidas usando a palavra-chave class seguida do nome da classe.
Variáveis e métodos podem ser definidos entre colchetes ({}) após o nome da classe.
Variáveis de classe são declaradas usando var e variáveis também podem ser inicializadas com valores.
As definições de funções são semelhantes às definições de funções do PHP, mas as funções só podem ser acessadas por meio da classe e dos objetos que ela instancia.
<?phpclass Site { /* Variáveis de membro*/ var $url; /* Funções de membro*/ function setUrl($par){ $this->url = $par } function getUrl(){ echo $this; ->url . PHP_EOL; função setTitle($par){ $this->title = $par; função getTitle(){ echo $this->title . }}?>A variável $this representa seu próprio objeto.
PHP_EOL é o caractere de nova linha.
Após a criação de uma classe, podemos usar o operador new para instanciar objetos dessa classe:
$codercto = novo Site;$taobao = novo Site;$google = novo Site;
No código acima, criamos três objetos. Cada um dos três objetos é independente. A seguir, vamos dar uma olhada em como acessar métodos e variáveis de membros.
Depois de instanciar um objeto, podemos usar o objeto para chamar métodos membros. Os métodos membros do objeto só podem operar nas variáveis membro do objeto:
// Chame a função de membro para definir o título e o URL $codercto->setTitle( "Coder Tutorial" );$taobao->setTitle( "Taobao" );$google->setTitle( "Google Search" );$codercto- > setUrl( 'www.codercto.com' );$taobao->setUrl( 'www.taobao.com' );$google->setUrl( 'www.google.com' );// Chame a função membro para obter o título e a URL $codercto->getTitle();$taobao->getTitle();$google->getTitle();$codercto->getUrl();$taobao-> getUrl( );$google->getUrl();
O código completo é o seguinte:
< ? php class Site { / * Variáveis de membro * / var $ url ; var $ title ; este -> url . PHP_EOL ; função setTítulo ( $par ){ $ este - > título = $par ; função getTítulo (){ echo $este -> título . }} $codercto = new Site ; $taobao = new Site ; $google = new Site ; // Chama a função de membro, define o título e a URL $ codercto - > setTitle ( " Coder Tutorial" ); " ); $google -> setTitle ( "Pesquisa Google" ); $codercto -> setUrl ( 'www.codercto.com' ); $taobao -> setUrl ( 'www.taobao.com' ) ; $google -> setUrl ( ' www.google.com ' ); // Chame a função membro para obter o título e URL $codercto -> getTitle (); ) ; $ google - > getTítulo ( ) ; $ codercto - > getUrl ( ) ;Executando o código acima, o resultado da saída é:
Tutorial do Code Farmer Taobao Pesquisa no Google www.codercto.comwww.taobao.comwww.google.com
Construtor é um tipo especial de método. É usado principalmente para inicializar o objeto ao criá-lo, ou seja, atribuir valores iniciais às variáveis membro do objeto e usá-lo com new na instrução para criar o objeto.
O PHP 5 permite aos desenvolvedores definir um método como um construtor em uma classe, com a seguinte sintaxe:
void __construct ([ misto $args [, $... ]] )
No exemplo acima, podemos inicializar as variáveis $url e $title através do construtor:
function __construct($par1, $par2) { $this->url = $par1;}Agora não precisamos mais chamar os métodos setTitle e setUrl:
$codercto = novo Site('www.codercto.com', 'Tutorial do Codificador');$taobao = novo Site('www.taobao.com', 'Taobao');$google = novo Site('www.google . com', 'Pesquisa Google'); // Chame a função de membro para obter o título e o URL $codercto->getTitle();$taobao->getTitle();$google->getTitle();$codercto->getUrl();$taobao->getUrl(); $google ->getUrl();Destruidor (destruidor) Ao contrário do construtor, quando o objeto termina seu ciclo de vida (por exemplo, a função na qual o objeto está localizado foi chamada), o sistema executa automaticamente o destruidor.
O PHP 5 introduziu o conceito de destruidores, que é semelhante a outras linguagens orientadas a objetos. Sua sintaxe é a seguinte:
void __destruct (void)
<?phpclass MyDestructableClass { function __construct() { print "construtorn"; $this->name = "n"; }$obj = new MyDestructableClass();?>Executando o código acima, o resultado da saída é:
Construtor destrói MyDestructableClass
PHP usa a palavra-chave extends para herdar uma classe. PHP não suporta herança múltipla.
class Child estende Parent { // Parte do código}No exemplo, a classe Child_Site herda a classe Site e estende suas funções:
<?php // Child_Site estende Site { var $category; function setCate($par){ $this->category = $par; function getCate(){ echo $this->category }}Se o método herdado da classe pai não puder atender às necessidades da subclasse, ele poderá ser reescrito. Esse processo é chamado de substituição de método, também conhecido como reescrita de método.
Os métodos getUrl e getTitle são substituídos no exemplo:
função getUrl() { echo $this->url . PHP_EOL; return $this->title;}O controle de acesso do PHP às propriedades ou métodos é obtido adicionando as palavras-chave public, protected ou private na frente.
público: os membros da classe pública podem ser acessados de qualquer lugar.
protegido: os membros da classe protegida podem ser acessados por si próprios e por suas subclasses e classes pai.
Privado: os membros da classe privada só podem ser acessados pela classe na qual estão definidos.
Os atributos de classe devem ser definidos como públicos, protegidos ou privados. Se definido com var, é considerado público.
<?php/** * Definir MinhaClasse */class MinhaClasse{ public $public = 'Público'; protegido $protegido = 'Protegido'; echo $this->protected; echo $this->private }}$obj = new MyClass();echo $obj->public; // Esta linha irá gerar um erro fatal echo $obj->private; // Esta linha também irá gerar um erro fatal $obj->printHello(); class MyClass2 estende MyClass{ // Público e protegido podem ser redefinidos, mas privado, mas não protegido $protected = 'Protected2'; $this->protected; echo $this->private }}$obj2 = new MyClass2();echo $obj2->public; // Esta linha pode ser executada normalmente echo $obj2->private; definido $obj2->protected; // Esta linha gerará um erro fatal $obj2->printHello();Os métodos em uma classe podem ser definidos como públicos, privados ou protegidos. Se essas palavras-chave não forem definidas, o padrão do método será público.
<?php/** * Define MyClass */class MyClass{ // Declara um construtor público public function __construct() { } // Declara um método público public function MyPublic() { } // Declara um método protegido protected function MyProtected( ) { } // Declara um método privado private function MyPrivate() { } // Este método é uma função pública Foo() { $this->MyPublic(); $this->MyProtected(); $this->MyPrivate(); }}$myclass = new MyClass;$myclass->MyPublic(); Esta linha irá gerar um erro fatal $myclass->MyPrivate(); // Esta linha irá gerar um erro fatal $myclass->Foo(); Define MyClass2 */class MyClass2 extends MyClass{ // Este método é uma função pública Foo2() { $this->MyPublic(); gerar um erro fatal}}$myclass2 = new MyClass2;$myclass2->MyPublic(); // Esta linha pode ser executada normalmente $myclass2->Foo2(); Tanto os públicos quanto os protegidos podem ser executados, mas os privados não podem. class Bar { public function test() { $this->testPrivate(); :testPublicn"; } private function testPrivate() { echo "Bar::testPrivaten"; }}class Foo estende Bar { public function testPublic() { echo "Foo::testPublicn"; } private function testPrivate() { echo "Foo::testPrivaten }}$myFoo = new foo();$myFoo->test(); // Foo::testPublic?>Usando uma interface, você pode especificar quais métodos uma classe deve implementar, mas não precisa definir o conteúdo específico desses métodos.
Uma interface é definida através da palavra-chave interface , assim como definir uma classe padrão, mas todos os métodos definidos nela estão vazios.
Todos os métodos definidos em uma interface devem ser públicos. Esta é uma característica das interfaces.
Para implementar uma interface, use o operador implements . A classe deve implementar todos os métodos definidos na interface, caso contrário um erro fatal será relatado. Uma classe pode implementar múltiplas interfaces. Use vírgulas para separar os nomes de múltiplas interfaces.
<?php// Declarar uma interface 'iTemplate' interface iTemplate{ public function setVariable($name, $var); public function getHtml($template);}// Implementar a classe de interface Template implements iTemplate{ private $vars = array( ) ; função pública setVariable($nome, $var) { $this->vars[$nome] = $var; foreach($this->vars as $nome => $valor) { $template = str_replace('{' . $nome . '}', $valor, $template } return $template }};Valores que permanecem inalterados ao longo de uma classe podem ser definidos como constantes. Não há necessidade de usar o símbolo $ ao definir e usar constantes.
O valor de uma constante deve ser fixo e não pode ser uma variável, um atributo de classe, o resultado de uma operação matemática ou uma chamada de função.
Desde o PHP 5.3.0, as classes podem ser chamadas dinamicamente usando uma variável. Mas o valor desta variável não pode ser uma palavra-chave (como self, parent ou static).
<?phpclass MinhaClasse{ const constante = 'valor constante'; function showConstant() { echo self::constant }}echo MinhaClasse::constant . PHP_EOL; // Desde 5.3.0 $class = new MyClass();$class->showConstant();echo $class::constant . // Desde PHP 5.3.0?>Qualquer classe deve ser declarada abstrata se pelo menos um método nela for declarado abstrato.
Classes definidas como abstratas não podem ser instanciadas.
Um método definido como abstrato apenas declara seu método de chamada (parâmetros) e não pode definir sua implementação de função específica.
Ao herdar uma classe abstrata, a subclasse deve definir todos os métodos abstratos na classe pai, além disso, o controle de acesso desses métodos deve ser o mesmo (ou mais relaxado) que na classe pai; Por exemplo, se um método abstrato for declarado como protegido, então o método implementado na subclasse deverá ser declarado como protegido ou público e não pode ser definido como privado.
<?phpabstract class AbstractClass{ // Obrigatório para as subclasses definirem esses métodos abstract protected function getValue(); print $this); - >getValue() . PHP_EOL; }}class ConcreteClass1 estende AbstractClass{ função protegida getValue() { return "ConcreteClass1" } função pública; prefixValue($prefix) { return "{$prefix}ConcreteClass1"; }}class ConcreteClass2 estende 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_') .Executando o código acima, o resultado da saída é:
ConcreteClass1FOO_ConcreteClass1ConcreteClass2FOO_ConcreteClass2
Além disso, os métodos da classe filha podem conter parâmetros opcionais que não estão presentes no método abstrato da classe pai.
Por exemplo, se uma subclasse definir um parâmetro opcional que não esteja incluído na declaração do método abstrato da classe pai, ela ainda poderá ser executada normalmente.
<?phpabstract class AbstractClass{ // Nosso método abstrato só precisa definir os parâmetros necessários abstract protected function prefixName($name);}class ConcreteClass extends AbstractClass{ // Nossa subclasse pode definir opções opcionais que não existem na assinatura da classe pai Parâmetros public function prefixName($name, $separator = ".") { if ($name == "Pacman") { $prefix = "Mr" } elseif ($name == "Pacwoman") { $prefix = "Sra" } else { $prefix = ""; return "{$prefix}{$separator} {$name}"; "), "n";echo $class->prefixName("Pacwoman"), "n";?>A saída é:
Sr. PacmanSra.
Declarar um atributo ou método de classe como estático permite acessá-lo diretamente sem instanciar a classe.
Propriedades estáticas não podem ser acessadas por meio de um objeto de uma classe que foi instanciada (mas métodos estáticos podem).
Como os métodos estáticos não requerem a chamada de um objeto, a pseudo variável $this não está disponível em métodos estáticos.
Propriedades estáticas não podem ser acessadas por objetos através do operador ->.
Desde o PHP 5.3.0, as classes podem ser chamadas dinamicamente usando uma variável. Mas o valor desta variável não pode ser as palavras-chave self, parent ou static.
<?phpclass Foo { public static $my_static = 'foo'; public function staticValue() { return self::$my_static }}print Foo::$my_static . >staticValue() .PHP_EOL;?>Executando o programa acima, o resultado de saída é:
foofoo
PHP 5 adiciona uma nova palavra-chave final. Se um método na classe pai for declarado final, a classe filha não poderá substituir o método. Se uma classe for declarada final, ela não poderá ser herdada.
Um erro será relatado ao executar o seguinte código:
<?phpclass BaseClass { public function test() { echo "BaseClass::test() chamado" }}class ChildClass estende. BaseClass { public function moreTesting() { echo "ChildClass::moreTesting() chamado" . Mensagem de erro Erro fatal: Não é possível substituir o método final BaseClass::moreTesting()?>O PHP não chamará automaticamente o construtor da classe pai no construtor da classe filha. Para executar o construtor da classe pai, você precisa chamar parent::__construct() no construtor da classe filha.
<?phpclass BaseClass { function __construct() { print "Método construtor na classe BaseClass" }}class SubClass extends BaseClass { function __construct() { parent::__construct(); O método construtor da classe print "Método construtor na classe SubClass" }}class OtherSubClass estende BaseClass { // Herda o método construtor de BaseClass}// Chame o construtor BaseClass $obj = new BaseClass(); // Chame os construtores BaseClass e SubClass $obj = new SubClass();Executando o programa acima, o resultado de saída é:
Método construtor na classe BaseClass Método construtor na classe SubClass Método construtor na classe BaseClass