Java - Duda sobre herencia

Hola, tengo una duda sobre herencia...

Tengo el siguiente escenario: clase B hereda a la clase A. En la aplicación existen objetos de ambas clases de tal manera que cuando tengo un objeto de la clase B puedo acceder a atributos y métodos de la clase A. Hasta ahí todo correcto.

El problema es que por características de la aplicación, un objeto de la clase B puede pertenecer a varios objetos de la clase A. Digamos que por características se puede dar ese caso. No es herencia múltiple porque siempre hereda de la misma clase (A) pero no es tampoco herencia simple.

Rompiendo la herencia se puede implementar si en la clase B se añade un array de objetos de clase A como atributo pero claro, pierdes las propiedades de la herencia.

Alguno se ha encontrado algo parecido y lo ha resuelto con Java? No se si ha quedado muy claro el problema, espero que sí ;-)

Gracias!
Kike.

Creo k t estas liando un poco,,k 2 clases esten relacionadas, no significa que una herede de la otra....
Un herencia multiple no esta permitido en Java, una clase Java unicamente puede heradar de 1 unica clase...y esta a su vez de otra,,,y asi sucesibamente, por lo tanto , siempre hay herenia simple. En cambio si pueden implemtar multiples interfaces.

En tu caso,,no se ,,pero t da algun problema k 2 clases de tipo A, tnga una referncia al mismo objeto B....??' Solo tiene l inconveniente de que si modificas el objeto B s modifica para las 2 d tipo A, ya que hacen referencia a la misma direccion de memoria.

Saludos..

Como ya te ha dicho angel estás mezclando cosas.

La herencia es una relación entre *clases* y las que tú describes (que un B pertenezca a varios A) son relaciones entre *objetos*.

¿Cómo se llaman tus clases realmente (no A y B, sino sus nombres reales, con significado) y cuál es su relación?

Entiendo lo que decís (herencia de clases y no de objetos) pero no lo veo claro en mi ejemplo. Le voy a poner nombres...

Clase A: Solucion (es una clase con características de una solución)
Clase B: Patron (es una clase que contiene caracteristicas más específicas de la clase Solucion)

Es decir, en un objeto de la clase Patron tenemos sus propiedades y las propiedades de la Solucion que son más genéricas.

El problema viene de la relación que tienen los objetos de ambas clases que son de muchos a muchos. Es decir, una Soluciones puede tener varios patrones y un patrón puede pertenecer a varias soluciones...

Espero haberme explicado bien... ;-)

Gracias por las respuestas!
Kike.

Te estás liando:
"en un objeto de la clase Patron tenemos sus propiedades y las propiedades _de_ un_ objeto_ de_ clase_ Solucion que son más genéricas."
Esto quiere decir que un OBJETO patron contiene atributos de un OBJETO solución, y se hace imposible que un objeto tenga dos "padres".

Lo que parece que quieres hacer, o lo implementas sin usar la herencia, o lo pones más extendido para que se entienda :-)

Por decir algo (a boleo) mira a ver si lo que necesitas es algo así:

class Solucion {
}

class Patron {
}

class Camino {
Solucion s;
Patron p;
}

Lo único que se me ocurre es hacerlo sin herencia... Algo así

class Solution {
}

class Patron {
Solution s[];
}

De esta manera funcionaría pero tendrías que hacer métodos no simples para encontrar todos los patrones que pertenezcan a la misma solución

Otra opción sería:

class Solution {
Patron[];
}

class Patron {
}

De esta manera directamente tendríamos directamente los patrones que pertenecen a una solución. Lo más costoso en este caso sería encontrar las soluciones que implementa un patrón.

Yo quiero algo de este estilo

[****]
class Solution {
}

class Patron extends Solution {
}

El problema es que no hay una equivalencia 1 a 1 entre Patron y Solution sino n a n. En concreto un patron pertenece a varias soluciones.

Ejemplo:

Objeto solucion1 (contiene atributo11, atributo12, atributo13 de la solucion)
Objeto solucion2 (contiene atributo21, atributo22, atributo23 de la solucion)

Objeto patron (contiene atrpatron1, atrpatron2)

En la realidad me interesaría que al instancia el objeto patron tuviese los atributos: atributo11, atributo12, atributo13 de la solucion1, atributo21, atributo22, atributo23 de la solucion2 y por suspuesto, los suyos atrpatron1, atrpatron2

En el caso de que un patron solamente perteneciese a 1 solucion la solución de herencia [****] sería correcta, pero al poder tener varios no se me ocurre hacerlo con herencia...

Gracias again por las respuestas
Kike

Ten paciencia conmigo, a ver si llegamos a algo, por favor.

No acabo de tener claro a qué te refieres con Solución, Patrón y Atributo. ¿Podrías decir qué son, qué representa cada uno?

Incluyo Atributo porque tal como lo cuentas parece que quizá Atributo debería ser un tipo particular. No sé si cuando hablas de los atributos y dices que tal Solución "contiene" tales atributos, los consideras como una clase (Atributo de la cual atributo11 o atributo23 son diferentes instancias) o si son propiedades de Solución (y atributo11 es simplemente un *valor* posible de una propiedad de Solución).

Si aclaras esto, quizá podamos pensar una estructura más clara.


Ah, y no me has respondido realmente a cuál es la relación (con palabras normales, no te preocupes por si extiende o no extiende) que hay entre una Solución y un Patrón.
Pregunto esto (aunque te parezca pesado) porque es muy importante. Esa relación es la que define si un Patron *es una* Solution, o si un Patron *tiene una* Solution, o si un Patron *es un tipo de* Solution, etc.

Da un paso atrás. Olvida por un segundo si una clase ddebe extender a otra o si ddebe tener un Array de otras y piensa simplemente en la descripción funcional de lo que quieres representar.

En primer lugar gracias por las respuestas, sino he respondido antes es porque he estado fuera...

Con atributo me refiero a una propiedad de una clase. A mí me lo enseñaron con ese nombre.

Ej:

class Solution {
int value;
}

value sería un atributo de la clase Solution.

Respecto a las relaciones entre las clases sería: Un Patron es una (o varias) Solution y una Solution tiene uno (o varios) Patrones.

La relación Patron - Solution es algo confusa. Realmente sería: Un Patron implementa una (o varias) Solution.

Una Solution tiene varios atributos generales de una solucion de seguridad informatica. Un Patron tiene atributos mas especificos de esa solucion de seguridad y tiene informacion a mas bajo nivel sobre la implementacion de esa solucion de seguridad.

Así, tenemos que una misma solucion de seguridad (Solution) puede tener varias implementaciones (Patron).

Por otro lado, una implementacion (Patron) puede pertenecer o ser solucion de una o varias soluciones de seguridad (Solution)

Gracias y un saludo!
Kike.

Lo siento pero no acabo de tener claras algunas cosas.

>Con atributo me refiero a una propiedad de una clase.

Bien, a lo que me refiero es, cuando antes decías:

>Objeto solucion1 (contiene atributo11, atributo12, atributo13 de la solucion)
>Objeto solucion2 (contiene atributo21, atributo22, atributo23 de la solucion)

atributo11, atributo12, etc, son valores? o quieres decir que solucion1 tiene esos atributos rellenos y el resto en blanco?

Es decir, sería algo así?:
class Solution {
int atributo11, atributo12, atributo13;
int atributo21, atributo22, atributo23;
// etc ...
}
Solution solucion1 = new Solution();
solucion1.setAtributo11(1);
solucion1.setAtributo12(2);
solucion1.setAtributo13(3);
Solution solucion2 = new Solution();
solucion2.setAtributo21(1);
solucion2.setAtributo22(1);
solucion2.setAtributo23(1);

O sería así?:
class Solution {
int atributo1, atributo2, atributo3;
// etc ...
}
Solution solucion1 = new Solution();
solucion1.setAtributo1(11);
solucion1.setAtributo2(12);
solucion1.setAtributo3(13);
Solution solucion2 = new Solution();
solucion2.setAtributo1(21);
solucion2.setAtributo2(22);
solucion2.setAtributo3(23);

O sería incluso algo así?:
class Solution1 {
int atributo11, atributo12, atributo13;
// ...
}
class Solution2 {
int atributo21, atributo22, atributo23;
// ...
}

Es decir, a lo que voy es a lo siguiente: ¿Hay realmente una clase Solution genérica y todas las soluciones tienen los mismos atributos? ¿Hay una clase Solution que tiene un montón de atributos pero cada objeto solución sólo usa unos cuantos atributos determinados? ¿Hay diferentes clases Solution?


Además, necesitas definir claramente qué es lo que representa Solution y qué es lo que representa Patron. Y sobre todo, necesitas definir claramente qué relación hay entre ellas __antes__ de decidir si Patron extends Solution o si necesitas tener un Array o detalles así.

Sobre todo, lo que me pregunto es por qué quieres que Patron herede de Solution. Que una clase herede de otra es una relación mucho más fuerte que simplemente usar o tener objetos de otra. ¿Realmente hay una relación tan fuerte entre Solution y Patron?

Gonzalo,

Sería así:

class Solution {
int atributo1, atributo2, atributo3;
// etc ...
}
Solution solucion1 = new Solution();
solucion1.setAtributo1(11);
solucion1.setAtributo2(12);
solucion1.setAtributo3(13);
Solution solucion2 = new Solution();
solucion2.setAtributo1(21);
solucion2.setAtributo2(22);
solucion2.setAtributo3(23);

los he nombrado (creando confusión, lo admito ;-) con atributo11, atributo21 para señalar que tienen diferentes valores pero realmente son los mismo atributos.

¿Hay realmente una clase Solution genérica y todas las soluciones tienen los mismos atributos?
Exacto

¿Hay una clase Solution que tiene un montón de atributos pero cada objeto solución sólo usa unos cuantos atributos determinados?
No, es más exacto lo anterior

¿Hay diferentes clases Solution?
No, hay una clase Solution y una clase Patron

Realmente veo que la herencia es necesaria porque un Patron es una Solution pero con informacion de más bajo nivel. Es decir, en la clase Solution se definen los metodos ya tributos comunes a todas las soluciones de seguridad de un determinado nivel. En la clase Patron se definen métodos y atributos más específicos de una solucion de seguridad

El problema que veo yo es que un Patron puede implementar varias soluciones de alto nivel (de la clase Solution).

Gracias y espero haber aclarado un poquito las cosas.
Kike

Bueno, veamos.

Tenemos claro entonces que:
- Hay una clase Solution con unos atributos.
- Hay una clase Patron.

Quieres que Patron tenga:
opción a. Los mismos atributos que Solution (ojo: NO los mismos valores que una solución determinada) y luego algunos atributos más.

opción b. Algunos atributos específicos propios y luego además, una relación con una o más Solutions que tendrán sus atributos.

Yo lo que entiendo (lo que empiezo a intuir) es que realmente lo que quieres es la opción b. Lo digo porque realmente tú no quieres relacionar Patron (como clase) con Solution (como clase) sino que lo que quieres es relacionar un determinado Patron con una (o más) determinadas Solutions.

Así tendrías:
class Patron {
int atribDePatron1, atribDePatron2, ...;
Solution[] solucionesImplementadas;
}
Es decir, que Patron tendría una serie de atributos propios y, además, una serie de soluciones que implementa.

No sé, pero al menos yo no veo que realmente Patron _sea_ una Solution.
>Realmente veo que la herencia es necesaria porque un Patron es una Solution
>pero con informacion de más bajo nivel.

¿Seguro? Quiero decir... quizá sí, pero esa relación que tú ves desde el punto de vista funcional, es una relación real? Es decir, ¿tiene sentido la frase "Patron es un tipo de Solution"?

Creo q tienes razón...

Quizás lo más sensato sería hacer algo de estilo, muy parecido a lo que tú propones...

class Solution {
int atrSol1, atrSol2, ...
Patron[] patrones;
}

class Patron {
int atrPatron1, atrPatron2, ...
Solution[] solutions;
}

De esta manera, a pesar de tener información redundante, tendríamos siempre una lista de patrones o soluciones asociadas (según el caso).

Por tanto, cuando tenga una solcuion, tendré disponible la informacion de los patrones que la implementa y cuando tenga un patron tendré disponible la informacion de las soluciones implementadas.

Creo que es lo más útil...

Gonzalo, gracias por tu tiempo y tus respuestas...
Kike.

PD. Postearé si veo pegas o saco más conclusiones...

que tal en esta pagina puede haber una informacion que te puede servir

http://www.sakux.com/content/relaciones-entre-objetos

saludos