cuál es la mejor práctica aquí ...
depende de su use case, ¿cómo está el usuario va a utilizar el sistema ?. ¿Sería un laboratorio "explotado" por un Person? o el caso de uso del sistema es tener algunos Person volar Labs?
o tal vez ni siquiera le importa: S
Al final el resultado es el mismo, pero lo importante aquí es la semántica del código. Si suena tonto que la gente explote Labs, entonces no lo hagas.
Así que la regla de oro, como mencionó BobTurbo, es encontrar al "experto en información" (ver: GRASP) en el sistema y darle el control a ese objeto.
Por lo general, se define una historia de usuario o narrativa de cómo se utilizaría el sistema, si, por ejemplo, la narrativa es:
Cuando una persona hace algo que todos en el laboratorio tiene que ser notificado.
Entonces, para mí significa que un Person obras en un Lab, cuando se crea, esa persona puede recibir el laboratorio trabaja en, y registrar a sí mismo para ser notificado de lo que ocurre en ese laboratorio perticula.
Desde el laboratorio tiene la lista de las personas que informen, tiene sentido de ser el laboratorio que realiza la notificación (persona da un control de laboratorio en este caso)
Entonces probablemente el Person se podría definir como:
labs.Person {
- name: String
- lab : Lab
+ Person(withLab: Lab , andName: String) {
self.lab = withLab
self.name = andName
self.lab.subscribe(self) // want to know what happens
}
+ blowUpLab() {
lab.boom!(blownBy:self)
}
// receive a lab even notification
// performed by "someone"
+ labEvent(lab:Lab, by: Person ) {
// if is my lab and it wasn't me?
if(self.labg .== lab .&& self .!= by) {
// ok it was someone else....
}
}
}
por lo tanto, la persona que hace algo en el laboratorio, en este caso el método público blowUpLab que acaba explota el laboratorio de la persona invocando el método del laboratorio boom!.
A su vez el Lab realice las acciones del procedimiento y notificar a todos sus suscriptores al final:
labs.Lab {
- labName:String
- subscribers: Person[0..*]
+ subscribe(to: Person) {
subscribers.add(to)
}
+ boom!(blowedBy: Person) {
// do blow up the lab
....
// and then notify:
subscriber.forEach(person: Person) {
person.labEvent(self, blowedBy)
}
}
}
Este es el patrón de observador.
Finalmente su aplicación principal creará las personas y de los laboratorios y ejecutar el caso de uso:
labs.MainApp {
_ main() {
blackMesaLab = Lab("BlackMesa")
gordon = Person(withLab: blackMesaLab, andName: "Gordon Freeman")
scott = Person(withLab: blackMesaLab, andName: "Scott Tiger")
james = Person(withLab: Lab("SO Labs"), andName:" James Hetfield");
persons = Array(gordon, scott, james)
....
while(true) {
// every now and then, have someone blowing up it's lab
if (randomNumber() .== 42) {
person.at(randomPosition).blowUpLab()
}
}
}
}
Esta aplicación principal, creará tres personas, con un poco de práctica de laboratorio, sólo dos de ellos están relacionados (Scott y Gordon)
Aleatoriamente uno de ellos recibirá el mensaje blowUpLab y realizará el método. El laboratorio, a su vez, notificará a todos los suscriptores de ese laboratorio.
Así, cuando James Hetfield, un golpe de su laboratorio, nadie va a ser notificado :)
El punto es Do Describe su caso de uso, e identificar el experto en información allí; darle el control a ese objeto, y dejar que ese objeto confíe el control a otro objeto, pero solo de acuerdo con su caso de uso
Espero que tenga sentido.
¿Qué es * devuelve T/F *? – OscarRyz
Supongo que devuelve verdadero o falso? –
Sí, lo siento T/F = devuelve verdadero o falso. –