Czy są jakieś utarte reguły dotyczące wyboru jednej z tych dwóch metod ?
Mam klasę ( w sumie nie jedną ) która wymaga Iterator'a. Pytanie tylko czy mam zaimplementować interfejs iteratora czy rozszerzyć i nadpisać kilka metod. Nie wiem którą z opcji wybrać. Szukam jakiejś reguły którą mógłbym się kierować przy wyborze.

Implmentacja bo szybsza - dziedziczenie jest strasznie powolne :]

Dziedziczenie stosuj tam gdzie masz zamiar skorzystać z polimorfizmu.

To lubię w tym forum. Konkretne i szybkie odpowiedzi

To jeszcze prosiłbym o sprawdzenie moich wypocin.

[PHP] pobierz, plaintext 
<?php
class Class_Method_Collection implements Iterator
{
    /**
     * For:
     * $this->_items[0]['name'] = '<method name>'; | myMethod
     * $this->_items[0]['return'] = '<variable type>'; | integer / string / etc.
     * $this->_items[0]['params'][0]['name'] = '<param name>'; | my_variable
     * $this->_items[0]['params'][0]['type'] = '<param type>'; | integer / string / etc.
     * or
     * $this->_items[0] = Class_Methods_Method
     * @var array
     */
    protected $_items = array();
    /**
     * Iterator index
     * @var integer
     */
    protected $_key = 0;
    /**
     * Identifiers stored in array
     * @var array
     */
    protected $_keys;
    /**
     * Converts data from array to Class_Methods_Method object
     * For:
     * $method['name'] = '<method name>'; | myMethod
     * $method['return'] = '<variable type>'; | integer / string / etc.
     * $method['params'][0]['name'] = '<param name>'; | my_variable
     * $method['params'][0]['type'] = '<param type>'; | integer / string / etc.
     * @param array $method
     */
    public function array2method($method)
    {
        $method['return'] = isset($method['return']) ? $method['return'] 'void';
        
        $ob = InstanceGet('library.class.method', '', InstanceRETURN_INSTANCE);
        $ob->setName($method['name']);
        $ob->setReturn($method['return']);
        foreach($method['params'] as $param)
        {
            $ob->setParam($param['name'], $param['type']);
        }
        return $ob;
    }
    /**
     * Loads methods collection in array format as class items for further operations
     * $this->_items[0]['name'] = '<method name>'; | myMethod
     * $this->_items[0]['return'] = '<variable type>'; | integer / string / etc.
     * $this->_items[0]['params'][0]['name'] = '<param name>'; | my_variable
     * $this->_items[0]['params'][0]['type'] = '<param type>'; | integer / string / etc.
     * or
     * $this->_items[0] = Class_Methods_Method
     * @param array $methods
     */
    public function load($methods)
    {
        if($this->validate($methods)) throw new Exception('Incorrect $methods format.');
        $this->_keys = array_keys($methods);
        $this->_items = $methods;
    }
    /**
     * Compares format of $methods array with required by load() method
     * @param array $methods
     */
    public function validate($methods)
    {
        $out = true;
        foreach($methods as $method)
        {
            if(!isset($method['name']))
            {
                $out = false;    break;
            } else
            if(isset($method['params']))
            {
                foreach($method['params'] as $param)
                {
                    if(!isset($param['name']) || !isset($param['type']))
                    {
                        $out = false;    break;
                    }
                }
            }
            if(!$out) break;
        }
        return $out;
    }
    // ----------------- //
    // SETTERS & GETTERS //
    // ----------------- //
    /**
     * Returns item
     * @param integer $key
     * @return misc
     */
    public function getItem($key)
    {
        return isset($this->_keys[$key]) && isset($this->_items[$this->_keys[$key]]) ? $this->_items[$this->_keys[$key]] false;
    }
    /**
     * Sets item
     * @param integer $key
     * @param misc $item
     */
    public function setItem($key, $item)
    {
        if(isset($this->_items[$key]))
        {
            $this->_items[$key] = $item;
        }
        else 
        {
            $this->_keys[] = $key;
            $this->_items[$key] = $item;
        }
    }
    // ---------------- //
    // ITERATOR METHODS //
    // ---------------- //
    /**
     * Returns current item
     * @return misc
     */
    public function current() 
    {
        return $this->valid() ? $this->array2method($this->_items[$this->_keys[$this->_key]]) false;
    }
    /**
     * Return key of current item or boolean false if item does not exists
     */
    public function key() 
    {
        return $this->valid() ? $this->_keys[$this->_key] false;
    }
    /**
     * Moves forward to next item
     */
    public function next() 
    {
        $this->_key += 1;
    }
    /**
     * Checks does current item exists
     * @return boolean
     */
    public function valid() 
    {
        return (isset($this->_keys[$this->_key]) && isset($this->_items[$this->_keys[$this->_key]]));
    }
    /**
     * Rewinds Iterator to the first element
     */
    public function rewind() 
    {
        $this->_key = 0;
    }
}
?>
[PHP] pobierz, plaintext 

Zastanawiam się czy nie lepiej wydzielić część iteracyjną do klasy abstrakcyjnej z abstrakcyjną metodą current(), bo będę chciał ten mechanizm zastosować w około 20 klasach.

Dlaczego masz:

[PHP] pobierz, plaintext 
<?php
/*
    * $this->_items[0]['name'] = '<method name>'; | myMethod
    * $this->_items[0]['return'] = '<variable type>'; | integer / string / etc.
    * $this->_items[0]['params'][0]['name'] = '<param name>'; | my_variable
    * $this->_items[0]['params'][0]['type'] = '<param type>'; | integer / string / etc.
    */
?>
[PHP] pobierz, plaintext 

Przecież wygodniej mieć obiekt. Do tego iterator powinien przechowywać tylko jeden typ elementów. Bo inaczej nie wiadomo co się dzieje, że PHP umożliwia różne dziwne rzeczy, nie znaczy że trzeba z tego korzystać.

Bo to jest kolekcja a pojedynczy element zwracam już jako obiekt.

Jak w takim razie powinno to wyglądać poprawnie ?

OT: Czy Ty celowo pomijasz dwukropek w Ternary Operatorze ? Czy może robisz tak ze względu na kolorowanie składni na forum, albo bez tego dwukropka też działa?
Np. tutaj:

[PHP] pobierz, plaintext 
<?php
/**
    * Return key of current item or boolean false if item does not exists
    */
   public function key()
   {
       return $this->valid() ? $this->_keys[$this->_key] false;
   }
?>
[PHP] pobierz, plaintext 

@jarek_bolo: BBCode forum coś się posypało i usuwa dwukropki.

~jarek_bolo. ~Crozin a nie wiem czy wiecie ale w PHP5.3 będzie skrócona wersja tego operatora:

[PHP] pobierz, plaintext 
<?php
 
(warunek logiczny) ? instrukcje_na_true;
 
?>
[PHP] pobierz, plaintext 

@mike: przyznam się, że myślałem, że już 5.2.3 to wprowadzili

@mike: a jeżeli warunek logiczny nie będzie spełniony to jaką wartość nam zwróci? NULL?

@NuLL:

Eeee? Mozesz to wyjasnic?

@mike

Eh? a z interfejsem to nie da sie wykonac polimorfizmu?

java:

Zabiłeś mnie.
Nie sądziłem, że Ci to napisze ale ... poczytaj sobie o polimorfiźmie to pogadamy
To co pokazałeś to nie do końca jest polimorfizm.

@mike: dalej nie czaje czemu niby polimorfizm [w programowaniu obiektowym] da sie zrobic tylko z uzyciem dziedziczenia.

moj kod powinien raczej wygladac:



Bo interfejsy to wlasciwie puste klasy abstrakcyjne i pozwalajace na wykonanie wielodziedziczenia (extends + implements) == mamy dziedziczenie, wiec w czym problem?

Polimorfizm możemy osiągnąć poprzez dziedzicznie, a także przez implementację interfejsu.

Ja tylko umieszcze cytat. Reszte flame'a z checia poczytam



Bruce Eckel, Thinking in Java ed. 4, s. 241.