PHP Object-Oriented

Nella programmazione orientata agli oggetti (in inglese: la programmazione orientata agli oggetti, Abbreviazione: OOP), l'oggetto è una descrizione del trattamento dati e le informazioni che consiste di un tutto, è la vera astrazione mondo.

Le cose sono oggetti del mondo reale che abbiamo di fronte, come computer, televisori, biciclette.

Tre caratteristiche principali dell'oggetto:

• Comportamento dell'oggetto: un oggetto che può essere applicato al funzionamento, accendere le luci, spegnere le luci è un comportamento.
• oggetto Forma: Quando si applica questi metodi è come rispondere alla oggetto, colore, dimensione, forma.
• Rappresentazione dell'oggetto: un oggetto che rappresenta l'equivalente di identità, in particolare distinguere ciò che è diverso lo stesso comportamento e lo stato.

Ad esempio, Animal (animale) è una classe astratta, ci può essere specifico di una pecora con un cane, e il cane con le pecore è un obiettivo specifico, hanno un attributo di colore, è possibile scrivere, è possibile eseguire altri atti di stato.

contenuti orientata agli oggetti

• Class - definisce le caratteristiche astratte di una cosa.definizione di classe contiene i dati del modulo e le operazioni sui dati.

• Oggetti - è un'istanza della classe.

• Variabili dell'utente - variabili definite all'interno della classe.Il valore esterno della variabile non è visibile, ma può essere accessibile da funzioni membro, dopo che la classe è istanziata come oggetto, le proprietà dell'oggetto può essere chiamato una variabile.

• funzione dell'utente - definita all'interno della classe può essere utilizzato per oggetti di accesso ai dati.

• Ereditarietà - L'ereditarietà è una sottoclasse di condivisione automatica delle strutture e dei metodi della classe genitore, che è una relazione tra classi di dati.Nella definizione e l'attuazione di una classe, possono venire in questa base esiste già effettuato, questa classe già esistente come definito dal contenuto del loro contenuto, e aggiungere alcuni nuovi contenuti.

• classe genitore - una classe ereditata da altre classi, la classe può essere chiamato il genitore di classe, gruppo o classe, o superclasse.

• Sottoclasse - una classe che eredita un'altra classe viene chiamato una sottoclasse può anche essere chiamata una classe derivata.

• Polimorfismo - Polimorfismo si riferisce alla stessa operazione o funzione, il processo può essere applicato ai diversi tipi di oggetti e ottenere risultati diversi.Oggetti diversi, si ricevono lo stesso messaggio può produrre risultati diversi, questo fenomeno è chiamato polimorfismo.

• Overload - breve, è una funzione o metodo con lo stesso nome, ma l'elenco parametro non è la stessa situazione, tale funzione o un metodo tra i diversi parametri dello stesso nome, ogni funzione o metodo sovraccaricato viene chiamato.

• Riassunto - L'abstract si riferisce ad avere struttura coerente dei dati (attributi) e il comportamento (operazioni) di oggetti in classi.Tale classe è un'astrazione, riflette le importanti proprietà associati all'applicazione, ignorando altri contenuti estranei. Qualsiasi divisione in classi è soggettiva, ma deve essere messo in relazione alla specifica applicazione.

• Pacchetti - Pacchetti riferisce alle proprietà e il comportamento di un oggetto nel mondo reale esiste per legare insieme e collocato in una unità logica.

• Constructor - principalmente utilizzato per inizializzare l'oggetto quando si crea un oggetto, l'oggetto viene assegnato un valore iniziale della variabile membro, utilizzare sempre la dichiarazione creazione di oggetti con l'operatore new.

• Destructor - destructor (destructor) e il costruttore Al contrario, quando la fine dell'oggetto del suo ciclo di vita (per esempio, in cui l'oggetto è una chiamata di funzione è completata), il sistema esegue automaticamente distruttore.I distruttori sono spesso utilizzati per fare "ripulire le conseguenze di" lavoro (ad esempio, quando si crea un oggetto con uno nuovo aperto lo spazio di memoria deve essere utilizzato prima di uscire nel distruttore eliminare release).

La figura seguente creiamo tre oggetti di classe Auto: Mercedes, Bmw e Audi.

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

definizione di classe PHP

PHP classe personalizzata di solito sintassi è la seguente:

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

Interpretato come segue:

• Dopo la classe utilizzandola parola chiave classpiù il nome della definizione di classe.

• Una coppia di parentesi dopo il nome della classe può definire variabili e metodi ({}) all'interno.

• variabili di classe che utilizzanovar per dichiarare le variabili possono essere inizializzati valori.

• PHP definizione di funzione è simile alla definizione della funzione, ma la funzione è accessibile solo attraverso la classe ei relativi oggetti istanziati.

Esempi

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

$ Questa variabile rappresentano i loro oggetti.

PHP_EOL nuova riga.

PHP per creare oggetti

Dopo aver creato la classe, possiamo usare l'operatorenew per istanziare un oggetto della classe:

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

Il codice di cui sopra creiamo tre oggetti, ognuno dei tre oggetti sono indipendenti, quindi guardiamo a come accedere ai metodi membri e le variabili membro.

Chiama il metodo membro

Dopo che l'oggetto viene creata un'istanza, possiamo usare l'oggetto per chiamare un metodo membro, il metodo dell'oggetto non può che essere un membro della variabile membro operativo dell'oggetto:

// 调用成员函数，设置标题和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();

Il codice completo è il seguente:

L'attuazione del codice di cui sopra, l'output è:

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

PHP Costruttore

Constructor è un metodo speciale. Principalmente utilizzato per inizializzare l'oggetto quando si crea un oggetto, l'oggetto viene assegnato un valore iniziale della variabile membro, utilizzare sempre l'istruzione creazione di oggetti con l'operatore new.

PHP 5 consente sviluppatori di definire una riga metodo in una classe come una sintassi costruttore è la seguente:

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

Nel precedente esempio, siamo in grado di inizializzare il $ url e la variabile titolo $ tramite il costruttore:

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

Ora non abbiamo bisogno di chiamare il metodo setTitle e setURL:

destructor

Destructor (destructor) e il costruttore Al contrario, quando la fine dell'oggetto del suo ciclo di vita (per esempio, in cui l'oggetto è una chiamata di funzione è completata), il sistema esegue automaticamente distruttore.

PHP 5 introduce il concetto di un distruttore, che è simile ad altri linguaggi orientati agli oggetti, la sintassi è la seguente:

void __destruct ( void )

Esempi

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

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

$obj = new MyDestructableClass();
?>

L'attuazione del codice di cui sopra, l'output è:

构造函数
销毁 MyDestructableClass

ereditare

PHPestende parola chiave per ereditare una classe PHP non supporta l'ereditarietà multipla, nel seguente formato:

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

Esempi

Esempio di classe Child_Site eredita la classe del sito, e estende le funzionalità:

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

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

override del metodo

Se non è possibile soddisfare le esigenze di una sottoclasse eredita dalla metodo della classe genitore, può essere riscritta, un processo chiamato sovrapposizione metodo (override), noto anche come il metodo prevalente.

Esempio riscritto getURL e getTitle metodi:

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

Access Control

PHP sulla proprietà o metodo di controllo di accesso è ottenuto aggiungendo parole chiave davanti al pubblico (pubblico), protetto (protetto) o privato (privato) per ottenere.

• pubblico (pubblico): membro della classe pubblico può accedere ovunque.
• protetta (protetto): membro della classe protetta si può accedere dal proprio così come la sua sotto-classe e la classe genitore.
• privato (privato): i membri della classe private sono accessibili solo dove la definizione di classe.

attributi di controllo accessi

attributo di classe deve essere definito come, protetto, uno pubblico e privato. Se si definisce con il var, è considerato pubblico.

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

?>

metodi di controllo di accesso

Metodo della classe può essere definita come pubblica, privata o protetta. Se non si impostano queste parole chiave, il metodo di default è pubblico.

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

interfaccia

Utilizzando l'interfaccia (interfaccia), è possibile specificare quali metodi di una classe deve implementare, ma non è necessario definire il contenuto specifico di questi metodi.

L'interfaccia è definitadalla parola chiave interfaccia,come la definizione di una classe standard, ma che definisce tutti i metodi sono vuoti.

Tutti i metodi definiti nell'interfaccia devono essere pubbliche, che è caratteristica dell'interfaccia.

Per implementare un'interfaccia, utilizzare l'operatoreattrezzi.La classe deve implementare tutti i metodi definiti in un'interfaccia, oppure segnalerà un errore fatale. Classe può implementare più interfacce, utilizzare le virgole per separare i nomi di interfacce multiple.

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

costante

È possibile inserire nella classe rimane gli stessi valori definiti come costanti. Nella definizione e l'uso delle costanti di tempo non è necessario utilizzare il simbolo $.

Il valore della costante deve essere un valore fisso, non una variabile, gli attributi di classe, i risultati di matematica o di chiamata di funzione.

Dal PHP 5.3.0 in poi, è possibile utilizzare una variabile per richiamare in modo dinamico la classe. Ma il valore della variabile non può essere una parola chiave (es sé, genitore o statico).

Esempi

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

Ogni classe, se contiene almeno un metodo astratto è dichiarato, allora questa classe deve essere dichiarata come astratta.

È definito come una classe astratta non può essere istanziato.

È definito come un metodo astratto dichiara solo la sua invocazione (parametri), non è possibile definire l'implementazione specifica funzione.

Ereditare una classe astratta, sottoclasse deve tutte le definizioni dei metodi di classe genitore astratti, inoltre, l'accesso a questi metodi di controllo e la classe genitore deve essere lo stesso (o più rilassato). Ad esempio, un metodo astratto è dichiarato protetto, allora il metodo implementato nel sottoclasse dovrebbe essere dichiarato come protetti o pubblico, ma non può essere definito come privati. Chiamato anche il metodo deve corrispondere, cioè il tipo e il numero di parametri necessari devono essere coerenti. Ad esempio, una sottoclasse definisce un parametro opzionale, e la dichiarazione del metodo astratto classe padre non c'è, allora non c'è alcun conflitto tra le due affermazioni.

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

L'attuazione del codice di cui sopra, l'output è:

ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2

Statico parola chiave

Dichiarare proprietà delle classi o metodi come statico (Static), non è possibile creare un'istanza della classe e l'accesso diretto.

Proprietà statica attraverso una classe non può essere istanziato oggetto di accesso (ma metodo statico Can).

Poiché i metodi statici non sono tenuti a chiamare attraverso l'oggetto, il $ pseudo-variabile questa non è disponibile in un metodo statico.

Per accedere al> operatore - Proprietà statica non dal soggetto.

Dal PHP 5.3.0 in poi, è possibile utilizzare una variabile per richiamare in modo dinamico la classe. Ma il valore della variabile non può essere una parola chiave sé, genitore o statico.

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

Il programma precedente, l'uscita è:

foo
foo

Parole chiave di finale

PHP 5 aggiunge una parola chiave finale. Se il metodo della classe genitore è dichiarata definitiva, la sottoclasse non può ignorare questo metodo. Se una classe è dichiarata definitiva, non può essere ereditata.

Il seguente errore l'esecuzione di codice:

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

Chiamare il costruttore della classe genitore

PHP non chiama automaticamente il costruttore del costruttore della classe genitore in sottoclasse. Per eseguire il costruttore della classe genitore, abbiamo bisogno di chiamare ilgenitore nel costruttore della sottoclasse :: __ 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();
?>

Il programma precedente, l'uscita è:

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