Ola,

Ik heb een class met daarin een paar constant values. Verder doet die class niks, en daarom wil ik voorkomen dat de class geinstantieerd kan worden.

Volgens mij zijn daar 2 manieren voor:
- de class abstract maken, óf...
- een private constructor in de class zetten

Heeft een van deze methodes een voorkeur? Maakt het iets uit? Of is er nog een andere manier?
Waarom zou je jezelf willen limiteren?

Voel je nu niet aangevallen, maar ik ontdek de laatste tijd erg in jouw vragen dat jij je applicatie heel erg wilt limiteren. Je wilt dat alles alleen uitgevoerd/gebruikt kan worden op de manier die je nu in je hoofd hebt. Uit ervaring, die jij waarschijnlijk wel kan delen, weet ik dat ik over hetzelfde problem over een paar maanden compleet anders denk. Ik zou dus iedereen altijd aanraden een applicatie zo open mogelijk te schrijven, "Open for extension, closed for modification" zoals het open/closed-principe zo mooi zegt.
Dankjewel voor het meedenken. Je hebt daar wel een punt. Echter, omdat ik er zeker van ben dat er verder met deze class niks gaat gebeuren en het zinloos is om 'm te instantiëren vind ik het netter om 'm dicht te gooien. En misschien heb je gelijk dat ik er over een paar maanden anders over denk, maar voor nu wil ik 'm dichtmaken :) Alleen de vraag is dus wat de beste manier daarvoor is. Abstract is van de ene kant netter omdat ik dan geen constructor in m'n class heb staan. Maar als ie abstract is kun je m wel weer extenden :-s
Goed, dan gaan we hem helemaal dichttimmeren:
<?php
final abstract class MijnMagJeNietGebruiken
{
const MIJ_WEL = 'Ja, ikke wel!!!';

final abstract private function __construct() {}
final abstract private function __wakeUp() {}
final abstract private function __sleep() {}
final abstract private function __clone() {}
final abstract private function __call() {}
final abstract private function __callStatic() {}
final abstract private function __get() {}
final abstract private function __set() {}
final abstract private function __destruct() {}
}
?>

Mja, da's toch een beetje jammer Wouter. Een abstract class kan niet final zijn :-)

On-topic. Om instantiëren te voorkomen. Abstract of private constructor?
PHP laat het bovenstaande niet toe...

Zijn het echt alleen maar een paar constante die je in een class hebt staan? Geen static methods?
Want dan zou ik gewoon constante defineren in een namespace. Dat is wat je wilt berijken door een class te hacken: constanten in een namespace stoppen. Stop in dat geval de constante gewoon in een namespace!
Ozzie\WeekDays::MONDAY vs Ozzie\WeekDays\MONDAY

PHP 5.6 heeft wel een coole nieuwe feature: http://3v4l.org/4peGi
>> Zijn het echt alleen maar een paar constante die je in een class hebt staan?

Ja inderdaad!

>> Zijn het echt alleen maar een paar constante die je in een class hebt staan?

Ik snap ff niet hoe dat werkt eigenlijk... Ik kan toc niet automatisch een namespace laden?
Emhe... zou je de tweede quote kunnen vervangen door de correcte quote? Ik weet niet waar je het nu over hebt.
Oh, excuus :-s
Die zat nog onder de ctrl-v knop :)

Het ging hier om:

>> Stop in dat geval de constante gewoon in een namespace!

Ik kan toch niet automatisch een namespace laden?
Je kunt dergelijke constanten in een interface zetten. Het overriden van interface-constanten is niet toegestaan, dus daarmee bereik je zoiets als een "final abstract" constante.

[code]
<?php
interface a
{
const b = 'Interface constant';
}
?>
[/ocde]
Ward, volgens mij werkt dat niet.

Ik wil bijv. dit kunnen doen:

<?php

setLanguage(language::NL);

?>

Reageren