Vale la pena di fare i metodi get e set in OOP?

Question

Ho visto alcuni progetti in cui le classi stanno ottenendo e impostando i metodi per manipolare i dati di inserimento. Dammi un esempio qui:

class Student extends dbClass 
{ 
    private $TableID; 
    private $FullName; 
    private $Gender; 
    private $Address; 




    function setTableID($Value) 
    { 
     $this->TableID = $Value; 
    } 

    function getTableID() 
    { 
     return $this->TableID; 
    } 

    function setFullName($Value) 
    { 
     $this->FullName = $Value; 
    } 

    function getFullName() 
    { 
     return $this->FullName; 
    } 

    function setGender($Value) 
    { 
     $this->Gender = $Value; 
    } 

    function getGender() 
    { 
     return $this->Gender; 
    } 

    function setAddress($Value) 
    { 
     $this->Address = $Value; 
    } 

    function getAddress() 
    { 
     return $this->Address; 
    } 


    function UpdateStudent() 
    { 
     $sql = "UPDATE INTO usertable SET 
     FullName = '".$this->getFullName()."', 
     Gender = '".$this->getGender()."', 
     Address = '".$this->getAddress()."' 
     where TableID='".$this->getTableID()."'"; 
     $this->query($sql); 
    } 
} 

è al di sopra della classe di esempio che ho visto. E sotto è il processo come lo stanno usando:

$student = new Student; 
$student->setTableID = 1; 
$student->setFullName('My Name'); 
$student->setGender('Male'); 
$student->setAddress('this is my address'); 

$studen->UpdateStudent(); 

Vale la pena farlo in questo modo? Personalmente ritengo sia inutile impostare il campo e quindi ottenere e aggiornare i record al suo interno. Ci vuole davvero molto tempo per farlo per ogni modulo. Qual è il modo migliore per gestire questa cosa? C'è qualche problema alla sicurezza in questo modo?

Answer 1

Vale la pena farlo in questo modo?

Dipende.

Astrarre un campo da parte dell'utente, esponendo una proprietà "intelligente" (vale a dire getter e/o setter) ha due svantaggi:

1. È necessario scrivere codice più; se la proprietà non fa nulla di intelligente, questo è un codice che non fa nulla di utile.
2. L'utente della proprietà è leggermente disturbato perché deve digitare un po 'di più.

E ha un vantaggio:

1. In futuro è possibile aggiungere logica per le proprietà, anche se prima non c'era senza infrangere il codice dei vostri utenti.

Se questo vantaggio è significativo (ad esempio, si sta scrivendo una libreria software riutilizzabile), ha molto senso scrivere proprietà anziché campi nudi. Altrimenti, stai lavorando senza alcun beneficio.

Qual è il modo migliore per gestire cosa del genere?

È possibile ignorare le magiche __get e __set funzioni (forse in una classe base in modo da poter ereditare l'override pure) per l'inoltro automatico di proprietà accessi ai tuoi getter e setter. codice semplificato:

public function __get($name) { 
    $getter = 'get'.$name; 
    if (method_exists($this, $getter)) { 
     return $this->$getter(); 
    } 

    $message = sprintf('Class "%1$s" does not have a property named "%2$s" or a method named "%3$s".', get_class($this), $name, $getter); 
    throw new \OutOfRangeException($message); 
} 

public function __set($name, $value) { 
    $setter = 'set'.$name; 
    if (method_exists($this, $setter)) { 
     return $this->$setter($value); 
    } 

    $getter = 'get'.$name; 
    if (method_exists($this, $getter)) { 
     $message = sprintf('Implicit property "%2$s" of class "%1$s" cannot be set because it is read-only.', get_class($this), $name); 
    } 
    else { 
     $message = sprintf('Class "%1$s" does not have a property named "%2$s" or a method named "%3$s".', get_class($this), $name, $setter); 
    } 
    throw new \OutOfRangeException($message); 
} 

Caveat emptor: Dal __get e __set vengono sovrascritte, __isset e __unset dovrebbe essere ignorato, come pure!

C'è qualche sicurezza interessata a farlo in questo modo?

No, nessuno (presumendo che non si inseriscano errori accidentalmente).

Answer 2

Fare setter e getter aiuta a rafforzare l'incapsulamento OOP. Non sono sicuro per PHP, ma per molti altri linguaggi (Java, C++), un buon IDE (eclipse/netbeans) genererà automaticamente questi setter e getter per te.

Potrebbe non essere immediatamente evidente per i tipi semplici, ma se è necessario eseguire qualsiasi tipo di elaborazione più complessa, diventa più ovvio.

Answer 3

Nelle lingue che non hanno le proprietà (le "variabili" del membro pubblico che in realtà portano a chiamate di funzione) si consiglia di utilizzare getter/setters invece di variabili pubbliche. Altrimenti non è possibile aggiungere la logica (ad es. Quando si imposta una variabile) in un secondo momento se le persone stanno già utilizzando il campo normale.

Dal momento che PHP è un tale linguaggio (purtroppo) la risposta è sì, li usa.