Mi primer objeto - critiquen!!!

[Italico76]

Amigos: este es mi primer intento de hacer un objeto en cualquier lenguaje y quiero que critiquen el diseño, implementacion y demas

La idea es simplificar la forma de hacer enlaces de texto o enlaces a imagenes y evitar usar parametros opcionales y otros enredos.

A continuacion mis clases "link2text" y "link2graph"

Código PHP:

  <? 
// Voy a intentar hacer la clase ENLACE (mi primer objeto)
 
class Img {  // clase img 
  private $url; 
  private $alt; 
  private $border;    
   
  function __construct($url){ 
   $this->url=$url;   
   $this->setborder(0);
  } 
  
 function addAlt($alt){
   $this->alt="alt='$alt'";
  }  
  
 function setBorder($border){
   $this->border="border='$border'";
 } 
 
  function getImg(){
   return $this->url; // aca habia un error (!)
 } 
 
 function getAlt(){
   return $this->alt;
 } 
  
 function show (){
  return "<img src='$this->url' $this->alt $this->border  />";           
 }     
} 
 
abstract class link { // super-clase no-instanciable
  protected $url;   
  protected $title; 
  protected $target; // relacionado con newPage()
    
 function __construct($url){ 
   $this->url=$url;        
 }     
  
 function addTitle($title){
   $this->title="title='$title'";   
 }
 
 function newPage(){
   $this->target="target ='_blank'";
  }  
 
 function getTarget(){
   return $this->target;
 }  
 
 function getUrl(){
   return $this->url;
 } 
}
 
class Link2text extends link{    // clase Link a texto
  private $anchor; 
    
  function __construct($url,$anchor){ 
   parent::__construct($url); 
   $this->anchor = $anchor; 
  } 
 
 function setAnchor($anchor){ // faltaba (!)
   $this->anchor=$anchor;
 }
 
 function getAnchor(){  // tenia un error (!)
   return $this->anchor;
 }
 
 function __toString() {  // 'metodo magico'  que genera una salida (me evito ponerle nombre a la funcion porque se ejecuta sola al hacer echo o print)
   if (isset($this->title)){
     $title=' '.$this->title;
   }else{     
     $title=$this->title;
   }     
   return "<a href='$this->url'".$title."$this->target>$this->anchor</a>";
 } 
}
 
class Link2graph extends link{  // clase Link a Grafico  
  private $imagen;
    
  function __construct($url,$img_url){ 
   parent::__construct($url);    
   $this->imagen = new img($img_url);    
  }
  
  function addAlt($alt){
   $this->imagen->addAlt($alt); // uso el metodo add_alt de la clase IMG
  }  
    
 function __toString (){       
   $img = $this->imagen->show();    
   $title=$this->title;        
    return "<a href='$this->url'  $this->title $this->target >$img</a>";
 }   
}
 
?>}  

Aca como la uso:

Código PHP:

  <?php
Include "clases.inc";
 
$enlace = new link2text("http://www.betadir.com","directorio de blogs");    
$enlace->add_title("directorio de blogs");
echo $enlace->show()."<p/>"; 
 
$enlace2 = new link2graph("http://www.asesdeljuego.com","http://www.asesdeljuego.com/juegos/100/finalfight.jpg");    
$enlace2->add_alt("juegos flash");
$enlace2->add_title("Juegos de lucha");
$enlace2->set_border(0);
echo $enlace2->show(); 
 
?>   

[lucasan]

Pues no soy experto para criticar tu objeto, pero lo que si veo es que es mas complejo usar la clase que hacer un simple:

<a href="http://loquesea.com" title="lo que sea">Lo que sea</a>

Que tu método; entonces no me atrevo a criticarlo como objeto, pero si me atrevo a decir que no es muy util.

Pero aplaudo fuerte tu iniciativa, la de aprender, excelente.

Ahora si, le doy paso a los expertos para que puedan dar su opinión al respecto.

[Italico76]

Lucas san: gracias por tu comentario

El tema es que tengo sitios relativamente complejos (miles de lineas de codigo) donde necesito muchas veces enlazar algo pero con diferentes parametros: anchors con strong, imagenes, imagenes pero con un alt, etc etc etc

Me estaba volviendo loco pasando mil parametros a funciones bastante complejas para ir reutilizando el codigo....... cuando en realidad lo que necesitaba era "extenderlo" y eso lo veo mas facil usando clases.

La verdad es que no se nada de objetos pero tuve un par de clases introductorias en la universidad y me dieron ganas de pensar alguna cosa que me fuera util

Gracias! y espero mas criticas!

[Acron_0248]

Realmente si es o no más fácil crear la tag ya hecha es en realidad cosa de perspectiva y en cuanto a la programación orientada a objetos se podría decir que la valía es la capacidad de crear "planos" sobre los cuales se pueda construir independientemente de las características de un proyecto :)

Sobre el objeto, no soy alguien de mucho saber pero me tomaré la libertad de apuntar algunas cosas si se me permite:

- El constructor lo podrías aprovechar mejor, los métodos add_anchor y add_title podrían simplemente implementarse dentro del constructor, por ejemplo:

Código PHP:

   function __construct($url, $anchor, $title){  
   $this->url=$url;         
   $this->anchor = $anchor;
   $this->title = $title;
 } 
   

De esa forma podrías crear el objeto así:

Código PHP:

  $enlace = new link('http://www.betadir.com', 'Directorio web', 'directorio de blogs'); 
   

- Tal vez esto sea cosa de preferencias y formas de programar pero a mi parecer deberías aprovechar el constrcutor y los métodos que usas para verificar los datos pasados en las variables, es decir, algo similar a:

Código PHP:

  function __construct($url){  
   if ($url == "") {
       throw new Exception('No se indicó ninguna dirección.');
   } else {
       $this->url=$url;
   }
} 
   

Lo de si usar Exception o simplemente die('Error') es cosa de preferencias también, pero referente al tema de la validación de los datos guardados en las variables podría ser algo en lo que te esmeres más dentro de los de los objetos.

Verificar si está vacía o no una variable la coloco como ejemplo, pero dependiendo de la fuente de los datos y en qué serán usados, muchas cosas más son las que puedes validar, por ejemplo, qué pasa si creo el objeto de esta manera utilizando tu actual clase?

Código PHP:

  $enlace = new link("<script>alert('Hola');</script>");
echo $enlace->show(); 
   

- En el método show no es necesario reasignar variables, es decir, no es necesario utilizar $url = $this->url, podrías simplemente generar el enlace con lo que ya existe y evitarte trabajo:

Código PHP:

  function show(){     
    $imagen="<img src=\"$this->img\" $this->alt $this->border />";     
    return "<a href=\"$this->url\"  $this->title >$imagen </a>";
} 
   

Tal vez pueda agregar más pero debo partir porque los perros quieren bajar =/

[Italico76]

Acron_0248: gracias desde ya!!! excelentes criticas!!

Lo de porque no le paso mas parametros al __construct es porque justamente quiero generalizar.
Actualice el post y ahora la CLASE LINK es abstracta y es heredada por las clases LINK2TEXT y LINK2GRAPH para enlaces a texto y graficos respectivamente.

Estrictamente en este problema, pasarle un anchor a la clase LINK no tendria sentido porque si lo que quiero enlazar es un grafico, el anchor no me serviria de nada (pero quizas no quedaba claro al principio cuando solo estaba la superclase Link y la clase hija link2graph)

Gracias de nuevo! voy a hacer una version mejorada con algunas cosas que me decis

Y sigan criticando que quiero aprender!

[Acron_0248]

Iniciado por Italico76

Estrictamente en este problema, pasarle un anchor a la clase LINK no tendria sentido porque si lo que quiero enlazar es un grafico, el anchor no me serviria de nada (pero quizas no quedaba claro al principio cuando solo estaba la superclase Link y la clase hija link2graph)

En eso tienes toda la razón, realmente no lo pillé bien por el apuro que me tenían los perros je je

Ahora, sobre la abstracción, aclárame algo, ¿tu código actual es para trabajar en servidores con versión php5?

Al principio asumí que utilizabas cosas como var $variable por razones de compatibilidad para que funcione la clase en servidores con php4, pero al ver que agregas abstract (tal vez no lo sepas, por eso pido aclaración) quedo confundido.

Cosas como el abstraccionismo, polimorfismo, protección de variables, overriding y demás están disponibles a partir de php5, es decir que en un servidor con php4 una clase abstracta no funcionará, el motor no tiene cómo procesar eso.

Si la clase la estás haciendo pensando en php5, entonces no hay necesidad de utilizar cosas como var $variable, simplemente aprovecha los diferentes tipos de accesos disponibles para propiedades y métodos como public, protected, private, final....

Por ejemplo, en la clase abstracta que igual terminarás extendiendo para implementar los métodos complementarios, los métodos podrían ser definidos como protected, incluyendo al constructor.

[Italico76]

Si la clase la estás haciendo pensando en php5, entonces no hay necesidad de utilizar cosas como var $variable, simplemente aprovecha los diferentes tipos de accesos disponibles para propiedades y métodos como public, protected, private, final....

Perdon! no tenia idea de nada asi que entre a mirar tutoriales y parece que hice un mix con PHP 4

Lo del tema del protected,...... es otra buena idea que voy a tomar

Muchisimas gracias!!!!!!!!!!!!!

[Italico76]

Ahora me surgió una duda: si la clase es ABSTRACT (o sea que es una super-clase), tiene sentido proteja las variables con protected ? o simplemente les pongo public ?

Puede ser que ponerles "protected", refuerce la idea pero no si es necesario (porque no se nada de POO)

Gracias desde ya!!!

PD: obviamente que cualquier cosa es mejor que dejar un "var" que es incorrecto (como bien dice Acron) y genera una advertencia E_STRICT.

[Acron_0248]

Abstract no define realmente control de acceso a propiedades o métodos, al menos no de la forma que lo hacen private, protected y similares.

Abstract solo indica que un método se ha declarado en una clase pero que en dicha clase no se ha definido la implementación del método, quiere decir que otras clases hijas se deberán encargar de esa implementación

Sin embargo, cierto es que una clase abstracte no debe ser implementada de forma directa al crear un objeto, sino que debería ser extendida y luego crear un objeto de la clase hija, en dicho sentido, sip, puedes ver el usar cosas como protected o private en una clase abstracta como un refuerzo, obviamente el dejar las propiedades y métodos como públicos en una clase abstracta no es que esté mal.

En todo caso, si defines cosas como protected o private en una clase abstracta lo que estarás definiendo es la forma en que las clases que extiendan a la abstracta van a funcionar, esto sería un ejemplo de ello:

Código PHP:

  abstract class Operacion 
{
    private $_operando1;
    private $_operando2;
    protected $_resultado;
 
    protected function __construct($operando1, $operando2)
    {
        $this->_operando1 = $operando1;
        $this->_operando2 = $operando2;
        $this->_resultado = $this->_operando1 + $this->_operando2;
    }
 
    public abstract function resta($operando1, $opreando2);
}
 
class SumaResta extends Operacion
{
    public function __construct($num1, $num2)
    {
         if ($num1 == "" || $num2 == "") {
             die('No hay nada que sumar.');
         } else if (!ctype_digit($num1) || !ctype_digit($num2)) {
             die('Solo se aceptan námeros para hacer la suma.');
         } else {
             parent::__construct($num1, $num2);
             echo $this->_resultado;
         }
    }
 
     public function resta($num1, $num2)
     {
          $this->_resultado = $num1 - $num2;
     }
} 
   

[Italico76]

Acron_0248: wow, ahora si que fui desbordado con ese ejemplo que te trajistes

Muy complejo para mi je je / te agradezco un monton todo el tiempo que le me haz dedicado

Aca mi version "final" en la que incluyo la clase "IMG" que arma una imagen, la cual es usada para hacer los enlaces graficos:

Código PHP:

  <?

class img {  // clase img 
  private $url; 
  private $alt; 
  private $border;    
  
  function __construct($url){ 
   $this->url=$url;   
   self::set_border(0);
  } 
  
  function add_alt($alt){
   $this->alt="alt='$alt'";
  }  
  
 function set_border($border){
   $this->border="border='$border'";
 } 

  function dame_img(){
   return $this->img;
 } 

 function dame_alt(){
   return $this->alt;
 } 
 
 function show (){
  return "<img src='$this->url' $this->alt $this->border />";           
 }     
} 

abstract class link { // super-clase no-instanciable
  protected $url;   
  protected $title; 
    
 function __construct($url){ 
   $this->url=$url;        
 }     
  
 function add_title($title){
   $this->title="title='$title'";
 }
 
 function dame_url(){
   return $this->url;
 } 
}

class link2text extends link{    // clase Link a texto
  private $anchor; 
    
  function __construct($url,$anchor){ 
   parent::__construct($url); 
   $this->anchor = $anchor; 
  } 

 function dame_anchor($anchor){
   return $this->anchor;
 }
   
 function show(){ 
   $url=$this->url;
   $anchor=$this->anchor;
   $title=$this->title;        
   return "<a href='$url'  $title >$anchor </a>";
 } 
}

class link2graph extends link{  // clase Link a Grafico  
  private $imagen;
    
  function __construct($url,$img_url){ 
   parent::__construct($url);    
   $this->imagen = new img($img_url);    
  }
  
  function add_alt($alt){
   $this->imagen->add_alt($alt); // uso el metodo add_alt de la clase IMG
  }  
    
 function show(){       
   $img = $this->imagen->show();    
   $title=$this->title;        
 return "<a href='".$this->url."'  $title > $img </a>";
 }   
}

?>   

[Acron_0248]

Iniciado por Italico76

Muy complejo para mi je je / te agradezco un monton todo el tiempo que le me haz dedicado

Neh, te aseguro que es una ilusión óptica ;)


Con respecto a la clase, algunas cosillas si me lo permites:

- La clase link no es abstracta por lo que no debería ser definida como tal, y la razón es que ninguno de los métodos en la clase carece de implementación, como tal vez te llegaste a confundir con alguna cosa, lo explico con ejemplos:

Esto es un método con implementación:

Código PHP:

  function add_title($title){
   $this->title="title='$title'";
 } 
   

En el método se ve "lo que se hace" con el parámetro pasado.

Esto es un método abstracto:

Código PHP:

  abstract function add_title($title); 
   

Acá sólo se ve que existe un método llamado add_title y que debe recibir un parámetro, pero en ningún momento se aprecia qué es lo que se hace con ese parámetro, por ello se considera y define como abstracto.

- El "self::" deberías usarlo cuando estés haciendo referencias a constantes o propiedades y métodos estáticos. No es que no puedas llamar a cualquier cosa self::metodo o self::propiedad o incluso clase::metodo, simplemente digamos que se ha tomado como una práctica (para evitar confusiones) el utilizar el operador de resolución de scope solo cuando se hace referencia a constantes y propiedades/métodos estáticos.

Aclaro, no está mal lo que hiciste, solo lo apunto =)

- El método show() de la clase link no necesita reasignar propiedades como te dije antes, simplemente con esto bastaría:

Código PHP:

   function show(){ 
   return "<a href='$this->url'  $this->title >$this->anchor </a>";
 } 
   

- Ya que no veo validación alguna en las clases, recuerda hacerlas en alguna otra parte de forma tal que los parámetros que lleguen a utilizarce en las clases ya estén validados.

[Italico76]

Acron: mil gracias por aportar luz a mi ignorancia

- El "self::" deberías usarlo cuando estés haciendo referencias a constantes o propiedades y métodos estáticos. No es que no puedas llamar a cualquier cosa self::metodo o self::propiedad o incluso clase::metodo, simplemente digamos que se ha tomado como una práctica (para evitar confusiones) el utilizar el operador de resolución de scope solo cuando se hace referencia a constantes y propiedades/métodos estáticos.

Muchas cosas que hago son por la mas pura ignorancia: no sabia que el $this-> funcionaba con metodos tal y como con atributos

Mi intencion de anteponer "abstract" a la superclase Link y es evitar se pueda instanciar. Como le antepuse un abstract, crei que con eso solo ya podia decir que era una clase abstracta

Gracias de nuevo por ayudarme!

PD: ya corregí el metodo show() como me indicastes

[Acron_0248]

Iniciado por Italico76

Mi intencion de anteponer "abstract" a la superclase Link y es evitar se pueda instanciar. Como le antepuse un abstract, crei que con eso solo ya podia decir que era una clase abstracta

Ignorante es aquel que tiene dudas y no pregunta =)

Sobre el abstraccionismo, desgraciadamente sin métodos abstractos una clase no puede ser abstracta.

Si te interesa evitar que una clase se pueda manipular directamente entonces simplemente debes definir sus métodos como protected o private, solo debes recordar que los private estarán disponibles solo para esa clase, definirlos como protected es mejor si esperas que la clase vaya a ser extendida y las clases hijas vayan a necesitar acceso a los métodos de la clase padre.

[GatorV]

Otro tip, en lugar de usar dame_link, o show(), mejor estandariza, te recomiendo usar el metodo __toString() que te da PHP para imprimir tus clases, por ejemplo:

Código php:

$link = new Link("texto", "pagina.php");
echo $link; // llama a __toString
 

Saludos.

[Italico76]

GatorV: hola,........ la verdad no entiendo como seria la implementacion en el caso de mis clases de eso que me dices con __string (?)

Podrias cambiar por ejemplo la clase Link2Text para que funcione como vos decis ? luego haria un echo como siempre del objeto ?

La verdad es que googleado bastante y no logro enganchar la idea

Gracias desde ya!

[Acron_0248]

Es simple, lo que te indica GatorV funcionaría así:

Código PHP:

  class link2text extends link{    // clase Link a texto
  private $anchor; 
    
  function __construct($url,$anchor){ 
   parent::__construct($url); 
   $this->anchor = $anchor; 
  } 
 
 function dame_anchor($anchor){
   return $this->anchor;
 }
   
 function __toString(){ 
   return "<a href='$this->url'  $this->title >$this->anchor </a>";
 } 
}
 
$link = new link2text('http://www.ejemplo.com', 'Mi Ejemplo!');
$link->add_title('Esto es un ejemplo');
echo $link; // mostrará: <a href='http://www.ejemplo.com' title='Esto es un ejemplo' >Mi Ejemplo!</a> 
   

[Italico76]

Ahora SI lo entendi!!! que bueno!!!!!!!!! me ahorro pensar el nombre de una funcion

function __toString() {
return "<a href='$this->url' $this->title >$this->anchor </a>";
}

Gracias!!!!!!

Acron: gracias a vos tambien! ahora que logre encontrar un ejemplo claro de los "metodos magicos" lo pude entender :)

Gracias a todoooooooooos!

[nx00]

solo una cosa que creo que nadie comento....

No tiene que ver con el objeto, es mas bien un consejo.

Código PHP:

  Include "clases.inc"; 
   

veo que llamaste a tu clase: clases.inc

Esto puede permitir que cuando subas tu "clases.inc" a un servidor alguien desde fuera lea tu código php y esto no debería ocurrir.

Podrias llamarla asi: clases.inc.php

[Italico76]

nx00: muy buen punto!!!!

gracias!!!

[enriqueplace]

Chicos, chicos, usen los estándares que para ello están: Clase.php

http://framework.zend.com/wiki/display/ZFDEV/PHP+Coding+Standard+(draft)

[Italico76]

Gracias Enrique.......

Vamos a ver que se puede hacer