Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Hola.

Tienes que crear un ActionListener para que el botón responda.

Puedes hacerlo creando una clase anidada dentro de la clase principal.

La clase que vas a crear ha de heredar de la clase ActionListener. AL heredar de esta clase, se ha implementar obligatoriamente un método llamado actionPerformed().
Dentro de este método, es donde vamos a escribir qué queremos que ocurra cuando se pulse el botón.

Aquí te pongo un ejemplo donde simplemente se muestran mensajes JOptionPane para informar si los datos de usuario y contraseña son correctos.
Ahí es donde deberías crear la otra ventana que se pide mostrar con una foto y no se que más.

   class AccionBotonOK implements ActionListener {
      @Override
      public void actionPerformed(ActionEvent e) {
         
         String pass=new String(Password.getPassword());

         if(User.getText().equals(usuario)&& pass.equals(contraseña)){
            JOptionPane.showMessageDialog(null, "Datos login aceptados",
                  "Login Usuario", JOptionPane.INFORMATION_MESSAGE);
         }
         else {
            JOptionPane.showMessageDialog(null, "Datos login rechazados",
                  "Login Usuario", JOptionPane.WARNING_MESSAGE);
         }
      }
   }

Una vez has escrito esta clase, tienes que instanciar un objeto de ella y añadírsela al botón correspondiente:

      JButton btnOk = new JButton("OK");
      btnOk.setBounds(135, 182, 89, 23);
      btnOk.addActionListener(new AccionBotonOK());
      frame.getContentPane().add(btnOk);

Así, cuando se pulse ese botón, se ejecutará el código escrito en la clase ActionListener que hemos escrito.

Te pego aquí el código completo.
He hecho un par de cambios menores. Para los textos de "Usuario" y "Contraseña" he usado dos JLabel en lugar de los JTexField.
Les he puesto fondo opaco y blanco para que se pueda ver sobre el fondo azul que pusiste.

También he cambiado el sitio donde declaras los String del nombre de usuario y contraseña correctos.
Tu los declaraste dentro del método initialize() pero ahí no servirá porque en cuanto ese método termine, esos String "morirán" junto con el método.

Los he puesto como atributo de clase, así siempre existirán mientras se esté ejecutando el programa.

También he quitado varios import que son totalmente innecesarios, al menos en el estado actual del programa.
Señalo en negrita los cambios:

import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JButton;
import javax.swing.JTextField;
import javax.swing.JPasswordField;
import java.awt.Color;

public class Contraseña {

   private JFrame frame;
   private JTextField User;
   private JPasswordField Password;
   private JLabel txtContrasea;
   private JLabel txtUsuario;

   //Datos login
   private String usuario="santiago";
   private String contraseña="1234";

   /**
    * Launch the application.
    */
   public static void main(String[] args) {
      EventQueue.invokeLater(new Runnable() {
         public void run() {
            try {
               Contraseña window = new Contraseña();
               window.frame.setVisible(true);
            } catch (Exception e) {
               e.printStackTrace();
            }
         }
      });
   }

   /**
    * Create the application.
    */
   public Contraseña() {
      initialize();
   }

   /**
    * Initialize the contents of the frame.
    */
   private void initialize() {
      frame = new JFrame();
      frame.getContentPane().setBackground(new Color(0, 0, 205));
      frame.setBounds(100, 100, 450, 300);
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.getContentPane().setLayout(null);

      User = new JTextField();
      User.setBounds(135, 31, 180, 20);
      frame.getContentPane().add(User);
      User.setColumns(10);

      Password = new JPasswordField();
      Password.setBounds(135, 80, 180, 20);
      frame.getContentPane().add(Password);

      txtContrasea = new JLabel();
      txtContrasea.setBackground(Color.WHITE);
      txtContrasea.setOpaque(true);
      txtContrasea.setText("Contrase\u00F1a");
      txtContrasea.setBounds(10, 80, 86, 20);
      frame.getContentPane().add(txtContrasea);

      txtUsuario = new JLabel();
      txtUsuario.setBackground(Color.WHITE);
      txtUsuario.setOpaque(true);
      txtUsuario.setText("Usuario");
      txtUsuario.setBounds(10, 31, 86, 20);
      frame.getContentPane().add(txtUsuario);

      JButton btnOk = new JButton("OK");
      btnOk.setBounds(135, 182, 89, 23);
      btnOk.addActionListener(new AccionBotonOK());
      frame.getContentPane().add(btnOk);

   }
   
   /*
    * Aquí programamos lo que queremos que ocurra cuando se
    * pulse el boton OK
    */
   class AccionBotonOK implements ActionListener {
      @Override
      public void actionPerformed(ActionEvent e) {
         
         String pass=new String(Password.getPassword());

         if(User.getText().equals(usuario)&& pass.equals(contraseña)){
            JOptionPane.showMessageDialog(null, "Datos login aceptados",
                  "Login Usuario", JOptionPane.INFORMATION_MESSAGE);
         }
         else {
            JOptionPane.showMessageDialog(null, "Datos login rechazados",
                  "Login Usuario", JOptionPane.WARNING_MESSAGE);
         }
      }
   }
}

Yo soy más de Java/Kotlin y C/C++

En otros lenguajes me pierdo un poco, pero veo un par de cosas a mencionar:

MiArray(10) = MiArray(i)Eso te dará error por que no hay ningún elemento con posicion 10.

Si el array tiene 10 elementos, estarán numerados del 0 al 9. Si intentas apuntar a la posición 10, será cuando te da error avisando de que te has salido "fuera".

Por otro lado, mueves los elementos sin guardar previamente el último valor (el de la posición 9). Este valor hay que guardarlo en otra variable, entonces mueves los elementos y terminado el proceso, el valor guardado se adjudica a la posición 0.

EL array es mejor recorrerlo a la inversa. Si empiezas desde el principio, seguramente solo conseguirás repetir el mismo número en todo el array.
Supón este array:

[10,20,30,40]

Eso son 4 elementos, numerados del 0 al 3.

El valor de la posición 0, hay que pasarlo a posición 1.
El valor de la posición 1, hay que pasarlo al posición 2.
-etc...

¿Qué pasa si empezamos desde el principio?
La i del bucle vale 0.

Así que cogemos el valor de la posición i (0) y lo pasamos a posición i+1 (1).
El array queda así:
[10,10,30,40]

Ya podemos darnos cuenta de que hemos perdido el valor 20
Pero sigamos, el bucle comienza el siguiente paso y ahora i vale 1

Así que cogemos el valor de la posición i (1) y lo pasamos a posición i+1 (2).
El array queda así:
[10,10,10,40]

No hace falta seguir, ahora hemos perdido el 30 y es evidente que también perderemos el 40.

Hay que recorrer al revés.

Bueno, lo primero como dije antes, es guardar el ultimo valor antes de que el bucle mueva nada.

Si volvemos al array de ejemplo:

[10,20,30,40]


Pues primero guardamos el 40, que está en posición 3.

variableAux = miArray(3)

OK, guardado. Ahora comienzca el bucle, pero ha de ir hacia atrás y comenzará en la posicion penúltima.
Al comenzar la i ha de tener la posicion valor 2.

Así que cogemos el valor de la posición i (2) y lo pasamos a posición i+1 (3).
El array queda así:
[10,20,30,30]

Hemos machacado el 40, pero no importa, ya que lo hemos guardado en una variable.
Sigamos el bucle va hacia atrás y la i vale 1.

Así que cogemos el valor de la posición i (1) y lo pasamos a posición i+1 (2).
El array queda así:
[10,20,20,30]

El bucle llega al último paso, la i vale 0.
Así que cogemos el valor de la posición i (0) y lo pasamos a posición i+1 (1).
El array queda así:
[10,10,20,30]


Vale, el bucle ha terminado. Ya solo queda coger el valor que habiamos guardado, el 409 y colocarlo al principio, en la posición 0.
El array queda así:
[40,10,20,30]

LISTO. Se han movido los valores como se pide, no se ha perdido ningún dato, el bucle for no va a intentar acceder a posiciones del array que no existen...

No necesitas ningún IF dentro del bucle.

Tan solo tienes que:
- Guardar último valor en otra variable.
- Hacer que la variable i del FOR vaya desde el penúltimo (no el último) hasta posición 0.
- En cada iteración del bucle, mover lo que está en posición i a la posición i+1
- Terminado el bucle, el valor que habíamos guardado lo colocamos en posicion 0.

Y ya está. La clave es saber establecer la condición ideal del bucle FOR

Notepad++ no compila nada. Tan solo es un editor de texto avanzado, que gracias a su resaltador de sintaxis te facilita escribir código al resaltar en distintos colores cuáles son las palabrar reservadas de Java y cuales no.

Quien compila es el programa javac que invocas desde la línea de comandos.

Seguramente tu problema es que en la línea de comandos no has especificado la extensión .java.

Si tu clase se llama "ernesto", prueba con:

javac ernesto.java

Por cierto, salvo que realmente estés obligado a solo usar editores de texto y compilar desde línea de comandos, yo recomendaría usar un IDE (interfaz de desarrollo) más avanzado.
NetBeans, Eclipse, IntelliJ... hay varios y todos te hacen la programación más cómoda y de hecho facilitan el aprendizaje.
No solo resaltan texto como NotePad++: detectan errores mientras escribes y te proponen como corregirlo, hacen sugerencias para mejorar el código, te muestran directamente los métodos de los que dispone cada clase, algunos como Eclipse basta con pasar el ratón sobre un comando Java y te muestra en una ventanita la documentación oficial de Oracle....

Te ayudan a visualizar la estructura de tu proyecto y sus packages para tener bien ordenadas las clases que compondrán tu programa.

Tienen modo debug, que ayuda a encontrar errores y también comprender mejor como se ejecuta el código internamente.

Además tienen su propia consola de salida así que no necesitarás la línea de comandos para ejecutar el programa.

Ofrecen un montón de ventajas y todos son gratuitos.

Eso no quita para que no sea importante saber manejarse con un editor de texto sencillo y con la linea de comandos de la consola del sístema.
A veces un programador profesional tiene que poder desarrollar código en ordenadores que no disponen de una interfaz gráfica tipo Windows, como por ejemplo grandes servidores donde no se pueden "desperdiciar" recursos mostrando ventanitas y colores.

Pero para facilitar el aprendizaje en programación creo que es mejor empezar con todas las ayudas posibles y luego ya se irá pasando a niveles más "hardcore" je je...

Hola, bueno  pensaba usar el "año mes día" aaaammdd,  como recomiendas, ...¿como se podria hacer esto? Gracias.

P.d. Estamos intentando eliminar productos o vendedores, alguna idea para realizarlo?

Vale usando ese formato es muy fácil ordenar.
Explico:
Colecciones como ArrayList tienen un método que permite ordenar los objetos que contiene. Es el método .sort().

Para usar este método hay dos maneras:
- Le pasamos por argumentos en el paréntesis una expresión para indicarle al ArrayList como debe ordenar los objetos que contiene..
- Le pasamos valor null, y confiamos en que el ArrayList sepa como ordenarse.

La primera manera puede ser algo complicado saber construir correctamente dicha expresión.

La segunda manera es la más fácil, pero claro, dependemos de que el ArrayList sepa ordenarse.
Aunque lo cierto, es que esto no depende del ArrayList, sino de los objetos que contiene. Son ellos los que tienen que saber como "compararse" unos con otros para decidir quien es menor y quien es mayor.
Los objetos que saben "compararse", son los que su clase implementa la interfaz Comparable

Por ejemplo los objetos de clases que representan números: Integer, Double, Float.... sí la implementan y por eso saben perfectamente que un 4 es menor que un 5.

La clase String, también la implementa, así que saben perfectamente que la cadena "b" es menor que la cadena "c".

Así que nunca tendremos problemas para ordenar un ArrayList de Integer o de String, basta con llamar a sort(null) y se ordenará al momento el solito.

Pero nuestro ArrayList de Registro de Facturas, va a contener objetos de la clase Factura.
Una clase que hemos creado nosotros y que sus objetos no saben como compararse para decidir quien es menor o mayor.
Así que ahora mismo nuestro ArrayList de Facturas, no sabe como ordenar sus objetos.

Pero para eso estamos nosotros, para enseñarle a la clase Factura como compararse.

Lo primero es implementarle la interfaz Comparable, indicándole el tipo de clase con el que se tiene que comparar, que lo normal es que sea ella misma.

public class Factura implements Comparable<Factura>{
......
......
Al implementar esta interfaz, el compilador inmediatamente nos obliga a implementar también el método compareTo().
Este método es el que explica como ha de compararse un objeto y ha de retorna un int.
Si los objetos se consideran del "mismo valor" ha de retorna 0
Si el objeto recibido por argumentos, es mayor respecto al objeto que invoca el método, ha de retornar -1.
Si el objeto recibido es menor, entonces ha de retornar 1.

Bien, en nuestro caso, tendríamos que escribir un código que compare las fechas.
Podemos ordenarlas de modo que las fechas más antiguas se consideren menores que las fechas más recientes.
Es decir, la fecha 20191105 es menor que la fecha 20191205, porque esta última es más reciente.
Bueno, para hacer esto podríamos empezar a trocear el String que contiene la fecha, para separar el valor del año, del mes y del dia...y parsearlos a valores int, y entonces....

Pero, ¡¡espera!!. Hemos dicho antes que los objetos String ya saben compararse. Y precisamente se comparan de forma que coincide a como queremos ordenar las fechas.

El String "20191105" se considera menor que el String "20191205".
Es más, podemos usar separadores como guiones y la comparación de String fucnionará igual.
"2019-11-05" es menor que "2019-12-05".

Así que no tenemos que hacer nada, tan solo decirle a nuestro método compareTo(), que retorne el resultado de comparar directamente los String de fechas.

@Override
public int compareTo(Factura otraFactura) {
return fecha.compareTo(otraFactura.getFecha());
}
Genial, ahora nuestra clase Factura ya sabe como compararse unas con otras para decidir cual es menor o mayor, en función de su fecha.

Ahora lo que podemos hacer es decirle a nuestra clase de Registro de Facturas, que cada vez que entre una nueva Factura en el ArrayList, lo ordene. Así siempre estará ordenado tras cada inserción.

public boolean addFactura(Factura factura) {
if (facturas.contains(factura))
return false;
else {
facturas.add(factura);
facturas.sort(null); //Null es porque las Facturas ya saben como compararse para ordenarse
return true;
}
}

Con esto, si desde el programa principal, tras haber hecho algunas facturas pedimos un listado, veremos que salen ordenadas por fecha, de más antigua a más moderna.
Las facturas de este listado yo las he ido creando por orden de ID: FAC01, FAC02, FAC03 y FAC04.
Pero al entrar en el ArrayList, se han ido ordenando por la fecha.

      FACTURAS REGISTRADAS

ID: FAC03 Fecha: 2018-12-12
Notas: jiol

ID: FAC02 Fecha: 2019-06-14
Notas: popop

ID: FAC01 Fecha: 2019-06-15
Notas: fasdfsa

ID: FAC04 Fecha: 2019-08-15
Notas: sdafsa

Bueno, ¿y si queremos que el orden sea al revés? ¿De más reciente a más antiguas?
Entonces bastaría con modificar el método comparteTo() de la clase Factura, diciéndole que modifique el signo del resultado de comparar los Strings de fechas.
Cuando el resultado sea -1, ha de devolver +1 y viceversa.
Para hacer esto, puesto que somos grandes matemáticos xD, ya sabemos que nos basta con multiplicar lo que retorna, por -1

   @Override
   public int compareTo(Factura otraFactura) {
      return fecha.compareTo(otraFactura.getFecha()) * -1;
   }

Esto revierte a como se ordenan las facturas, ahora las fechas recientes se consideran menores que las antiguas:

      FACTURAS REGISTRADAS

ID: FAC04 Fecha: 2019-08-15
Notas: sdafad

ID: FAC01 Fecha: 2019-06-15
Notas: fsadfa

ID: FAC02 Fecha: 2019-06-14
Notas: popop

ID: FAC03 Fecha: 2018-12-12
Notas: jiol

Y ya está.
Cierto es que hemos optado por la via fácil, usar un String con formato aaaa-mm-dd.
Y ojo, es que ese formato de fecha cumple en realidad con la norma ISO 8601 y es la que se suele usar en informática precisamente por esto, porque facilita mucho la ordenación alfanumérica.

Sin embargo en la mayoría de paises de habla hispana, lo habitual es usar dd-mm-aaaa.
Pero bueno, no creo que sea necesario ahora pelearse con formatos de fecha.

Lo importante aquí es aprender que para ordenar objetos, podemos hacerlo implementado la interfaz Comparable y decidir nosotros que atributos son decisivos para hacer la comparación.
En el Curso de Java Avanzado tienes un ejemplo algo más elaborado.

Sabiendo ya esto, puedes decidir ya si quieres usar otro formato de fecha, o usar clases como LocalDate

En ambos casos ya se requiere meter más programación.

Respecto a esto:

P.d. Estamos intentando eliminar productos o vendedores, alguna idea para realizarlo?

Los ArrayList tienen el metodo remove() que debería permitirte hacer esto fácilmente.

Por ejemplo, en la clase Inventario, si quiero eliminar un Producto de su ArrayLsit, me basta con escribirle este método:
public boolean eliminarProducto(Producto producto) {
return productos.remove(producto);
}
Este método recibe un objeto Producto que es el que se ha de eliminar.
Así que se lo pase al método remove() del ArrayList.
remove() lo que hace es que si dicho Producto existe en el ArrayList, lo elimina y retorna true.
Si no existiera, entonces retorna false.

Entonces, en el programa principal, cuando el usuario active la opción "eliminar Producto", tu tendrás que pedirle al usuario el ID de producto que quiere eliminar.
Con ese ID construyes un objeto Producto y se lo pasas a este método para que lo elimine del ArrayList de Inventario.

No hace falta que construyas un Producto con los datos idénticos a como esté en el ArrayList. No necesitas saber la cantidad ni la descripción del producto ni ningún otro valor, solo el ID.
Recuerda que Producto tiene un método llamado equals() en donde se indica que dos objetos Producto son IGUALES si coincide su ID.

Así que te basta con construir un Producto con el ID indicado, y el resto de parámetros del constructor pueden tener cualquier valor, no importa. Solo necesitas que coincida el ID.

Por ejemplo, mi clase Producto que escribí para este ejercicio, si recuerdas, tiene dos constructores y uno solo pide un String con el ID y un valor int para la cantidad.
Yo a ese int le puedo poner cualquier valor, no tiene que coincidir con la cantidad que marca el Inventario para poder borrarlo.
El código podría ser algo así:
System.out.print("Indique el ID del producto a eliminar: ")
String idPRoducto = stdIn.readLine();
if (inventario.eliminarProducto(new Producto(idProducto, 0)) //Pongo una cantidad cualquiera
    System.out.println("Producto ha sido eliminado");
else
    System.out.println("No hay ningún Producto con ese ID en el Inventario");


Vale, creo que te entiendo.
A ver, he añadido las nuevas clases a mi código, lo básico para ver como hacer lo que pides.

A mi modo de ver, sería interesante que cada Factura incluyese su propio ArrayList con los objetos Producto que se están facturando. Así es más cómodo gestionarlo todo.

Mira, esta podría ser la clase Producto con los atributos básicos que supongo ha de tener.
Fíjate que aquí se me ha ocurrido ponerle dos constructores.

En uno, se pide el id de producto, la descripcion y la cantidad.
Este constructor podría ser más útil para añadir Productos al Inventario, ya que aquí los añadiremos una única vez y querremos que tengan su descripción más completa.

En el otro constructor, solo se pide el id y la cantidad. No se pide la descripción.
Este sería más cómodo para cuando tengamos que añadir Productos a una Factura, nos ahorramos tener que poner la descripción.

Que no es necesario hacerlo así, esto es algo que se me ha ocurrido sobre la marcha y aunque luego no se aplique, está bien saber que existe esta posibilidad de tener distintos constructores para elegir según cada ocasión.

Atenta a un método llamado variarCantidad(). Este método, a diferencia de setCantidad(), lo que hará será sumar la cantidad recibida por argumentos a la cantidad actual, y será uno de los método que nos ayudará a cumplir con lo que pides.
Si le pasasemos una cantidad con valor negativo, entonces dicha cantidad se restaría.
Por eso he preferido llamarlo variarCantidad() en lugar de por ejemplo sumarCantidad(), aunque el nombre es irrelevante.

Por supuesto, la clase también incorpora el método equals(), pues dentro de nuestro Inventario no deberían haber objetos Producto repetidos.

Aquí la clase Producto

public class Producto {

private String idProducto;
private String descripcion;
private int cantidad;

/*
* Podemos hacer dos constructores.
* Uno donde no sea necesario dar la descripcion, ideal para añadir Productos en Facturas.
* Otro donde sí se pida la descripción, más adecuado para añadir Productos al Inventario.
*/

public Producto(String id, int cant) {
idProducto = id;
cantidad = cant;
setDescripcion("");
}

public Producto(String id, String descripcion, int cant) {
idProducto = id;
cantidad = cant;
this.setDescripcion(descripcion);
}

public String getIdProducto() {
return idProducto;
}

public String getDescripcion() {
return descripcion;
}

public void setDescripcion(String descripcion) {
this.descripcion = descripcion;
}

public int getCantidad() {
return cantidad;
}

public void setCantidad(int cantidad) {
this.cantidad = cantidad;
}

public void variarCantidad(int cantidad) {
this.cantidad += cantidad;
}

@Override
public boolean equals(Object obj) {
if (obj instanceof Producto) {
Producto otroProducto = (Producto)obj;

return idProducto.equals(otroProducto.getIdProducto());
}
else
return false;
}
}

Los Productos se guardarán en la clase Inventario, que básicamente es un ArrayList donde insertar Productos.
Como ya hemos dicho, no pueden haber Productos con el mismo ID, así que antes de insertar un Producto se comprueba si ya existe en el inventario o no.

Aquí hay que destacar el método actualizaCantidadProducto() (sí, es muy largo, puedes ponerle uno más corto si quieres)
Este método lo que hace es recibir un ID de producto y una cantidad, y entonces buscará en el Inventario el Producto que coincida con ese ID y le sumará la cantidad recibida.
De este modo, cuando tengamos una Factura, con este método podremos actualizar el Inventario con las nuevas cantidades indicadas por la Factura.

Clase Inventario
public class Inventario {

private ArrayList<Producto> productos;

public Inventario() {
productos = new ArrayList<Producto>();
}

public boolean addProducto(Producto producto) {
if (productos.contains(producto))
return false;
else
return productos.add(producto);
}

public boolean actualizaCantidadProducto(String idProducto, int cantidad) {
for (Producto prod: productos) {
if (prod.getIdProducto().equals(idProducto)) {
prod.variarCantidad(cantidad);
return true; //Producto encontrado y actualizado
}
}
//Si el bucle termina sin retornar true, es que no se ha encontrado producto con ese id
return false;
}

}

Ahora pasamos a las Facturas.
Como dije antes, además del ID y su atributo notas, me parece interesante que tenga un ArrayList donde se irán añadiendo los Productos que se van a facturar.

A la hora de agregar Productos, al tratarse de una Factura y no el Inventario, en este caso podríamos admitir tener Productos repetidos (mismo ID) en el ArrayList de la Factura.
Pero, creo que es más interesante hacer que cuando se quiera registrar un Producto que ya está listado en la Factura, lo que podemos hacer es sumar la cantidad del Producto recibido a la cantidad del Producto que ya está en la Factura.
Así cada Producto solo estará listado una sola vez, pero con todas las cantidades que se hayan querido facturar.

De todo esto se encargará el método addProducto()
Fíjate que hay otro método llamado getProductosFacturados() que retorna el ArrayList completo.
Este método nos será útil para, cuando en el programa principal hayamos registrado una Factura, obtener los Productos de los cuáles hemos de actualizar las cantidades en el Inventario. Eso lo veremos luego.

Aquí clase Factura, con su obligado método equals(), pues no podemos admitir Facturas repetidas con el mismo ID.
public class Factura {

private String idFactura;
private String nota;
private ArrayList<Producto> productosFacturados;

public Factura(String id, String nota) {
idFactura = id;
this.nota = nota;
productosFacturados = new ArrayList<Producto>();
}

public String getIdFactura() {
return idFactura;
}

public String getNota() {
return nota;
}

public void setNota(String nota) {
this.nota = nota;
}

public void addProducto(Producto producto) {
if (productosFacturados.contains(producto)) {
/*
* Si ya existe este Producto en la factura, en lugar de
* añadirlo, lo que haremos será sumar las cantidades.
* Así en la Factura cada producto aparece una sola vez
* pero con la suma de todas las cantidades facturadas
*/
int indice = productosFacturados.indexOf(producto); //Averiguamos indice del producto coincidente
productosFacturados.get(indice).variarCantidad(producto.getCantidad()); //Sumamos las cantidades
}
else
productosFacturados.add(producto);
}

public ArrayList<Producto> getProductosFacturados() {
return productosFacturados;
}

@Override
public boolean equals(Object obj) {
if (obj instanceof Factura) {
Factura otraFactura = (Factura)obj;
return idFactura.equals(otraFactura.getIdFactura());
}
else
return false;
}

}
Y ahora necesitamos una clase para Registrar las Facturas.
Siguiendo la mecánica habitual, se va a tratar básicamente de un ArrayList para insertar Facturas y que impedirá que estas se repitan.
No tiene nada destacable.

public class FacturasRegistro {

private ArrayList<Factura> facturas;

public FacturasRegistro() {
facturas = new ArrayList<Factura>();
}

public boolean addFactura(Factura factura) {
if (facturas.contains(factura))
return false;
else
return facturas.add(factura);
}

}
OK. Ya tenemos todos los elementos necesarios para trabajar. Ahora hay que ver como los ponemos en funcionamiento.

No se exactamente como quieres que funcione esto en el programa principal.
Pero vamos a suponer que en el menu habrá una opción para registrar una Factura y que al registrarla, se actualicen las cantidades de los Productos facturados en el Inventario.
La secuencia de pasos podría ser:
- Pedir datos para crear una nueva Factura.
- Pedir datos para crear Productos hasta que el usuario indique finalizar.
   Los Productos que se van creando se añaden a la nueva Factura
- Cuando la Factura está lista, se inserta en el Registro de Facturas.
- Si la Factura se ha registrado correctamente (su ID no estaba repetido), entonces actualizamos los Productos del Inventario con las nuevas cantidades.
- Informamos por pantalla de si algún Producto no se ha podido actualizar, quizás porque en el Inventario no se ha encontrado un Producto coincidente con alguno de los que hay en la Factura.


Bien, pues todos estos pasos, son los que va a realizar este método que estaría declarado en la clase Sistema (la principal) y podría ser invocado desde una de las opciones del menú.

private static void facturarArticulos() {
//Creamos factura
System.out.println("Ingresar datos factura: ID, Notas");
try {
Factura nuevaFactura = new Factura(stdIn.readLine(), stdIn.readLine());
//Tenemos factura creada. Hay que añadir artículos.
String idProducto = "";
int cantidad = 0;
do {
System.out.println("Facturando productos.");
System.out.println("Teclee ID del Producto a facturar o escriba 'fin' para terminar");
System.out.println("ID Producto: ");
idProducto = stdIn.readLine();
if (!idProducto.equals("fin")) {
System.out.print("Cantidad a facturar: ");
cantidad = Integer.parseInt(stdIn.readLine());
//Añadimos producto a Factura
nuevaFactura.addProducto(new Producto(idProducto, cantidad));
}
}while(!idProducto.equals("fin"));
//Articulos añadidos a Factura. Hay que registrarla.
if (facturasRegistro.addFactura(nuevaFactura)) {
//La Factura ha sido aceptada, hay que actualizar el inventario.
System.out.println("Factura aceptada.\nSe va a actualizar el Inventario");
for (Producto prod: nuevaFactura.getProductosFacturados()) {
if (inventario.actualizaCantidadProducto(prod.getIdProducto(), prod.getCantidad()))
System.out.println("Producto con ID " + prod.getIdProducto() + "actualizado" );
else {
System.out.println("\nProducto con ID " + prod.getIdProducto() + "no actualizado");
System.out.println("Este producto no existe en el Inventario.\n");
}
}
}
else //La factura NO ha sido aceptada en el Registro.
System.out.println("Factura no registrada. Ya existe una factura con ese ID");
} catch (IOException e) {
System.out.println("Error en lectura de datos.");
} catch (NumberFormatException e) {
System.out.println("El dato introducido no es un número");
}
}
Parece que hay mucho código, pero no es tanto y básicamente lo que hace es seguir los pasos que he descrito antes.

Fíjate que cuando actualizamos las cantidades de los Productos del Inventario, si ocurre el caso de que un Producto que está en la Factura, no está en el Inventario (y por tanto no se puede actualizar ninguna cantidad), aquí se nos abre la posibilidad de añadir directamente ese Producto al Inventario.
Aunque es un Producto que en ese momento no tiene nada en su atributo Descripcion, y quizás antes de añadirlo habría que pedirle al usuario este dato.

Pero bueno, esto lo comento como una posibilidad que puedes decidir añadirla o no. Tampoco es necesario crear el "programa perfecto", si no aprender a a trabajar con distintas clases, aprender como relacionarlas y como almacenarlas en distintas colecciones de datos.

Creo que esto es más o menos lo que querías conseguir. Leete con detenimiento cada clase que he posteado, asegurate de que te queda claro para qué vamos a necesitar cada uno de los métodos que he destacado y sobre todo entender bien este último método, que simplemente cumple con los pasos enumerados anteriormente.

He de decir que no he tenido ocasión de probar su funcionamiento.
Lo he escrito pero no he podido probarlo...estoy bastante seguro de que funciona, pero nunca se sabe je je
 
Cualquier duda o cosa que no entiendas, ya sabes, pregúntala por aquí.
Un saludo.

Sobre la clase CatalogoCliente aquí me surge una pregunta.
¿Es necesario que implemente la interfaz Iterator?
Yo es que nunca he necesitado usar iteradores, aunque bueno, solo soy un aprendiz más, apenas un aficionado a la programación. Pero bueno, como tampoco sé todavía cuáles son las funcionalidades completas que ha de tener tu programa, lo dejamos implementado.

Lo que si creo que está mal, es que dentro de esta clase está trabajando con la clase Persona.
Si esto va a ser un Catálogo de Clientes, lo normal, es que trabajemos con la clase Cliente, no con la clase Persona.
Así que hay que modificar todos los métodos, parámetros y argumentos para que hagan referencia a la clase Cliente en lugar de a Persona.

Además hay que aumentar la funcionalidad de algunos métodos.

Por ejemplo, el metodo para añadir un Cliente al ArrayList.
- Los Clientes tienen un idCliente que los identifica y los hace únicos.
- Si los hace únicos, significa que en nuestro ArrayList no podemos permitir tener dos Clientes con el mismo id, ya que en realidad serían el mismo.
- Para impedir que se nos repitan los Clientes en el ArrayList, nos ayudará el método equals() que le habíamos escrito a la clase Cliente, que es precisamente para que nos ayude en estos casos.

El método lo podemos reescribir así:

public boolean addCliente(Cliente cliente) {
if (clientes.contains(cliente)) //Ya existe un cliente con el mismo ID
return false; //Lo rechazamos
else {
clientes.add(cliente); //Aceptamos el Cliente
return true;
}
}
Aquí el ArrayList se llama clientes.
Y antes de añadir el nuevo cliente, le preguntamos al ArrayList si ya contiene ( contains() ) un cliente "igual" al que pretendemos añadir.
Nosotros no lo vemos, pero contains() lo que hace es recorrer todos los objetos Cliente dentro del ArrayList y va preguntando si alguno es igual ( equals() ) al CLiente que le hemos pasado por argumentos.

Si encuentra alguno igual, es decir, uno que tenga el mismo ID (ya que a la clase CLiente le hemos dicho que el atributo IdCliente es quien decide si son iguales o no) devolverá TRUE y en este caso, no debemos aceptar este Cliente, porque ya lo tenemos en el listado y si lo aceptamos lo tendremos repetido.

Así que nuestro método para añadir Clientes, ya no los acepta directamente sin más. Comprueba si está repetido o no y además informa con TRUE/FALSE si el Cliente ha sido aceptado/rechazado.

Además hay un método para buscar una Persona por su ID. Como ya hemos dicho, lo correcto sería que buscase Clientes por ID, no personas.
Lo modificamos y además te recuerdo que para comparar datos de tipo String, hay que usar el método equals()
Si usas el comparador básico de igualdad, el doble igual,  == no te dará resultados válidos.
Este comparador solo sirve para tipos primitivos como int, char, double, float, byte...
Para comparar objetos (los String son objetos, no son primitivos) hay que usar equals()

public Cliente getClienteByID(String idCliente) {
for (Cliente cli: clientes) {
if (cli.getIdCliente().equals(idCliente))
return cli;
}
return null;
}
Ahora viene un método para eliminar Clientes del ArrayList pasando como argumento un objeto Cliente.
EL método que has puesto está bien, pero quizás sería interesante que el método informase de si ha eliminado o no el Cliente.
¿Y si nos han pasado un Cliente para eliminar, que en realidad no existe en el ArrayList?
Quizás sería conveniente informar al usuario de este hecho, ya que quizás así se de cuenta de que nos ha pasado un Cliente posiblemente equivocado.
Si no le informamos, el usuario pensará que nos ha pasado un Cliente correcto y que ha sido eliminado, cuando en realidad no ha sido así.

Mejor informarle de qué resultado ha dado su intento de borrado, y además es muy fácil de hacer, ya que el metodo remove() del ArrayList ya devuelve true/false según si ha borrado o no.
Así que nos basta con retornar, lo que esté retornando este método:

public boolean eraseCliente (Cliente cliente) {
return clientes.remove(cliente); //Si el cliente no existiese, retornara false
}
Luego tienes un método llamado imprimirAll() para mostrar todos los Clientes del listado en pantalla. Has puesto que devuelve un String, pero no es necesario que retorne nada, basta con que escriba en pantalla y punto. Nada más.
Así que lo declaramos como void y quitamos la sentencia return

public void ImprimirAll () {   
for(int i=0;i<clientes.size();i++){
System.out.println(clientes.get(i));   }
}
Los siguientes métodos están relacionados con el Iterator, que no se si los necesitaremos o no realmente. De momento los dejamos tal cual.

Ahora viene el programa principal, de este también hablaremos en otro post separado.

Aquí te falta el indice i

  if (edad.ToString()[i] == edad.ToString()[j])

Por otro lado, no se mucho de C# (¿o estas con VB.net?).
Me baso en tu código para suponer que es correcto usar indices tras la invocación de ToString()

Es más, esto me resulta un poco extraño_
int edad = listBox1.Items.Count;
A mí eso me suena que estás metiendo en la variable edad la longitud de listBox1.
Es decir, eso te daría cuántos items tiene ese listBox.

Pero no se si estás metiendo la edades. Apostaría que no, pues la variable edad es un simple int, así que tan solo puede almacenar un único valor numérico.
Como mucho, podrías guardar una de las edades.., pero es que me parece que ni siquiera eso es lo que contiene, sino como dije, lo que tiene es la longitud de listBox1.

Siento no poder ayudarte mejor, lo mio es Java... pero, desde mi desconocimiento de otros lenguajes, diría que ese código no está haciendo lo que tú necesitas y tendrías que revisarlo.

Espero que alguien más hábil que yo en este foro te pueda orientar.

No necesitas hacer push() como si trabajases con una pila(stack).

Simplemente accede a los elementos valiendote del índice que va aumentando progresivamente gracias al bucle for

function productoria (num){
    var multiplicar = 1;
  for (var i = 0; i < num.length; i++){
     multiplicar = multiplicar * num[i];
  }
  return multiplicar;
}

Clase GR

Es la clase que pone en marcha el juego.

Tiene 4 atributos/variables globales:

static Tablero tablero;
static Dados dados;
static int jugador;
static int intentos;
Un objeto Tablero, los Dados, un entero que irá alternando entre los valores 1 y 2 para indicar que Jugador está activo en cada turno, y un contador de intentos.

El enunciado dice que tras dos intentos fallidos, el juego termina. Es decir, dos intentos por cada uno de los dos jugadores, 4 en total
Así que la condición que para que el juego continue ejecutándose, es que el contador de intentos se mantenga por debajo de 4.

Esa es la condición que he puesto al bucle while que dentro del main pone todo en marcha.

En el main declaro un Tablero de 20x20 y pongo en marcha el juego.
El juego es automático así que el usuario no juega, solo observa. Para facilitar la observación, usaré un método que pausará la ejecución del programa en determinados momentos y el usuario podrá continuar pulsando la tecla INTRO.

Lo primero que hace el flujo de programa, es comenzar con el Jugador 1 y empieza por decidir (al azar) si en lugar de tirar los dados, el Jugador quiere eliminar un Rectángulo del rival.
Si el código decide que sí quiere eliminar un Rectángulo del rival, se hará y finalizará su turno.
Si esta decisión al azar sale negativa, o bien sale positiva pero el rival no tiene Rectángulos para poder eliminar, entonces se procederá a tirar los dados para crear un Rectángulo e intentar insertarlo.

Si la inserción falla, el contador de intentos fallidos aumenta y pasa turno al siguiente jugador.
Si la inserción tiene éxito, el contado de intentos se reinicia a 0 y pasa turno al rival.

En todo momento se informa de qué está pasando y se va mostrando los Rectángulos generados y como va quedando el Tablero tras cada turno.

Finalizado el bucle while, se informa de quien ha ganado.

public static void main(String[] args) {
      
      tablero = new Tablero(20, 20);
      dados = new Dados();
      jugador = 1;
      intentos = 0;
      
      while (intentos < 4) { //Limite dos intentos seguidos fallidos por cada jugador
         System.out.println("\nTurno Jugador: " + jugador);
         
         if (!decidirEliminarRectangulo(jugador)) {
            
            dados.tirarDados();
            Rectangulo rect = new Rectangulo(dados.getDado1(), dados.getDado2(), jugador);
            System.out.println(rect);
            pausa();
            
            if (tablero.insertarRectangulo(rect)) {
               System.out.printf("Rectángulo insertado en %d,%d\n",
                     rect.getPosiciones()[0], rect.getPosiciones()[1]);
               intentos = 0;
            }
            else {
               System.out.println("No se pudo insertar Rectángulo");
               intentos++; //Contamos intento fallido
            }
         }
         
         System.out.println("Tablero actual:");
         System.out.println(tablero);
         pausa();
         cambioTurno();
      }
      tablero.indicarGanador();
   }

Para decidir al azar si eliminar o no un Rectángulo del rival, pues he pensado en un método que la mayoría de las veces decida NO eliminar.
Para ello lo que hago es generar un int entre 0 y 100. Y solo si el número generado es múltiplo de 5, intento eliminar Rectángulos, lo cuál puede que de todos modos no sea posible debido a que el rival no tiene ahora mismo Rectángulos para eliminar.

private static boolean decidirEliminarRectangulo(int jugador) {
      Random aleatorio = new Random();
      int num = aleatorio.nextInt(100)+1;
      if (num % 5 == 0) {
         return tablero.eliminarRectangulo(jugador);
      }
      else
         return false;
   }

Y creo que no queda nada más importante por explicar.

Clase GR
//https://aprenderaprogramar.com/foros/index.php?topic=7311.0
package dibujaRectangulos;

import java.io.IOException;
import java.util.Random;

public class Gr {

static Tablero tablero;
static Dados dados;
static int jugador;
static int intentos;

public static void main(String[] args) {

tablero = new Tablero(20, 20);
dados = new Dados();
jugador = 1;
intentos = 0;

while (intentos < 4) { //Limite dos intentos seguidos fallidos por cada jugador
System.out.println("\nTurno Jugador: " + jugador);

if (!decidirEliminarRectangulo(jugador)) {

dados.tirarDados();
Rectangulo rect = new Rectangulo(dados.getDado1(), dados.getDado2(), jugador);
System.out.println(rect);
pausa();

if (tablero.insertarRectangulo(rect)) {
System.out.printf("Rectángulo insertado en %d,%d\n",
rect.getPosiciones()[0], rect.getPosiciones()[1]);
intentos = 0;
}
else {
System.out.println("No se pudo insertar Rectángulo");
intentos++; //Contamos intento fallido
}
}

System.out.println("Tablero actual:");
System.out.println(tablero);
pausa();
cambioTurno();
}
tablero.indicarGanador();
}

private static void cambioTurno() {
if (jugador == 1)
jugador = 2;
else
jugador = 1;
}

private static boolean decidirEliminarRectangulo(int jugador) {
Random aleatorio = new Random();
int num = aleatorio.nextInt(100)+1;
if (num % 5 == 0) {
return tablero.eliminarRectangulo(jugador);
}
else
return false;
}

private static void pausa() {
System.out.println("\nPulse INTRO para continuar...\n");
try {
System.in.read();
} catch (IOException e) {
e.printStackTrace();
}
}

}

Pruébalo, comprueba que funciona como debe y pregunta lo que no entiendas o tengas dudas.
Creo que cumple con lo que se pide y que ya he depurado todos los posibles fallos.

Un saludo.

Bueeeno.
Pues ya lo tengo.

El enfoque que comenté en el mensaje anterior.... fue descartado. Mientras lo desarrollaba efectivamente me parecía demasiado complicado y se me ocurrió otro enfoque algo más sencillo.

En lugar de pedir al Rectángulo que nos diera TODAS las posibles posiciones a su alrededor y empezar a probar una por una, he preferido hacer que el Tablero, una vez insertado el Rectángulo en un sitio donde no haya solapamiento, compruebe si a su alrededor hay un Rectángulo "hermano" con el que quedar anexionado. Si no lo hay, no puede quedarse en ese espacio y ha de probar en otro.
Así es más sencillo de programar.

A ver, voy a poner por aquí las clases que he usado. En realidad son las mismas que has usado tú, pero las he reescrito.

Comenzamos por la básica.
Clase Dados
No creo que haya que explicar nada.
Dos atributos int que cada uno representa un dado, quienes reciben un entero aleatorio cada vez que se invoca el método tirarDados()
import java.util.Random;

public class Dados {

private int dado1;
private int dado2;

public void tirarDados() {
Random aleatorio = new Random();
dado1 = aleatorio.nextInt(6)+1;
dado2 = aleatorio.nextInt(6)+1;
}

public int getDado1() {
return dado1;
}

public int getDado2() {
return dado2;
}

}
Clase Rectangulo
Los Rectangulos se irán generando con los atributos ancho y alto según el resultado de tirar los dados.
Otro atributo es el int jugador, sirve para determinar a quien pertenece este Rectangulo, si al Jugador1 o si al Jugador2.
De este modo cuando haya que "dibujarlo" en el Tablero, se sabrá facilmente si hay que rellenarlo con 1 o con 2.

El cuatro atributo, es un array llamado posiciones con 2 valores int. Ahí se guardan las coordenadas donde fue colocado este Rectángulo en el tablero.
Guardar esta información resulta útil para varias cosas, especialmente para cuando un Jugador decide eliminar un Rectángulo del otro jugador.
Teniendo estas coordenadas, sabremos donde debemos situarnos para eliminarlo del Tablero.

En cuanto a métodos, tiene algunos básicos getters y setters. Quizás se pueda destacar es que devuelve el area del rectángulo. Esto servirá al final del programa para decidir quien ha ganado, pues el Jugador cuyos Rectángulo sumen mayor area, será el ganador.

public class Rectangulo {

private int altura;
private int ancho;
private int[] posiciones;
private int jugador;


public Rectangulo(int a, int l, int jug){
altura = a;
ancho = l;
jugador = jug;
}

public void setPosiciones(int[] pos) {
posiciones = pos;
}

public int[] getPosiciones() {
return posiciones;
}

public int getAltura() {
return altura;
}


public int getAncho() {
return ancho;
}


public int getJugador() {
return jugador;
}

public int getArea() {
return altura * ancho;
}

@Override
public String toString() {
StringBuilder sb = new StringBuilder("Rectángulo de jugador " + jugador +": \n");
for (int a = 0; a < altura; a++) {
for (int l = 0; l < ancho; l++)
sb.append("| " + jugador + " |");
sb.append("\n");
}
return sb.toString();
}

}
Clase Tablero
Esta es la clase más importante de todas, es quien lleva todo el peso de la lógica del juego.

Tiene 4 atributos.
Una matriz que representa el tablero, y una segunda matriz que se usará como duplicado de la primera como copia de apoyo.

Esto es para facilitar el proceso de inserción de Rectángulos. Los Rectángulos básicamente se van a insertar por el método de "ensayo y error". Es decir, donde encuentre una posicion disponible en la matriz (con valor 0) se comenzará a insertar el Rectángulo escribiendo 1 si es del Jugador 1 o escribiendo 2 si es el segundo Jugador.
Durante este proceso, puede que el Tablero descubra que no hay sitio para el Rectángulo en esa posicion, o que no queda anexionado a un Rectángulo "hermano".
Entonces, ha de deshacer lo que ha escrito y probar en otro sitio.

Deshacer lo que se ha escrito puede ser complicado de programar, así que lo que hago es intentar las inserciones en la copia del Tablero, si la inserción fracasa pues se descarta esta copia y ya está.
Y si hemos tenido éxito, entonces la copia pasa a ser el nuevo Tablero.

Así todo queda guay de forma sencilla.

Los otros atributos son dos ArrayList donde se van a ir guardando los Rectángulos que cada Jugador ha conseguido insertar.
Guardarlos es necesario, sirve para luego poder elegir Rectángulos a eliminar cuando los Jugadores lo pidan y también para al final del juego, sumar areas de Rectángulos y determinar un ganador.

Pego aquí la clase y sigo en otro post:

import java.util.ArrayList;

public class Tablero {

/*
* El tablero tendrá tres posibles valores en sus matrices:
* 0 - espacio libre
* 1 - area rectangulo jugador 1
* 2 - area rectangulo jugador 2
*/

private int[][] tablero;
private int[][] copiaTablero;
private ArrayList<Rectangulo> rectangulosJug1;
private ArrayList<Rectangulo> rectangulosJug2;

public Tablero(int x,int y){
tablero=new int[x][y];
copiaTablero=new int[x][y];
rectangulosJug1 = new ArrayList<Rectangulo>();
rectangulosJug2 = new ArrayList<Rectangulo>();
}

/**
* Recibe un Rectángulo e intenta insertarlo en el Tablero.<br>
* La inserción se considera exitosa si el Rectángulo puede colocarse
* sin solaparse con otros y además queda anexionado a otro Rectángulo
* "hermano" que pertenezca al mismo Jugador.<br>
* Si consigue insertarse, guardará el Rectángulo en el ArrayList correspondiente
* y grabará en que coordenadas fue insertado.
* @param rect <b>Rectangulo</b> que vamos a insertar.
* @return <b>true</b> si la inserción fue posible, <b>false</b> en caso contrario.
*/
public boolean insertarRectangulo(Rectangulo rect) {

if (rect.getJugador() == 1) {
//Intentarmos inserciones comenzando por la esquina superior izquierda del tablero
for (int a = 0; a <= (tablero.length - rect.getAltura()); a++)
for (int l = 0; l <= (tablero[0].length - rect.getAncho()); l++) {
//Establecemos las posiciones que ha de ocupar el rectangulo en el tablero
int[] posiciones = new int[] {a, l};
rect.setPosiciones(posiciones);
//Intentamos insercion
if (insertar(rect, rectangulosJug1.isEmpty())) {
rectangulosJug1.add(rect);
return true;
}
}
//Bucles finalizados sin insercion exitosa. No se puede insertar este Rectángulo
return false;
}
else { //Se trata del jugador 2
//Intentaremos inserciones comenzando por la esquina inferior derecha del tablero
for (int a = (tablero.length - rect.getAltura()); a >= 0; a--)
for (int l = (tablero[0].length - rect.getAncho()); l >= 0; l--) {

int[] posiciones = new int[] {a, l};
rect.setPosiciones(posiciones);
if (insertar(rect, rectangulosJug2.isEmpty())) {
rectangulosJug2.add(rect);
return true;
}
}
return false;
}

}

/**
* Invoca a los 4 métodos que comprueban si el Rectángulo ha quedado
* anexionado a un Rectángulo "hermano" por algunos de sus cuatro costados.<br>
* Basta con que uno de esos métodos devuelva <b>true</b> para dar por buena
* la anexión.
* @param rect <b>Rectangulo</b> que ha de quedar anexionado.
* @return <b>true</b> si hubo éxito, <b>false</b> en caso contrario.
*/
private boolean comprobarAnexion(Rectangulo rect) {
return (compruebaDerecha(rect) || compruebaIzquierda(rect) ||
compruebaArriba(rect) || compruebaAbajo(rect));
}

/**
* Comprueba si el Rectángulo tiene a un "hermano" por su costado izquierdo.
* @param rect <b>Rectangulo</b> que se ha de anexionar.
* @return <b>true</b> si hubo éxito, <b>false</b> en caso contrario.
*/
private boolean compruebaIzquierda(Rectangulo rect) {
int[] posi = rect.getPosiciones();
for (int a = posi[0]; a < posi[0] + rect.getAltura(); a++)
try {
if (copiaTablero[a][posi[1]-1] == rect.getJugador())
return true; //Hay al menos una celda contigua a un Rectángulo "hermano"
}catch(Exception e) {
//Nada que hacer aquí, seguiremos probando en otras posiciones
}
return false; //No se encontraron celdas "hermanas"
}

/**
* Comprueba si el Rectángulo tiene a un "hermano" por su costado derecho.
* @param rect <b>Rectangulo</b> que se ha de anexionar.
* @return <b>true</b> si hubo éxito, <b>false</b> en caso contrario.
*/
private boolean compruebaDerecha(Rectangulo rect) {
int[] posi = rect.getPosiciones();
for (int a = posi[0]; a < posi[0] + rect.getAltura(); a++)
try {
if (copiaTablero[a][posi[1] + rect.getAncho()] == rect.getJugador())
return true;
}catch(Exception e) {

}
return false;
}

/**
* Comprueba si el Rectángulo tiene a un "hermano" por su costado superior.
* @param rect <b>Rectangulo</b> que se ha de anexionar.
* @return <b>true</b> si hubo éxito, <b>false</b> en caso contrario.
*/
private boolean compruebaArriba(Rectangulo rect) {
int[] posi = rect.getPosiciones();
for (int l = posi[1]; l < posi[1] + rect.getAncho(); l++)
try {
if (copiaTablero[posi[0]-1][l] == rect.getJugador())
return true;
}catch(Exception e) {

}
return false;
}

/**
* Comprueba si el Rectángulo tiene a un "hermano" por su costado inferior.
* @param rect <b>Rectangulo</b> que se ha de anexionar.
* @return <b>true</b> si hubo éxito, <b>false</b> en caso contrario.
*/
private boolean compruebaAbajo(Rectangulo rect) {
int[] posi = rect.getPosiciones();
for (int l = posi[1]; l < posi[1] + rect.getAncho(); l++)
try {
if (copiaTablero[posi[0] + rect.getAltura()][l] == rect.getJugador())
return true;
}catch(Exception e) {

}
return false;
}

/**
* Intentará insertar un rectangulo en las posiciones indicadas.<br>
* @param rect Rectángulo que hay que insertar
* @param unicoEnTablero Informa de si se está insertando el único Rectángulo del jugador
* actual en el Tablero.<br>Si NO es el único Rectángulo, habrá que comprobar que la
* inserción de este Rectángulo ha sido anexa a otro Rectángulo del mismo jugador.
* @return <b>true</b> si tuvo éxito la inserción, <b>false</b> en caso contrario.
*/
private boolean insertar(Rectangulo rect, boolean unicoEnTablero) {
hacerCopia(); //Hacemos copia de seguridad tablero actual
int[] pos = rect.getPosiciones();
try {
for (int a = pos[0]; a < pos[0] + rect.getAltura(); a++)
for (int l = pos[1]; l < pos[1] + rect.getAncho(); l++) {
if (copiaTablero[a][l] == 0) //Espacio disponible
copiaTablero[a][l] = rect.getJugador();
else  //Espacio ocupado, imposible insertar
return false;
}
/*
* Ha sido insertado sin solapamientos. Pero si este NO es el único
* Rectángulo del jugador, hay que comprobar además si ha quedado anexo a otro
* Rectángulo del mismo jugador
*/
if (!unicoEnTablero)
if (!comprobarAnexion(rect)) { //No ha quedado anexo
return false;
}
} catch(Exception e) { //Hay riesgo de salirnos de las dimensiones del tablero
return false;
}
//Si se han completado los bucles, es que la insercion ha sido correcta
restaurarCopia(); //Pasamos la copia sobre la que hemos trabajado al tablero principal
return true;
}

/**
* Intentará eliminar un Rectángulo del jugador opuesto.<br>
* El Rectángulo a eliminar se elige al azar.
* @param jugador Jugador que quiere eliminar un Rectángulo del rival.
* @return <b>true</b> al eliminar un Rectángulo,
* <b>false</b> si el rival no tiene Rectángulos para eliminar
*/
public boolean eliminarRectangulo(int jugador) {
if (jugador == 1) { //Jugador1 elimina rectangulo de Jugador2
if (rectangulosJug2.isEmpty())
return false; //No hay rectangulos para eliminar
else {
int azar = (int)(Math.random() * rectangulosJug2.size());
int[] posi = rectangulosJug2.get(azar).getPosiciones();
for (int a = posi[0]; a < posi[0] + rectangulosJug2.get(azar).getAltura() ; a++)
for (int l = posi[1]; l < posi[1] + rectangulosJug2.get(azar).getAncho(); l++)
tablero[a][l] = 0;
rectangulosJug2.remove(azar);
System.out.printf("Jugador %d ha eliminado un Rectangulo en %d,%d de su oponente\n",
jugador, posi[0], posi[1]);
return true;
}
}
else {
if (rectangulosJug1.isEmpty())
return false; //No hay rectangulos para eliminar
else {
int azar = (int)(Math.random() * rectangulosJug1.size());
int[] posi = rectangulosJug1.get(azar).getPosiciones();
for (int a = posi[0]; a < posi[0] + rectangulosJug1.get(azar).getAltura(); a++)
for (int l = posi[1]; l < posi[1] + rectangulosJug1.get(azar).getAncho(); l++)
tablero[a][l] = 0;
rectangulosJug1.remove(azar);
System.out.printf("Jugador %d ha eliminado un Rectangulo en %d,%d de su oponente\n",
jugador, posi[0], posi[1]);
return true;
}
}
}

/**
* Hace una copia del Tablero original.<br>
* Todos los intentos de inserción se harán en la copia
* y será descartada en caso de fracaso.
*/
private void hacerCopia() {
for (int i = 0; i < tablero.length; i++)
for (int j = 0; j < tablero[0].length; j++)
copiaTablero[i][j] = tablero[i][j];
}

/**
* Si la insercion de un Rectángulo ha sido exitosa, la
* copia pasará a ser el Tablero original.
*/
private void restaurarCopia() {
for (int i = 0; i < tablero.length; i++)
for (int j = 0; j < tablero[0].length; j++)
tablero[i][j] = copiaTablero[i][j];
}

/**
* Determina quien ha sido el ganador del juego.<br>
* Para determinar ganador, se calcula el area total
* de la suma de los Rectángulos que cada jugador ha conseguido colocar.
*/
public void indicarGanador() {

double areaTablero = tablero.length * tablero[0].length;
double areaJug1 = 0;
double areaJug2 = 0;

for (Rectangulo rect: rectangulosJug1)
areaJug1 += rect.getArea();

for (Rectangulo rect: rectangulosJug2)
areaJug2 += rect.getArea();

areaJug1 = areaJug1 * 100 / areaTablero;
areaJug2 = areaJug2 * 100 / areaTablero;

System.out.printf("\nArea ocupada por Jugador1: %.2f\n", areaJug1);
System.out.printf("Area ocupada por Jugador2: %.2f\n", areaJug2);

if (areaJug1 == areaJug2)
System.out.println("Los JUGADORES han empatado.");
else if (areaJug1 > areaJug2)
System.out.println("Ha ganado el Jugador 1");
else
System.out.println("Ha ganado el Jugador 2");
}

@Override
public String toString() {
StringBuilder sb = new StringBuilder("Estado del Juego: \n");
for (int a = 0; a < tablero.length; a++) {
for (int l = 0; l < tablero[0].length; l++)
sb.append("| " + tablero[a][l] + " |");
sb.append("\n");
}
return sb.toString();
}

}