[OO] Verschil tussen :: en ->

Patrick

Zoals de topic titel zegt kan iemand goed uitleggen wat in classes het verschil is tussen:

::

en

->

dus bijv:

$var->output;

en:
$var::output;

Spinazie

Je gebruikt dubbele punten wanneer je een methode van een klasse statisch aan wilt roepen. Dat is heel handig wanneer je werkt met objecten die over het gehele systeem gebruikt worden. Om het om te zetten van geïnstantieerde methoden naar statische, kun je de singleton-oplossing gebruiken. Daar weet Wikipedia meer over, gaat een lang verhaal worden als ik dat hierin moet proppen.

Het is nu al duidelijk dat je het 'pijltje' gebruikt wanneer je een instantie van het object hebt. Dat is handig wanneer je objecten hebt waar je duidelijk en gestructureerd in wilt werken. Verwar statische objecten niet met geïnstantieerde! Het kan heel irritant zijn wanneer je als programmeur telkens instanties aan moet maken of als global moet aanroepen.

$var::output gaat trouwens niet werken, aangezien 'output' hier geen methode, noch statische variabele is.

Succes!

Darsstar

-> gebruik je in object context...
dat houd in dan je een object hebt gecreeerd door middel van het new keyword.

bijvoorbeeld:

PHP

$voorbeeld = new Voorbeeld;
echo $voorbeeld->output;

$voorbeeld bevat dus het object.
Binnen de methods in de class is het wel handig als je toegang hebt tot dat object, daar is de magische variable $this voor.
Met $this kan je zelfs meer dan met $voorbeeld buiten methods...
$this betekend dat je binnen de class zit, en dan heb je toegang tot protected en private methods en variabelen.

:: gebruik je in statische context
Je kan zo dingen doen zonder eerst een object aan te maken, bijvoorbeeld om een statische protected variabele aan te passen.
Omdat het statisch is is die voor elke instantie van die class het zelfde.
De niet-statische methodes hebben gewoon toegang tot alle variabelen en eigenschappen van die class (ok, ik laat private deels achterwegen nu), dus die kunnen die in vergelijkingen gebruiken, of bijvoorbeeld de bestanden van het juiste theme kiezen...

voorbeeld:

PHP

class Template {


    protected static $theme = 'default';


    pulic static theme($theme = NULL)
    {
        if (is_string($theme))
        {
            self::$theme = $theme;
        }


        return self::$theme;
    }


    public function inlucde($file)
    {
        include 'templates/'.self::$theme.'/'.$file;
    }
}


Template::theme('strangeness');


$template = new Template;
$template->include('test.php');

Toon Meer

Patrick

Hierbij even een eigen class gemaakt na heeeeeeel wat uitleg van darsstar begin ik het lichtelijk te snappen:

PHP

<?php


/**
 * @author Patrick rennings
 * @copyright 2010
 */


class TestClass {
    
    
    static public function TestStatic ( $var )
    {
        
        if ( is_string ( $var ) )
        {
            
            self::$TestStaticVar = $var;
            
        }
        
        
        return self::$TestStaticVar;
    }    




    public function TestStatic2 ( $var )
    {
        
        if ( is_string ( $var ) )
        {
            
            self::$TestStaticVar2 = $var;
            
        }
        
        
        return self::$TestStaticVar2;
    } 


}


TestClass::TestStatic('Testing');


# Geeft error
TestClass::TestStatic2('Testing');


$TestClass = new TestClass;


# Output 'Testing';
echo TestStatic;


?>

Toon Meer

Darsstar

Je vergeet $TesTStaticVar en $TestStaticVar2 te defineren...
Ik heb geen idee waaromje een instantie van dat object zou maken...
En de constante TestStatic bestaat niet...

Patrick

Dus dan moet dit er nog boven:

PHP

static public $TestStaticVar;
static public $testStaticVar2;

En waarom ik dit maak zodat mensen zoals jij makkelijk kunnen zien of het goed is of niet

en dan nog 1 ding, constante TestStatic bedoel je wat ook alweer precies mee [a]

Spinazie

Ik zou public static doen

Patrick

Zo weer even een testclass aangemaakt tips / probs etc:

PHP

<?php


/**
 * @author Patrick Rennings
 * @copyright 2010
 */


class TestClass {
    
    
    public static $StatVar;
    public $DynVar;
    
    public static function StatSet ( $var = NULL )
    {
        
        if ( is_string ( $var ) )
        {
            
            self::$StatVar = $var;
            
        }
        
    }
    
    public function DynSet ( $var = NULL )
    {
        
        if ( is_string ( $var ) )
        {
        
            $this->DynVar = $var;
        
        }
        
    }
    
    public function ReturnResults ( )
    {
        
        return self::$StatVar . ' <br /> ' $this->DynVar;
        
    }
    
}


TestClass::$StatVar = ' Static variable ';
$Class1 = new TestClass;
$Class1->DynSet( 'Dynamic variable' );


# Result: Static variable <br /> Dynamic variable
$Class1->ReturnResults();






$Class2 = new TestClass;
$Class2->DynSet( 'Dynamic variable second edition' );


# Result: Static variable <br /> Dynamic variable second edition
$Class2->ReturnResults();






$Class3 = new TestClass;


# Result: Static variable <br />
$Class3->ReturnResults();




TestClass::$StatVar = ' Static Variable second edition ';
$class4 = new TestClass;
$Class4->DynSet( 'Dynamic variable thirth edition' );


# Result: Static variable second edition <br /> Dynamic variable thirth edition
$Class4->ReturnResults();




?>

Toon Meer

Spinazie

Het idee van de syntaxis klopt (voor zover ik het snel over gekeken heb).
Ik denk dat je not wat moet oefenen op het objectgeoriënteerd denken.
ReturnResults() is niet echt nodig, aangezien er niet zo veel bewerkingen nodig zijn om het resultaat te krijgen en je class variabelen public zijn. Als ze private zijn, heb je wel getters en setters nodig. Daar is ongetwijfeld wel iets over te vinden op Google.

Denk er dus aan dat je klassen logisch, objectgeoriënteerd, dynamisch en gebruiksvriendelijk in elkaar vallen.

Patrick

ja maar om even te laten zien met die ouput dat jullie kunnen zien dat ik het snap [a]

Spinazie

Getters gebruiken voor publieke variabelen is niet echt de beste manier om dat te doen
Denk dat je toch maar even onze instructies moet opvolgen. De eerste stappen zijn even moeilijk, maar als je daar doorheen bent gaat het al iets gemakkelijker.

Patrick

PHP

Class TestClass
{
    
    public static $StatVar;
    public $StatVar;
    
    public function __SET ( $var = NULL, $spec = NULL )
    {
        
        if ( is_string ( $var ) )
        {
        
            if ( $spec == 'static' )
            {
                    
                $this->setstatic ( $var );
                
            }
            else
            {
                
                $this->setdyn ( $var );
                
            }
            
        }
        
    }
    
    private function SetStatic ( $var = NULL )
    {
        
        self::$StatVar = $var;
        return;
        
    }
    
    private function SetDyn ( $var = NULL )
    {
        
        $this->DynVar = $var;
        
    }
    
    public function __GET ( )
    {
        
        return $this->DynVar . ' <br /> ' . self:$StatVar;
        
    }
    
}

Toon Meer

weer een nieuwe nu met een __GET en __SET maar denk dat het hard faald! :o

Darsstar

Redelijk ja...

__set() en __get() hebben geen zin als je alleen public variabelen hebt en niets doet voor variabelen die niet bestaan...
Ik vraag me ook af of je __get() en __set() wel door hebt...
__get() heeft namelijk één argument nodig, nu heeft het er geen...

PHP

<?php


class TestClass {


    public $var1, $var2, $var3, $var4;
    protected $var5, $vars = array();


    public function __set($name, $value)
    {
		if (property_exists($this, $name)) // isset() werkt niet omdat alleen $vars een standaard waarde heeft, en de $var5 dus NULL is...
		{
			$this->$name = $value;
		}
		else
		{
			$this->vars[$name] = $value;
		}
    }


    public function __get($name)
    {
		if (isset($this->$name))
			return $this->$name;


		if ( ! array_key_exists($name, $this->vars))
            throw new Exception;


        return $this->vars[$name];
    }


    public function debug()
    {
        var_dump($this);
    }
}


$test         = new TestClass;
$test->var1   = 'boe!'; // geen __get(), de variabele is public
$test->var5   = 5; // __get() wordt aangeroepen omdat de variabele niet public is
$test->var10  = 'schrik!'; // geen error door __set()
$test->var100 = 'aaargh!'; // idem


try
{
    echo $test->var10; // schrik!
    echo $test->var; // __get() gooit een exception
}
catch(Exception $e)
{
    echo 'sorry, die variabele bestaat niet...';
}


$test->debug();
/*
object(TestClass)#1 (6) {
  ["var1"]=>
  string(4) "boe!"
  ["var2"]=>
  NULL
  ["var3"]=>
  NULL
  ["var4"]=>
  NULL
  ["var5:protected"]=>
  int(5)
  ["vars:protected"]=>
  array(2) {
    ["var10"]=>
    string(7) "schrik!"
    ["var100"]=>
    string(7) "aaargh!"
  }
}
*/

Toon Meer

Jouw set is dus een beetje vreemd...
Geef de parameters van __set(), __get() etc alleen defaults als je daar een erg goede reden voor hebt...
TestClass::SetDyn() en TestClass::SetStatic() hebben ook geen defaults nodig, je doet er niets mee...
Als je die methods zonder argumenten aanroept ben je ze eigenlijk aan het unsetten...
De return in TestClass::SetStatic() slaat ook nergens op...

Patrick

Ik dacht het beste leer je door gewoon dingen te maken waar je wat later aan hebt dus zo ben ik begonnen met een "register" class:

Comments so far:

PHP

<?php


/**
 * @author Patrick rennings
 * @copyright 2010
 */




class Register {
    
    public static $UsernameMaxLength = 20;
    public static $UsernameMinLength = 3;
    
    public static $PasswordMaxLength = 20;
    public static $PasswordMinlength = 5;
    
    protected $db;


    public function __construct ( )
    {
        
        $this->db = Database::Connect();
        
    }
    
    public function CheckValue ( $value, $type, $OptPar = NULL )
    {
        
        if ( is_string ( $value ) AND is_int ( $type ) )
        {
            
            switch ( $type )
            {
                    
                # Username check
                case 1:
                    
                    if ( strlen ( $value ) > $UsernameMaxLength OR strlen ( $value ) < $UsernameMinLength )
                    {
                            
                        return FALSE;
                            
                    }
                    else
                    {
                            
                        if ( $db->NumQuery( ' SELECT * FROM `users` WHERE `username` = "' . addslashes ( $value ) . '"  ' ) > 1)
                        {
                                
                            return FALSE;
                                
                        }
                        else
                        {
                                
                            return TRUE;
                               
                        }
                            
                    }
                     
                ;
                    
                # Password check
                case 2:
                    
                    if ( strlen ( $value ) > $PasswordMaxLength OR strlen ( $value ) < $PasswordMinLength )
                    {
                            
                        return FALSE;
                            
                    }
                    else
                    {
                            
                        if ( is_string ( $OptPar ) )
                        {
                                
                            if ( $Value != $OprPar )
                            {
                                    
                                return FALSE;
                                    
                            }
                            else
                            {
                                    
                                return TRUE;
                                    
                            }
                                
                        }
                        else
                        {
                                
                            return false;
                                
                        }
                            
                    }
                    
                ;
                    
            }
            
        }
        
    }
    
}


?>

Toon Meer

$db-> bestaat nog niet (wordt database class die ik hierna ga brouwen)

Spinazie

protected $db;
Register heeft geen parent (is niet extended, zoek maar even op Google naar 'php extends' of zoiets), dus je kunt beter private gebruiken.
Voor hetgeen wat jij probeert met je database variabele, heeft men dus statische klassen/Singleton uitgevonden. Je zou je database dan op deze manier kunnen benaderen:

PHP

DB::select('id')
->from('users')
->where('id', '=', '1')
->execute();

(Gebaseerd op Kohana, dus jouw manier zal waarschijnlijk iets anders zijn)

if ( strlen ( $value ) > $PasswordMaxLength OR strlen ( $value ) < $PasswordMinLength )
Dit geeft een error. Gebruik hier self::$PasswordMinLength. Het is trouwens niet nodig in een niet-statische methode een statische variabele te gebruiken, tenzij je van plan bent hem ooit nog zonder instantie aan te roepen.

Verder zitten er nog wat andere foutjes in, maar daar kom je wel uit als je de bovenstaande dingen verbeterd hebt.
Dit is trouwens geen OO. Ik weet niet hoe belangrijk het is om dat in het begin te snappen, aangezien ik het ook later pas door kreeg.
Afijn, kijk maar eens goed naar je code. Je denkt in procedures, niet in objecten

Patrick

Object is bijv:

je hebt een class hond, en je daar doe je eigenschappen van een hond inzetten like: 4 poten etc.

Daaronder kan je een object lassie maken die dan weer speciale kenmerken van die hond heeft alleen ik weet niet goed hoe ik dan zoiets kan neer zetten in een echte class {} vorm

Spinazie

class Hond { }
class Lassie extends Hond { }

Bedoel je dat?

Patrick

ja maar dat is niet echt een object er van maken want hoe kan je dan objecten maken @ een register class???

Spinazie

Je registratie klasse is een object. Ik bedoel dat je 'dingen' met bepaalde eigenschappen gescheiden houdt. Het controleren van iets kun je bijvoorbeeld beter in een andere klasse zetten die het controleren regelt. Zo kun je dingen hergebruiken, bijvoorbeeld als je je gebruikersnaam of wachtwoord wilt veranderen.

Patrick

wat zou jij dan in een registratie class zetten?

ICTscripters

Dé plek voor IT

Dé plek voor IT

Na 15 jaar terug van weggeweest: iCriminals.nl is terug (BETA)!

Developer Gezocht

Op zoek naar de legends

[FREE] WeFact Hosting module

Help testers nodig voor android app Urgent

Versio vervanger

Afspraken systeem met planbeperking

Partner Gezocht om meerdere NFT Collecties op Open Sea te Plaatsen

Meerdere mafia game template te koop

Van een pixelige afbeelding naar een strakke, moderne website

302 Nieuwe Domeinnamen November 2025

[OO] Verschil tussen :: en ->

Participate now!

Fijne feestdagen

Kritieke update voor Really Simple Security-plug-in

ING Nederland streeft naar ondersteuning van Google Pay tegen eind februari

Functioneel ontwerp

Access Control List implementatie in PHP/MySQL - deel 1/2

Access Control List implementatie in PHP/MySQL - deel 2/2

Gebruikers die dit topic bekijken