Mensajes

me van a tener que seguir soportando

se siente raro quedar hablando solo

pequeña contribución un ejemplo de un bus de eventos
para que puedas desacoplar tus aplicación  
para que puedas comunicar entre varios formularios de tu aplicacion de escritorio javafx swing o lo que sea

porfavor respondamen no me castiges con el latigo de tu indiferencia
no me rechazes como ella


ejemplo de uso

Código [Seleccionar] Expandir


public class Main {
public static void main(String args[]) {
EventBus eventBus = new EventBus();
eventBus.chanel("/sistema/session/parametros").on(t -> System.out.println(t));
eventBus.chanel("/sistema/session/parametros").fire(new RegistraParametro("mi parametrito"));


}
}


Código [Seleccionar] Expandir


public class RegistraParametro {

private String string;

public RegistraParametro(String string) {
this.string = string;

}

@Override
public String toString() {
return "RegistraParametro [string=" + string + "]";
}

}

el resto de clases son cortitas

Código [Seleccionar] Expandir


import java.util.function.Function;

public interface Callbak { void apply(Object obj); }



Código [Seleccionar] Expandir


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.function.Consumer;
import java.util.function.Function;

public class Chanel {

private List<Callbak> events = new ArrayList<>();

public void fire(Object event) {
events.forEach(p -> p.apply(event));
}

public void on(Callbak event) {
events.add(event);
}

}



Código [Seleccionar] Expandir

import java.util.HashMap;

public class EventBus {

private HashMap<String, Chanel> chanels = new HashMap<>();

public Chanel chanel(String string) {
return chanels.computeIfAbsent(string, p -> new Chanel());

}

}


la composición es solo una cuestión referencial para guiar
en el momento del análisis y diseño nadie
entiende como se debe poner en código y nadie le da
importancia solo sirve para tener discusiones
eternas sin sentido

Dependiendo del lenguaje en concreto puede variar bastante
en los pequeños detalles y casos limites e internos
el ciclo de vida de los objetos
en java la regla general es que para eliminar un objeto
lo igualas a null y si un objeto no es referenciado por
nadie el garbage collector se temo la potestad de
liberar la memoria cuando mejor le parezca usando un
algoritmo en concreto (mark swep,g1) este proceso
en la basta mayoría de veces funciona de maravilla de manera
automagica(yo tengo la teoría de que los duendes vienen en la
noche y lo hacen por mi como en el cuento) y en los casos
que si importa generalmente se hace mal y muere
miserable estrepitosamente y escandalosamente


la clase cliente se deberá declarar en la clase hotel??

Noooo eso es un muy mal diseño que definitivamente destruirá
el rendimiento la aplicación pongas donde lo pongas malogra
la ran del proyecto

pues necesito entender donde va el array y como se utiliza luego

La forma más común de poner el array es en clase contenedora

Es mejor que la clase contenedora sea la que tienen el array mejor
si es List<T> para mayor facilidad le agregas unos métodos para
agregar y eliminar y preferible no poner relaciones cuando pasa
por una clase de manera indirecta
es mejor evitar relacionar hotel con cliente debido a que hay una
clase intermedia reserva puedes evitar usar la clase reserva
siempre y cuando no necesitas grabar nada de la reserva


Veamos el mismo ejemplo

ejemplo sin getters y setters y con clase reserva el sapo aprueba esta manera

class hotel{
   private int id;
   private String nombre;   
}

class Reserva{
   private int id;
   private Hotel hotel;
   private Cliente cliente;
   private DateTime fechaReserva;
}

class Cliente{
   private int id;
   private String nombre;
   private String apellido;
}

ejemplo getter y setters sin clase reserva muy poca recomendada


class hotel{
   private int id;
   private String nombre;   
   private List<Cliente> cliente ;
}

class Cliente{
   private int id;
   private String nombre;
   private String apellido;
   private List<Reserva> cliente ;
}





tenemos dos formar one to many bidirectional y unidirectional
la bidirecional es mejor evitar por que usa más memoria y dejas
la posibilidad abierta a bucles infinitos y requiere más cuidado
que los frameworks y librerías puedan serializar correctamente


sin usar one to many no bidireacional


public class Factura{
   private int id;
   private Cliente cliente;
   private Empleado cajero;
   private List<DetalleFactura> detalles;

   public void agregarDetalle(DetalleFactura detalleFactura){
      detalles.add(detalleFactura);
   }
   public int cantidadLineas(){
      return detalles.length();
   }
   
   public double total(){
      return detalles.stream().map(p->p.getTotal()).sum();
   }
}

public class DetalleFactura{
   private int codigoDetalle;
   private int cantidad ;
   private PrecioProducto precioProducto;
   
   public double total(){
      return cantidad*precioProducto.getPrecio();
   }
}

public class PrecioProducto {
   private int id;
   private Producto producto;
   private double precio;
   private DateTime fechaAsignado;
   
   
}

public class Producto{
   private int id
   private String nombre;
   
}


ahora bidireccional el sapo no lo aprueba malogra la memora y las librerías


public class Factura{
   private int id;
   private Cliente cliente;
   private Empleado cajero;
   private List<DetalleFactura> detalles;

   public void agregarDetalle(DetalleFactura detalleFactura){
      detalles.add(detalleFactura);
   }
   public int cantidadLineas(){
      return detalles.length();
   }
   
   public double total(){
      return detalles.stream().map(p->p.getTotal()).sum();
   }
}

public class DetalleFactura{
   private int codigoDetalle;
   private int cantidad ;
   private PrecioProducto precioProducto;
   
   public double total(){
      return cantidad*precioProducto.getPrecio();
   }
}

public class PrecioProducto {
   private int id;
   private Producto producto;
   private double precio;
   private DateTime fechaAsignado;
   private DetalleFactura detalleFactura ;
   
}

public class Producto{
   private int id
   private String nombre;
   List<PrecioProducto> precios;
}




me baso en varias fuentes yo sigo el ejemplo de los libros de
martin fowler que estan muy bien echos y son muy realistas
y a la vez muy teórico apegado a dar definiciones y clasificaciones
estrictas

tiene más que ver con patrones, pero da un montón de ejemplos de
como usa el análisis y el diseño en situaciones comunes y reales
https://martinfowler.com/eaaCatalog/

mucho más específico y enfocado al tema en cuestión
https://www.amazon.com/UML-Java%C2%BF-Programmers-Robert-Martin/dp/0131428489

mucho más específico sobre dónde poner las cosas
https://www.amazon.com/Applying-UML-Patterns-Introduction-Object-Oriented/dp/0131489062

ya si quieres algo mucho mas avanzado sobre como lidear 
software muy complejo como analisar e implementar el dominio
https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215

este es muy bueno donde mi tio grady da una explicación de ejemplos
https://www.amazon.com/Object-Oriented-Analysis-Design-Applications-3rd/dp/020189551X

y recuerda que cuando lees todas las fuentes que te di 
lo más importante que entenderás es que ni siquiera estarías gateando

tienes una melcocha de ideas DJango no es un lenguaje es un framework web

el framework web mas comun es spring boot (recomendado sin usar xml)

prueba cambiando la linea 42 en la 15

arregla la linea 81   pasale un objeto o le pasas un callback

no me castigues con el látigo de tu indiferencia con una respuesta pasivo agresiva es suficiente

esta es una contribución pequeña

Cuando haces prueba a código que es asynchrono junit  muestra mensaje inesperado y te manda al demonio mostrándote el dedo del medio como cuando le dices a la panchita que quieres hacer cosas indecorosas con ella

Este es un código de ejemplo de como hacer una prueba unitaria a código que es asynchrono

Código (java) [Seleccionar] Expandir


package testingasync;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
import static org.junit.Assert.*;

public class asyn_gretting_should_Test {

   private static interface Callback<T> {
       void call(T t);
   }

   private static class AssynGreating {

       public void sayHi(String name, Callback<String> callback) {
           new Thread(() -> callback.call("hi " + name)).start();
       }
   }

   @Test
   public void say_hi() throws InterruptedException {
       CountDownLatch countDownLatch = new CountDownLatch(1);
       StringBuilder stringBuilder = new StringBuilder();
       new AssynGreating().sayHi("luis", (name) -> {
           stringBuilder.append(name);
           countDownLatch.countDown();
       });
       countDownLatch.await(1, TimeUnit.SECONDS);
       assertEquals("hi luis", stringBuilder.toString());
   }
}



pro favor den una respuesta aunque sea troll pero no me rachasen y no me respondan

ya es demasiado difícil entrar a temas mas avanzados (que estoy interesado en desarrollador) con una sola clase seria demasiado grande difícil de atender y muy frágil así que cambio de estrategia

voy a crear una clase interpretador que transforme el código fuente en una lista de instruciones tipo ensamblador y realize una seria de normalizaciones y pequeñas limpieza para que no tengas que crear codigo fuente de manera perfecta a la primera ves y si no se puede informara la linea del error

luego tendre una clase para el preporcesamiento de los comandos (para las validaciones para que te diga si estas escribiendo estupidez que nunca funcionaran)   y post procesacion de los comandos(para las optimizaciones)

luego una clase maquina virtual para que se encarge de ejecutar los comandos

es de escritorio o web?
estas usando frameworks?