OOP syntaxen en werkingen
Pagina: « vorige 1 2 3 4 volgende »
moet ik hem dan bijv in die interface laden of in de sql type class?
Code (php)
Dit is een abstracte class. Hoewel de functies setName en getName public zijn, kan je er op die moment niets mee, want je geen instantie maken van deze class. Je kan dus niet doen:
Code (php)
1
2
3
4
2
3
4
<?php
//dit levert een foutmelding op
$obj = new Base_Class();
?>
//dit levert een foutmelding op
$obj = new Base_Class();
?>
Je kan wel een descending class maken:
Code (php)
Omdat Persoon de Base_Class extend en zelf niet abstract is kan je nu ook de publieke functies van Base_Class aanroepen:
Overigens kan je ook niets 'in een interface laden'. Een interface definieert alleen (deels) hoe een class eruit moet zien. Verder kan je niets met een interface, je kan er ook geen instantie van maken. Een interface heeft ook nooit een implementatie.
is dit hieronder zo goed dan?
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<?php
interface Connection_Interface
{
}
class databaseConnectMySql implements Connection_Interface extends databaseConfig
{
}
abstract class databaseConfig
{
private $hostname;
private $username;
private $pass;
private $database;
private $table;
private $connector;
function __construct($hostname = NULL, $username = NULL, $pass = NULL, $database = NULL, $prefix = NULL, $connector = NULL)
{
$this->hostname = !empty($hostname) ? $hostname : "";
$this->username = !empty($username) ? $username : "";
$this->pass = !empty($pass) ? $pass : "";
$this->database = !empty($database) ? $database : "";
$this->table = !empty($table) ? $table : "";
$this->connector = !empty($connector) ? $connector : ""; //mysql of mysqli waarde opgeven (database)
}
function __destruct()
{
#destruction!
}
}
?>
interface Connection_Interface
{
}
class databaseConnectMySql implements Connection_Interface extends databaseConfig
{
}
abstract class databaseConfig
{
private $hostname;
private $username;
private $pass;
private $database;
private $table;
private $connector;
function __construct($hostname = NULL, $username = NULL, $pass = NULL, $database = NULL, $prefix = NULL, $connector = NULL)
{
$this->hostname = !empty($hostname) ? $hostname : "";
$this->username = !empty($username) ? $username : "";
$this->pass = !empty($pass) ? $pass : "";
$this->database = !empty($database) ? $database : "";
$this->table = !empty($table) ? $table : "";
$this->connector = !empty($connector) ? $connector : ""; //mysql of mysqli waarde opgeven (database)
}
function __destruct()
{
#destruction!
}
}
?>
Gewijzigd op 11/06/2012 16:12:12 door Reshad F
Op die manier heb je de functionaliteit uit de superclass al en je implementeert de interface waardoor andere objecten weten dat die class bepaalde functionaliteit biedt.
Overigens schrijf ik het altijd andersom:
class ... extends ... implements ...
Ik weet niet of dit verplicht is, maar zo is het duidelijker omdat je eerst de class hierarchie laat zien en dan wat het implementeert.
dan heb ik alleen nog een vraagje voor ik dit allemaal verder uit ga bouwen.
ik twijfel over dit stukje. en dan vooral het construct gedeelte en de code die ik erin aanroep. doe ik dit zo goed in deze klasse?
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
class databaseConnectMySql extends databaseConfig implements Connection_Interface
{
/**
* declareren van alle functies
*/
public $hostname;
public $username;
public $pass;
public $database;
public $table;
public $connector;
public function __construct($hostname, $username, $pass, $database, $table, $connector)
{
$this->databaseConfig = $databaseConfig;
}
}
?>
class databaseConnectMySql extends databaseConfig implements Connection_Interface
{
/**
* declareren van alle functies
*/
public $hostname;
public $username;
public $pass;
public $database;
public $table;
public $connector;
public function __construct($hostname, $username, $pass, $database, $table, $connector)
{
$this->databaseConfig = $databaseConfig;
}
}
?>
Gewijzigd op 11/06/2012 16:42:24 door Reshad F
Vraag is ook, wat wil je dat dat is? Want dit is toch je connector class? Dan moet je er geen connector meer aan mee geven natuurlijk.
http://pastebin.com/mf7VUCn6
Verder heb je in de abstracte class alle properties op private gezet. Op zich ben ik het daar mee eens (mening), maar je hebt ze wel nodig in databaseConnectMySql. Ofwel dan moet je getters en setters ervoor hebben zodat je ze aan kan roepen, ofwel je moet ze allemaal protected maken, dan kan je ze direct aanroepen.
Wat je in elk geval niet moet doen is ze nogmaals declareren in databaseConnectMySql. Dan heb je namelijk een private en een public property met dezelfde naam en dan durf ik niet te zeggen hoe dat gaat werken.
dan krijg ik dus zoiets?
Wouter J op 11/06/2012 16:58:38:
Erwin (en Reshad), dbConfig en dbConnect hebben toch een HEEFT_EEN relatie en niet een IS_EEN relatie? Die hele extend hoort daar toch niet? Je wilt toch zoiets doen:
Volgens mij ligt dat een beetje in het midden. Zoals het nu is opgebouwd is de abstracte basis class precies dat; een basis class voor alle connector objecten. Daar kan ik mee leven. Daarna heb je nog een class nodig die de database functionaliteit beschikbaar maakt voor de applicatie. Die class zal een HEEFT_EEN relatie hebben met de connectie classes.
Toevoeging op 11/06/2012 17:08:01:
Hmm, volgens mij loopt het een beetje door elkaar door de naamgeving. Volgens mij de vertaling tussen Reshad's classes en de namen van Wouter:
databaseConfig (abstract) - dbConnect
databaseConnectMySql - dbConnectMySQL
..... - dbConfig
Naamgeving loopt volgens mij dus niet helemaal 1-op-1, maar het idee wel.
Of ben ik nu degene die de weg kwijt is :-)
Gewijzigd op 11/06/2012 17:09:05 door Erwin H
en jongens bedankt voor de tijd en moeite ik waardeer het enorm!
1 klasse waarin db settings worden opgeslagen (zoals username, password, host, database, prefix, ect.) = dbConfig, en 1 set van klassen die de connection regelt met een mooi adapter pattern = dbConnect en de hele reeks erachteraan.
Het connect gedeelte deelde ik wel, maar daar bovenop een facade zo je wilt die met een simpele functie een complete query kan draaien. Dit is wat ik zelf namelijk heb en daar lees je dan al snel naartoe natuurlijk. Dus het extra object dat je aangaf zag ik als die facade, niet als het config object. Alleen is dan de HEEFT_EEN relatie omgedraaid.
ik heb het zelfs getest en ik krijg gewoon rijen etc uit de database terug en hij werkt zelfs!
alleen nu mijn vraag. is het een beetje OO http://pastebin.com/zgShuEjV
Want waar denk je dat je die dbConfig klasse nu voor gebruikt? En waarom denk je dat hij abstract moet zijn?
Tevens moet je dubbele code weglaten en plaatsen in de superklasse. Stel je maakt er nog een adapter bij dan heb je hier nog code in staan die dubbel is en dus niet per adapter verschilt. Plaats die dan in de abstracte dbConnect klasse, zodat alle subklassen (dus alle adapters) deze automatisch al krijgen.
En waarom definieer je methods in de superklasse dbConfig en maak je die vervolgens na in de dbConfigMySQL klasse? Als je niet weet hoe je een method moet invullen, omdat deze verschilt voor alle subklassen moet je hem abstract maken en laten invullen door de subklassen.
Gewijzigd op 12/06/2012 13:48:06 door Wouter J
Pagina: « vorige 1 2 3 4 volgende »