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

Para eso, tienes dos opciones.

1. La más fácil y por tanto la más recomendable.
Añadir como atributo de Cliente un double donde acumular los importes de sus compras.

public class Cliente {
   
   private int id;
   private String nombres;
   private String apellidos;
   private String email;
   private int telefono;
   private StringBuilder facturacion; //Simula un histórico de ventas´
   private double totalFacturado;

   public Cliente (int id, String nombres, String apellidos, String email, int telefono) {
      this.id = id;
      this.nombres = nombres;
      this.apellidos = apellidos;
      this.email=email;
      this.telefono = telefono;
      facturacion = new StringBuilder();
      totalFacturado = 0;
   }

Así luego, en su método facturar(), no solo le pasamos la línea para el StringBuilder, si no también el importe de la venta, que ha sido calculado en el main

   
   /*
    * Añade una nueva línea de facturación
    * al StringBuilder
    */
   public void facturar(String linea, double importe) {
      facturacion.append(linea);
      totalFacturado += importe;
   }

Ahora en el Main, además de pasarle la línea formateada para el StringBuilder, le pasaremos también el importe double para que lo sume a su nuevo atributo:

               //Y también en la facturación personal del comprador
               comprador.facturar(String.format("Codigo: %s Nombre: %s Unidades compradas: %d Importe: %.2f\n",
                     codigo, solicitado.getNombre(), unidades, facturar), facturar);

2- Un poco más compleja pero que no requiere añadir atributos ni cambiar nada en el main.
Hacer malabarismos con la clase String para detectar y extraer los caracteres que representan los importes, convertirlos a double y sumarlos.
El StringBuilder contiene una serie de líneas de cadenas, cada una con el importe al final de ella.
Pues habrá que separar estas líneas, detectar donde se encuentra el importe, extraerlo para poder convertirlo a double y poder hacer una suma con los importes de todas las líneas.
Todo este proceso lo haríamos en el método mostrarDetalles(), y solo si hay algo facturado.

   public void mostrarDetalles() {
      System.out.println("ID: " + id);
      System.out.println("Nombre: " + nombres +  " " + apellidos);
      System.out.println("E-Mail: " + email + " Telf: " + telefono);
      System.out.println("\tFACTURACION");
      System.out.println(facturacion.length()==0?"No hay historico de ventas":facturacion.toString());

      //Hacemos una suma del total facturado, si es que hay facturas
      if (facturacion.length() > 0) {
         double total = 0;
         //1-Creamos un arreglo donde cada elemento es una linea del StringBuilder
         String[] lineas = facturacion.toString().split("\n");
         //2-Recorremos cada linea con un bucle
         for (int in = 0; in < lineas.length; in++) {
            //3-Buscamos el último espacio en blanco de cada linea
            int pos = lineas[in].lastIndexOf(" ");
            //4-Tras ese último espacio en blanco, está el importe de la venta, lo extraemos
            String importe = lineas[in].substring(pos+1);
            //5-El importe está escrito con "coma decimal", pero el parseo solo funciona con "punto decimal".
            //Lo reemplazamos
            importe = importe.replace(',' , '.');
            //6-Parseamos a double y lo acumulamos en el total
            total += Double.parseDouble(importe);
         }
         //6-Finalizado el bucle, ya tenemos el total
         System.out.printf("\nEl total de los importes es: %.2f\n", total);
      }
   }

Como ves, serviría para hacer un examen sobre la clase String y el tratamiento de cadenas. 
Es enrevesado, pero funciona, si lo ejecutamos veremos que se realiza la suma de importes correctamente.

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
4 = Gestion Inventario
5 = Gestion Clientes
0 = Salir
Elija la opcion: 2

Indique el ID del Cliente
ID: 19034211
Cliente identificado:
[id= 19034211, nombre= Laura, apellidos= Juan, email= lajuanita@hotmail.com, telefono= 3451212]

Indique el CODIGO del electrodoméstico para realizar la venta.
CODIGO: LAV-0090

Detalles del producto:
Clase Lavadora
Marca: Whirlpool
Precio 109.9
Cantidad: 4
Capacidad de Lavado: 18Kg
Ciclos: 8
Velocidad: 1200

Unidades a facturar (MAX=4): 2

Importe a pagar: 246,18
Gracias por su compra

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
4 = Gestion Inventario
5 = Gestion Clientes
0 = Salir
Elija la opcion: 2

Indique el ID del Cliente
ID: 19034211
Cliente identificado:
[id= 19034211, nombre= Laura, apellidos= Juan, email= lajuanita@hotmail.com, telefono= 3451212]

Indique el CODIGO del electrodoméstico para realizar la venta.
CODIGO: COC-0350

Detalles del producto:
Clase Cocina
Marca: Miele
Precio: 109.9
Nº de Hornillas: 4
Con Horno
Sistema de Coccion: Induccion

Unidades a facturar (MAX=4): 1

Importe a pagar: 123,09
Gracias por su compra

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
4 = Gestion Inventario
5 = Gestion Clientes
0 = Salir
Elija la opcion: 5

      GESTION CLIENTES

1 == Añadir Cliente
2 == Eliminar Cliente
3 == Listar Clientes
0 == Regresar Menu Principal
Opcion: 3

      LISTADO DE CLIENTES

      ***********************
ID: 17183451
Nombre: Roberto Torres
E-Mail: roberto@hotmail.com Telf: 2134121
   FACTURACION
No hay historico de ventas
      ***********************
ID: 19034211
Nombre: Laura Juan
E-Mail: lajuanita@hotmail.com Telf: 3451212
   FACTURACION
Codigo: LAV-0090 Nombre: Renta Max Unidades compradas: 2 Importe: 246,18
Codigo: COC-0350 Nombre: Pyro Master Unidades compradas: 1 Importe: 123,09


El total de los importes es: 369,27
      ***********************

      GESTION CLIENTES

1 == Añadir Cliente
2 == Eliminar Cliente
3 == Listar Clientes
0 == Regresar Menu Principal
Opcion: 0

Regresando a menu principal...

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
4 = Gestion Inventario
5 = Gestion Clientes
0 = Salir
Elija la opcion: 0

      FIN DE PROGRAMA

Lo primero, añadir como atributo el gestor de clientes

public class Main {
   
   private static GestorClientes gestorCl = new GestorClientes();
   private static Inventario inventario = new Inventario();
   private static Scanner teclado = new Scanner(System.in);
   private static StringBuilder facturacion = new StringBuilder();
   private static double totalFacturado = 0;

Ampliamos menú principal con la nueva funcionalidad:

   public static void main(String[] args) {
      
      int opcion = 0;
      
      do {
         System.out.println("\nELECTRODOMESTICOS ELECTROHOGAR");
         System.out.println("       MENU DE OPCIONES");
         System.out.println("1 = Listar Inventario");
         System.out.println("2 = Venta");
         System.out.println("3 = Facturacion");
         System.out.println("4 = Gestion Inventario");
         System.out.println("5 = Gestion Clientes");
         System.out.println("0 = Salir");
         System.out.print("Elija la opcion: ");
         opcion = Integer.parseInt(teclado.nextLine());
         
         switch(opcion) {
         case 1:
            listar();
            break;
         case 2:
            venta();
            break;
         case 3:
            facturacion();
            break;
         case 4:
            gestion();
            break;
         case 5:
            gestionClientes();
            break;
         case 0:
            System.out.println("\n\t\tFIN DE PROGRAMA");
            break;
         default:
            System.out.println("Opcion equivocada");
         }
      } while(opcion != 0);

Y tenemos que escribir el nuevo método gestionClientes().
Aquí ofreceremos un submenú de opciones: Añadir, eliminar y listar clientes

private static void gestionClientes() {
int opcion = 0;
do {
System.out.println("\n\t\tGESTION CLIENTES\n");
System.out.println("1 == Añadir Cliente");
System.out.println("2 == Eliminar Cliente");
System.out.println("3 == Listar Clientes");
System.out.println("0 == Regresar Menu Principal");
System.out.print("Opcion: ");
opcion = Integer.parseInt(teclado.nextLine());

switch(opcion) {
case 1:
System.out.println("\t\tNUEVO CLIENTE");
if (gestorCl.buscaPosicionLibrecl() == -1)
System.out.println("No hay espacio para añadir un nuevo Cliente");
else {
System.out.print("ID: ");
int nuevoId = Integer.parseInt(teclado.nextLine());
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Apellidos: ");
String apellidos = teclado.nextLine();
System.out.print("E-Mail: ");
String eMail = teclado.nextLine();
System.out.print("Telefono: ");
int telef = Integer.parseInt(teclado.nextLine());

if (gestorCl.agregarCliente(new Cliente(nuevoId, nombre, apellidos, eMail, telef)))
System.out.println("Nuevo Cliente registrado");
else
System.out.println("No se pudo registrar Cliente.\n"
+ "Puede que no haya espacio libre");
}
break;
case 2:
System.out.println("\nIndique ID del Cliente a eliminar.");
System.out.print("ID: ");
int id = Integer.parseInt(teclado.nextLine());
if (gestorCl.eliminarCliente(id))
System.out.println("\nCliente eliminado.");
else
System.out.println("\nNo existe Cliente con ID: " + id);
break;
case 3:
gestorCl.listarTodos();
break;
case 0:
System.out.println("\nRegresando a menu principal...");
break;
default:
System.out.println("Opcion equivocada");
}
}while(opcion != 0);
}
¿Y con esto ya queda implementa la entidad Cliente en nuestro programa?
Casi, pero no.
Falta modificar el proceso de venta de un electrodoméstico, de manera que ahora intervenga esta entidad.
Habrá que pedir el ID del cliente que va a hacer la compra, dejar constancia de dicho cliente en la "facturación general" de la empresa, y también en la facturación personal de este cliente.
Estos cambios los hacemos en el método venta().
Y nos va a quedar bastante gordito de código, pero es lo que hay... 

   
   private static void venta() {
      //Pedimos Cliente que va a comprar
      System.out.println("\nIndique el ID del Cliente");
      System.out.print("ID: ");
      int id = Integer.parseInt(teclado.nextLine());
      //Comprobamos si existe
      Cliente comprador = gestorCl.getPorID(id);
      if (comprador == null) //No existe, aquí termina el proceso de venta
         System.out.println("No hay Cliente con el ID: " + id);
      else { //Si existe, continuamos con la venta
         System.out.println("Cliente identificado:\n" + comprador);
         //Pedimos Electrodomestico que se va a comprar
         System.out.println("\nIndique el CODIGO del electrodoméstico para realizar la venta.");
         System.out.print("CODIGO: ");
         String codigo = teclado.nextLine();
         //Comprobamos si existe
         Electrodomestico solicitado = inventario.getPorCodigo(codigo);
         if (solicitado == null) //No existe, aqui termina el proceso venta
            System.out.println("No hay electrodoméstico con el CODIGO: " + codigo);
         else { //Sí existe, seguimos adelante
            System.out.println("\nDetalles del producto:");
            solicitado.mostrarDetalles();
            //Pedimos cantidad de unidades deseadas, controlamos que nos de un valor válido.
            //Aunque primero comprobamos si hay stock disponible
            if (solicitado.getCantidad() <= 0)
               System.out.println("\nProducto agotado");
            else {
               int unidades = 0;
               do {
                  System.out.print("\nUnidades a facturar (MAX="+ solicitado.getCantidad() +"): ");
                  unidades = Integer.parseInt(teclado.nextLine());
               }while(unidades > solicitado.getCantidad());
               //Calculamos importe a facturar, actualizamos stock producto e informamos en pantalla
               double facturar = solicitado.calcularPrecioFinal(unidades);
               solicitado.setCantidad(solicitado.getCantidad() - unidades);
               System.out.printf("\nImporte a pagar: %.2f\n", facturar);
               System.out.println("Gracias por su compra");
               //Dejamos constancia en la facturacion
               facturacion.append(String.format("# ID. Cliente: %d Codigo: %s Nombre: %s Unidades vendidas: %d Importe: %.2f\n",
                     id, codigo, solicitado.getNombre(), unidades, facturar));
               totalFacturado += facturar;
               //Y también en la facturación personal del comprador
               comprador.facturar(String.format("Codigo: %s Nombre: %s Unidades compradas: %d Importe: %.2f\n",
                     codigo, solicitado.getNombre(), unidades, facturar));
            }
         }
      }
   }

Parece que ya está,¿no? Que emoción, vamos a probarlo.
Si intentamos una venta, nos vamos a llevar un chasco...

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
4 = Gestion Inventario
5 = Gestion Clientes
0 = Salir
Elija la opcion: 2

Indique el ID del Cliente
ID: 19034211
Exception in thread "main" java.lang.NullPointerException
   at electrodomesticos.GestorClientes.getPorID(GestorClientes.java:26)
   at electrodomesticos.Main.venta(Main.java:73)
   at electrodomesticos.Main.main(Main.java:34)

¿Qué ha pasado?
Pues que como todo buen programa que se precie, tiene sus bugs....
Hay un detalle que hemos pasado por alto en la gestión de los arreglos. Al principio no había problema porque escribimos el programa pensando en un arreglo que siempre iba a tener 10 electrodomésticos.
Pero luego añadimos la funcionalidad de poder eliminar electrodomésticos, así como ahora clientes.

Esto significa que ahora en nuestros arreglos vamos a tener posiciones con valor null. Entonces, a la hora de buscar elementos en ellos, o listar su contenido, tenemos que evitar las posiciones null. Ya que si intentamos preguntar cuál es el ID del cliente a una posición null, va a ocurrir esa excepción que nos ha salido en pantalla.

Toca corregir todos los métodos que hagan recorridos de los arreglos, excepto los métodos que buscan posiciones libres, ya que esos precisamente se dedican a buscar posiciones null y no van dar ningún problema.

Además, ahora hay que contemplar la posibilidad de que los arreglos sean completamente null y no tengamos ni clientes ni electrodomésticos para mostrar en pantalla.
Esto también deberíamos controlarlo para informar en pantalla correctamente.

En la clase GestorClientes, estos métodos se han de modificar para no actuar sobre posiciones null en el arreglo:

   
   public void listarTodos() {
      System.out.println("\n\t\tLISTADO DE CLIENTES");
      System.out.println("\n\t\t***********************");
      
      boolean arregloVacio = true;
      for (int i = 0; i < clientes.length; i++) {
         if (clientes[i ] != null) {
            arregloVacio = false;
            clientes[i ].mostrarDetalles();
            System.out.println("\t\t***********************");
         }
      }
      //Comprobamos si el arreglo resulta estar vacio
      if (arregloVacio)
         System.out.println("\nNo hay Clientes registrados");
   }
   
   public Cliente getPorID(int id) {
      
      for (int i = 0; i < clientes.length; i++) {
         if (clientes[i ] != null) {
            if (clientes[ i].getId() == id)
               return clientes[i ]; //Cliente encontrado, lo retornamos
         }
      }
      //Si bucle FOR termina sin retornar nada, es que no hay cliente con ese ID
      return null;
   }
   
   public boolean eliminarCliente(int id) {
      //Buscamos por codigo, si lo encontramos, asignamos valor null a la posicion.
      for (int i = 0; i < clientes.length; i++) {
         if (clientes[i ] != null) {
            if (clientes[i ].getId() == id) {
               clientes[i ] = null; //Cliente eliminado
               return true; //Informamos que se ha eliminado con exito
            }
         }
      }
      //Bucle FOR no ha retornado TRUE, no se ha encontrado cliente buscado
      return false;
   }

Y en la clase Inventario, con cuatro los métodos que se han de modificar:

   public void listarTodos() {
      System.out.println("\n\t\tLISTADO DE ELECTRODOMESTICOS");
      System.out.println("\n\t\t***********************");

      boolean arregloVacio = true;
      for (int i = 0; i < productos.length; i++) {
         if (productos[i ] != null) {
            arregloVacio = false;
            productos[i ].mostrarDetalles();
            System.out.println("\t\t***********************");
         }
      }
      //Comprobamos si el arreglo resulta estar vacio
      if (arregloVacio)
         System.out.println("\nNo hay Electrodomesticos registrados");
   }

   public void listarPorClase(String clase) {
      boolean encontrado = false; //Para controlar si se han encontrado productos de la clase solicitada
      System.out.println("\n\t\tLISTADO DE " + clase.toUpperCase());
      System.out.println("\n\t\t***********************");

      for (int i = 0; i < productos.length; i++) {
         if (productos[i ] != null) {
            if (productos[i ].getClass().toString().contains(clase)) {
               encontrado = true; //Se ha encontrado al menos un coincidente
               productos[i ].mostrarDetalles();
               System.out.println("\t\t***********************");
            }
         }
      }

      //Si no se encontró ningún producto de la clase solicitada, informamos
      if (!encontrado)
         System.out.println("No hay electrodomesticos de esta clase");
   }

   public Electrodomestico getPorCodigo(String codigo) {

      for (int i = 0; i < productos.length; i++) {
         if (productos[i ] != null) {
            if (productos[i ].getCodigo().equals(codigo))
               return productos[i ]; //Producto encontrado, lo retornamos
         }
      }
      //Si bucle FOR termina sin retornar nada, es que no hay producto con ese codigo
      return null;
   }

   public boolean eliminarElectrodomestico(String codigo) {
      //Buscamos por codigo, si lo encontramos, asignamos valor null a la posicion.
      for (int i = 0; i < productos.length; i++) {
         if (productos[i ] != null) {
            if (productos[i ].getCodigo().equals(codigo)) {
               productos[i ] = null; //Producto eliminado
               return true; //Informamos que se ha eliminado con exito
            }
         }
      }
      //Bucle FOR no ha retornado TRUE, no se ha encontrado el producto buscado
      return false;
   }

Ok, ahora sí.
Podemos mostrar listados aunque hayan posiciones null en los arreglos, y si hacemos una venta la facturación general registra el id del cliente y el cliente a su vez registra la venta en su facturación personal:

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
4 = Gestion Inventario
5 = Gestion Clientes
0 = Salir
Elija la opcion: 5

      GESTION CLIENTES

1 == Añadir Cliente
2 == Eliminar Cliente
3 == Listar Clientes
0 == Regresar Menu Principal
Opcion: 3

      LISTADO DE CLIENTES

      ***********************
ID: 17183451
Nombre: Roberto Torres
E-Mail: roberto@hotmail.com Telf: 2134121
   FACTURACION
No hay historico de ventas
      ***********************
ID: 19034211
Nombre: Laura Juan
E-Mail: lajuanita@hotmail.com Telf: 3451212
   FACTURACION
No hay historico de ventas
      ***********************

      GESTION CLIENTES

1 == Añadir Cliente
2 == Eliminar Cliente
3 == Listar Clientes
0 == Regresar Menu Principal
Opcion: 0

Regresando a menu principal...

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
4 = Gestion Inventario
5 = Gestion Clientes
0 = Salir
Elija la opcion: 2

Indique el ID del Cliente
ID: 19034211
Cliente identificado:
[id= 19034211, nombre= Laura, apellidos= Juan, email= lajuanita@hotmail.com, telefono= 3451212]

Indique el CODIGO del electrodoméstico para realizar la venta.
CODIGO: TLV-2338

Detalles del producto:
Clase Televisor
Marca: LG
Precio: 799.9
Cantidad: 17
Pulgadas: 34
Resolucion: 3840x2160
Tipo Pantalla: LED

Unidades a facturar (MAX=17): 3

Importe a pagar: 2687,66
Gracias por su compra

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
4 = Gestion Inventario
5 = Gestion Clientes
0 = Salir
Elija la opcion: 3

      REGISTRO DE FACTURACION

# ID. Cliente: 19034211 Codigo: TLV-2338 Nombre: Pentax Advance Unidades vendidas: 3 Importe: 2687,66

Total facturado: 2687,66

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
4 = Gestion Inventario
5 = Gestion Clientes
0 = Salir
Elija la opcion: 5

      GESTION CLIENTES

1 == Añadir Cliente
2 == Eliminar Cliente
3 == Listar Clientes
0 == Regresar Menu Principal
Opcion: 3

      LISTADO DE CLIENTES

      ***********************
ID: 17183451
Nombre: Roberto Torres
E-Mail: roberto@hotmail.com Telf: 2134121
   FACTURACION
No hay historico de ventas
      ***********************
ID: 19034211
Nombre: Laura Juan
E-Mail: lajuanita@hotmail.com Telf: 3451212
   FACTURACION
Codigo: TLV-2338 Nombre: Pentax Advance Unidades compradas: 3 Importe: 2687,66

      ***********************

      GESTION CLIENTES

1 == Añadir Cliente
2 == Eliminar Cliente
3 == Listar Clientes
0 == Regresar Menu Principal
Opcion: 0

Regresando a menu principal...

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
4 = Gestion Inventario
5 = Gestion Clientes
0 = Salir
Elija la opcion: 0

      FIN DE PROGRAMA

Y con esto parece que ya está.
Puede que probándolo a fondo aparezca algún otro bug. Si ocurriese, coméntalo aquí.
Un saludo.

increíble muchísimas gracias si yo modifico para submenus eso si puedo, quería preguntarte por la observación de precio final como lo implemento porque al pegarlo en la parte precio final me da un error

Sobre el precio.
Yo lo que haría sería eliminar los métodos calcularSubtotal() y calcularIva().
Y escribiría el método calcularPrecioFinal() en la clase Electrodomestico de esta manera:
public double calcularPrecioFinal(int cantidad) {
return precio * cantidad * 1.12;
}
Por tanto deja de ser un método abstracto.
El único método que si interesa que se abstracto es mostrarDetalles(), porque este si va a ser distinto según cada clase hija.
Aunque de este método, eliminaría la línea que muestra el "valor a pagar por el electrodoméstico", ya que lo que mostraba era el precio de comprar TODAS las unidades existentes.

Y ya luego, en la clase Main donde hacemos la venta, ahora podemos calcular el precio final de esa venta llamando al nuevo método que hemos escrito:

            //Calculamos importe a facturar, actualizamos stock producto e informamos en pantalla
            double facturar = solicitado.calcularPrecioFinal(unidades);
            solicitado.setCantidad(solicitado.getCantidad() - unidades);
            System.out.printf("\nImporte a pagar: %.2f\n", facturar);
            System.out.println("Gracias por su compra");

hola me olvide decir que cual era la manera de hacer una funcion que agregue producto y elimine producto y como incluyo los datos de una persona me toca hacer una clase persona para eso ?  si una persona quiere comprar mas de 1 producto osea una cocina, una refrigerador y asi se puede integrar eso al programa?

Para hacer todo eso bien hecho, habría que usar ArrayList o una base de datos, es decir, colecciones dinámicas que puedan crecer o reducir su tamaño.
Como solo nos permiten usar arreglos, que no son los adecuados para estos menesteres, pues se puede intentar hacer algo parecido, algo que simule esas funcionalidades.

Añadir o eliminar productos. Como ya dijimos, estamos limitados a los elementos con los que inicializamos el arreglo.
Hemos puesto 10 y ese es nuestro límite.
Podemos poner 20, ó 100,  ó 1000.... eso nos da más margen, pero seguiremos teniendo un límite concreto.

Sin embargo, podemos hacer algo que parezca que añdimos/eliminamos productos. En el arreglo, para eliminar un producto podemos asignar valor null a la posición que ocupa y así tendríamos una posición libre para añadir otro producto.

Vamos a la clase Inventario, la que gestiona el arreglo, y la dotamos con estos tres métodos:

public boolean eliminarElectrodomestico(String codigo) {
//Buscamos por codigo, si lo encontramos, asignamos valor null a la posicion.
for (int i = 0; i < productos.length; i++) {
if (productos[i].getCodigo().equals(codigo)) {
productos[i] = null; //Producto eliminado
return true; //Informamos que se ha eliminado con exito
}
}
//Bucle FOR no ha retornado TRUE, no se ha encontrado el producto buscado
return false;
}

public int buscaPosicionLibre() {
for (int i = 0; i < productos.length; i++) {
if (productos[i] == null) //Esta posicion esta libre
return i; //Retornamos la posicion
}

return -1; //Significa que no hay posiciones libres
}

public boolean agregarElectrodomestico(Electrodomestico nuevo) {
int libre = buscaPosicionLibre();

if (libre == -1)
return false; //No hay espacio para añadir nada
else {
productos[libre] = nuevo; //Añadimos
return true; //Informamos que todo OK
}
}No requieren demasiada explicaciones creo.
El primero elimina un producto según el código indicado.
El segundo busca una posición libre en arreglo y la retorna. Si no la hay, retorna -1.
El tercero añade un nuevo Electrodomestico al arreglo, si es que hay espacio libre.

Y ahora vamos al Main y ampliamos el menú con una nueva opción:

   public static void main(String[] args) {
      
      int opcion = 0;
      
      do {
         System.out.println("\nELECTRODOMESTICOS ELECTROHOGAR");
         System.out.println("       MENU DE OPCIONES");
         System.out.println("1 = Listar Inventario");
         System.out.println("2 = Venta");
         System.out.println("3 = Facturacion");
         System.out.println("4 = Gestion Inventario");
         System.out.println("0 = Salir");
         System.out.print("Elija la opcion: ");
         opcion = Integer.parseInt(teclado.nextLine());
         
         switch(opcion) {
         case 1:
            listar();
            break;
         case 2:
            venta();
            break;
         case 3:
            facturacion();
            break;
         case 4:
            gestion();
            break;
         case 0:
            System.out.println("\n\t\tFIN DE PROGRAMA");
            break;
         default:
            System.out.println("Opcion equivocada");
         }
      } while(opcion != 0);

   }

Y tenemos que escribir un nuevo método para llevar a cabo esta gestión.
Aquí mostraremos un submenú para que el usuario elija entre añadir un nuevo Electrodoméstico o eliminar uno existente.

   
   private static void gestion() {
      int opcion = 0;
      do {
         System.out.println("\n\t\tGESTION INVENTARIO\n");
         System.out.println("1 == Añadir Electrodomestico");
         System.out.println("2 == Eliminar Electrodomestico");
         System.out.println("0 == Regresar Menu Principal");
         System.out.print("Opcion: ");
         opcion = Integer.parseInt(teclado.nextLine());
         
         switch(opcion) {
         case 1:
            System.out.println("\nIndique la CLASE de Electrodomestico para añadir");
            System.out.print("CLASE: ");
            nuevoElectrodomestico(teclado.nextLine());
            break;
         case 2:
            System.out.println("\nIndique CODIGO del Electrodoméstico a eliminar.");
            System.out.print("CODIGO: ");
            String codigo = teclado.nextLine();
            if (inventario.eliminarElectrodomestico(codigo))
               System.out.println("\nElectrodomestico eliminado.");
            else
               System.out.println("\nNo existe electrodomestico con CODIGO: " + codigo);
            break;
         case 0:
            System.out.println("\nRegresando a menu principal...");
            break;
         default:
            System.out.println("Opcion equivocada");
         }
      }while(opcion != 0);
   }

He marcado en azul la invocación a otro método.
El proceso de crear un nuevo electrodoméstico requiere bastante código, porque hay que pedir muchos datos. Pero es que encima esos datos son distintos según la clase de electrodoméstico que vamos a registrar. Y hay cuatro diferentes....
Por eso mejor escribir todo esto en otro método independiente.

De nuevo, vamos a dar por hecho que el usuario nos va a dar una clase correcta, aunque vamos a ser "tolerantes" con las mayúsculas y minúsculas.
El método lo que hará será pedir primero los datos que son comunes a TODOS los electrodomésticos.
Y luego, según la clase indicada, pedirá los datos específicos de cada tipo de electrodoméstico.

Una vez recopilados esos datos, añadiremos el producto al inventario.
Pero, antes de hacer todo esto, comprobaremos primero si hay espacio libre, porque si no lo hay..., pues para que vamos a pedir ningún dato...

private static void nuevoElectrodomestico(String clase) {

//Comprobamos si hay espacio libre
if (inventario.buscaPosicionLibre() == -1)
System.out.println("\nNo hay espacio para añadir un nuevo Electrodomestico");
else {
Electrodomestico nuevo = null;
//Pedimos datos comunes
System.out.print("\nNombre: ");
String nombre = teclado.nextLine();
System.out.print("Codigo: ");
String codigo = teclado.nextLine();
System.out.print("Marca: ");
String marca = teclado.nextLine();
System.out.print("Cantidad: ");
int cantidad = Integer.parseInt(teclado.nextLine());
System.out.print("Precio: ");
double precio = Double.parseDouble(teclado.nextLine());

//Pedimos datos específicos, según la clase indicada
switch(clase.toLowerCase()) {
case "cocina":
System.out.print("Nº de Hornillas: ");
int hornillas = Integer.parseInt(teclado.nextLine());
System.out.print("Tiene Horno(Si/No): ");
boolean tieneHorno = teclado.nextLine().equalsIgnoreCase("si");
System.out.print("Sistema de Coccion: ");
String coccion = teclado.nextLine();
nuevo = new Cocina(nombre, codigo, marca, cantidad, precio, hornillas, tieneHorno, coccion);
break;
case "refrigeradora":
System.out.print("Pies: ");
double pies = Double.parseDouble(teclado.nextLine());
System.out.print("Nivel Congelamiento: ");
int nivel = Integer.parseInt(teclado.nextLine());
nuevo = new Refrigeradora(nombre, codigo, marca, cantidad, precio, pies, nivel);
break;
case "televisor":
System.out.print("Pulgadas: ");
int pulgadas = Integer.parseInt(teclado.nextLine());
System.out.print("Resolucion: ");
String resolucion = teclado.nextLine();
System.out.print("Tipo Pantalla: ");
String pantalla = teclado.nextLine();
nuevo = new Televisor(nombre, codigo, marca, cantidad, precio, pulgadas, resolucion, pantalla);
break;
case "lavadora":
System.out.print("Velocidad: ");
int velocidad = Integer.parseInt(teclado.nextLine());
System.out.print("Capacidad de Lavado: ");
String capacidad = teclado.nextLine();
System.out.print("Ciclos: ");
int ciclos = Integer.parseInt(teclado.nextLine());
nuevo = new Lavadora(nombre, codigo, marca, cantidad, precio, velocidad, capacidad, ciclos);
break;
}
//Nuevo electrodomestico construido, lo añadimos
if (nuevo == null)
System.out.println("\nERROR. No existen Electrodomesticos de la clase " + clase);
else if (inventario.agregarElectrodomestico(nuevo))
System.out.println("\nNuevo Electrodomestico registrado");
else
System.out.println("\nNo se pudo registrar Electrodomestico."
+ " Puede que no haya espacio libre en el Inventario.");
}

}

Y listo, si lo ponemos a prueba, vemos que al comenzar el programa no deja añadir nada porque no hay espacio libre.
Pero si eliminamos algo, ya podemos añadir nuevo electrodoméstico, y comprobarlo en el listado:

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
4 = Gestion Inventario
0 = Salir
Elija la opcion: 4

      GESTION INVENTARIO

1 == Añadir Electrodomestico
2 == Eliminar Electrodomestico
0 == Regresar Menu Principal
Opcion: 1

Indique la CLASE de Electrodomestico para añadir
CLASE: Lavadora

No hay espacio para añadir un nuevo Electrodomestico

      GESTION INVENTARIO

1 == Añadir Electrodomestico
2 == Eliminar Electrodomestico
0 == Regresar Menu Principal
Opcion: 2

Indique CODIGO del Electrodoméstico a eliminar.
CODIGO: LAV-0115

Electrodomestico eliminado.

      GESTION INVENTARIO

1 == Añadir Electrodomestico
2 == Eliminar Electrodomestico
0 == Regresar Menu Principal
Opcion: 1

Indique la CLASE de Electrodomestico para añadir
CLASE: lavadora

Nombre: Lavatronic 2000
Codigo: LAV-1010
Marca: Zanussi
Cantidad: 4
Precio: 119.90
Velocidad: 950
Capacidad de Lavado: 12Kg
Ciclos: 3

Nuevo Electrodomestico registrado

      GESTION INVENTARIO

1 == Añadir Electrodomestico
2 == Eliminar Electrodomestico
0 == Regresar Menu Principal
Opcion: 0

Regresando a menu principal...

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
4 = Gestion Inventario
0 = Salir
Elija la opcion: 1

Indique la clase que quiere listar.
Pulse ENTER con el campo vacio para listar todas las clases.
Clase: Lavadora

      LISTADO DE LAVADORA

      ***********************
Clase Lavadora
Marca: Whirlpool
Precio 109.9
Cantidad: 4
Capacidad de Lavado: 18Kg
Ciclos: 8
Velocidad: 1200
      ***********************
Clase Lavadora
Marca: Zanussi
Precio 119.9
Cantidad: 4
Capacidad de Lavado: 12Kg
Ciclos: 3
Velocidad: 950
      ***********************

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
4 = Gestion Inventario
0 = Salir
Elija la opcion: 0

      FIN DE PROGRAMA

Sobre lo de incluir una persona.
A ver, si quieres guardar un registro de "clientes", pues sí, necesitarás una clase Persona y una clase similar a Inventario que gestione un arreglo de tipo Persona.

Pero si solo quieres reflejar su nombre y algún dato más en la facturación, pues bastaría con pedirlos en el momento de la venta e incluirlos en la línea que se añade al StringBuilder en cada venta.

Hombre, la primera opción es más interesante.
Una clase que podría llamarse Agenda y gestione un arreglo de clase Persona.
Que haga lo mismo que Inventario: añadir personas, eliminar, listar todas las personas, listar por DNI/cédula, .....

Incluso, la clase Persona que escribas, podría incluir como atributo otro StringBuilder como el que usamos en la clase Main.
Así cada Persona tendría su propio registro de lo que se le factura y por tanto tendrías la posibilidad de mostrar TODA la facturación (la registrada en el Main) o solo la facturación de un determinado cliente(la registrada en clase Persona)

Todo esto supone hacer crecer más el código con más menús, más clases, más líneas en el proceso de venta (pedir un cliente, comprobar que existe, registrarle lo que se le factura...)

Si tienes tiempo y ganas, adelante...

Veamos.
Yo ahora haría dos clases más, una que gestione un arreglo de Electrodomesticos y la clase Main principal que ponga en marcha el programa.

La clase que gestione el arreglo, es decir, la que controla los productos que hay disponibles en tienda la podríamos llamar Inventario(cualquier otro nombre será igual de válido)

Tendrá como atributo el arreglo de electrodomésticos y los métodos que podamos necesitar para hacer distintas gestiones.
Esos método ya los iremos viendo sobre la marcha, de momento, podemos comenzar la clase con el arreglo iniciado para 10 elementos y en el constructor iniciamos esos elementos con distintos productos para tener ya cosas disponibles en el inventario.

public class Inventario {

private Electrodomestico[] productos;

public Inventario() {
//Inicializamos el arreglo con capacidad para 10 electrodomesticos
productos = new Electrodomestico[10];
//Añadimos electrodomesticos al inventario
productos[0] = new Cocina("Fogo Prime","COC-0100", "Balay", 6, 89.90, 2, true, "Gas");
productos[1] = new Televisor("Visio Suprem", "TLV-1221", "Sharp", 12, 899.90, 65, "3840x2160", "IPS");
productos[2] = new Refrigeradora("Ultra Frost", "REF-3810", "Balay", 2, 129.90, 18, -18);
productos[3] = new Lavadora("Renta Max", "LAV-0090", "Whirlpool", 4, 109.90, 1200, "18Kg", 8);
productos[4] = new Cocina("Pyro Master","COC-0350", "Miele", 4, 109.90, 4, true, "Induccion");
productos[5] = new Televisor("Pentax Basic", "TLV-2334", "LG", 23, 399.90, 34, "2560x1440", "VA");
productos[6] = new Refrigeradora("Cooler Veritas", "REF-2909", "FAF", 5, 139.90, 22, -25);
productos[7] = new Lavadora("Petit Eco", "LAV-0115", "Corbero", 10, 79.90, 800, "12Kg", 5);
productos[8] = new Cocina("Fuoco Chef","COC-3200", "Schmidt", 12, 69.90, 2, false, "Gas");
productos[9] = new Televisor("Pentax Advance", "TLV-2338", "LG", 17, 799.90, 34, "3840x2160", "LED");
}

}
Insisto en el detalle importante de que, al tratarse de un arreglo, no podemos añadir o eliminar elementos. Siempre serán 10.
Esos elementos se podrían ir sustituyendo por otros, pero el tamaño del arreglo no cambiará.

Vamos a comenzar también la clase Main, así iremos desarrollando estas dos clases  al mismo tiempo.

La clase principal tendrá como atributo un objeto Inventario y un Scanner.
Mostraremos un menú en pantalla y según la opción que elija el usuario, al inventario le iremos pidiendo distintas gestiones.

Comenzamos así:
public class Main {

private static Inventario inventario = new Inventario();
private static Scanner teclado = new Scanner(System.in);

public static void main(String[] args) {

int opcion = 0;

do {
System.out.println("\nELECTRODOMESTICOS ELECTROHOGAR");
System.out.println("       MENU DE OPCIONES");
System.out.println("1 = Listar Inventario");
System.out.println("2 = Venta");
System.out.println("3 = Facturacion");
System.out.println("0 = Salir");
System.out.print("Elija la opcion: ");
opcion = Integer.parseInt(teclado.nextLine());

switch(opcion) {
case 1:
listar();
break;
case 2:
venta();
break;
case 3:
facturacion();
break;
case 0:
System.out.println("\n\t\tFIN DE PROGRAMA");
break;
default:
System.out.println("Opcion equivocada");
}
} while(opcion != 0);

}

private static void listar() {
//TODO código para listado
}

private static void venta() {
//TODO código para ventas
}

private static void facturacion() {
//TODO código para facturacion
}
}Fíjate que en el switch no ejecutamos código directamente, si no que llamaremos a distintos métodos, aún no escritos, que estarán separados del método main(), así este queda más legible al no sobrecargarlo con código.

La primera opción que he puesto es "Listar Inventario", es decir, mostrar en pantalla los productos que hay inventariados.
Podemos hacer que el usuario disponga de dos tipos de listado: un "listado total" donde se muestre todo, y otro donde el usuario indique que clase de electrodoméstico quiere ver: solo Lavadoras, o solo Televisores, etc..

Este podría ser el código del método listar():

   
   private static void listar() {
      System.out.println("\nIndique la clase que quiere listar.");
      System.out.println("Pulse ENTER con el campo vacio para listar todas las clases.");
      System.out.print("Clase: ");
      String clase = teclado.nextLine();
      
      if (clase.isBlank())
         inventario.listarTodos();
      else
         inventario.listarPorClase(clase);
   }

En azul marco las dos peticiones que le vamos a hacer a la clase Inventario, a la cuál ahora tenemos que añadirle dos métodos que cumplan con esas tareas.
Un método listará en pantalla todo lo que encuentre en el arreglo de electrodomésticos.
El otro método, hará un filtrado y solo mostrara los electrodomésticos que coincidan con la clase que hay indicado el usuario.
Estos son los dos métodos que le añadimos a la clase Inventario:

public void listarTodos() {
System.out.println("\n\t\tLISTADO DE ELECTRODOMESTICOS");
System.out.println("\n\t\t***********************");

for (int i = 0; i < productos.length; i++) {
productos[i].mostrarDetalles();
System.out.println("\t\t***********************");
}
}

public void listarPorClase(String clase) {
boolean encontrado = false; //Para controlar si se han encontrado productos de la clase solicitada
System.out.println("\n\t\tLISTADO DE " + clase.toUpperCase());
System.out.println("\n\t\t***********************");

for (int i = 0; i < productos.length; i++) {
if (productos[i].getClass().toString().contains(clase)) {
encontrado = true; //Se ha encontrado al menos un coincidente
productos[i].mostrarDetalles();
System.out.println("\t\t***********************");
}
}

//Si no se encontró ningún producto de la clase solicitada, informamos
if (!encontrado)
System.out.println("No hay electrodomesticos de esta clase");
}
Fíjate que para saber la clase de un elemento, llamamos al método getClass(). Este método devuelve en realidad otro objeto complejo, pero si a continuación llamamos a su método toString(), ya tenemos una cadena con el nombre de la clase que podemos utilizar para saber si contiene el nombre de la clase que el usuario ha indicado por teclado.
Para no complicar más el código, vamos a dar por hecho que el usuario va a escribir los nombres de clases correctamente, es decir, con la primera letra en mayúscula.
Si hacemos una prueba de ejecución y pedimos mostrar la clase "Televisor", funciona correctamente:

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
0 = Salir
Elija la opcion: 1

Indique la clase que quiere listar.
Pulse ENTER con el campo vacio para listar todas las clases.
Clase: Televisor

      LISTADO DE TELEVISOR

      ***********************
Clase Televisor
Marca: Sharp
Precio: 899.9
Cantidad: 12
Pulgadas: 65
Resolucion: 3840x2160
Tipo Pantalla: IPS
Valor a pagar por el Televisor:12094.655999999999
      ***********************
Clase Televisor
Marca: LG
Precio: 399.9
Cantidad: 23
Pulgadas: 34
Resolucion: 2560x1440
Tipo Pantalla: VA
Valor a pagar por el Televisor:10301.423999999999
      ***********************
Clase Televisor
Marca: LG
Precio: 799.9
Cantidad: 17
Pulgadas: 34
Resolucion: 3840x2160
Tipo Pantalla: LED
Valor a pagar por el Televisor:15230.096
      ***********************

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
0 = Salir
Elija la opcion: 0

      FIN DE PROGRAMA

Pero si escribimos mal el nombre, no encontrará la clase que pedimos:

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
0 = Salir
Elija la opcion: 1

Indique la clase que quiere listar.
Pulse ENTER con el campo vacio para listar todas las clases.
Clase: televisor

      LISTADO DE TELEVISOR

      ***********************
No hay electrodomesticos de esta clase

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
0 = Salir
Elija la opcion: 0

      FIN DE PROGRAMA

Como digo, con más código podríamos hacer el programa más "tolerante" a errores por parte del usuario, pero por ahora no lo vamos a complicar más.

Pensemos ahora en cómo hacer una venta.
Puesto que ya hay una opción para listar el inventario, incluso filtrando por el tipo de electrodoméstico, vamos a dar por sentado de que el usuario ya está en disposición de indicarnos el código de producto exacto del que quiere hacer una venta.
No será necesario mostrar un submenú para que elija qué tipo de electrodoméstico quiere.
Luego más adelante, si tu quieres hacerlo porque que queda más vistoso o lo que sea, pues ya lo modificarás.
Pero por ahora hagamos que todo funcione de la forma más simple posible.

Así que pedimos un código de producto al usuario. ¿Qué hacemos con ese código?
Pues le pediremos al Inventario que nos retorne una referencia al electrodoméstico que tenga ese código.
Con esa referencia, podemos mostrar en pantalla los detalles y preguntar cuántas unidades quiere vender.
A continuación calculamos el importe de la venta, según la cantidad indicada.
Restamos las unidades vendidas para que conste en el inventario y mostramos en pantalla el importe a facturar.

Pues este podría ser el código del método venta() de la clase Main:

   
   private static void venta() {
      System.out.println("Indique el CODIGO del electrodoméstico para realizar la venta.");
      System.out.print("CODIGO: ");
      String codigo = teclado.nextLine();
      
      Electrodomestico solicitado = inventario.getPorCodigo(codigo);
      if (solicitado == null)
         System.out.println("No hay electrodoméstico con el CODIGO: " + codigo);
      else {
         System.out.println("\nDetalles del producto:");
         solicitado.mostrarDetalles();
         //Pedimos cantidad de unidades deseadas, controlamos que nos de un valor válido.
         //Aunque primero comprobamos si hay stock disponible
         if (solicitado.getCantidad() <= 0)
            System.out.println("\nProducto agotado");
         else {
            int unidades = 0;
            do {
               System.out.print("\nUnidades a facturar (MAX="+ solicitado.getCantidad() +"): ");
               unidades = Integer.parseInt(teclado.nextLine());
            }while(unidades > solicitado.getCantidad());
            //Calculamos importe a facturar, actualizamos stock producto e informamos en pantalla
            double facturar = solicitado.getPrecio() * unidades * 1.12;
            solicitado.setCantidad(solicitado.getCantidad() - unidades);
            System.out.printf("\nImporte a pagar: %.2f\n", facturar);
            System.out.println("Gracias por su compra");
         }
      }
   }

En azul marco la petición que le hacemos al Inventario. Será un método que reciba un String con el código del producto solicitado y si lo encuentra, lo retornará.
Si no lo encuentra, retornará valor null.

Este sería el método que hay que añadirle a la clase Inventario:

public Electrodomestico getPorCodigo(String codigo) {

for (int i = 0; i < productos.length; i++) {
if (productos[i].getCodigo().equals(codigo))
return productos[i]; //Producto encontrado, lo retornamos
}
//Si bucle FOR termina sin retornar nada, es que no hay producto con ese codigo
return null;
}
Si hacemos una prueba de venta, podemos ver que solo deja facturar una cantidad menor o igual a lo que haya disponible.
Y que tras la venta, la disponibilidad disminuye. Y si se agota el producto, pues no se puede facturar nada.

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
0 = Salir
Elija la opcion: 2
Indique el CODIGO del electrodoméstico para realizar la venta.
CODIGO: LAV-0115

Detalles del producto:
Clase Lavadora
Marca: Corbero
Precio 79.9
Cantidad: 10
Capacidad de Lavado: 12Kg
Ciclos: 5
Velocidad: 800
Valor a pagar por la Lavadora:894.88

Unidades a facturar (MAX=10): 23

Unidades a facturar (MAX=10): 10

Importe a pagar: 894,88
Gracias por su compra

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
0 = Salir
Elija la opcion: 2
Indique el CODIGO del electrodoméstico para realizar la venta.
CODIGO: LAV-0115

Detalles del producto:
Clase Lavadora
Marca: Corbero
Precio 79.9
Cantidad: 0
Capacidad de Lavado: 12Kg
Ciclos: 5
Velocidad: 800
Valor a pagar por la Lavadora:0.0

Producto agotado

ELECTRODOMESTICOS ELECTROHOGAR
       MENU DE OPCIONES
1 = Listar Inventario
2 = Venta
3 = Facturacion
0 = Salir
Elija la opcion: 0

      FIN DE PROGRAMA

Continúo en el mensaje siguiente.

¿Y cuál sería la función que ha de cumplir el arreglo?
Nos será más fácil ayudarte si nos indicas cuál es el enunciado del ejercicio o explicas que tiene que hacer el programa.

La principal diferencia entre un ArrayList y un arreglo "primitivo", es que este último va a tener un tamaño predeterminado.
Un ArrayList es dinámico, puede aumentar su tamaño cada vez que añadimos un elemento.

Un arreglo no. al crearlo hay que decirle la cantidad exacta de elementos que va a contener.

Si el programa va a funcionar con una cantidad de electrodomésticos concreta, no debería haber problema en usar un arreglo.

Pero insisto, indícanos el enunciado del ejercicio y podremos ayudarte mejor.

Saludos.

El diagrama de flujo para el proceso de facturación podría ser algo así:



Sobre el código Java que solicita,mmmmh, aunque no lo parezca, puede ser bastante extenso.

Para empezar, pide una clase Cliente, que podría ser como esta:
public final class Cliente {

private String id;
private String nombre;
private String telefono;
private String domicilio;

public Cliente(String id, String nombre, String telefono, String domicilio) {
this.id = id;
this.nombre = nombre;
this.telefono = telefono;
this.domicilio = domicilio;
}

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {
this.nombre = nombre;
}

public String getTelefono() {
return telefono;
}

public void setTelefono(String telefono) {
this.telefono = telefono;
}

public String getDomicilio() {
return domicilio;
}

public void setDomicilio(String domicilio) {
this.domicilio = domicilio;
}

@Override
public String toString() {
return String.format("ID: %s\t\t\t\t Nombre: %s\nTelef: %s\t\t\t Domicilio: %s",
id, nombre, telefono, domicilio);
}

}
Luego pide una clase Factura, donde se debe asociar un Cliente con una relación de artículos que se le facturan, así como sus cantidades e importes.
Además luego cada Factura ha de mostrarse en pantalla indicando la relación de artículos, la suma total de las cantidades y la suma total de los importes.
Así que hay que pensar en como relacionamos todos estos datos de forma que luego fácilmente se puedan mostrar y hacer esos cálculos.
No se pide una clase Artículo, así que a priori podemos usar un String para este dato.
Precio de cada artículo un double y las cantidades un int, vale, ¿Pero como coleccionamos esos datos para que cada Factura tenga varios artículos, cada uno con un precio y una cantidad facturada?

Podrían usarse tres arrays primitivos, pero como no sabemos de antemano cuántos artículos va a tener una factura, no nos sirve.
Tres ArrayLists nos solucionarían el problema, pero creo que para optimizar aún más el proceso, podemos crear una clase (aunque no la pida el enunciado) que relacione directamente esos tres datos juntos en un único objeto.
Podría llamarse LineaFactura, porque representaría las distintas líneas de productos facturados que tendrá una factura.
public final class LineaFactura {

private String producto;
private double precio;
private int cantidad;

public LineaFactura(String producto, double precio, int cantidad) {
this.producto = producto;
this.precio = precio;
this.cantidad = cantidad;
}

//Para esta clase solo nos interesan tener dos getters
public int getCantidad() {
return cantidad;
}

public double getImporteLinea() {
return precio * cantidad;
}

@Override
public String toString() {
return String.format("%20s\t\t%5.2f\t%6d\t\t%5.2f", producto, precio, cantidad, getImporteLinea());
}

}
Gracias a esto, la clase Factura ya no va a requerir de tres ArrayList, bastará con solo uno que almacene las distintas líneas de facturación
Esta clase Factura va a requerir de un objeto Cliente y también de una fecha, la cuál podemos pedirla por teclado o usar la clase LocalDate y automáticamente coger la fecha actual del sistema.
Podemos añadirle también un atributo ID, un número que identifique una factura. No tiene porque ser un "dato real", podemos generar números al azar, ya que es simplemente una simulación.
Factura tendrá un método que se encargará de mostrar en pantalla todas las "líneas de factura", datos del cliente, fecha y calcular los totales.
import java.time.LocalDate;
import java.util.ArrayList;

public final class Factura {

private int numFactura;
private Cliente cliente;
private LocalDate fecha;
private ArrayList<LineaFactura> facturado;

public Factura(Cliente cliente) {
numFactura = (int) (Math.random() * 10000);//Numero de factura lo generamos al azar
this.cliente = cliente;
fecha = LocalDate.now();
facturado = new ArrayList<LineaFactura>();
}

public Cliente getCliente() {
return cliente;
}

public void agregarLinea(LineaFactura linea) {
facturado.add(linea);
}

public void imprimirFactura() {

/*
* Recorreremos la lista de productos facturados para
* mostrar los datos en pantalla de cada linea.
* De paso, iremos sumando el total de artículos
* y los importes de cada línea para mostrar al final
*/
int productosTotales = 0;
double importeTotal = 0d;

System.out.println("\n\t\t****** FACTURA #" + numFactura + " *****");
System.out.println("\n\tFecha: " + fecha.toString());
System.out.println("\n\t\tDatos del Cliente");
System.out.println("\t\t----- --- -------");
System.out.println(cliente);
System.out.println("\n\t\t\tProductos Facturados");
System.out.println("\t\t\t--------- ----------\n");

System.out.println(" LINEA\t\tPRODUCTO\t\tPRECIO\tCANTIDAD\tTOTAL LINEA");
System.out.println(" -----\t\t--------\t\t------\t--------\t-----------");
for (int i = 0; i < facturado.size(); i++) {
System.out.println("> #" + (i+1) + facturado.get(i));
productosTotales += facturado.get(i).getCantidad();
importeTotal += facturado.get(i).getImporteLinea();
}

System.out.println("\nTotal Articulos: " + productosTotales);
System.out.printf("Importa a facturar: %.2f",  importeTotal);
System.out.println("\n\n\t\t****** FIN DE FACTURA *****");
}

/*
* Indica si esta factura carece de líneas.
* Será útil para decidir si esta factura
* debemos guardarla en el sistema o descartarla
*/
public boolean facturaEnBlanco() {
return facturado.isEmpty();
}

}
Bien, tenemos una clase Cliente y una clase Factura, que se apoya en una clase secundaria llamada LineaFactura para organizar los datos de los artículos que se facturan.

Se podría comenzar con el programa principal, pero si nos fijamos en el enunciado nos dice que este va a tener "3 módulos": Cliente, Facturación y Finanzas
Es decir, el programa se va a dividir en tres partes: una para la gestión de clientes, otra para facturar artículos y otra que no estoy seguro de su cometido, pero supongo será para  cosas como mostrar las facturas registradas en el sistema.

Esto implica mucho código, pues son tres subprogramas dentro de uno solo.
Para repartir el código en lugar de concentrarlo todo en una única clase principal, podemos crear más clases de apoyo que se encarguen de tareas específicas.

Por ejemplo, podemos hacer una clase que se encargue de la gestión de los Clientes.
Esta clase tendrá un ArrayList de Cliente y tendrá métodos para registar un cliente nuevo, para mostrar los clientes registrados, para buscar un cliente en concreto...
import java.util.ArrayList;
import java.util.Scanner;

public final class GestorClientes {

public ArrayList<Cliente> clientes;
private Scanner teclado;

public GestorClientes() {
teclado = new Scanner(System.in);
clientes = new ArrayList<Cliente>();
//Añadimos unos clientes predefinidos para comenzar el programa con algun dato cargado.
//El ID se autogenera según el tamaño del ArrayList
clientes.add(new Cliente("ID00" + clientes.size(), "Pablo Segura", "656901234", "C/Paloma nº12"));
clientes.add(new Cliente("ID00" + clientes.size(), "Laura Juan", "690579012", "C/Carretas nº23"));
clientes.add(new Cliente("ID00" + clientes.size(), "Jorge Morales", "677119854", "C/Girasol nº56"));
clientes.add(new Cliente("ID00" + clientes.size(), "Carmen Robledo", "609718131", "C/Real nº3"));
}

public Cliente registrarCliente() {
System.out.println("\n\t\tREGISTAR CLIENTE");
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Telefono: ");
String telef = teclado.nextLine();
System.out.print("Domicilio: ");
String domi = teclado.nextLine();
Cliente nuevo = new Cliente("ID00" + clientes.size(), nombre, telef, domi);
clientes.add(nuevo);
System.out.println("\n\t\tCLIENTE REGISTRADO");
return nuevo;
}

public void listarClientes() {
System.out.println("\n\t\tLISTADO CLIENTES");
for (Cliente cl: clientes)
System.out.println(cl + "\n");
}

public Cliente buscarPorId() {
System.out.print("\nIntroduzca ID cliente: ");
String id = teclado.nextLine();
//Buscamos Cliente
for (Cliente cl: clientes)
if (cl.getId().equals(id))
return cl; //Encontrado

//Si bucle FOR termina sin retornar nada, es que no existe este cliente
return null;
}

public Cliente buscarPorNombre() {
System.out.print("\nIntroduzca nombre completo de cliente: ");
String nombre = teclado.nextLine();
//Buscamos Cliente
for (Cliente cl: clientes)
if (cl.getNombre().equals(nombre))
return cl; //Encontrado

//Si bucle FOR termina sin retornar nada, es que no existe este cliente
return null;
}

}
Y lo mismo con las Finanzas, una clase gestora con un ArrayList donde se almacenarán Facturas y se encargue de mostrar listados, ya sea de todas las facturas como también facturas de clientes concretos.
import java.util.ArrayList;

public final class GestorFinanzas {

private ArrayList<Factura> facturas = new ArrayList<Factura>();

public void agregarFactura(Factura fc) {
facturas.add(fc);
}

public void listarFacturas() {
System.out.println("\n\t\tLISTADO GENERAL FACTURAS");
if (facturas.isEmpty())
System.out.println("No hay FACTURAS que mostrar");
else
for (Factura fc: facturas)
fc.imprimirFactura();
System.out.println("\n\t\tFIN DE LISTADO");
}

public void listarPorID(String id) {
boolean encontrado = false;
System.out.println("\n\tLISTADO FACTURAS CLIENTE: " + id);
for (Factura fc: facturas)
if (fc.getCliente().getId().equals(id)) {
encontrado = true;
fc.imprimirFactura();
}

if (!encontrado)
System.out.println("No hay facturas de este cliente");
}

public void listarPorNombre(String nombre) {
boolean encontrado = false;
System.out.println("\n\tLISTADO FACTURAS CLIENTE: " + nombre);
for (Factura fc: facturas)
if (fc.getCliente().getNombre().equals(nombre)) {
encontrado = true;
fc.imprimirFactura();
}

if (!encontrado)
System.out.println("No hay facturas de este cliente");
}

}
Esta clase, sin embargo, no puede encargarse de crear facturas porque no tiene acceso a la lista de clientes que están en GestorClientes.
Puede registrar Facturas ya creadas, pero no crearlas por ella misma.

Así que la clase GestorClientes hará las principales tareas del "módulo Cliente".
La clase GestorFinanzas hará las del "módulo Finazas".

¿Y quién se encarga del "módulo Facturación"?
Pues esta tarea va a recaer en el propio programa principal, ya que es el que va a tener acceso tanto a Clientes como al registro de Facturas (mediante las clases gestoras correspondientes).
Total, el "módulo Facturación" es simplemente pedir datos para crear una Factura, realmente no necesita una clase específica para eso.

Así que a continuación pongo la clase Main principal.
Es muy extensa pero porque hay muchos menús.
Está el menú principal para escoger "módulo", y cada "módulo" tiene su propio submenú.

Todo está repartido en distintos métodos, así que en realidad el método main() principal es minúsculo.
Esto ayuda a entender mejor el código. Si uno quiere centrarse en leer y querer comprender un "módulo" en concreto, solo ha de irse a leer el método correspondiente a ese "módulo", en lugar de intentar vislumbrarlo en 200 líneas de código si se hubiera escrito todo junto.
import java.util.Scanner;

public final class Main {

private static Scanner teclado = new Scanner(System.in);
private static GestorClientes clientes = new GestorClientes();
private static GestorFinanzas finanzas = new GestorFinanzas();

public static void main(String[] args) {

int opcion = 0;
do {
System.out.println("\n\t\tMENU SISTEMA <<SEASHELL>>");
System.out.println("[1] -- Modulo Clientes");
System.out.println("[2] -- Modulo Facturacion");
System.out.println("[3] -- Modulo Finanzas");
System.out.println("[4] -- TERMINAR PROGRAMA");
opcion = Integer.parseInt(teclado.nextLine());

switch(opcion) {
case 1:
moduloClientes();
break;
case 2:
moduloFacturacion();
break;
case 3:
moduloFinanzas();
break;
case 4:
System.out.println("\n\t\tFIN DE PROGRAMA");
break;
default:
System.out.println("Opcion equivocada");
}

}while (opcion != 4);

}

private static void moduloClientes() {
int opcion = 0;
do {
System.out.println("\n\n\t\tMODULO CLIENTES");
System.out.println("[1] -- Registrar Cliente");
System.out.println("[2] -- Listar todos los Clientes");
System.out.println("[3] -- Buscar Cliente por ID");
System.out.println("[4] -- Buscar Cliente por Nombre");
System.out.println("[5] -- REGRESAR");
opcion = Integer.parseInt(teclado.nextLine());

switch(opcion) {
case 1:
clientes.registrarCliente();
break;
case 2:
clientes.listarClientes();
break;
case 3:
Cliente buscaID = clientes.buscarPorId();
if (buscaID == null)
System.out.println("No hay Cliente con ese ID");
else
System.out.println(buscaID);
break;
case 4:
Cliente buscaNom = clientes.buscarPorNombre();
if (buscaNom == null)
System.out.println("No hay Cliente con ese Nombre");
else
System.out.println(buscaNom);
break;
case 5:
System.out.println("\n\tREGRESANDO A MENU PRINCIPAL\n");
break;
default:
System.out.println("Opcion equivocada");
}

}while (opcion != 5);
}

private static void moduloFacturacion() {
Cliente cliente = null;
int opcion = 0;
do {
System.out.println("\n\n\t\tMODULO FACTURACION");
System.out.println("[1] -- Identificar Cliente por ID");
System.out.println("[2] -- Identificar Cliente por Nombre");
System.out.println("[3] -- Registrar Nuevo Cliente");
System.out.println("[4] -- REGRESAR");
opcion = Integer.parseInt(teclado.nextLine());

switch(opcion) {
case 1:
cliente = clientes.buscarPorId();
if (cliente == null)
System.out.println("No hay Cliente con ese ID");
else
nuevaFactura(cliente);
break;
case 2:
cliente = clientes.buscarPorNombre();
if (cliente == null)
System.out.println("No hay Cliente con ese Nombre");
else
nuevaFactura(cliente);
break;
case 3:
cliente = clientes.registrarCliente();
nuevaFactura(cliente);
break;
case 4:
System.out.println("\n\tREGRESANDO A MENU PRINCIPAL\n");
break;
default:
System.out.println("Opcion equivocada");
}

}while (opcion != 4);
}

private static void moduloFinanzas() {
int opcion = 0;
do {
System.out.println("\n\n\t\tMODULO FINANZAS");
System.out.println("[1] -- Listar Facturas por ID");
System.out.println("[2] -- Listar Facturas por Nombre");
System.out.println("[3] -- Listar todas las Facturas");
System.out.println("[4] -- REGRESAR");
opcion = Integer.parseInt(teclado.nextLine());

switch(opcion) {
case 1:
Cliente buscaID = clientes.buscarPorId();
if (buscaID == null)
System.out.println("No hay Cliente con ese ID");
else
finanzas.listarPorID(buscaID.getId());
break;
case 2:
Cliente buscaNombre = clientes.buscarPorNombre();
if (buscaNombre == null)
System.out.println("No hay Cliente con ese Nombre");
else
finanzas.listarPorNombre(buscaNombre.getNombre());
break;
case 3:
finanzas.listarFacturas();
break;
case 4:
System.out.println("\n\tREGRESANDO A MENU PRINCIPAL\n");
break;
default:
System.out.println("Opcion equivocada");
}

}while (opcion != 4);
}

private static void nuevaFactura(Cliente cliente) {

Factura nueva = new Factura(cliente);
String articulo = "";
do {
System.out.println("\nIntroduzca nuevo ARTICULO o pulse ENTER dejando el campo vacio para terminar.");
System.out.print("Nombre Articulo: ");
articulo = teclado.nextLine();
if (!articulo.isBlank()) {
//Pedimos datos para crear una LineaFactura
System.out.print("PVP del Artículo: ");
double pvp = Double.parseDouble(teclado.nextLine());
System.out.print("Cantidad unidades: ");
int cantidad = Integer.parseInt(teclado.nextLine());

nueva.agregarLinea(new LineaFactura(articulo, pvp, cantidad));
}

}while(!articulo.isBlank());

//Antes de guardar esta factura, comprobamos si tiene articulos registrados
if (!nueva.facturaEnBlanco()) {
finanzas.agregarFactura(nueva);
nueva.imprimirFactura();
System.out.println("\n\t\tFACTURA REGISTRADA");
}
}
}

He dado una explicación general de la lógica que se ha aplicado, sin entrar en cosas concretas porque entonces la explicación sería muy extensa y poco práctica.

Pero podéis preguntar cualquier duda que surja, cualquier cosa que no se entienda, instrucciones que sean desconocidas.., lo que sea ...

Un saludo.

El problema está en que intentas guardar un valor que originalmente es un double, en una variable int.

Esto supone perder información, ya que un double es un número real, es decir, tiene una parte entera y otra decimal.
Pero un int solo es un entero y no puede albergar parte decimal.

Es decir, si yo el valor double 5.25 lo guardo en un int, se me quedaría en 5.
El 0.25 restante desaparece, o sea, que he perdido información.

¿Entonces es imposible guardar un double en un int?
No, no es imposible. Lo que pasa es que Java, por seguridad, no nos lo va a permitir, a no ser que hagamos lo que se llama un casting.
Un casting es una forma de decirle a Java que somos conscientes de la perdida de información que puede suponer este cambio de tipo, y que nos da igual.

Esto es muy fácil de hacer, basta con envolver con paréntesis el valor o expresión que origina el valor double y anteponer también entre paréntesis, el tipo de dato al que queremos transformar:

   public MultiplicadorDieces(){}
   
    public int multiplicarPorDieces(double a, int b){
        int resultado = 1;
        for(int i=1;i<=b; i++){
            resultado=resultado*10;
        }
        resultado = (int) (a * resultado);
        return  resultado;
    }

Y ya está, con esto Java ya no se quejará.

Sin embargo, en este ejercicio, ¿realmente queremos que el resultado sea un entero?

Habrá ocasiones en las que si nos convenga, o no nos importe, que un double acabe siendo un int.

Pero no en este caso, porque esa pérdida de información nos va a dar resultados matemáticos incorrectos.

Si probamos a multiplicar 2.55 por 2 dieces (o sea, por 100):
    public static void main(String[] args) {
   
    MultiplicadorDieces mult = new MultiplicadorDieces();
   
    System.out.println("Resultado:" + mult.multiplicarPorDieces(2.55, 2));
   
    }

El resultado debería ser 255. Pero nuestro método nos va a dar un resultado erróneo:
Resultado:254

He aquí el problema de convertir doubles a enteros. Como dijimos, en el proceso se pierde información y por eso Java no lo permite hacer a no ser que el programador lo pida expresamente con un casting

El caso es, que para nuestro ejercicio, resultado no puede ser un int.
Si estamos operando con un double, lo ideal es que el resultado final también sea un double (salvo en casos especiales como dije antes)
Así que el tipo de resultado, y el tipo que retorna el método, ha de cambiar a double:

   public MultiplicadorDieces(){}
   
    public double multiplicarPorDieces(double a, int b){
        double resultado = 1;
        for(int i=1;i<=b; i++){
            resultado=resultado*10;
        }
        resultado = a * resultado;
        return  resultado;
    }

Si lo probamos ahora, el resultado se acerca un poco más al correcto.
¡¡Pero sigue sin ser correcto del todo!!
Resultado:254.99999999999997
¡¡Aaghh!! Por algún sitio se han esfumado 0.00000000000003 décimas.
No es mucho, pero no deja de ser un resultado incorrecto.

Sinceramente, no se a que es debido. Pero desde luego no es por un error de programación por nuestra parte.
Será por alguna peculiaridad a nivel interno, ya sea de Java o de la propia CPU, cuando tratan con números de tan alta precisión.

¿Qué podemos hacer entonces?
Aunque no es un error nuestro, podemos probar a simplificar un poco el código.
Tu código no está mal, pero primero acumulas una multiplicación de varios "dieces" y luego lo multiplicas por el valor inicial.
Insisto, no está mal. Pero es un paso que podemos ahorrarnos.

Podemos inicializar la variable resultado directamente con el valor inicial.
Y en el bucle, por cada repetición, le aplicamos directamente una multiplicación por 10.

Así operamos directamente sobre el valor inicial, en lugar de acumular previamente unos "dieces multiplicados."

   public MultiplicadorDieces(){}
   
    public double multiplicarPorDieces(double a, int b){
        double resultado = a;
       
        for(int i=1;i<=b; i++){
            resultado=resultado*10;
        }
       
        return  resultado;
    }

Esto ahora, sí nos da un resultado correcto:
Resultado:255.0
Insisto en que tu lógica estaba bien y seguramente si solo trabajásemos con int habría funcionado.
Pero por algún motivo, al aplicarla con doubles, ocurre un pequeño baile de décimas y no se por qué.... 

Cambiando de tema, este es un buen ejercicio para aplicar "Recursividad" en la solución.
La Recursividad es una forma bastante óptima de resolver determinados cálculos, pero puede ser algo difícil de comprender su proceso lógico.

Una función recursiva (o método recursivo) lo que hace es que los cómputos de sus valores se van realizando en sucesivas llamadas a sí misma.
Es decir, un método "normal" hace él todos los cómputos y retorna el valor computado.

Un método "recursivo" lo que hace es computar solo una parte y a continuación se llama a sí mismo para pasarse de nuevo esos valores y continuar con los cómputos.
Este proceso de llamarse a sí mismo una y otra vez (recursividad) finaliza cuando se ha cumplido una determinada condición y es entonces cuando se obtiene el resultado final.

Sí, no es fácil de explicar, y aún menos de entender.
Así que no te preocupes si ahora todo esto te suena a chino.

Pero aún así te voy a mostrar como podría resolverse de forma recursiva. Aunque no lo entiendas(que quizás sí lo entiendas, en realidad no hace falta ser un genio), guarda este ejemplo como referencia para el futuro.
En algún momento se te pedirá aplicar recursividad y tener algún ejemplo a mano viene bien.

En tu clase he puesto los dos métodos, el "tradicional" y el "recursivo"

   public MultiplicadorDieces(){}
   
    public double multiplicarPorDieces(double a, int b){
        double resultado = a;
       
        for(int i=1;i<=b; i++){
            resultado=resultado*10;
        }
       
        return  resultado;
    }
   
    public double multiplicarPorDiecesRecursivo(double a, int b) {
       if (b == 0) //Si el multiplicador de dieces ya llegó a 0
          return a; //Retornamos el valor y termina el proceso recursivo
       else { //Si el multiplicador de dieces aún no es 0
          a = a * 10; // Multiplicamos un 10
          b = b - 1; //Decrementamos el multiplicador
          return multiplicarPorDiecesRecursivo(a, b); //Llamada recursiva con los valores actuales
       }
    }

Lo que hace es comprobar el valor del "multiplicador de dieces"
Si no es 0, significa que hay que multiplicar al menos un 10 al valor original.
Pues se multiplica ese 10, se reduce el valor del "multiplicador de dieces" y se pasan estos valores a una llamada recursiva a ese mismo método.

Tras una o varias llamadas recursivas, el "multiplicador de dieces" alcanzará el valor 0.
Eso significa que se han multiplicado todos los "dieces" necesarios, así que ya podemos retornar el resultado final y poner fin a las llamadas recursivas.

Si probamos ambos métodos en un programa:
   
    public static void main(String[] args) {
   
    MultiplicadorDieces mult = new MultiplicadorDieces();
   
    System.out.println("Resultado:" + mult.multiplicarPorDieces(2.55, 2));
    System.out.println("Resultado Recursivo:" + mult.multiplicarPorDiecesRecursivo(2.55, 2));
   
    }
Ambos darán el mismo resultado en pantalla:
Resultado:255.0
Resultado Recursivo:255.0

La ventaja de la recursividad es que permite simplificar el código y reducir las operaciones necesarias.
Quizás en este ejercicio no se perciba tanta diferencia entre un método y otro, pero en ejercicios más complejos la diferencia si puede ser mayor.

Además lo he escrito de forma un poco más extensa para que se entienda mejor la lógica que se está siguiendo y poder comentar cada línea para explicarlo.
Si aplicásemos los distintos operadores que ofrece Java para comprimir el código, el método recursivo podría quedar así:
    public double multiplicarPorDiecesRecursivo(double a, int b) {
    if (b == 0)
    return a;
    else
    return multiplicarPorDiecesRecursivo(a*=10, --b);
    }
Y si usamos el "condicional ternario", todo queda resuelto en una sola línea:
    public double multiplicarPorDiecesRecursivo(double a, int b) {
   
    return (b == 0)? a: multiplicarPorDiecesRecursivo(a*=10, --b);

    }

Pero insisto en que ahora no es necesario, ni prudente, que te calientes el cerebro intentando asimilar todo esto.
Tan solo guarda este ejercicio a mano para poder revisitarlo en el futuro.

Un saludo.

Más cosas a comentar ahora que veo a fondo tu código.

Mucho ojo con el orden en que ponemos los parámetros para los constructores.
Para la clase SalonCasa, has puesto que primero recibe el String de tipoSalon y luego el int de numero televisores:

    public SalonCasa(String valorTipoSalon, int valorNumeroDeTelevisores){
        tipoSalon=valorTipoSalon;
        numeroDeTelevisores=valorNumeroDeTelevisores;}
Vale, eso está muy bien, pero luego cuando quieras construir un objeto de esta clase, recuerda que los parámetros ha de recibirlo en ese mismo orden.

Porque en la clase Casa, en el constructor donde construyes un SalonCasa, se los estás pasando invertidos. Y Java también se quejará por esto:

    public Casa(double valorSuperficie, String valorDireccion, SalonCasa objetoSalon, CocinaCasa objetoCocina){
        superficie=valorSuperficie;
        direccion=valorDireccion;
        salon=new SalonCasa(objetoSalon.getNumeroDeTelevisores(), objetoSalon.getTipoSalon());
        cocina=new CocinaCasa(objetoCocina.getEsIndependiente(), objetoCocina.getNumeroDeFuegos());}

Hay que dárselos en el orden correcto:

    public Casa(double valorSuperficie, String valorDireccion, SalonCasa objetoSalon, CocinaCasa objetoCocina){
        superficie=valorSuperficie;
        direccion=valorDireccion;
        salon=new SalonCasa(objetoSalon.getTipoSalon(), objetoSalon.getNumeroDeTelevisores());
        cocina=new CocinaCasa(objetoCocina.getEsIndependiente(), objetoCocina.getNumeroDeFuegos());}

Sigamos hablando de este constructor, porque has hecho algo que es muy interesante de comentar.
La forma en que tu constructor inicializa los objetos salon y cocina:

    public Casa(double valorSuperficie, String valorDireccion, SalonCasa objetoSalon, CocinaCasa objetoCocina){
        superficie=valorSuperficie;
        direccion=valorDireccion;
        salon=new SalonCasa(objetoSalon.getTipoSalon(), objetoSalon.getNumeroDeTelevisores());
        cocina=new CocinaCasa(objetoCocina.getEsIndependiente(), objetoCocina.getNumeroDeFuegos());}

Haciéndolo de esa manera, has de tener en cuenta que estás creando NUEVOS objetos a partir de los que has recibido entre paréntesis.
Es decir, van a tener los mismos valores para los atributos, pero no serán IGUALES. Serán objetos distintos.
Esto no es necesariamente un problema. Habrá ocasiones en que precisamente nos interese hacerlo así, pero normalmente NO.

Cuando un constructor recibe objetos entre paréntesis, normalmente se asignan esos mismos objetos a los atributos, sin crear unos nuevos a partir de ellos:

    public Casa(double valorSuperficie, String valorDireccion, SalonCasa objetoSalon, CocinaCasa objetoCocina){
        superficie=valorSuperficie;
        direccion=valorDireccion;
        salon=objetoSalon;
        cocina=objetoCocina;}

¿Ves? Entre paréntesis hemos recibido unas "referencias" a unos objetos, y esas mismas referencias las asignamos a los atributos.
Y ya está, con esto es suficiente.

Pero tú lo que has hecho ha sido coger los "valores" de esas referencias, y usarlos para crear objetos nuevos

En otros lenguajes como C/C++, hay de hecho instrucciones específicas para indicar si un parámetro queremos pasarlo por "referencia" o por "valor".
En Java no las hay, simplificaron este aspecto.
Los datos primitivos (int, double, char...) se pasan por "valor" y los objetos de clase se pasan por "referencia".

Lo que tú has hecho ha sido una forma artificial de pasar por "valor" algo que Java solo permite pasar por "referencia"

¿Esto es incorrecto?
No, para nada. Pero implica unas diferencias que debemos tener en cuenta.

Al pasar por referencia un objeto externo y asignarlo a los atributos de otro objetos (que es lo habitual), esos objetos quedan conectados.
Es decir, para construir una Casa, primero he tenido que construir un SalonCasa.
Son objetos distintos, pero Casa incluye en su interior un SalonCasa.
Entonces, si pasamos por referencia, los cambios que ocurran en el objeto externo SalonCasa también quedarán reflejados en el atributo interno del objeto Casa

Esto se verá mucho mejor con un ejemplo.
Mira, aquí estoy creando un salon y una cocina.
Luego creo una casa y a su constructor les paso ese salon y cocina.

Y le pido a casa que muestre los valores de su nuevo salon y cocina (por cierto, a tu clase Casa le faltan setters y getters para los atributos de Salon y Cocina)

Después de mostrarlos, modifico los valores del salon y de la cocina.

Y vuelvo a pedir a  casa que muestre de nuevo sus valores de salon y cocina.
public class Prueba {

public static void main(String[] args) {

SalonCasa miSalon = new SalonCasa("Gigante", 10);
CocinaCasa miCocina = new CocinaCasa(true, 100);

Casa miCasa = new Casa(300, "Calle Paraiso", miSalon, miCocina);

System.out.println("Televisores: " + miCasa.getSalon().getNumeroDeTelevisores());
System.out.println("Fuegos: " + miCasa.getCocina().getNumeroDeFuegos());

//Cambiamos valores de miSalon y miCocina
miSalon.setNumeroDeTelevisores(3);
miCocina.setnumeroDeFuegos(4);
System.out.println("\n--Valores de salon y cocina cambiados --\n");

System.out.println("Televisores: " + miCasa.getSalon().getNumeroDeTelevisores());
System.out.println("Fuegos: " + miCasa.getCocina().getNumeroDeFuegos());
}

}
Resultado en pantalla:

Televisores: 10
Fuegos: 100

--Valores de salon y cocina cambiados --

Televisores: 3
Fuegos: 4

Fíjate que casa muestra el cambio de valores, a pesar de que en el objeto casa no hemos hecho cambios.
Los cambios los hemos hecho en los objetos salon y cocina, pero como casa tiene "referencias" a esos objetos, pues casa se verá afectada por esos cambios.


Ahora vamos a hacer exactamente el mismo ejercicio, pero usando el constructor que tú habías escrito.
Es decir, no vamos a pasar por "referencia", si no que de forma artificial vamos pasar por "valor".
¿Cuál será el resultado en pantalla?

Televisores: 10
Fuegos: 100

--Valores de salon y cocina cambiados --

Televisores: 10
Fuegos: 100

  ¡Oh!
El resultado es distinto. Esta vez los cambios que hemos hecho en cocina y salon, no han afectado al objeto casa.
Y esto es porque en tu constructor no asignabas la "referencia" recibida entre paréntesis, si no que construías objetos totalmente nuevos con los "valores" de esas "referencias".

Y vuelvo a preguntar, ¿esto es un problema?
Podría serlo.

Imagina que tenemos un objeto Alumno, que representa a "Juanito" y que vive en la calle "Las Flores".

Y tenemos una clase llamada Curso, donde tenemos insertados a 25 alumnos, entre ellos a "Juanito"

Supongamos que ahora "Juanito" se muda de domicilio y ahora vive en la calle "Las Cortes"

Si cambiamos este dato en el objeto que representa a "Juanito", y resulta que al objeto Curso lo habíamos pasado por "valor" y no por "referencia", tendremos el problema de que el "Juanito" que está dentro de Curso tiene el domicilio antiguo a diferencia del objeto "Juanito" que es externo a Curso.

Esto es un problema, en un sistema informático no podemos consentir esta discrepancia de datos.
Es que además "Juanito" puede estar insertado en múltiples objetos además de Curso. Puede estar insertado en un objeto que agrupe a los alumnos que hacen actividades extraescolares, otro objeto que agrupe alumnos que han solicitado beca, etc...

Cada vez que un alumno cambie de domicilio, no podemos ir rastreando todos los objetos donde ande insertado para cambiarle a todos ese dato.

Por eso es mejor pasar los objetos por "referencia", porque así haciendo un único cambio, este se verá reflejado en todos demás objetos donde pueda estar insertado.

Habrá ocasiones donde sí vamos a querer hacer una copia del "valor" un objeto para que no compartan "referencia" y sean objetos independientes.
Pero no es lo habitual.


Disculpa si me he extendido demasiado con explicaciones.
Pero no quería decirte simplemente "así no se hace, hazlo asá..."
Quería explicarte el motivo y es que además este es un tema que no es fácil de entender al principio.

El asunto de pasar datos por "valor o por "referencia" da para mucha literatura. Así que no te preocupes si aún no te ha quedado claro. Tampoco es algo que deba preocuparte mucho ahora mismo.

Simplemente recuerda que cuando recibas objetos en un constructor, salvo casos muy concretos, lo que vamos a hacer es asignar directamente esas referencias a los atributos.

public Casa(double valorSuperficie, String valorDireccion, SalonCasa objetoSalon, CocinaCasa objetoCocina){
        superficie=valorSuperficie;
        direccion=valorDireccion;
        salon=objetoSalon;
        cocina=objetoCocina;}

Lo haces ver muy facil pero de verdad no lo es.

Sí que lo es.
Pero claro, se necesita tiempo para aprender y familiarizarse con la programación en general, y en este caso, con Java en particular.

Estas cosas no se aprenden en dos semanas, ni en cuatro..., ni en seis meses...
Podemos memorizar las instrucciones y utilizarlas aún sin entender del todo cómo y por qué funcionan.
Pero pasado un tiempo, es cuando empezamos a asimilar ese conocimiento, a comprenderlo. Y es entonces cuando nos damos cuenta de que es la cosa más simple y sencilla del mundo.

Por cierto, si nuestro "predicado" fuera un poco más sencillo, si podríamos haberlo creado con una expresión lambda sin tener que escribir una clase completa.

Suponiendo que el filtro fuera un único objeto Salud, no un array, podríamos haberlo hecho así:

public class Filtro {

   public static void main(String[] args) {
      Salud[] arrayRecords = new Salud[]{
            new Salud("Sangre", "Colesterol"),
            new Salud("Termometro", "Temperatura"),
            new Salud("Oximetro", "Oxigeno"),
            new Salud("Tensiometro", "Presion Arterial"),
            new Salud("Glucosa", "Azucar en la Sangre"),

      };
      
      Salud filtroUnico = new Salud("Tensiometro", "Alcohol");

      Arrays.stream(arrayRecords).filter(a -> a.equals(filtroUnico)).forEach(System.out::println);
      
   }
}

Pero en nuestro caso, sí necesitamos un array con varios filtros con los que comparar, y para ello se necesita que intervenga un bucle.

Aunque, ahora que lo pienso... también podríamos haberlo hecho así:

public class Filtro {

   public static Salud[] arrayFiltro;

   public static void main(String[] args) {
      Salud[] arrayRecords = new Salud[]{
            new Salud("Sangre", "Colesterol"),
            new Salud("Termometro", "Temperatura"),
            new Salud("Oximetro", "Oxigeno"),
            new Salud("Tensiometro", "Presion Arterial"),
            new Salud("Glucosa", "Azucar en la Sangre"),

      };

      arrayFiltro = new Salud[]{
            new Salud("Gasa", "Suturas"),
            new Salud("Tensiometro", "Alcohol")
      };
      
      for (Salud filtro: arrayFiltro)
         Arrays.stream(arrayRecords).filter(a -> a.equals(filtro)).forEach(System.out::println);
      
   }
}

De esta forma tampoco necesitamos crear una clase Predicate.
Basta con poner un bucle que recorrar el array de filtros, y cada filtro de ese array se lo pasamos a la expresión lambda..
Y solucionado 

Esto es lo que más me gusta de la programación. Que hay muchas formas de conseguir un mismo objetivo, y a poco que te pares a pensar, vas encontrando maneras más sencillas y con menos código de hacer lo mismo.