Para que te hagas una idea, tengo una especie de tienda virtual que puede
vender productos de cualquier tipo. Para vender un producto solo se
necesitan dos cosas:

1. Crear un codigo de producto nuevo en la base de datos
2. Asociar dicho producto a una clase que se encarga de "tratarlo". Una
misma clase puede gestionar multiples productos. Añadir nuevas clases es
tan sencillo como compilarlas y dejarlas en un directorio.

¿Como se cargan? Asi:

ProductosBase pbase = ProductosBase.GetProduct("1234");
pbase.generarformulario();
....
....
pbase.procesarformulario();
pbase.insertar();

El método GetProducto(codproducto) busca en una tabla de la base de datos
la clase que hay que crear (que debe descender de ProductosBase), y
devuelve un objeto del tipo adecuado. El codigo seria mas o menos este (lo
siento, es "cuasi" c#, no uso java):

function ProductosBase GetProducto(string codproducto){
string clase = ObtenerClaseDeBBDD(codproducto);
return (ProductosBase)Activator.CreateInstance(clase);
}



> Hola gente,
>
> Pues aunque no me prodigo mucho escribiendo al foro
> ultimamente, pero ahí sigo leyendo (casi) todo lo que
> escribís...
>
> Bueno, ando con una duda de análisis-diseño OO sobre
> J2SE 1.4.2 (si ya se que anda la 1.5.0 desde hace
> algún tiempo, y que la 1.6.0 está ya a la vuelta de la
> esquina..pero eso no viene al cuento) a ver de las
> mentes pensantes que sepan más que yo quien me puede
> echar una mano. La situación es como sigue:
>
> Tengo una unidad de algo que declaro como abstracto y
> que encapsula todo lo común a los diferentes tipos de
> unidades concretas que puedo encontrar. A día de hoy
> conozco en torno a unas 20-25 tipos de unidad
> concretas, pero no estoy seguro que en el futuro
> puedan aparecer otras, así que quiero dejar la puerta
> abierta. Hasta aquí sin problemas ya que para crear
> nuevas, simplemente heredo una nueva subclase concreta
> de mi superclase Unidad.
>
> El punto es que para averiguar el subtipo concreto no
> me quedaría de otra que usar el getClass(). No soy muy
> amigo de usar ese método por ciertas razones, así que
> empiezo a pensar y se me ocurre que podría tener un
> campo tipoUnidad, de tipo int y tener una serie de
> constantes (final) que identificasen de forma concreta
> a las subclases:
>
> Ej:
> public static final int UNIDAD_CONCRETA_A=1;
> public static final int UNIDAD_CONCRETA_B=2;
> ...
>
> Y aquí viene el problema; Si estas constantes las
> pongo en la superclase no me quedará de otra que
> violar el encapsulamiento si eventualmente aparecen
> nuevas clases concretas. Pero si decido bajarlo a las
> subclases y que cada subclase defina su constante
> resulta que no puedo asegurar que cada subclase elija
> un valor distinto a las otras ya que las subclases no
> necesariamente se conocen entre si...amén de que no
> tendría todas las constantes en la misma clase y eso
> supone un problema a la hora de usarlas...
>
> A alguien se le ocurre algo más, que no sea el ya
> mencionado uso de getClass()? Algún patrón de diseño
> por ahí que haga esto?
>
> En fin, cualquier sugerencia será bienvenida...sino,
> me temo que tenré que usar el getClass() "manque" me
> pese...
>
> Saludos,
>
> Felipe
>
>
>
>
________________________________________________________________________________\
____
> Any questions? Get answers on any topic at www.Answers.yahoo.com. Try it
> now.
>