OOP - Generel kode

Instantiering (H)

For at funktionaliteten i en klasse kan tages i brug fra et HTML-program (bortset fra "static") skal klassen knyttes til programmet - det kaldes, at klassen skal "instantieres". Det gøres som regel i HTML-programmets top-del eller - sjældnere - fra det sted i HTML-koden, hvor den pågældende klasse skal bruges. Instantiering kan dog også foretages fra en funktion

Klasser, der kun indeholder public-static funktioner, skal ikke instantieres.

$objCatalogue = new Catalogue();
$objKlassenavn = new Klassenavn();

Instantierede klasser kan navngives frit som enhver anden variabel. Det er dog god kodeskik at bruge "obj" som prefix og klassens navn som suffix.

Det der sker ved instantiering er rent teknisk, at objektkoden kopieres fra harddisk eller andet lagringsmedie og placeres (som oftest i HTML-koden) som værdidelen af en variabel. "new" fortæller PHP, at der er tale om objektdata.
Det indebærer, at objektkoden kan bruges et ubegrænset antal gange ved siden af hinanden og forskudt for hinanden uden at der kan ske datamæssig sammenblanding.

extends (K)

Ofte kan der være behov for at anvende den samme "ekstra" funktionalitet i flere klasser. Man etablerer da den ekstra funktionalitet i en klasse for sig og i stedet for at instantiere den knyttes ("extendes") den til de klasser, der har behov for dens funktionalitet.

Public og protected parametre og funktioner i den extendede klasse følger med, når den primære klasse instantieres.

extends minder lidt om include.

Det nok mest umiddelbare er (via klassen Dbconnect) at extende klassen Dbase til alle klasser der indeholder CRUD-kode. (Se Dbconnect nedenfor)

Abc.php programnavn

<?php
class Abc extends klassenavn{ Klassenavn med 'extends'
.....
}

Dbconnect (K)

I den bagved denne beskrivelse af OOP liggende kildekode anvendes klassenavnet "Application". Det kan dog nok give mere umiddelbar mening at anvende betegnelsen Dbconnect.

Til hver klasse, der indeholder CRUD-kode til en eller flere DB-tabeller extendes klassen Dbconnect (her Application).

class Order extends Application { ... }

Klassen Dbconnect anvendes til 3 ting:: - at etablere parameteret db; - at instantiere klassen Dbase med en __construct; - klassen Dbase knyttes til parameteret db

<?php
class Application {
   public $db ;
   public function __construct() {
   $this->db = new Dbase ();
   }
}

-> og :: samt $this og self (H+K)

Ved kald fra HTML-program eller funktion til en egenskab eller en funktion skal der altid angives sti og klassenavn til den (når den ikke automatisk findes via "framework").

Ved kald til en funktion indenfor aktuel klasse er der ingen sti at anføre, men "$this" eller "self" anvendes som stedfortræder for den manglende angivelse af sti og klassenavn.

"::" og "->" anvendes efter klassenavn som "fortegn" for, om det efterfølgende kald vedrører en "static" eller "non-static" egenskab eller funktion.

->	Bruges ved kald til private, protected og public egenskaber i funktioner i egen eller extended klasse. "Fortegn" for koden til kald af "non-static" egenskab eller funktion fra den foran anførte klasse. Ved kald i aktuel klasse anvendes "$this" som klassehavn. $category = $objCatalogue->getCategory($cat);
::	Bruges ved kald til "static" data. "Fortegn" for koden til kald af "static" egenskab eller funktion fra den foran anførte klasse. Ved kald i aktuel klasse anvendes "self" som klassehavn. cat= Url::getParam('category'); if(!self::isLogged(self::$_login_admin)) { ...

Funktionskald (H+K)

Alle funktioner (bortset fra __construct) skal kaldes udefra for at blive udført.

En funktion kan kaldes enten fra HTML-kode eller fra en funktion.

Funktioner uden return af data kan kaldes med funktionskald alene. For funktioner med return skal funktionskaldet derimod placeres som værdidelen af en variabel.

Fra HTML (H)

Start af funktioner fra HTML-programmer:

Uden "return"
Når der ikke skal sendes data ud af den kaldte funktion.

$core->run();
$klassenavn->funktionsnavn();
Med "return"
Når der skal sendes data retur fra den kaldte funktion til funktionskaldet.
Funktionskald opbygges som variabler.

$product = $objCatalogue->getProduct($id);
$variabelnavn = $navn på instantieret klasse->funktionsnavn(evt.parameter);
Static med "return"

$cat = Url::getParam('category');
$variabelnavn = Klassenavn::funktionsnavn(evt.parameter);

Fra Funktion (K)

Start af funktion fra anden funktion:

Uden "return"
Når der ikke skal sendes data ud af den kaldte funktion.

Med "return"
Når der skal sendes data retur fra den kaldte funktion til funktionskaldet.
Funktionskald opbygges som variabler.

public function getCategories() {
$sql = "SELECT * FROM `{$this->_table}`
ORDER BY `name` ASC";
return $this->db->fetchAll($sql);
}

public function fetchAll($sql) {
$result = $this->query($sql);
$out = array();
while($row = mysql_fetch_assoc($result)) {
$out[] = $row;
}
mysql_free_result($result);
return $out;
}

Funktionskald - parametre (H+K)

Til et funktionskald kan i (...) knyttes ingen, et eller flere parametre. Parametrene skal (evt. bortset fra statiske konstanter) være etablerede forinden som variabler eller egenskaber.

Ved parameternavne, der kommer fra egenskaber skal der ikke foranstilles $. I alle andre tilfælde skal $ foranstilles.

Paramerterdata kan tilføres en funktion fra parameterkald og / eller egenskaber. De kan opbygges som:

reference
Parameteret indsættes ved anførelse af dets navn. Det kan give problemer, hvis navnet ikke er defineret eller tilgængeligt.

$par-navn
værdi
Parameteret tilføres en default konstant værdi. Den overskrives, hvis parameteret er defineret variabel eller egenskab og har en anden værdi.
$par-navn = værdi
"null"
Parameteret vil altid enten have værdien "null" eller en tilført anden værdi fra variabel eller egenskab.
null-varianten er nyttig, da den er god at lave validering på.

$par-navn = null

if (!empty($this->_par_navn)) { .... }
else
{ .... }

Ved to eller flere parametre:: placeres de kommasepareret; placeres de efter "faldende vigtighed"

Return (K)

Opgaven er for mange funktioner at returnere data til brug i anden sammenhæng. Kommandoen "return" anvendes til at returnere de data, der er knyttet til den. Return kan kun returnere en ident. Det kan være værdien af en enkelt variabel, eller data for flere identer samlet i en array.

returner variabel
returner array

data født som array:

Der skal ikke foretages tilpasninger.

return $this->db->fetchAll($sql);

data født som variabler:

Der skal foretages følgende tilpasninger.

Return skal have et sted at returnere dataene til. Det etableres ved at opbygge funktionskaldet som en variabel, der har funktionskaldet som sin værdi. Efter udførelsen af funktionen indsætter return sine data som variablens værdi i stedet for funktionskaldet.

Kald
Return	return isset($_GET[$par]) && $_GET[$par] != "" ? $_GET[$par] : null

Kald	$category = $objCatalogue->getCategory($cat);
Return	public function getCategory($id) { $sql = "SELECT * FROM `{$this->_table}` WHERE `id` = '".$this->db->escape($id)."'"; return $this->db->fetchOne($sql); }

Kald
Return

Kald
Return

Redirigering (header("Location ...")) (H + K)

Efter at have afsluttet et HTML-program vil det ofte være relevant at skifte / redirigere automatisk til et andet program. Dertil benyttes header("Location ...").

HTML (H)

Indsæt funktionskald, der hvor redirigeringen skal ske fra. Det program, der skal redirigeres til skal være etableret som variabel eller som egenskab.

$url ="programnavn";
Helper::redirect($url);
eller
Helper::redirect(Klassenavn::$_egenskab);

Der kan knyttes URL-parametre til programnavnet.

Klasse (K)

Redirigeringen foretages med Helper-'redirect'-funktion:

public static function redirect($url = null) {
   if (!empty($url)) {
      header("Location: {$url}");
      exit;
   }
}

I stedet for $url

Links

<a href="/?page=programnavn uden suffix">Tekst</a>	Programmer, der skal skiftes til via include_path i Framework

URL parametre

Byg

Næste program skal findes via Framework.

Tekst i form af billede <a href="/ ?page=catalogue-item &category=<?php echo $category['id']; ?> &id= <?php echo $row['id']; ?> "> <img src="<?php echo $image; ?>" alt="<?php echo Helper:: encodeHtml($row['name'], 1); ?>" width="<?php echo $width; ?>" /> </a>	<A-tag URL-parameter til brug i Framework. URL-parameter 1 til brug i næste program. URL-parameter 2 til brug i næste program. Slut <A-tag forreste del. Tekst i form af billede Tekst i form af billede Tekst i form af billede Tekst i form af billede <A-tag slut del.
Almindelig tekst fra DB <a href="/ ?page=catalogue-item &category=<php echo $category['id']; ?> &id=<?php echo $row['id']; ?> "> <?php echo Helper::encodeHtml($row['name'], 1); ?> </a>	<A-tag URL-parameter til brug i Framework. URL-parameter 1 til brug i næste program. URL-parameter 2 til brug i næste program. Slut <A-tag forreste del. Tekst fra DB <A-tag slut del.
2 simple uden DB <p><a href="/?page=basket">View Basket</a> \| <a href="/?page=checkout">Checkout</a></p>

Brug

Byg: category=".$cat['id']." Brug i HTML-top: $cat = Url::getParam('category');	URL-parameteren opbygges som: category=cat-id. Det hentede parameter bruges umiddelbart til at hente data fra DB til variablen $cat.

::::::::::::::::::::::::::::::::::::::

Operatorer

I forbindelse med OOP er der tilgået to nye operatorer til PHP:

-> ("arrow"- pil operator)
Construct der etablerer forbindelse til parametre og metoder i aktuelt objekt.
:: (double colon - dobbelt kolon operator)
Giver adgang til "static", "constant" eller "overridden" parameter eller metode i den anførte klasse.

Url::getParam('category')
` (back tick)
Bruges ikke mere. Har tidligere været brugt omkring variabelnavne etc i relation til MySQL.

Metoder / variabler

: Metoder inde i en klasse kaldes functions (funktioner); Variabler inde i en klasse kaldes properties (parametre).

$this pseudo-variabel

Funktioner er som udgangspunkt meget lukkede kasser der har begrænsninger i at modtage data udefra og levere data tilbage til omverdenen. Den begrænsning rådes der i klasser bod på med pseudo-variablen "$this".

Der findes 2 former for anvendelsen af "$this"-variabler:

Link variabel

$this -> funktionsnavn();
Når fortolkeren undervejs ned gennem koden i en funktion møder en link-variabel skiftes til starten på den anførte funktion og afvikling af den påbegyndes. Mødes ingen ny link-variabel før den ny funktion er gennemløbet vendes tilbage til næste linie på den oprindelige funktion og gennemløbet af den fortsætter. Der fortsættes indtil "sporet" ender blindt nederst i en funktion.

Der må ikke være to link-variabler der linker til samme funktion. Der kan godt være flere linkvariabler i koden på en funktion.

Kun __construct-funktionen starter uden at en link-variabel peger på den.
Klasse variabel
Anvendelsen af en klasse-variabel (incl. array) forudsætter, at den er deklareret som et parameter. (Dens værdi opbevares deri).

En klasse-variabel skal have samme navn som det parameter, hvori dens data opbevares.

$this -> variabelnavn .....;

Denne variabel fungerer kodemæssigt som en almindelig variabel, men bevæger sig hen over funktioner overalt indenfor klassen.

Funktionstyper

Funktioner og parametre kan i OOP være af en af 3 typer med hver sin mulighed for anvendelse (scope / visibility / egenskabe).Synligheden af (adgangen til) parametre og funktioner kan styres med nøgleordene "public", "protected" og "private".

Private
Metoder og funktioner i aktuel klasse kan nås fra:
- den klasse, hvori de er erklæret
De kan ikke nås fra:
- klasse, hvori de ikke er erklæret
- klasser, hvori de er ikke er arvet

private function xxx(){}
Protected
Metoder og funktioner i aktuel klasse kan nås fra:
- den klasse, hvori de er erklæret
- klasser, der arver (inherit) den klasse, hvori de er erklæret
De kan ikke nås fra:
- klasser, hvori de ikke er erklæret.

protected function xxx(){}
Public
Metoder og funktioner i aktuel klasse kan nås fra:
- den klasse, hvori de er erklæret
- de klasser, der arver (inherit) den klasse, hvori de er erklæret
- klasser, hvori de hverken er erklæret eller arvet
public function xxx(){}

Static

Static har størst anvendelighed for parametre / funktioner, der ikke behøver at blive instantierede, men hvor der kun er behov for et enkelt (quick and dirty) opslag; f.eks. i URL-klassen.

Skal et parameter / funktion primært bruges til beregninger / modifikationer via instantiering er der ingen grund til "static".

->this	Kan ikke bruges i en static funktion.
::self	Kan kun bruges i en static funktion.

Funktioner

Static (keyword) tillader, at en "static" funktion kan kaldes selvom den klasse, den er indeholdt i, ikke er instantieret.

public static function xxx(){}

Pseudo-variablen $this må ikke anvendes i "static" funktioner.

Parametre

Static (keyword) tillader, at en "static"-paramter / variabel kan kaldes selvom den klasse, den er indeholdt i, ikke er instantieret.

public static $xxx = 'aaa';

Statiske parametre kan ikke tilgås med "this"-variablen.

Variabler

En statisk variabel forbliver i sin funktion og beholder sin default-værdi når funktionen forlades og andre data udgår. Den kan under brug i funktionen antage sin default og alle andre værdier.

STATIC $varnavn = varværdi;

Læs / brug static parameter / metode

Fra "static" parametre og metoder kan der hentes / arbejdes med data med denne syntax:

Klassenavn::$_parameter- / metodenavn;

Parametre (variabler)

Ved deres definition typestyres parametre på samme måde som funktioner.

public $navn = "aaa";
protected $adresse = "bbb";
private $sted = "ccc";

Når et parameter fra en instantieret klasse bruges som variabel i det brugende program, er det ikke nødvendigt at foranstille "$"-tegnet.

Klasse:	public $navn = "aaa";
Program:	$name->navn;

Klassevarianter

Klassestrukturen kan når nødvendigt opbygges i forskellige varianter til forskellige formål

"extend" / Inheritance
Tillader at klassen fra den extendede klasse arver / får tilføjet alle "public" og "protected" parametre og funktioner.

class Aaaa extends Bbbb {}

"Private-" parametre og metoder kan ikke indgå i inheritance.
Encapsulation
Det samme som visibility (dog set fra det modsatte udgangspunkt): indkapsling med protected eller private.
Polymorphism
Abstraction

En abstraction er en klasse eller metode, der ikke kan instantieres direkte, men kun via inheritance. En abstract klasse kan indeholde fuldt funktionelle metoder. En klasse, der indeholder en abstract metode skal selv være abstract.

abstract class klassenavn { public function metodenavn() { return 1; } }

abstract class klassenavn { public abstract function metodenavn() { return 1; } }
Interface

!!!!!!!!

Require_once

"require_once" anvendes til at inkludere en PHP-fil i en anden, der derved fremstår som en enhed bestående af dem begge. "include_once" udfører samme opgave, men er mere fejltolerant. Den samme forskel gælder for "require" og "include".

require_once('aaa/bbb.php'); eller $ddd ->

$this-> / self::

Med instantiering:

public static $fornavn = "Sebastian";

public function getUser() {
return self::$fornavn;
}

Returnerer Sebastian.

public $fornavn = "Sebastian";

public function getUser() {
return this->fornavn;
}

Returnerer Sebastian

Uden instantiering:

public static $fornavn = "Sebastian";

public static function getUser() {
return self::$fornavn;
}

echo Klassenavn::getUser(); Returnerer Sebastian.

public $fornavn = "Sebastian";

public static function getUser() {
return self::$fornavn;
}

echo Klassenavn::getUser(); Returnerer fatal fejl.

public $fornavn = "Sebastian";

public static function getUser() {
return $this->fornavn;
}

echo Klassenavn::getUser(); Returnerer fatal fejl.

---------------------------------------------------------------------------

ToDo liste

refelction

Dynamic dispatch

Polymorphism

Open recursion

Override

Static

Constant

Namespaces

Traits