PHP orientado a objeto

Na programação orientada a objetos (Inglês: Programação orientada a objetos, Abreviatura: OOP), o objeto é uma descrição do processamento de informações e informações que consiste em um todo, é a abstração mundo real.

As coisas são objetos do mundo real que enfrentamos, como computadores, televisores, bicicletas.

Três principais características do objeto:

• Comportamento do objeto: um objeto que pode ser aplicado para a operação, acender as luzes, desligar as luzes é um comportamento.
• Forma de objeto: Ao aplicar esses métodos é como responder ao objeto, cor, tamanho, forma.
• Representação do objeto: um objeto que representa o equivalente a identidade, distinguir especificamente o que é diferente no mesmo comportamento e estado.

Por exemplo, animais (animal) é uma classe abstrata, que podem ser específicas de uma ovelha com um cão, eo cão com as ovelhas é um alvo específico, eles têm um atributo de cor, você pode escrever, você pode executar outros atos de Estado.

conteúdo orientado a objeto

• Class - define as características abstratas de uma coisa.definição de classe contém os dados do formulário e operações sobre dados.

• Objetos - é uma instância da classe.

• variáveis membros - variáveis definidas dentro da classe.O valor externo da variável não é visível, mas pode ser acessado por funções de membro, depois que a classe é instanciado como um objeto, as propriedades do objeto pode ser chamado de uma variável.

• função de membro - definido dentro da classe pode ser usada para objetos de acesso a dados.

• Hereditariedade - Herança é uma subclasse de partilha automática de estruturas e métodos da classe principal, que é uma relação entre as classes de dados.Na definição e implementação de uma classe, eles podem vir em tal base existe já realizado, esta classe já existente, conforme definido pelo conteúdo de seu conteúdo, e adicionar algum conteúdo novo.

• classe pai - uma classe herdada por outras classes, a classe pode ser chamado o pai classe, grupo ou classe, ou superclasse.

• Subclasse - uma classe que herda outra classe é chamado de uma subclasse também pode ser chamado de uma classe derivada.

• Polimorfismo - Polimorfismo refere-se a uma única operação ou função, o processo pode ser aplicado aos vários tipos de objectos e obter resultados diferentes.Objetos diferentes, você recebe a mesma mensagem pode produzir resultados diferentes, este fenômeno é chamado polimorfismo.

• Sobrecarga - curto, que é uma função ou um método com o mesmo nome, mas a lista de parâmetros não é a mesma situação, uma tal função ou método de entre os diferentes parâmetros do mesmo nome, cada função ou método sobrecarregado é chamado.

• Resumo - O resumo refere-se a ter uma estrutura consistente de dados (atributos) e comportamento (operações) de objetos em classes.Essa classe é uma abstração, ele reflete as propriedades importantes associados ao aplicativo, ignorando outros tipos de conteúdo não relacionado. Qualquer divisão de classes é subjetivo, mas deve estar relacionada com a aplicação específica.

• Pacote - Pacote refere-se às propriedades e o comportamento de um objecto no mundo real existe para se ligarem em conjunto e colocados em uma unidade lógica.

• Construtor - principalmente usado para inicializar o objeto quando você cria um objeto, o objeto é atribuído um valor inicial da variável de membro, sempre usar a instrução de criação do objeto com o novo operador.

• Destructor - destructor (destructor) eo construtor Em contraste, quando o fim objeto de seu ciclo de vida (por exemplo, onde o objeto é uma chamada de função é concluída), o sistema realiza automaticamente destructor.Destruidores são muitas vezes utilizados para fazer "limpar o rescaldo de" trabalho (por exemplo, quando você cria um objeto com um novo abriu-se espaço de memória deve ser utilizado antes de sair no processo de destruição excluir release).

A figura a seguir criamos três objetos classe Car: Mercedes, BMW e Audi.

$mercedes = new Car ();
$bmw = new Car ();
$audi = new Car ();

definição de classe PHP

PHP classe personalizada normalmente sintaxe é a seguinte:

<?php
class phpClass {
  var $var1;
  var $var2 = "constant string";
  
  function myfunc ($arg1, $arg2) {
     [..]
  }
  [..]
}
?>

Interpretado da seguinte forma:

• Após a classe usandoa palavra-chave classemais o nome da definição de classe.

• Um par de chaves após o nome da classe pode definir variáveis ​​e métodos ({}) no interior.

• variáveis de classe usandovar para declarar variáveis também pode ser inicializado valores.

• definição de função PHP é semelhante à definição da função, mas a função só pode ser acessado por meio da classe e seus objetos instanciados.

Exemplos

<?php
class Site {
  /* 成员变量 */
  var $url;
  var $title;
  
  /* 成员函数 */
  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;
  }
}
?>

$ Esta variável representar seus objetos.

nova linhaPHP_EOL.

PHP para criar objetos

Após a classe é criada, podemos usar o operadornew para instanciar um objeto da classe:

$w3big = new Site;
$taobao = new Site;
$google = new Site;

O código acima criamos três objetos, cada um dos três objetos são independentes, então olhamos para como acessar métodos membros e variáveis ​​de membro.

Chama o método membro

Depois que o objeto é instanciado, podemos usar o objeto para chamar um método membro, o método do objeto só pode ser um membro da variável membro operacional do objeto:

// 调用成员函数，设置标题和URL
$w3big->setTitle( "本教程" );
$taobao->setTitle( "淘宝" );
$google->setTitle( "Google 搜索" );

$w3big->setUrl( 'www.w3big.com' );
$taobao->setUrl( 'www.taobao.com' );
$google->setUrl( 'www.google.com' );

// 调用成员函数，获取标题和URL
$w3big->getTitle();
$taobao->getTitle();
$google->getTitle();

$w3big->getUrl();
$taobao->getUrl();
$google->getUrl();

O código completo é como segue:

Implementação do código acima, a saída é:

本教程
淘宝
Google 搜索
www.w3big.com
www.taobao.com
www.google.com

PHP Constructor

Construtor é um método especial. Principalmente usado para inicializar o objeto quando você cria um objeto, o objeto é atribuído um valor inicial da variável de membro, sempre usar a instrução de criação do objeto com o novo operador.

PHP 5 permite aos desenvolvedores definir uma linha de método em uma classe como uma sintaxe do construtor é a seguinte:

void __construct ([ mixed $args [, $... ]] )

No exemplo acima, podemos inicializar o $ url e variável título $ via o construtor:

function __construct( $par1, $par2 ) {
   $this->url = $par1;
   $this->title = $par2;
}

Agora não precisa chamar o setTitle método e setURL:

destruidor

Destructor (destructor) eo construtor Em contraste, quando o fim objeto de seu ciclo de vida (por exemplo, onde o objeto é uma chamada de função é concluída), o sistema realiza automaticamente destructor.

PHP 5 introduz o conceito de um processo de destruição, que é semelhante a outras linguagens orientadas a objeto, a sintaxe é a seguinte:

void __destruct ( void )

Exemplos

<?php
class MyDestructableClass {
   function __construct() {
       print "构造函数\n";
       $this->name = "MyDestructableClass";
   }

   function __destruct() {
       print "销毁 " . $this->name . "\n";
   }
}

$obj = new MyDestructableClass();
?>

Implementação do código acima, a saída é:

构造函数
销毁 MyDestructableClass

herdar

PHP palavra-chaveextends para herdar uma classe, O PHP não suporta herança múltipla, no seguinte formato:

class Child extends Parent {
   // 代码部分
}

Exemplos

classe de exemplo Child_Site herda a classe de sites, e estende a funcionalidade:

<?php 
// 子类扩展站点类别
class Child_Site extends Site {
   var $category;

	function setCate($par){
		$this->category = $par;
	}
  
	function getCate(){
		echo $this->category . PHP_EOL;
	}
}

substitui o método

Se você não pode satisfazer as necessidades de uma subclasse herda o método da classe pai, ele pode ser reescrita, um processo chamado de método de sobreposição (override), também conhecido como o método de substituição.

Exemplo reescrito getUrl e getTitle métodos:

function getUrl() {
   echo $this->url . PHP_EOL;
   return $this->url;
}
   
function getTitle(){
   echo $this->title . PHP_EOL;
   return $this->title;
}

Controle de acesso

PHP sobre a propriedade ou método de controle de acesso é conseguido através da adição de palavras-chave na frente do público (público), protegido (protegido) ou privada (privado) para alcançar.

• público (Público): membro da classe pública pode ser acessado em qualquer lugar.
• protegido (protegida): membro da classe protegido pode ser acessado pelo seu próprio bem como a sua sub-classe e da classe pai.
• onde a definição de membros de classe privada só pode ser acessadoclasse: private (privado).

atributos de controle de acesso

atributo de classe deve ser definida como, protegidos uma pública e privada. Se definido com o var, considera-se pública.

<?php
/**
 * Define 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; // 这行能被正常执行
echo $obj->protected; // 这行会产生一个致命错误
echo $obj->private; // 这行也会产生一个致命错误
$obj->printHello(); // 输出 Public、Protected 和 Private


/**
 * Define MyClass2
 */
class MyClass2 extends MyClass
{
    // 可以对 public 和 protected 进行重定义，但 private 而不能
    protected $protected = 'Protected2';

    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}

$obj2 = new MyClass2();
echo $obj2->public; // 这行能被正常执行
echo $obj2->private; // 未定义 private
echo $obj2->protected; // 这行会产生一个致命错误
$obj2->printHello(); // 输出 Public、Protected2 和 Undefined

?>

métodos de controle de acesso

Método na classe pode ser definida como pública, privada ou protegida. Se você não definir essas palavras-chave, os padrões de método para público.

<?php
/**
 * Define MyClass
 */
class MyClass
{
    // 声明一个公有的构造函数
    public function __construct() { }

    // 声明一个公有的方法
    public function MyPublic() { }

    // 声明一个受保护的方法
    protected function MyProtected() { }

    // 声明一个私有的方法
    private function MyPrivate() { }

    // 此方法为公有
    function Foo()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate();
    }
}

$myclass = new MyClass;
$myclass->MyPublic(); // 这行能被正常执行
$myclass->MyProtected(); // 这行会产生一个致命错误
$myclass->MyPrivate(); // 这行会产生一个致命错误
$myclass->Foo(); // 公有，受保护，私有都可以执行


/**
 * Define MyClass2
 */
class MyClass2 extends MyClass
{
    // 此方法为公有
    function Foo2()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate(); // 这行会产生一个致命错误
    }
}

$myclass2 = new MyClass2;
$myclass2->MyPublic(); // 这行能被正常执行
$myclass2->Foo2(); // 公有的和受保护的都可执行，但私有的不行

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
?>

interface

Usando a interface (interface), você pode especificar quais os métodos de uma classe deve implementar, mas não precisa de definir o conteúdo específico desses métodos.

A interface é definidopelo interface de chave, tal como a definição de uma classe de padrão, mas o qual define todos os métodos estão vazios.

Todos os métodos definidos na interface deve ser pública, o que é característico da interface.

Para implementar uma interface, use o operador deimplementos.A classe deve implementar todos os métodos definidos em uma interface, ou então irá reportar um erro fatal. Classe pode implementar várias interfaces, use vírgulas para separar os nomes de várias interfaces.

<?php

// 声明一个'iTemplate'接口
interface iTemplate
{
    public function setVariable($name, $var);
    public function getHtml($template);
}


// 实现接口
class Template implements iTemplate
{
    private $vars = array();
  
    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }
  
    public function getHtml($template)
    {
        foreach($this->vars as $name => $value) {
            $template = str_replace('{' . $name . '}', $value, $template);
        }
 
        return $template;
    }
}

constante

Você pode colocar na classe permanece os mesmos valores definidos como constantes. Na definição e à utilização das constantes de tempo não precisa usar o símbolo $.

O valor da constante deve ser um valor fixo, não variável, atributos de classe, os resultados de matemática ou chamada de função.

Desde o PHP 5.3.0 em diante, você pode usar uma variável para chamar dinamicamente a classe. Mas o valor da variável não pode ser uma palavra-chave (por exemplo, auto, pai ou estática).

Exemplos

<?php
class MyClass
{
    const constant = '常量值';

    function showConstant() {
        echo  self::constant . PHP_EOL;
    }
}

echo MyClass::constant . PHP_EOL;

$classname = "MyClass";
echo $classname::constant . PHP_EOL; // 自 5.3.0 起

$class = new MyClass();
$class->showConstant();

echo $class::constant . PHP_EOL; // 自 PHP 5.3.0 起
?>

classe abstrata

Qualquer classe, se ele contém pelo menos um método é declarado abstrato, então esta classe deve ser declarada como abstrato.

É definida como uma classe abstrata não pode ser instanciado.

É definido como um método abstrato única declara sua invocação (parâmetros), não é possível definir a implementação função específica.

Herdar uma classe abstrata, subclasse deve toda a classe pai definições de métodos abstratos; Além disso, o acesso a estes métodos de controle e a classe pai deve ser o mesmo que (ou mais relaxado). Por exemplo, um método abstrato é declarado protegido, em seguida, o método implementado na subclasse deve ser declarado como protegido ou público, mas não pode ser definido como privado. Também chamado pelo método deve corresponder, que é o tipo eo número de parâmetros necessários devem ser consistentes. Por exemplo, uma subclasse define um parâmetro opcional, e a declaração do método abstrato classe pai não existe, então não há conflito entre as duas declarações.

<?php
abstract class AbstractClass
{
 // 强制要求子类定义这些方法
    abstract protected function getValue();
    abstract protected function prefixValue($prefix);

    // 普通方法（非抽象方法）
    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;
?>

Implementação do código acima, a saída é:

ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2

estática de palavras-chave

Declare propriedades ou métodos de classe como estáticos (estático), você não pode instanciar a classe e acesso directo.

propriedade estática através de uma classe não pode ser instanciado objeto para o acesso (mas método estático pode).

Como os métodos estáticos não são obrigados a chamar através do objeto, a pseudo-variável $ this não é disponível em um método estático.

Para acessar o operador> - Propriedade estática não pelo assunto.

Desde o PHP 5.3.0 em diante, você pode usar uma variável para chamar dinamicamente a classe. Mas o valor da variável não pode ser um auto palavra-chave, os pais ou estático.

<?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;
?>	

O programa acima, a saída é:

foo
foo

palavra-chave final

PHP 5 acrescenta uma palavra-chave final. Se o método de classe pai é declarado final, a subclasse não pode substituir esse método. Se uma classe é declarado final, que não podem ser herdadas.

O seguinte erro de execução de código:

<?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;
   }
}
// 报错信息 Fatal error: Cannot override final method BaseClass::moreTesting()
?>

Chamar o construtor da classe pai

O PHP não ligar automaticamente para o construtor do construtor da classe pai na subclasse. Para executar o construtor da classe pai, precisamos chamar opai no construtor da subclasse :: __ construct ().

<?php
class BaseClass {
   function __construct() {
       print "BaseClass 类中构造方法" . PHP_EOL;
   }
}
class SubClass extends BaseClass {
   function __construct() {
       parent::__construct();  // 子类构造方法不能自动调用父类的构造方法
       print "SubClass 类中构造方法" . PHP_EOL;
   }
}
class OtherSubClass extends BaseClass {
    // 继承 BaseClass 的构造方法
}

// 调用 BaseClass 构造方法
$obj = new BaseClass();

// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();

// 调用 BaseClass 构造方法
$obj = new OtherSubClass();
?>

O programa acima, a saída é:

BaseClass 类中构造方法
BaseClass 类中构造方法
SubClass 类中构造方法
BaseClass 类中构造方法