Bekijk de onderstaande video om te zien hoe je onze site als een web app op je startscherm installeert.
Opmerking: Deze functie is mogelijk niet beschikbaar in sommige browsers.
abstract class A {
// deze functie MOET overschreven worden in een class die A extend, en je kunt A niet instantieren
abstract function doeIets();
}
class B extends A {
function doeIets() {
// hier komt dan de echte functie
}
}
// dit mag
$b = new B;
// dit geeft een Fatal Error: cannot instantiate abstract class A
$a = new A;
class Main{
public function x(){
return 1 + 1;
}
}
interface iSub{
public function x();
}
class Sub extends Main implements iSub{
public function x(){
return 1 + 2;
}
}
Ik neem aan dat je het zelfde probleem hebt als je bijde methods protected hebt?Dat betekent dat als je x() in Sub weglaat, hij ook werkt omdat er in de Main nog een public x() zit.
class Sub extends Main implements iSub{
public function x(){
parent->x();
return 1 + 2;
}
}
Ik wil dit dus gebruiken om verplicht een method 'uit te brijden'. Is deze aanpak verkeerd ofzo? En zoja, hoe kan het beter?
class Main{
protected function x(){
// Zooi code
}
}
class Sub extends Main implements iSub{
protected function x(){
parent::x();
// Code specifiek voor deze class
}
}
abstract class A {
function Parent () {
return $this->Child() + 1;
}
abstract function Child();
}
class B extends A {
function Child() {
return 2;
}
}
protected abstract static function setFormInputSettings();
public final static function formInputHTML($coordinates, $input_name, $is_mandatory, $is_disabled, $field_args) {
SMFormInput::setFormInputSettings();
class A {
static abstract function A ();
}
class B extends A {
function A () {
return 1;
}
}
// dit kan, want hij gaat nu naar B en die extend van A
B::A();
// dit kan nog steeds niet, want in A zelf is de functie abstract
A::A();
abstract class A {
static abstract function A ();
static function beeeh() {
// hier wil ik A() aanroepen - wat volledig gaat als deze method niet static is, mar blijkbaar niet als dat wel zo is
}
}
class B extends A {
function A () {
return 1;
}
}
abstract class A {
abstract function A ();
function B () {
return $this->A() + 1;
}
}
class B extends A {
private $reference = null;
// je kunt niet new B doen, behalve in class B zelf.
// dit zorgt ervoor dat er nooit meer dan 1 instantie van B is, zodat je hem nog steeds kunt behandelen als static.
private function __construct() {
}
function A() {
return 1;
}
static function getB () {
if ( self::$reference === null ) {
self::$reference = new B;
}
return self::$reference;
}
}
We gebruiken essentiële cookies om deze site te laten werken, en optionele cookies om de ervaring te verbeteren.