Buenas tardes, hoy veremos la segunda parte del Capitulo 6, en las que veremos las Association relationships y Composition relationships un poco en practica con buenos ejemplos, para que nos quede todo mas claro.
El objetivo de esta parte es el desarrollo del código que implemente clases simples de asociación, código que implemente la multiplicidad usando arrays, y reconocer el código que implementa la composición como oposición a asociaciones simples, y el código que implemente la navegación de asociaciones (Association Navigation)
En esta sección veremos ejemplos prácticos de association y composition. Esto tambien demostrará como se representan las diferentes multipicidades en el código. Los siguientes ejemplos y explicaciones deberían ayudar a proveer un entendimiento sólido de estos conceptos.
Las siguientes puntos serán los que veremos:
|
|---|
Examples of Class Association Relationships
Aquí veremos las relaciones de clases por Association. Lo siguientes 3 ejemplos demostrarán las posibles multiplicidades de una aggregation association. Una explicación acompañará los puntos mas importantes de los ejemplos:
- One-to-one class association
- One-to-many class association
- Many-to-many class association
One-to-one Clas Association
El siguiente ejemplo es un objeto Truck y un objeto Trailer. Esto es un ejemplo de una Direct Association:
public class Truck {
Trailer trailer;
void setTrailer(Trailer t){
trailer=t;
}
//El resto de la clase Truck
}
En este ejemplo de una asociación one-to-one, el objeto Truck contiene una referencia a un objeto Trailer. Esto es una one-to-one association porque la variable trailer es una variable sola. No es parte de un array o una colección. Este ejemplo es de una direct association ya que el objeto Truck no es responsable del ciclo de vida de la variable trailer. Otra indicación de que es una direct association es que lógicamente el objeto Truck tiene un objeto Trailer. Ene ste ejemplo y en la mayoría que se nos dé en situaciones reales, esto no es siempre facil o casi posible determinar si un objeto controla el ciclo de vida de otro. A menudo, deberemos hacer la mejor determinación basada en la información que tenemos disponible. En este ejemplo la variable trailer está siendo establecida por el método setTrailer. Desde que este método es usado para establecer un valor en la variable, se puede asumir que otros objetos contienen una referencia al objeto trailer.
Finalmente, desde que fue determinado a ser una direct association, la relación puede ser generalizada como una Association Relationship.
One-to-many Class Association
El siguiente ejemplo muestra una aggregation association. Tiene una relación one-to-many. Los objetos Wheel serán parte del objeto Car.
public class Car {
Wheel[] wheel = new Wheel[4];
void setWheels (Wheel w){
wheel[0] = w;
wheel[1] = w;
wheel[2] = w;
wheel[3] = w;
}
//El resto de la clase Car va aquí
}
Este ejemplo tiene un array de objetos Wheel. Desde que el objeto Car tiene 4 objetos Wheel, esta relación es one-to-many. Con una relación one-to-many los múltiples obetos serán normalmente almacenados en un array o en una colección, como por ejemplo un Vector. Este ejemplo es una aggregation asociation desde que el objeto wheel forma parte del objeto Car. Ya que es una relación débil y no hay responsabilidades de ciclos de vida, esto puede ser generalizado como una Association.
Many-to-many class association
Las relaciones many-to-many son mas complejas que las vistas previamente. Esta relación la llevaremos a cabo con un grupo de objetos Car y un grupo de objetos TrafficLight. Los siguientes segmentos de código nos meustran los 2 objetos:
public class Car {
TrafficLight[] allTrafficLights;
Car(TrafficLight[] trafficLights){
allTrafficLights = trafficLights;
}
}
public class TrafficLight {
int lightID;
TrafficLight (int ID){
lightID = ID;
}
}
El siguiente segmento de código es el que crea ambos objetos. Este segmento es importante porque muestra como se forman las relaciones entre 2 objetos:
public class TrafficSimulator {
Car[] cars = new Car[3];
TrafficLight[] trafficLights = new TrafficLight[8];
public static void main (String[] args){
new TrafficSimulator();
}
TrafficSimulator(){
for (int i = 0; i<trafficLights.length;i++){
trafficLights[i] = new TrafficLight(i);
}
cars[0] = new Car(trafficLights);
cars[1] = new Car(trafficLights);
cars[2] = new Car(trafficLights);
}
}
Este segmento contiene un método main. El único trabajo de main es crear un nuevo objeto TrafficSimulator. El objeto TrafficSimulator contiene un array de objetos Car y TrafficLight. Primero son creados los objetos TrafficLight. Cada objeto TrafficLight almacena un ID único. Despues, es creado el objeto Car. Cada objeto Car contiene un array de objetos TrafficLight. Este ejemplo es una relación many-to-many porque cada objeto Car tiene el mismo número de objetos TrafficLight. Esta relación puede ser clasificada como direct association porque los objetos Car tiene un array de objetos TrafficLight.
Examples of Class Composition Relationships
Esta sección es similar a la anterior excepto que mostraremos la Composition Association. Estas solo permiten 2 multiplicidades. Tendremos un ejemplo seguido de su explicación.
One-to-one Composition
Este ejemplo demostrará una relación one-to-one de composition. Será una composition association ya que es el único tipo de association que puede crear una composition relationship.
public class Tire {
TireAirPressure tireAirPressure;
Tire(){
tireAirPressure = new TireAirPressure();
}
}
En este ejemplo, el objeto Tire y el objeto TireAirPressure tienen una relación one-to-one. El objeto Tire está compuesto por el objeto TireAirPressure. Esto representa una Composition Association. La relación entre los 2 objetos es fuerte, ya que el objeto Tire tiene un manejo del ciclo de vida y es responsable del objeto TireAirPressure. Si el objeto Tire fuera destruido, el objeto TireAirPressure tambien desaparecería.
One-to-many Composition
Este ejemplo final demostrará una composition relationship con una multiplicidad one-to-many. El siguiente segmento es una clase SensorStatus:
public class SensorStatus {
int status;
public SensorStatus(int newStatus){
status = newStatus;
}
}
El siguiente segmento demuestra como un objeto CarComputer está compuesto por un array de 5 objetos SensorStatus:
public class CarComuputer {
SensorStatus[] sensorStatus = new SensorStatus[5];
public void CarComputer(){
sensorStatus[0] = new SensorStatus(1);
sensorStatus[1] = new SensorStatus(1);
sensorStatus[2] = new SensorStatus(1);
sensorStatus[3] = new SensorStatus(1);
sensorStatus[4] = new SensorStatus(1);
}
}
Desde que el objeto CarComputer tiene 5 objetos SensorStatus, este representa relación one-to-many. Es una relación de composition association. De nuevo vemos que es una relación fuerte y que el array de SensorStatus depende del objeto CarComputer para manejar su ciclo de vida.
Examples of Association Navigation
Es la habilidad de navegar en una relación. El siguiente ejemplo muestra un objeto PinStripe que está compuesto por un objeto Color.
public class PinStripe {
Color color = new Color(2);
Color getColor(){
return color;
}
}
En este ejemplo, cualquier objeto que tiene acceso al objeto PinStripe podría usar su método getColor(), que es considerato un getter, para navegar por el objeto Color. En este ejemplo, la navegación es solo unidireccional (en una sola dirección).
Hasta aquí el Capitulo 6, en el cual hemos terminado viendo unos ejemplos de las relaciones de la Parte I pero vistas en aplicación con clases de ejemplo, que siempre es mas facil entenderlo con ejemplos.
Cualquier corrección o aporte es bienvenido.
Saludos!!!