Danish (Dansk) translation by Hamdan Veerlax (you can also view the original English article)
For mange PHP programmører er objekt-orienteret programmering et skræmmende koncept, fuld af komplicerede syntaks og andre vejspærringer. Som beskrevet i min bog, Pro PHP og jQuery, du vil lære begreberne bag objekt-orienteret programmering (OOP), en stil af kodning i hvilke relaterede handlinger grupperes i klasser, støtte til at skabe mere kompakt, effektiv kode.
Forståelse af Objekt Orienteret Programmering
Objekt-orienteret programmering er en stil af kodning, der gør det muligt for udviklere at gruppere lignende opgaver i klasser. Dette hjælper med at holde kode efter princippet ''gentage dig selv'' (DRY) og let-at-vedligeholde.
"Objekt-orienteret programmering er en stil af kodning, der gør det muligt for udviklere at gruppere lignende opgaver i klasser."
En af de store fordele ved DRY programmering er, at hvis en del oplysninger ændrer sig i dit program, er det normalt kun en ændring der kræves for at opdatere koden. En af de største mareridt for udviklere opretholde kode hvor data er erklæret igen og igen, hvilket betyder, at eventuelle ændringer til programmet blive et uendeligt mere frustrerende spil af Where's Waldo? som de jage dublerede data og funktionalitet.
OOP er skræmmende på en masse udviklere, fordi det introducerer nye syntaks og et overblik, synes at være langt mere kompleks end simpel proceduremæssige eller inline, kode. Men ved nærmere eftersyn, OOP er faktisk en meget ligetil og i sidste ende enklere tilgang til programmering.
Forståelse Objekter og Klasser
Før du kan få for dybt ind i de finere punkter i OOP, en grundlæggende forståelse af forskellene mellem objekter og klasser er nødvendigt. Dette afsnit vil gå over byggestenene i klasser, deres forskellige kapaciteter, og nogle af deres anvendelser.
Anerkende for Skellene Mellem Objekter og Klasser
Udviklere begynde at tale om objekter og klasser, og de synes at være indbyrdes udskiftelige vilkår. Det er dog ikke, tilfældet.
Lige fra bat, der er forvirring i OOP: erfaren udviklere begynde at tale om objekter og klasser, og de synes at være indbyrdes udskiftelige vilkår. Dette er ikke tilfældet, men selvom forskellen kan være svært at wrap dit hoved rundt i første omgang.
En klasse er for eksempel, som en plan for et hus. Det definerer husets form på papir, med forhold mellem de forskellige dele af huset klart defineret og planlagt ud, selv om huset ikke eksisterer.
Et objekt er da som det egentlige hus bygget i henhold til den pågældende plan. Data gemt i objektet er ligesom træ, ledninger, og konkret at komponere huset: uden samlet efter opskriften, det er bare en bunke af ting. Men når det hele kommer sammen, bliver det en organiseret, nyttigt hus.
Klasser udgør strukturen i data og handlinger og bruge disse oplysninger til at opbygge objekter. Mere end ét objekt kan bygges fra samme klasse på samme tid, hver en uafhængig af de andre. Fortsætter med vores byggeri analogi, det er lig den måde en hel inddeling kan bygges fra den samme blueprint: 150 forskellige huse at alle ser det samme, men har forskellige
familier og dekorationer inde.
Strukturering af Klasser
Syntaxen for at oprette en klasse er ret ligetil: Erklære en klasse ved hjælp af klassens søgeord, efterfulgt af klassens navn og et sæt krøllede seler ({}):
<?php
class MyClass
{
// Class properties and methods go here
}
?> Efter at skabe klassen, kan en ny klasse instantieres og gemt i en variabel ved hjælp af de nye søgeord:
$obj = new MyClass;
For at se indholdet af klassen, bruge var_dump():
var_dump($obj);
Prøv denne proces ved at sætte alle de foregående kode i en ny fil, der hedder test.php i [din lokale] testmappe:
<?php
class MyClass
{
// Class properties and methods go here
}
$obj = new MyClass;
var_dump($obj);
?> Indlæse siden i din browser på http://localhost/test.php og følgende skal vises:
object(MyClass)#1 (0) { } I sin enkleste form, har du lige fuldført din første OOP script.
Definere Klassee Genskaber
For at tilføje data til en klasse, der egenskaber eller klasse-specifikke variabler, bruges. Disse virker præcis ligesom regelmæssige variabler, bortset fra at de er bundet til objektet og derfor kan kun tilgås ved hjælp af objektet.
Føje en egenskab til MinKlasse, skal du tilføje følgende kode til dit script:
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
}
$obj = new MyClass;
var_dump($obj);
?> Nøgleordet offentlig bestemmer synligheden af den ejendom, som du vil lære om lidt senere i dette kapitel. Derefter, navngives ejendommen vha. Standard variabel syntax, og en værdi er tildelt (selvom klasseegenskaber ikke har brug for en indledende værdi).
At læse denne egenskab og output det til browseren, referere til objektet fra at læse og egenskaben læses:
echo $obj->prop1;
Fordi flere forekomster af en klasse kan eksistere, hvis det enkelte objekt ikke refererer til, ville scriptet være i stand til at bestemme hvilket objekt til at læse fra. Brugen af pilen (->) er en OOP konstruktion, der giver adgang til de indeholdte egenskaber og metoder af et givet objekt.
Redigere scriptet i test.php læse egenskaben i stedet for dumping hele klassen ved at ændre koden, som vist:
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
}
$obj = new MyClass;
echo $obj->prop1; // Output the property
?> Genindlæse din browser nu viser følgende:
I'm a class property!
Definerende Klasse Metoder
Metoder er klasse-specifikke funktioner. Individuelle handlinger, at et objekt vil være i stand til at udføre er defineret inden for klassen som metoder.
For eksempel, for at skabe metoder, der ville indstille og få værdien af egenskaben klasse $prop1, skal du tilføje følgende i din kode:
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . "<br />";
}
}
$obj = new MyClass;
echo $obj->prop1;
?> Bemærk – OOP tillader objekter at referere til sig selv ved hjælp af $this. Når du arbejder i en metode, skal du bruge $this på samme måde du ville bruge objektnavn uden for klassen.
At bruge disse metoder, kalder dem ligesom regelmæssige funktioner, men først skal referere til objektet de tilhører. Læse egenskaben fra MinKlasse, ændre dens værdi, og læse den igen ved at foretage de ændringer i nedenstående:
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . "<br />";
}
}
$obj = new MyClass;
echo $obj->getProperty(); // Get the property value
$obj->setProperty("I'm a new property value!"); // Set a new one
echo $obj->getProperty(); // Read it out again to show the change
?> Genindlæse din browser, og du vil se følgende:
I'm a class property! I'm a new property value!
"Magt af OOP bliver synlige, når du bruger flere forekomster af den
samme klasse."
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . "<br />";
}
}
// Create two objects
$obj = new MyClass;
$obj2 = new MyClass;
// Get the value of $prop1 from both objects
echo $obj->getProperty();
echo $obj2->getProperty();
// Set new values for both objects
$obj->setProperty("I'm a new property value!");
$obj2->setProperty("I belong to the second instance!");
// Output both objects' $prop1 value
echo $obj->getProperty();
echo $obj2->getProperty();
?> Når du indlæser resultaterne i din browser, lyder de som følger:
I'm a class property! I'm a class property! I'm a new property value! I belong to the second instance!
Som du kan se, holder OOP objekter som separate enheder, hvilket gør for nem adskillelse af forskellige stykker af kode i små, relaterede bundter.
Magiske metoder i OOP
For at lette brugen af objekter, indeholder PHP også en række magiske metoder, eller specielle metoder, der kaldes, når visse fælles handlinger finder sted inden for objekter. Dette giver udviklere til at udføre en række nyttige opgaver med relativ lethed.
Brug af Byggere og Destruktorer
Når et objekt instantieres, er det ofte ønskeligt at fastsætte et par ting ret off bat. For at håndtere dette, giver PHP magiske metoden __construct(), som kaldes automatisk, når et nyt objekt er
oprettet.
Med henblik på at illustrere begrebet konstruktører, tilføje en konstruktør til MinKlasse, der vil output en besked hver gang en ny forekomst af klassen er oprettet:
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
public function __construct()
{
echo 'The class "', __CLASS__, '" was initiated!<br />';
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . "<br />";
}
}
// Create a new object
$obj = new MyClass;
// Get the value of $prop1
echo $obj->getProperty();
// Output a message at the end of the file
echo "End of file.<br />";
?> Bemærk — __CLASS__ returnerer navnet på den klasse, som det kaldes; Dette er, hvad er kendt som en magisk konstant. Der er flere tilgængelige magiske konstanter, som du kan læse mere om i PHP manual.
Genindlæse filen i din browser vil give følgende resultat:
The class "MyClass" was initiated! I'm a class property! End of file.
For at kalde en funktion, når objektet er ødelagt, er den __destruct() magiske metode tilgængelig. Dette er nyttigt for klasse oprydning (lukke en databaseforbindelse, for eksempel).
Output en besked, når objektet er ødelagt ved at definere den magiske metode__destruct() i MinKlasse:
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
public function __construct()
{
echo 'The class "', __CLASS__, '" was initiated!<br />';
}
public function __destruct()
{
echo 'The class "', __CLASS__, '" was destroyed.<br />';
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . "<br />";
}
}
// Create a new object
$obj = new MyClass;
// Get the value of $prop1
echo $obj->getProperty();
// Output a message at the end of the file
echo "End of file.<br />";
?> Med en destructor defineret, genindlæse filen testresultater i følgende output:
The class "MyClass" was initiated! I'm a class property! End of file. The class "MyClass" was destroyed.
"Når slutningen af en fil er nået, PHP frigiver automatisk alle ressourcer."
For at eksplicit udløse destructor, du kan ødelægge objekt ved hjælp af den
funktionen unset():
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
public function __construct()
{
echo 'The class "', __CLASS__, '" was initiated!<br />';
}
public function __destruct()
{
echo 'The class "', __CLASS__, '" was destroyed.<br />';
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . "<br />";
}
}
// Create a new object
$obj = new MyClass;
// Get the value of $prop1
echo $obj->getProperty();
// Destroy the object
unset($obj);
// Output a message at the end of the file
echo "End of file.<br />";
?> Nu ændres resultatet til følgende, når indlæst i din browser:
The class "MyClass" was initiated! I'm a class property! The class "MyClass" was destroyed. End of file.
Konvertering til en Streng
For at undgå en fejl, hvis et script forsøger at output MinKlasse som en streng, er en anden magiske metode brugt kaldet __toString().
Uden __toString(), forsøger at output objektet som en streng resultater i en fatal fejl. Forsøg at bruge echo til output objekt uden et magisk metode på plads:
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
public function __construct()
{
echo 'The class "', __CLASS__, '" was initiated!<br />';
}
public function __destruct()
{
echo 'The class "', __CLASS__, '" was destroyed.<br />';
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . "<br />";
}
}
// Create a new object
$obj = new MyClass;
// Output the object as a string
echo $obj;
// Destroy the object
unset($obj);
// Output a message at the end of the file
echo "End of file.<br />";
?> Dette resulterer i følgende:
The class "MyClass" was initiated! Catchable fatal error: Object of class MyClass could not be converted to string in /Applications/XAMPP/xamppfiles/htdocs/testing/test.php on line 40
Du kan undgå denne fejl, skal du tilføje en __toString() metode:
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
public function __construct()
{
echo 'The class "', __CLASS__, '" was initiated!<br />';
}
public function __destruct()
{
echo 'The class "', __CLASS__, '" was destroyed.<br />';
}
public function __toString()
{
echo "Using the toString method: ";
return $this->getProperty();
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . "<br />";
}
}
// Create a new object
$obj = new MyClass;
// Output the object as a string
echo $obj;
// Destroy the object
unset($obj);
// Output a message at the end of the file
echo "End of file.<br />";
?> I dette tilfælde forsøger at konvertere objektet til en streng resultater i et kald til metoden getProperty(). Indlæse test script i din browser for at se resultatet:
The class "MyClass" was initiated! Using the toString method: I'm a class property! The class "MyClass" was destroyed. End of file.
Tip — Ud over de magiske metoder omtales i dette afsnit, flere andre er tilgængelige. For en komplet liste over magiske metoder, se PHP manual side.
Ved hjælp af klasse arv
Klasser kan arve metoder og egenskaber i en anden klasse bruger den udvider søgeord. For eksempel, hvis du vil oprette en anden klasse, der udvider MinKlasse og tilføjer en metode, ville du tilføje følgende til din test-fil:
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
public function __construct()
{
echo 'The class "', __CLASS__, '" was initiated!<br />';
}
public function __destruct()
{
echo 'The class "', __CLASS__, '" was destroyed.<br />';
}
public function __toString()
{
echo "Using the toString method: ";
return $this->getProperty();
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . "<br />";
}
}
class MyOtherClass extends MyClass
{
public function newMethod()
{
echo "From a new method in " . __CLASS__ . ".<br />";
}
}
// Create a new object
$newobj = new MyOtherClass;
// Output the object as a string
echo $newobj->newMethod();
// Use a method from the parent class
echo $newobj->getProperty();
?> Ved ladning test-fil i din browser, er følgende output:
The class "MyClass" was initiated! From a new method in MyOtherClass. I'm a class property! The class "MyClass" was destroyed.
Overskrivning af arvelige egenskaber og metoder
For at ændre funktionaliteten af en eksisterende egenskab eller metode i den nye klasse, kan du blot overskrive det ved at erklære det igen i den nye klasse:
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
public function __construct()
{
echo 'The class "', __CLASS__, '" was initiated!<br />';
}
public function __destruct()
{
echo 'The class "', __CLASS__, '" was destroyed.<br />';
}
public function __toString()
{
echo "Using the toString method: ";
return $this->getProperty();
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . "<br />";
}
}
class MyOtherClass extends MyClass
{
public function __construct()
{
echo "A new constructor in " . __CLASS__ . ".<br />";
}
public function newMethod()
{
echo "From a new method in " . __CLASS__ . ".<br />";
}
}
// Create a new object
$newobj = new MyOtherClass;
// Output the object as a string
echo $newobj->newMethod();
// Use a method from the parent class
echo $newobj->getProperty();
?> Dette ændrer output i browseren til at:
A new constructor in MyOtherClass. From a new method in MyOtherClass. I'm a class property! The class "MyClass" was destroyed.
Bevare oprindelige metode funktionalitet mens overskrive metoder
For at tilføje ny funktionalitet til en arvelig metode samtidig med den oprindelige metode intakt, skal du bruge nøgleordet forælder med rækkevidde resolution operatør (:):
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
public function __construct()
{
echo 'The class "', __CLASS__, '" was initiated!<br />';
}
public function __destruct()
{
echo 'The class "', __CLASS__, '" was destroyed.<br />';
}
public function __toString()
{
echo "Using the toString method: ";
return $this->getProperty();
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
public function getProperty()
{
return $this->prop1 . "<br />";
}
}
class MyOtherClass extends MyClass
{
public function __construct()
{
parent::__construct(); // Call the parent class's constructor
echo "A new constructor in " . __CLASS__ . ".<br />";
}
public function newMethod()
{
echo "From a new method in " . __CLASS__ . ".<br />";
}
}
// Create a new object
$newobj = new MyOtherClass;
// Output the object as a string
echo $newobj->newMethod();
// Use a method from the parent class
echo $newobj->getProperty();
?> Det viser resultatet af både forælder constructoren og den nye klasse konstruktør:
The class "MyClass" was initiated! A new constructor in MyOtherClass. From a new method in MyOtherClass. I'm a class property! The class "MyClass" was destroyed.
Tildeling af synligheden af egenskaber og metoder
For ekstra kontrol over objekter, er metoder og egenskaber tildelt synlighed. Dette styrer, hvordan og hvor egenskaber og metoder kan tilgås. Der er tre sigtbarhed søgeord: offentlig, beskyttet og privat. Ud over dets synlighed, kan en metode eller egenskab erklæres som statisk, som gør det muligt for dem at få adgang til uden en instantiering af klassen.
"Ekstra kontrol over objekter, metoder og egenskaber er tildelt synlighed."
Bemærk – Synlighed er en ny funktion i PHP 5. For oplysninger om OOP kompatibilitet med PHP 4, se PHP manual side.
Offentlige egenskaber og metoder
Alle metoder og egenskaber du har brugt hidtil har været offentlige. Dette betyder, at de kan tilgås hvor som helst, både inden for klassen og eksternt.
Beskyttede egenskaber og metoder
Når en ejendom eller metode er erklæret beskyttet, kan den kun fås i selve klassen eller i efterkommende klasser (klasser, der udvider klassen, der indeholder den beskyttede metode).
Erklære getProperty() metoden, som beskyttet i MinKlasse og forsøger at få adgang til det direkte fra uden for klassen:
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
public function __construct()
{
echo 'The class "', __CLASS__, '" was initiated!<br />';
}
public function __destruct()
{
echo 'The class "', __CLASS__, '" was destroyed.<br />';
}
public function __toString()
{
echo "Using the toString method: ";
return $this->getProperty();
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
protected function getProperty()
{
return $this->prop1 . "<br />";
}
}
class MyOtherClass extends MyClass
{
public function __construct()
{
parent::__construct();
echo "A new constructor in " . __CLASS__ . ".<br />";
}
public function newMethod()
{
echo "From a new method in " . __CLASS__ . ".<br />";
}
}
// Create a new object
$newobj = new MyOtherClass;
// Attempt to call a protected method
echo $newobj->getProperty();
?> Når du forsøger at køre dette script, vises følgende fejl:
The class "MyClass" was initiated! A new constructor in MyOtherClass. Fatal error: Call to protected method MyClass::getProperty() from context '' in /Applications/XAMPP/xamppfiles/htdocs/testing/test.php on line 55
Nu, oprette en ny metode i MyOtherClass til at kalde metoden getProperty():
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
public function __construct()
{
echo 'The class "', __CLASS__, '" was initiated!<br />';
}
public function __destruct()
{
echo 'The class "', __CLASS__, '" was destroyed.<br />';
}
public function __toString()
{
echo "Using the toString method: ";
return $this->getProperty();
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
protected function getProperty()
{
return $this->prop1 . "<br />";
}
}
class MyOtherClass extends MyClass
{
public function __construct()
{
parent::__construct();
echo "A new constructor in " . __CLASS__ . ".<br />";
}
public function newMethod()
{
echo "From a new method in " . __CLASS__ . ".<br />";
}
public function callProtected()
{
return $this->getProperty();
}
}
// Create a new object
$newobj = new MyOtherClass;
// Call the protected method from within a public method
echo $newobj->callProtected();
?> Dette skaber det ønskede resultat:
The class "MyClass" was initiated! A new constructor in MyOtherClass. I'm a class property! The class "MyClass" was destroyed.
Private Ejendomme og Metoder
En egenskab eller metode erklæret privat er tilgængelige kun fra den klasse der definerer det. Det betyder, at selv om en ny klasse udvider den klasse, der definerer en privat ejendom, at egenskab eller metode ikke vil være tilgængelige på alle i klassen barn.
Dette kan demonstreres erklære getProperty() som privat i MinKlasse, og forsøger at kalde callProtected() fraMyOtherClass:
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
public function __construct()
{
echo 'The class "', __CLASS__, '" was initiated!<br />';
}
public function __destruct()
{
echo 'The class "', __CLASS__, '" was destroyed.<br />';
}
public function __toString()
{
echo "Using the toString method: ";
return $this->getProperty();
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
private function getProperty()
{
return $this->prop1 . "<br />";
}
}
class MyOtherClass extends MyClass
{
public function __construct()
{
parent::__construct();
echo "A new constructor in " . __CLASS__ . ".<br />";
}
public function newMethod()
{
echo "From a new method in " . __CLASS__ . ".<br />";
}
public function callProtected()
{
return $this->getProperty();
}
}
// Create a new object
$newobj = new MyOtherClass;
// Use a method from the parent class
echo $newobj->callProtected();
?> Genindlæse din browser, og følgende fejl vises:
The class "MyClass" was initiated! A new constructor in MyOtherClass. Fatal error: Call to private method MyClass::getProperty() from context 'MyOtherClass' in /Applications/XAMPP/xamppfiles/htdocs/testing/test.php on line 49
Statiske Egenskaber og Metoder
En metode eller egenskab erklæret statisk kan tilgås uden første instantiere klassen; du leverer blot klassenavnet, rækkevidde resolution operatør og navnet egenskab eller metode.
"En af de store fordele ved at bruge statiske egenskaber er, at de holder deres lagrede værdier for varighed af scriptet."
For at demonstrere dette, tilføje en statisk egenskab, der kaldes $count og en statisk metode kaldet plusOne() til MinKlasse. Derefter oprette en do...while loop til output forøget værdien af $count så længe værdien er mindre end 10:
<?php
class MyClass
{
public $prop1 = "I'm a class property!";
public static $count = 0;
public function __construct()
{
echo 'The class "', __CLASS__, '" was initiated!<br />';
}
public function __destruct()
{
echo 'The class "', __CLASS__, '" was destroyed.<br />';
}
public function __toString()
{
echo "Using the toString method: ";
return $this->getProperty();
}
public function setProperty($newval)
{
$this->prop1 = $newval;
}
private function getProperty()
{
return $this->prop1 . "<br />";
}
public static function plusOne()
{
return "The count is " . ++self::$count . ".<br />";
}
}
class MyOtherClass extends MyClass
{
public function __construct()
{
parent::__construct();
echo "A new constructor in " . __CLASS__ . ".<br />";
}
public function newMethod()
{
echo "From a new method in " . __CLASS__ . ".<br />";
}
public function callProtected()
{
return $this->getProperty();
}
}
do
{
// Call plusOne without instantiating MyClass
echo MyClass::plusOne();
} while ( MyClass::$count < 10 );
?> Bemærk — Ved adgang til statiske egenskaber, dollaren underskrive
($) kommer efter rækkevidde resolution operatør.
Når du indlæser denne script i din browser, er følgende output:
The count is 1. The count is 2. The count is 3. The count is 4. The count is 5. The count is 6. The count is 7. The count is 8. The count is 9. The count is 10.
Kommentere med DocBlocks
"DocBlock kommenterede stil er et bredt
accepteret metode til at dokumentere klasser."
Mens ikke en officiel del af OOP er DocBlock kommenterede stil en bredt accepteret metode til at dokumentere klasser. Bortset fra at levere en standard for
udviklere kan bruge, når du skriver kode, det er også blevet vedtaget af mange af de mest populære devkits (SDK'er), som Eclipse og NetBeans, og vil blive brugt til at generere kode hints.
En DocBlock er defineret ved hjælp af en blok kommentar, der starter med en ekstra stjerne:
/** * This is a very basic DocBlock */
Den reelle magt i DocBlocks kommer med evnen til at bruge tags, som starter med en på symbol (@) umiddelbart efterfulgt af tag navn og værdi af tag. DocBlock tags giver udviklere til at definere forfatterne af en fil, licensen til en klasse, egenskaben eller metoden oplysninger og andre nyttige oplysninger.
De mest almindelige tags anvendes følge:
- @author: forfatteren af det aktuelle element, (som kan være en klasse, fil, metode eller enhver smule kode) er angivet ved hjælp af dette mærke. Flere forfatter tags kan bruges i den samme DocBlock, hvis mere end én forfatter er krediteret. Formatet for forfatterens navn er
John Doe <john.doe@email.com>. - @copyright: Dette betyder ophavsretten år og navnet på indehaveren af ophavsretten til det aktuelle element. Formatet er
2010 Copyright indehaver. - @license: Dette links til licensen til det aktuelle element. Formatet for licens information er
http://www.example.com/Path/to/License.txt licens benævne. - @var: Dette gælder type og beskrivelse af en variabel eller klasse ejendom. Formatet er
type element beskrivelse. - @param: Denne tag viser type og beskrivelse af en funktion eller metode parameter. Formatet er
type $element_name elementbeskrivelse. - @return: Den type og beskrivelse af den returnerede værdi af en funktion eller metode er fastsat i dette mærke. Formatet er
type returelement beskrivelse.
En prøve klasse kommenteret med DocBlocks kunne se således ud:
<?php
/**
* A simple class
*
* This is the long description for this class,
* which can span as many lines as needed. It is
* not required, whereas the short description is
* necessary.
*
* It can also span multiple paragraphs if the
* description merits that much verbiage.
*
* @author Jason Lengstorf <jason.lengstorf@ennuidesign.com>
* @copyright 2010 Ennui Design
* @license http://www.php.net/license/3_01.txt PHP License 3.01
*/
class SimpleClass
{
/**
* A public variable
*
* @var string stores data for the class
*/
public $foo;
/**
* Sets $foo to a new value upon class instantiation
*
* @param string $val a value required for the class
* @return void
*/
public function __construct($val)
{
$this->foo = $val;
}
/**
* Multiplies two integers
*
* Accepts a pair of integers and returns the
* product of the two.
*
* @param int $bat a number to be multiplied
* @param int $baz a number to be multiplied
* @return int the product of the two parameters
*/
public function bar($bat, $baz)
{
return $bat * $baz;
}
}
?> Når du scanner den foregående klasse, fordelene ved DocBlock er synlige: alt er klart defineret, således at næste udvikleren kan afhente koden og behøver ikke at spekulerer på, hvad et kodestykke betyder eller hvad den skal indeholde.
Sammenligning af Objekt-Orienteret og Proceduremæssige Kode
Der er ikke rigtig en rigtigt og forkert måde at skrive kode. Når det er sagt, beskrives i dette afsnit et stærkt argument for et objekt-orienteret tilgang i softwareudvikling, især i store applikationer.
Årsag 1: Lethed i Gennemførelsen
"Selv om det kan være skræmmende ved første, OOP faktisk giver en nemmere tilgang til at håndtere data."
Mens det kan være skræmmende ved første, OOP faktisk giver en nemmere tilgang til at håndtere data. Fordi et objekt kan gemme data internt, skal variabler ikke overføres fra funktion til funktionen kan fungere korrekt.
Også, fordi flere forekomster af samme klasse kan eksistere samtidig, beskæftiger sig med store datasæt er uendeligt lettere. For eksempel, Forestil dig du har to mennesker oplysninger der behandles i en fil. De har brug for navne, erhverv og aldre.
Den Processuelle Tilgang
Her er den processuelle tilgang til vores eksempel:
<?php
function changeJob($person, $newjob)
{
$person['job'] = $newjob; // Change the person's job
return $person;
}
function happyBirthday($person)
{
++$person['age']; // Add 1 to the person's age
return $person;
}
$person1 = array(
'name' => 'Tom',
'job' => 'Button-Pusher',
'age' => 34
);
$person2 = array(
'name' => 'John',
'job' => 'Lever-Puller',
'age' => 41
);
// Output the starting values for the people
echo "<pre>Person 1: ", print_r($person1, TRUE), "</pre>";
echo "<pre>Person 2: ", print_r($person2, TRUE), "</pre>";
// Tom got a promotion and had a birthday
$person1 = changeJob($person1, 'Box-Mover');
$person1 = happyBirthday($person1);
// John just had a birthday
$person2 = happyBirthday($person2);
// Output the new values for the people
echo "<pre>Person 1: ", print_r($person1, TRUE), "</pre>";
echo "<pre>Person 2: ", print_r($person2, TRUE), "</pre>";
?> Når henrettet, viser koden følgende:
Person 1: Array ( [name] => Tom [job] => Button-Pusher [age] => 34 ) Person 2: Array ( [name] => John [job] => Lever-Puller [age] => 41 ) Person 1: Array ( [name] => Tom [job] => Box-Mover [age] => 35 ) Person 2: Array ( [name] => John [job] => Lever-Puller [age] => 42 )
Mens denne kode er ikke nødvendigvis dårligt, er der en masse at huske på, mens kodning. Vifte af den berørte person attributter skal være bestået og vendte tilbage fra hvert funktionskald, der efterlader margin for fejl.
For at rydde op i dette eksempel, ville det være ønskeligt at efterlade så få ting op til bygherren som muligt. Eneste helt væsentlige oplysninger for den aktuelle operation skal overføres til funktionerne.
Dette er hvor OOP ind og hjælper dig med at rense ting.
OOP Tilgang
Her er OOP tilgang til vores eksempel:
<?php
class Person
{
private $_name;
private $_job;
private $_age;
public function __construct($name, $job, $age)
{
$this->_name = $name;
$this->_job = $job;
$this->_age = $age;
}
public function changeJob($newjob)
{
$this->_job = $newjob;
}
public function happyBirthday()
{
++$this->_age;
}
}
// Create two new people
$person1 = new Person("Tom", "Button-Pusher", 34);
$person2 = new Person("John", "Lever Puller", 41);
// Output their starting point
echo "<pre>Person 1: ", print_r($person1, TRUE), "</pre>";
echo "<pre>Person 2: ", print_r($person2, TRUE), "</pre>";
// Give Tom a promotion and a birthday
$person1->changeJob("Box-Mover");
$person1->happyBirthday();
// John just gets a year older
$person2->happyBirthday();
// Output the ending values
echo "<pre>Person 1: ", print_r($person1, TRUE), "</pre>";
echo "<pre>Person 2: ", print_r($person2, TRUE), "</pre>";
?> Dette viser følgende i browseren:
Person 1: Person Object ( [_name:private] => Tom [_job:private] => Button-Pusher [_age:private] => 34 ) Person 2: Person Object ( [_name:private] => John [_job:private] => Lever Puller [_age:private] => 41 ) Person 1: Person Object ( [_name:private] => Tom [_job:private] => Box-Mover [_age:private] => 35 ) Person 2: Person Object ( [_name:private] => John [_job:private] => Lever Puller [_age:private] => 42 )
Der er en lille smule mere setup involveret at gøre tilgang objektorienteret, men når klassen er defineret, oprettelse og redigering af mennesker er en brise; oplysninger om en persons behøver ikke at være bestået eller returneret fra metoder, og kun absolut oplysninger sendes videre til hver metode.
"OOP vil væsentligt reducere din arbejdsbyrde hvis gennemføres korrekt."
Denne forskel kan ikke virke som meget i lille målestok, men som dine applikationer vokse i størrelse, OOP markant vil reducere din arbejdsbyrde, hvis de gennemføres korrekt.
Tip — Ikke alt skal være objektorienteret. En hurtig funktion, der håndterer noget lille i ét sted i programmet behøver ikke nødvendigvis at være pakket ind i en klasse. Brug din bedste dømmekraft, når det besluttes mellem objekt-orienterede og proceduremæssige tilgange.
Årsag 2: Bedre organisation
En anden fordel ved OOP er, hvor godt det egner sig til at være let pakket og katalogiseret. Hver klasse kan generelt holdes i sin egen separat fil, og hvis en uniform naming convention bruges, adgang til klasserne er ekstremt simpelt.
Antage du har fået et program med 150 klasser, der kaldes dynamisk gennem en controller fil i roden af din ansøgning filsystem. Alle 150 klasser følge naming convention class.classname.inc.php og er placeret i mappen inc i din ansøgning.
Controlleren kan gennemføre PHP'S __autoload() funktion til dynamisk trække kun klasser det behov, som de kaldes, frem for at medtage alle 150 i filen controller tilfældes skyld eller kommer op med nogle smart måde herunder filerne i din egen kode :
<?php
function __autoload($class_name)
{
include_once 'inc/class.' . $class_name . '.inc.php';
}
?> At have hver klasse i en separat fil gør også kode mere bærbare og lettere at genbruge i nye programmer uden en masse kopiering og indsætning.
Årsag 3: Lettere Vedligeholdelse
På grund af den mere kompakte karakter af OOP, når det gøres korrekt, er ændringer i koden som regel meget nemmere at se og gøre end i en lang spagetti-kode proceduremæssig implementering.
Hvis en bestemt række oplysninger gevinster en ny attribut, kraeve en proceduremæssig stykke software (i et worst-case scenario), den nye attribut kan føjes til hver funktion, der bruger matrixen.
Et OOP program kunne potentielt blive opdateret som nemt føje den nye egenskab og derefter tilføje de metoder, der beskæftiger sig med nævnte ejendom.
En masse af de fordele, der er omfattet af dette afsnit er et produkt af OOP i kombination med TØRRE programmering praksis. Det er absolut muligt at skabe nem at vedligeholde proceduremæssige kode, der ikke forårsager mareridt, og det er ligeledes muligt at skabe forfærdelige objektorienteret kode. [Pro PHP og jQuery] vil forsøge at påvise en kombination af god kodning vaner i forbindelse med OOP til at generere ren kode, der er let at læse og bevare.
Resumé
På dette tidspunkt, du bør føle sig godt tilpas med den objekt-orienteret programmering stil. Læring OOP er en fantastisk måde at tage din programmering til det næste niveau. Når gennemføres korrekt, vil OOP hjælpe dig producere let at læse, let at vedligeholde, bærbare kode, der vil spare dig (og de udviklere, der arbejder sammen med dig) timers ekstra arbejde. Sidder du fast på noget, der ikke var dækket i denne artikel? Er du allerede bruger OOP og har nogle tips for begyndere? Dele dem i kommentarerne!
Author's Note — denne tutorial blev et uddrag fra Pro PHP og jQuery (Apress, 2010).
