Java Programa Venta de Electrodomesticos solo con arreglos arrays sin ArrayList

[THELUXENTON]

Hola a todos. Soy nuevo y necesito ayuda con un programa que estoy haciendo sobre la venta de electrodomésticos. En un principio lo completé con ArrayList pero la profesora me dijo que lo debía hacer con arreglos (arrays). El problema es que no sé cómo hacerlo. Tengo todas las clases pero ahora tengo que eliminar el ArrayList y no sé cómo hacer.

Tengo todas estas clases:

-Electrodomesticos que es una superclase abastracta
-Cocina
-Refrigeradora
-Lavadora
-Televisor
-Producto
-main

[Kabuto]

¿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.

[THELUXENTON]

"Seleccionar un tema para un programa que realice transacciones (Venta, compra, facturacion, etc.). Presenta un menu (6), solo debe utilizar un arreglos no arraylist, al tema seleccionado , agregar conceptos de modificadores de acceso y de comportamiento, el proyecto debe ser funcional y con operaciones como crear, modificar, borrar y consultar."


este es el enunciado de de mi trabajo yo seleccione como tema venta de electrodomésticos y si queria que tenga una cantidad de 10 electrodomésticos 

[Mario R. Rancel]

Hola THELUXENTON, es conveniente que pegues aquí el código que tengas, hasta donde hayas podido llegar, pues así facilitas que se te pueda ayudar. Mira en  https://aprenderaprogramar.com/foros/index.php?topic=1460.0 las indicaciones. Saludos.

[THELUXENTON]

Vale mira tengo todo esto:

Electrodomesticos

Código: [Seleccionar]

package Principal;

public abstract class electrodomesticos {
private String Nombredelproducto;
private String codigo;
private String Marca;
private int Cantidad;
private double Precio;

public electrodomesticos (){


}
public electrodomesticos(String Nombredelproducto, String codigo,String Marca, int Cantidad, int Precio) {
this.codigo=codigo;
this.Nombredelproducto = Nombredelproducto;
this.Marca = Marca;
this.Cantidad = Cantidad;
this.Precio=Precio;



}
public String getNombredelproducto() {
return Nombredelproducto;
}
public void setNombredelproducto(String nombredelproducto) {
Nombredelproducto = nombredelproducto;
}
public String getCodigo() {
return codigo;
}
public void setCodigo(String codigo) {
this.codigo = codigo;
}
public String getMarca() {
return Marca;
}
public void setMarca(String marca) {
Marca = marca;
}
public int getCantidad() {
return Cantidad;
}
public void setCantidad(int cantidad) {
Cantidad = cantidad;
}
public double getPrecio() {
return Precio;
}
public void setPrecio(double precio) {
Precio = precio;
}
public abstract double calcularpreciofinal();
public abstract double calcularsubtotal();
public abstract double calculariva();
public abstract void mostrarDetalles();
}



Cocina

Código: [Seleccionar]

package Clases;
import Principal.electrodomesticos;

public class cocina extends electrodomesticos  {


@Override
public String toString() {
return "cocina [codigo=" + codigo + ", Hornillas=" + Hornillas + ", horno=" + horno + ", sistemadecoccion="
+ sistemadecoccion + "]";
}
private String codigo;
private int Hornillas;
private Boolean horno;
private String sistemadecoccion;


public cocina() {
}
public cocina(String Nombredelproducto, String codigo,String Marca, int Cantidad, int Precio,
int Hornillas,Boolean horno,String sistemadecoccion) {
super(Nombredelproducto,codigo,Marca,Cantidad,Precio);
this.codigo=codigo;
this.Hornillas= Hornillas;
this.horno = horno;
this.sistemadecoccion=sistemadecoccion;
}

public String getCodigo() {
return codigo;
}

public void setCodigo(String codigo) {
this.codigo = codigo;
}

public int getHornillas() {
return Hornillas;
}

public void setHornillas(int hornillas) {
Hornillas = hornillas;
}

public Boolean getHorno() {
return horno;
}

public void setHorno(Boolean horno) {
this.horno = horno;
}

public String getSistemadecoccion() {
return sistemadecoccion;
}

public void setSistemadecoccion(String sistemadecoccion) {
this.sistemadecoccion = sistemadecoccion;
}


@Override
public double calcularpreciofinal() {
// TODO Auto-generated method stub
return this.calcularsubtotal()+this.calculariva();
}

@Override
public double calcularsubtotal() {
// TODO Auto-generated method stub
return this.getPrecio()*this.getCantidad();
}

@Override
public double calculariva() {
// TODO Auto-generated method stub
return this.calcularsubtotal()* 0.12;
}

@Override
public void mostrarDetalles(){
System.out.println("Clase Cocina");
    System.out.println(this.getMarca());
    System.out.println(this.getPrecio());
    System.out.println(this.getHornillas());
    System.out.println(this.getHorno());
    System.out.println(this.sistemadecoccion);
    System.out.println("Valor a pagar por la cocina:"+this.calcularpreciofinal());

}
public void saludar () {
System.out.print("cocina");
}


}
Refrigeradora

Código: [Seleccionar]

package Clases;
import Principal.electrodomesticos;
public class refrigeradora extends electrodomesticos  {

private String codigo;
private double pies;
private int niveldecongelamiento;

public refrigeradora () {

}
public refrigeradora (String Nombredelproducto, String codigo,String Marca, int Cantidad,
int Precio,double pies,int niveldecongelamiento) {
super(Nombredelproducto,codigo,Marca,Cantidad,Precio);
this.codigo=codigo;
    this.pies= pies;
    this.niveldecongelamiento = niveldecongelamiento;

}
public String getCodigo() {
return codigo;
}
public void setCodigo(String codigo) {
this.codigo = codigo;
}
public double getPies() {
return pies;
}
public void setPies(double pies) {
this.pies = pies;
}
public int getNiveldecongelamiento() {
return niveldecongelamiento;
}
@Override
public String toString() {
return "refrigeradora [codigo=" + codigo + ", pies=" + pies + ", niveldecongelamiento=" + niveldecongelamiento
+ "]";
}
public void setNiveldecongelamiento(int niveldecongelamiento) {
this.niveldecongelamiento = niveldecongelamiento;
} @Override
public double calcularpreciofinal() {
// TODO Auto-generated method stub
return this.calcularsubtotal()+this.calculariva();
}

@Override
public double calcularsubtotal() {
// TODO Auto-generated method stub
return this.getPrecio()*this.getCantidad();
}

@Override
public double calculariva() {
// TODO Auto-generated method stub
return this.calcularsubtotal()*0.12;
}

@Override
public void mostrarDetalles(){
System.out.println("Clase refrieradora");
System.out.println(this.getMarca());
System.out.println(this.getPrecio());
System.out.println(this.getCantidad());
System.out.println(this.getPies());
System.out.println(this.niveldecongelamiento);
System.out.println("Valor a pagar por la refrigeradora:"+this.calcularpreciofinal());

}
      public void saludar () {
System.out.print("refrigeradora");
}


}Televisor

Código: [Seleccionar]

package Clases;
import Principal.electrodomesticos;

public class televisor extends electrodomesticos  {

private int pulgadas;
private String resolucion;
private String tipodepantalla;

public televisor() {


}
@Override
public String toString() {
return "televisor [pulgadas=" + pulgadas + ", resolucion=" + resolucion + ", tipodepantalla=" + tipodepantalla
+ "]";
}
public televisor(String Nombredelproducto, String codigo,String Marca, int Cantidad,
int Precio,String resolucion, String tipodepantalla,int pulgadas) {
super(Nombredelproducto,codigo,Marca,Cantidad,Precio);
this.pulgadas=pulgadas;
this.resolucion=resolucion;
this.tipodepantalla=tipodepantalla;


}

public int getPulgadas() {
return pulgadas;
}
public void setPulgadas(int pulgadas) {
this.pulgadas = pulgadas;
}
public String getResolucion() {
return resolucion;
}
public void setResolucion(String resolucion) {
this.resolucion = resolucion;
}
public String getTipodepantalla() {
return tipodepantalla;
}
public void setTipodepantalla(String tipodepantalla) {
this.tipodepantalla = tipodepantalla;
}


@Override
public double calcularpreciofinal() {
// TODO Auto-generated method stub
return this.calcularsubtotal()+this.calculariva();
}

@Override
public double calcularsubtotal() {
// TODO Auto-generated method stub
return this.getPrecio()*this.getCantidad();
}

@Override
public double calculariva() {
// TODO Auto-generated method stub
return this.calcularsubtotal()*0.12;
}

@Override
public void mostrarDetalles(){
System.out.println("Clase Televisor");
System.out.println(this.getMarca());
System.out.println(this.getPrecio());
System.out.println(this.getCantidad());
System.out.println(this.getPulgadas());
System.out.println(this.getResolucion());
System.out.println(this.getTipodepantalla());

System.out.println("Valor a pagar por el Televisor:"+this.calcularpreciofinal());

}
      public void saludar () {
System.out.print("televisor");
}

}
lavadora

Código: [Seleccionar]

package Clases;
public class lavadora extends Principal.electrodomesticos  {

private int velocidad;
private String Capacidaddelavado;
private int Ciclos;

public lavadora() {

}
@Override
public String toString() {
return "lavadora [velocidad=" + velocidad + ", Capacidaddelavado=" + Capacidaddelavado + ", Ciclos=" + Ciclos + "]";
}
public lavadora(String Nombredelproducto, String codigo,String Marca, int Cantidad, int Precio,
String Capacidaddelavado,int velocidad, int Ciclos) {
super(Nombredelproducto,codigo,Marca,Cantidad,Precio);
this.Capacidaddelavado=Capacidaddelavado;
this.Ciclos=Ciclos;
this.velocidad=velocidad;



}
public int getVelocidad() {
return velocidad;
}
public void setVelocidad(int velocidad) {
this.velocidad = velocidad;
}
public String getCapacidaddelavado() {
return Capacidaddelavado;
}
public void setCapacidaddelavado(String capacidaddelavado) {
Capacidaddelavado = capacidaddelavado;
}
public int getCiclos() {
return Ciclos;
}
public void setCiclos(int ciclos) {
Ciclos = ciclos;
}

@Override
public double calcularpreciofinal() {
// TODO Auto-generated method stub
return this.calcularsubtotal()+this.calculariva();
}

@Override
public double calcularsubtotal() {
// TODO Auto-generated method stub
return this.getPrecio()*this.getCantidad();
}

@Override
public double calculariva() {
// TODO Auto-generated method stub
return this.calcularsubtotal()*0.12;
}

@Override
public void mostrarDetalles(){
System.out.println("Clase Lavadora");
System.out.println(this.getMarca());
System.out.println(this.getPrecio());
System.out.println(this.getCantidad());
System.out.println(this.getCapacidaddelavado());
System.out.println(this.getCiclos());
System.out.println(this.getVelocidad());

System.out.println("Valor a pagar por la Lavadora:"+this.calcularpreciofinal());

}
      public void saludar () {
System.out.print("lavadora");
}



}

producto

Código: [Seleccionar]

package Gestor;
import java.util.ArrayList;

import Principal.electrodomesticos;
import personas.clientes;
import personas.gestorclientes;

public class producto extends ArrayList<electrodomesticos> {

public producto() {



}
public void agregarProducto(electrodomesticos e) {
this.add(e);
}
public electrodomesticos getProducto(int hola) {
return this.get(hola);
}
public ArrayList<electrodomesticos>getProducto(){
return this;
}

public void getStock(){
if(this.size()>0) {
electrodomesticos p;
System.out.println("\nProductos Stock");
for(int i=0;i<this.size();i++) {
p=this.get(i);

System.out.println(p.getMarca()+"Cantidad en Stock "+p.getCantidad());
}
}else {
System.out.println("\nNo hay articulos en stock");
}
}
public void total_general() {
double subp=0,IVA=0,totalp=0;
if (this.size()>0) {
electrodomesticos p;
System.out.println("\nProductos Vendidos");
for (int i=0;i< this.size();i++) {
p= this.get(i);
System.out.println("Electrodomestico: "+p.getNombredelproducto());
System.out.println("Marca: "+ p.getMarca());
System.out.println("PRECIO: "+ p.getPrecio());
System.out.println("cantidad: "+ p.getCantidad());
System.out.println("subtotal: "+ p.calcularsubtotal());
System.out.println("IVA: "+ p.calculariva());
System.out.println("total: "+ p.calcularpreciofinal());
subp +=p.calcularsubtotal();
IVA += p.calculariva();
totalp+=p.calcularpreciofinal();
System.out.println();
System.out.println("total general");
System.out.println("Subtotal general "+ subp);
System.out.println("IVA general: "+ IVA);
System.out.println("total a pagar "+ totalp);


}
        }else {
System.out.println("\nNO HAY VENTAS");
        }
}
}

Main

Código: [Seleccionar]

package Menu;
import java.util.Scanner;
import Gestor.Inventario;
import personas.clientes;
import personas.gestorclientes;
import Clases.cocina;
import Clases.refrigeradora;
import Clases.televisor;
import Clases.lavadora;
import Gestor.producto;
import Principal.electrodomesticos;

public class main extends Inventario{

public static void main(String[]args ) {

electrodomesticos p=null;
int i=-1;
producto stock= new producto();

lavadora lavadora1 = new lavadora("Lavadora", "8", "Samnsung ", 3, 550, "54 KG", 4, 8);
stock.add(lavadora1);

refrigeradora refrigeradora1 = new refrigeradora("lg","6","ultra",20,50,8,500);
stock.add(refrigeradora1);

televisor televisor1 = new televisor("Televisor", "2", "Sony ", 4, 200, "4k", "amoled", 75);
stock.add(televisor1);

cocina cocina1 = new cocina("INDURAMA","2","diament ",50,200,2,true,"induccion");
stock.add(cocina1);

producto compra= new producto();

int op= 0 ;

do {
Scanner sc = new Scanner(System.in);
System.out.println("\nELECTRODOMESTICOS ELECTROHOGAR");
System.out.println("       MENU DE OPCIONES");
System.out.println("1 = Verificar Stock");
System.out.println("2 = Venta");
System.out.println("3 = facturacion");
System.out.println("0 = Salir");
System.out.println("Elija la opcion: ");

op = sc.nextInt();

int ban=0;


switch (op) {
   case 1:

   break;
   case 2:
System.out.println("VENTA");
System.out.println("\n Cocina");
System.out.println("\n Refrigeradora");
System.out.println("\n Televisores");
System.out.println("\n Ingrese el codigo de electrodomestico que desea comprar: ");

String op1=sc.next();

for (i=0;i< stock.size();i++) {
p=stock.get(i);
if(p.getCodigo().compareTo(op1.toUpperCase())==0) {
ban=1;
System.out.println();
System.out.println("Electrodomesticos:"+p.getNombredelproducto());
System.out.println("Marca:"+p.getMarca());
System.out.println("precio:"+p.getPrecio());
System.out.println("Cantidad de stock:"+p.getCantidad());
break;
}
}
if (ban==1) {
System.out.println(("Que cantidad desea comprar:"));
int cantc=sc.nextInt();
p=stock.get(i);
if (cantc<=p.getCantidad()) {
p.setCantidad(p.getCantidad()-cantc);
System.out.println("Actual stock: "+ p.getCantidad());
p.setCantidad(cantc);
compra.add(p);
}else {
System.out.println("No se puede realizar la venta porque excede la cantidad en stock ");
}
}else {
System.out.println("El codigo no esta registrado");
}
break;

case 3:
if (compra.size()>0) {
System.out.println();
System.out.println("\nARRAYLIST COMPRA");

for (int o=0;o<compra.size();o++) {

p=compra.get(o);

System.out.println();
System.out.println("Electrodomesticos:"+p.getNombredelproducto());
System.out.println("marca: "+p.getMarca());
System.out.println("Precio: "+p.getPrecio());
System.out.println("Cantidad Vendida"+p.getCantidad());
System.out.println("subtotal"+p.calcularsubtotal());
System.out.println("IVA"+p.calculariva());
System.out.println("Precio Final: "+p.calcularpreciofinal());

compra.total_general();

gestorclientes clientes = new gestorclientes();
clientes.nuevoCliente();

}
}else {
System.out.println("\nNo hay ventas");
}


}







}while(op !=0);
}
}

El programa funciona con el arraylist pero la profesora me indico que debe ser con arreglos no con arraylist y nose como modificarlo o me tocara hacer nuevo

[THELUXENTON]

help me

[Kabuto]

Vale, voy a intentar reescribir tu programa clase a clase, corrigiendo algunas cosas que no son correctas o que pueden resultar en una mala práctica.
Por ejemplo, los nombres de las clases deberían comenzar con mayúscula y los nombres de variables/atributos en minúscula.

Comencemos por la clase Electrodomestico. Como he dicho, nombre de clase en mayúscula y atributos en minúscula.
También conviene evitar nombres de atributos largos siempre que sea posible. En lugar de usa "nombreDelProducto", puede bastar con usar simplemente "nombre". Como es un atributo, ya se sobre entiende que es el nombre del electrodoméstico.

Luego, el constructor que no recibe parámetros, en lugar de dejarlo vacío, es mejor inicializar los atributos con unos valores por defecto. Aunque sean cadenas vacías para los String y valor 0 para los atributos numéricos.

Y ya que en las clases hijas vas a incluirles el método toString(), yo también se la incluiría a esta clase madre. Para que luego las clases hijas puedan mostrar la información completa, la que heredan de su madre y la suya propia.

Código: [Seleccionar]

public abstract class Electrodomestico {

private String nombre;
private String codigo;
private String marca;
private int cantidad;
private double precio;

public Electrodomestico() {
nombre = "";
codigo = "";
marca = "";
cantidad = 0;
precio = 0;
}

public Electrodomestico(String nombre, String codigo, String marca, int cantidad, double precio) {
this.nombre = nombre;
this.codigo = codigo;
this.marca = marca;
this.cantidad = cantidad;
this.precio = precio;
}

public String getNombre() {
return nombre;
}

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

public String getCodigo() {
return codigo;
}

public void setCodigo(String codigo) {
this.codigo = codigo;
}

public String getMarca() {
return marca;
}

public void setMarca(String marca) {
this.marca = marca;
}

public int getCantidad() {
return cantidad;
}

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

public double getPrecio() {
return precio;
}

public void setPrecio(double precio) {
this.precio = precio;
}

public abstract double calcularPrecioFinal();
public abstract double calcularSubtotal();
public abstract double calcularIva();
public abstract void mostrarDetalles();

@Override
public String toString() {
return "[nombre=" + nombre + ", codigo=" + codigo + ", marca=" + marca + ", cantidad="
+ cantidad + ", precio=" + precio + "]";
}

}

La clase Cocina.
Veo que le has puesto un atributo para "código". Pero esta clase ya tiene ese atributo porque lo está heredando de Electrodomestico, así que ponérselo también a Cocina es redundante. Mejor no ponerlo.

También hay que inicializar los atributos en su constructor sin parámetros, además de llamar al constructor de su clase madre con la instrucción super()

En su método toString() también incluiremos lo que retorna el toString de su "superclase".

Bien, yo ahora tengo ciertas reservas con los métodos heredados:
calcularPrecioFinal(), calcularSubtotal() y calcularIva().

Estos métodos hacen unos cálculos que SOLO dependen de los atributos de la superclase Electrodomestico, no influyen los atributos que puedan tener las clases hijas. Por tanto, no habría sido necesario declararlos como abstractos para que los sobrescriban las clases hijas.
Podrían haberse escrito directamente en la clase madre, ya que solo dependen de esta para sus cálculos.

Luego, el subtotal y el precio que calculan estos métodos, lo hacen sobre las cantidades existentes de cada electrodoméstico.
No nos van a decir el precio por comprar UNA cocina, si no que nos dirán el precio a pagar por comprar TODAS las cocinas que haya en la tienda.

Voy a dejar estos métodos tal y como tú los has planteado y seguir avanzando con el ejercicio. Pero cuando el programa esté terminado, quizás quieras revisar si son esos los cálculos que te interesan hacer.

Código: [Seleccionar]

public class Cocina extends Electrodomestico {

private int hornillas;
private boolean tieneHorno;
private String sistemaDeCoccion;

public Cocina() {
super();
hornillas = 0;
tieneHorno = false;
sistemaDeCoccion = "";
}

public Cocina(String nombre, String codigo, String marca, int cantidad, double precio,
int hornillas, boolean tieneHorno, String sistemaDeCoccion) {
super(nombre, codigo, marca, cantidad, precio);
this.hornillas = hornillas;
this.tieneHorno = tieneHorno;
this.sistemaDeCoccion = sistemaDeCoccion;
}

public int getHornillas() {
return hornillas;
}

public void setHornillas(int hornillas) {
this.hornillas = hornillas;
}

public boolean tieneHorno() {
return tieneHorno;
}

public void setHorno(boolean tieneHorno) {
this.tieneHorno = tieneHorno;
}

public String getSistemaDeCoccion() {
return sistemaDeCoccion;
}

public void setSistemaDeCoccion(String sistemaDeCoccion) {
this.sistemaDeCoccion = sistemaDeCoccion;
}

@Override
public double calcularPrecioFinal() {
return calcularSubtotal() + calcularIva();
}

@Override
public double calcularSubtotal() {
return getPrecio() * getCantidad();
}

@Override
public double calcularIva() {
return calcularSubtotal() * 0.12;
}

@Override
public void mostrarDetalles() {
System.out.println("Clase Cocina");
    System.out.println("Marca: " + getMarca());
    System.out.println("Precio: " + getPrecio());
    System.out.println("Nº de Hornillas: " + hornillas);
    System.out.println(tieneHorno?"Con Horno":"Sin Horno");
    System.out.println("Sistema de Coccion: " + sistemaDeCoccion);
    System.out.println("Valor a pagar por la cocina:" + calcularPrecioFinal());
}

@Override
public String toString() {
return "Cocina [" + super.toString() + " hornillas=" + hornillas +
", horno=" + tieneHorno + ", sistemaDeCoccion=" + sistemaDeCoccion + "]";
}

}
Estos mismos cambios que hemos hecho a Cocina, los aplicamos al resto de clases hijas:
Refrigeradora

Código: [Seleccionar]

public class Refrigeradora extends Electrodomestico {

private double pies;
private int nivelDeCongelamiento;

public Refrigeradora() {
super();
pies = 0;
nivelDeCongelamiento = 0;
}

public Refrigeradora(String nombre, String codigo, String marca, int cantidad, double precio,
double pies, int nivelDeCongelamiento) {
super(nombre, codigo, marca, cantidad, precio);
this.pies = pies;
this.nivelDeCongelamiento = nivelDeCongelamiento;
}

public double getPies() {
return pies;
}

public void setPies(double pies) {
this.pies = pies;
}

public int getNivelDeCongelamiento() {
return nivelDeCongelamiento;
}

public void setNivelDeCongelamiento(int nivelDeCongelamiento) {
this.nivelDeCongelamiento = nivelDeCongelamiento;
}

@Override
public double calcularPrecioFinal() {
return calcularSubtotal() + calcularIva();
}

@Override
public double calcularSubtotal() {
return getPrecio() * getCantidad();
}

@Override
public double calcularIva() {
return calcularSubtotal() * 0.12;
}

@Override
public void mostrarDetalles() {
System.out.println("Clase Refrigeradora");
System.out.println("Marca: " + getMarca());
    System.out.println("Precio: " + getPrecio());
System.out.println("Cantidad: " + getCantidad());
System.out.println("Pies: " + pies);
System.out.println("Nivel Congelamiento: " + nivelDeCongelamiento);
System.out.println("Valor a pagar por la refrigeradora:" + calcularPrecioFinal());

}

@Override
public String toString() {
return "Refrigeradora [" + super.toString() + " pies=" +
pies + ", nivelDeCongelamiento=" + nivelDeCongelamiento + "]";
}

}
Televisor

Código: [Seleccionar]

public class Televisor extends Electrodomestico {

private int pulgadas;
private String resolucion;
private String tipoPantalla;

public Televisor() {
super();
pulgadas = 0;
resolucion = "";
tipoPantalla = "";
}

public Televisor(String nombre, String codigo, String marca, int cantidad, double precio,
int pulgadas, String resolucion, String tipoPantalla) {
super(nombre, codigo, marca, cantidad, precio);
this.pulgadas = pulgadas;
this.resolucion = resolucion;
this.tipoPantalla = tipoPantalla;
}

public int getPulgadas() {
return pulgadas;
}

public void setPulgadas(int pulgadas) {
this.pulgadas = pulgadas;
}

public String getResolucion() {
return resolucion;
}

public void setResolucion(String resolucion) {
this.resolucion = resolucion;
}

public String getTipoPantalla() {
return tipoPantalla;
}

public void setTipoPantalla(String tipoPantalla) {
this.tipoPantalla = tipoPantalla;
}

@Override
public double calcularPrecioFinal() {
return calcularSubtotal() + calcularIva();
}

@Override
public double calcularSubtotal() {
return getPrecio() * getCantidad();
}

@Override
public double calcularIva() {
return calcularSubtotal() * 0.12;
}

@Override
public void mostrarDetalles() {
System.out.println("Clase Televisor");
System.out.println("Marca: " + getMarca());
System.out.println("Precio: " + getPrecio());
System.out.println("Cantidad: " + getCantidad());
System.out.println("Pulgadas: " + pulgadas);
System.out.println("Resolucion: " + resolucion);
System.out.println("Tipo Pantalla: " + tipoPantalla);

System.out.println("Valor a pagar por el Televisor:" + calcularPrecioFinal());
}

@Override
public String toString() {
return "Televisor [" + super.toString() + "pulgadas=" + pulgadas +
", resolucion=" + resolucion + ", tipoPantalla=" + tipoPantalla
+ "]";
}

}
Lavadora

Código: [Seleccionar]

public class Lavadora extends Electrodomestico {

private int velocidad;
private String capacidadDeLavado;
private int ciclos;

public Lavadora() {
super();
velocidad = 0;
capacidadDeLavado = "";
ciclos = 0;
}

public Lavadora(String nombre, String codigo, String marca, int cantidad, double precio,
int velocidad, String capacidadDeLavado, int ciclos) {
super(nombre, codigo, marca, cantidad, precio);
this.velocidad = velocidad;
this.capacidadDeLavado = capacidadDeLavado;
this.ciclos = ciclos;
}

public int getVelocidad() {
return velocidad;
}

public void setVelocidad(int velocidad) {
this.velocidad = velocidad;
}

public String getCapacidadDeLavado() {
return capacidadDeLavado;
}

public void setCapacidadDeLavado(String capacidadDeLavado) {
this.capacidadDeLavado = capacidadDeLavado;
}

public int getCiclos() {
return ciclos;
}

public void setCiclos(int ciclos) {
this.ciclos = ciclos;
}

@Override
public double calcularPrecioFinal() {
return calcularSubtotal() + calcularIva();
}

@Override
public double calcularSubtotal() {
return getPrecio() * getCantidad();
}

@Override
public double calcularIva() {
return calcularSubtotal() * 0.12;
}

@Override
public void mostrarDetalles() {
System.out.println("Clase Lavadora");
System.out.println("Marca: " + getMarca());
System.out.println("Precio " + getPrecio());
System.out.println("Cantidad: " + getCantidad());
System.out.println("Capacidad de Lavado: " + capacidadDeLavado);
System.out.println("Ciclos: " + ciclos);
System.out.println("Velocidad: " + velocidad);

System.out.println("Valor a pagar por la Lavadora:" + calcularPrecioFinal());
}

@Override
public String toString() {
return "Lavadora [" + super.toString() + "velocidad=" + velocidad +
", capacidadDeLavado=" + capacidadDeLavado + ", ciclos=" + ciclos
+ "]";
}

}

Vale, tenemos modeladas las entidades principales.
Hasta aquí tengo claro lo que has hecho.

Pero a partir de aquí, ya me pierdo en tus planteamientos. Has puesto una clase llamada Producto y luego ya la clase Main.
Pero veo que en el código se mencionan una clase Inventario, una clase GestorCliente... que no las has publicado, y de hecho no se si realmente las tienes escritas o se han colado por copiar/pegar de otros códigos..., no sé...

Así que a partir de aquí voy a seguir según lo haría yo....¡¡pero ahora mismo no dispongo de más tiempo!! 

Luego cuando pueda, retomaré este ejercicio y veremos cómo podemos hacer la gestión de electrodomésticos con un arreglo.

Saludos.

[THELUXENTON]

Hola, gracias hare esas correcciones si eh puesto la clase gestorcliente pero estaba haciendo pruebas si funcionaba para integrarlo,  el inventario mas de lo mismo estaba tratando de hacer los arrays pero no consegui hacer que imprima y en ves de dar mas informacion talves estaba retrasando  por eso decidí no incluirlas

[Kabuto]

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.

Código: [Seleccionar]

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í:

Código: [Seleccionar]

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:

Código: [Seleccionar]


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:

Código: [Seleccionar]


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.

[Kabuto]

Bueno, pues lo siguiente es pensar en la opción de Facturacion.
Aquí deberíamos mostrar un informe de las ventas que se han realizado durante el día.
Lo ideal sería usar un ArrayList, porque no hay forma de saber cuántas ventas se van a hacer en cada sesión y por tanto usar un arreglo sería un fastidio porque hay que darle un tamaño fijo.
Pero como nos han vetado el uso de ArrayList  , hay que pensar otra alternativa.

Lo que podemos hacer es construir un String con el detalle de cada venta. Tras vender un producto, añadiremos una línea nueva a ese String.
Además podemos utilizar un acumulador de tipo double para sumar el total facturado.
Para construir el String es mejor usar la clase StringBuilder.

Así que añadimos estos dos nuevos atributos a la clase Main

public class Main {
   
   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;

Y vamos a hacer unos cambios en el método venta(), pues ahora queremos que cada venta realizada quede reflejada en la facturación:

   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");
            //Dejamos constancia en la facturacion
            facturacion.append(String.format("# Codigo: %s Nombre: %s Unidades vendidas: %d Importe: %.2f\n",
                  codigo, solicitado.getNombre(), unidades, facturar));
            totalFacturado += facturar;
         }
      }
   }

Y con estos cambios, ya podemos escribir el método facturacion(), que básicamente lo único que tiene que hacer es mostrar lo que hemos ido registrando en el StringBuilder.

Código: [Seleccionar]


private static void facturacion() {
System.out.println("\n\t\tREGISTRO DE FACTURACION\n");
if (totalFacturado == 0)
System.out.println("No se han registrado ventas.");
else {
System.out.println(facturacion.toString());
System.out.printf("Total facturado: %.2f\n", totalFacturado);
}
}
Probémoslo. Hagamos unas cuantas ventas y a ver cómo queda registrado:

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: COC-0100

Detalles del producto:
Clase Cocina
Marca: Balay
Precio: 89.9
Nº de Hornillas: 2
Con Horno
Sistema de Coccion: Gas
Valor a pagar por la cocina:604.1280000000002

Unidades a facturar (MAX=6): 3

Importe a pagar: 302,06
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: COC-0350

Detalles del producto:
Clase Cocina
Marca: Miele
Precio: 109.9
Nº de Hornillas: 4
Con Horno
Sistema de Coccion: Induccion
Valor a pagar por la cocina:492.35200000000003

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
0 = Salir
Elija la opcion: 2
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
Valor a pagar por el Televisor:15230.096

Unidades a facturar (MAX=17): 4

Importe a pagar: 3583,55
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: REF-2909

Detalles del producto:
Clase Refrigeradora
Marca: FAF
Precio: 139.9
Cantidad: 5
Pies: 22.0
Nivel Congelamiento: -25
Valor a pagar por la refrigeradora:783.44

Unidades a facturar (MAX=5): 1

Importe a pagar: 156,69
Gracias por su compra

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

      REGISTRO DE FACTURACION

# Codigo: COC-0100 Nombre: Fogo Prime Unidades vendidas: 3 Importe: 302,06
# Codigo: COC-0350 Nombre: Pyro Master Unidades vendidas: 1 Importe: 123,09
# Codigo: TLV-2338 Nombre: Pentax Advance Unidades vendidas: 4 Importe: 3583,55
# Codigo: REF-2909 Nombre: Cooler Veritas Unidades vendidas: 1 Importe: 156,69

Total facturado: 4165,39

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

      FIN DE PROGRAMA

Bueno, no es muy elegante pero funciona. Ahora ya si se quiere, se puede modificar para que quede mejor.


El caso es que con todo esto, pues ya hemos hecho algo parecido a un programa de gestión de ventas usando un arreglo.

Hay cosas a revisar. Como esto que comenté anteriormente:

Bien, yo ahora tengo ciertas reservas con los métodos heredados:
calcularPrecioFinal(), calcularSubtotal() y calcularIva().

Estos métodos hacen unos cálculos que SOLO dependen de los atributos de la superclase Electrodomestico, no influyen los atributos que puedan tener las clases hijas. Por tanto, no habría sido necesario declararlos como abstractos para que los sobrescriban las clases hijas.
Podrían haberse escrito directamente en la clase madre, ya que solo dependen de esta para sus cálculos.

Luego, el subtotal y el precio que calculan estos métodos, lo hacen sobre las cantidades existentes de cada electrodoméstico.
No nos van a decir el precio por comprar UNA cocina, si no que nos dirán el precio a pagar por comprar TODAS las cocinas que haya en la tienda.

Quizás el método calcularPrecioFinal() convenga reescribirlo para que reciba como argumento las unidades que se quieren vender y haga el cálculo sobre estas unidades, y no sobre el total disponible en el inventario.
Así ese método haría lo que yo he hice en esta línea, cuando hacemos una venta y calculamos el importe a pagar:

            //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);

Pero bueno, eso ya lo puedes ir valorando tú mismo y si tienes más dudas o quieres añadir más funciones al programa y aún no sabes como proceder, pues consultalo por aquí.

Saludos.

[THELUXENTON]

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

[THELUXENTON]

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?

[Kabuto]

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:

Código: [Seleccionar]

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:

Código: [Seleccionar]


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...

Código: [Seleccionar]


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...

[THELUXENTON]

hola muchas gracias mira hice esta clase de clientes  este gestor de clientes porque queria integrarlo en la parte de facturacion en el StringBuild




Clientes

Código: [Seleccionar]

package Principal;

public class Clientes {
private int id;
private String nombres;
private String apellidos;
private String email;
private int telefono;
private String pago;

public Clientes (int id, String nombres, String apellidos,String email, int telefono, String pago) {
this.id = id;
this.nombres = nombres;
this.apellidos = apellidos;
this.email=email;
this.telefono = telefono;
this.pago = pago;
}

@Override
public String toString() {
return "clientes [id=" + id + ", nombres=" + nombres + ", apellidos=" + apellidos + ", email=" + email
+ ", telefono=" + telefono + ", pago=" + pago + "]";
}

public int getId() {
return id;
}

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

public String getNombres() {
return nombres;
}

public void setNombres(String nombres) {
this.nombres = nombres;
}

public String getApellidos() {
return apellidos;
}

public void setApellidos(String apellidos) {
this.apellidos = apellidos;
}

public String getEmail() {
return email;
}

public void setEmail(String email) {
this.email = email;
}

public int getTelefono() {
return telefono;
}

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

public String getPago() {
return pago;
}[code]
   public void setPago(String pago) {
      this.pago = pago;
   }
   public void mostrar() {
}
}[/code]


gestorclientes

Código: [Seleccionar]

package Principal;
import Principal.Clientes;
import java.util.Scanner;


public final class gestorclientes {

private Scanner teclado;{

teclado = new Scanner(System.in);
}
private static Clientes[] cliente;

public gestorclientes() {
//Inicializamos el arreglo con capacidad para 10 electrodomesticos
cliente = new Clientes[3];
//Añadimos electrodomesticos al inventario
cliente[0] = new Clientes(17183451, "Roberto", "Torres", "roberto@hotmail.com", 2134121, "Efectivo");

}

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

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

public boolean agregarCliente(Clientes nuevo) {
int libre = buscaPosicionLibrecl();

if (libre == -1)
return false; //No hay espacio para añadir nada
else {
cliente[libre] = nuevo; //Añadimos
return true; //Informamos que todo OK
}


}
}
 en el main hice esto

Código: [Seleccionar]

private static void nuevoCliente() {

//Comprobamos si hay espacio libre
if (gestorclientes.buscaPosicionLibrecl() == -1)
System.out.println("\nNo hay espacio para añadir un nuevo cliente");
else {
Clientes nuevo = null;
//Pedimos datos comunes
System.out.print("\nCedula: ");
int id = Integer.parseInt(teclado.nextLine());
System.out.print("Nombres: ");
String nombres = teclado.nextLine();
System.out.print("Apellidos: ");
String apellidos = teclado.nextLine();
System.out.print("Email: ");
String email = teclado.nextLine();
System.out.print("Telefono:");
int telefono = Integer.parseInt(teclado.nextLine());
System.out.print("Tipo de Pago: ");
String pago = teclado.nextLine();

pero nose como integrarlo sinceramente

[Kabuto]

Veamos.
La clase yo la llamaría Cliente, en singular. Porque esa clase va a representar la información de un cliente concreto. Si fuera a representar una colección de clientes, entonces si la pondría en plural.

Luego, el atributo "String pago", parece que quieres guardar la forma de pago del cliente.
Pero no tengo claro que sea necesario. Un cliente hoy puede pagar en efectivo, pero mañana con tarjeta, y al otro con transferencia bancaria...
Además no creo que sea un atributo asociable a una entidad Cliente, yo lo asociaría más bien a una entidad Factura..., es decir, que indique cómo se ha pagado una determinada factura.
Yo no usaría ese atributo en la clase Cliente, aunque por supuesto tú puedes dejarlo. Quizás se le ves un sentido que yo no.

Para anotar la facturación de un Cliente, debemos usar un StringBuilder, que nos da objetos dinámicos que permiten agregar cadenas de texto para luego convertirlas en un String normal.
La clase String es estática e inmutable. Se le puede añadir nuevas cadenas de texto, pero internamente lo que ocurre es que se crea un String nuevo cada vez que añadimos texto y los String "viejos" quedan en memoria sin referencia, son basura que ocupan recursos inútilmente.

Por eso es más óptimo usar como atributo un StringBuilder al que podemos llamar "facturacion", ya que contendrá lo que facturemos a este Cliente

Este atributo, en principio, no debería recibir valor por constructor, ya que en el momento de crear un nuevo Cliente, no va a tener ninguna facturación. El constructor lo que hará será inicializarlo y que luego pueda ir recibiendo "líneas de facturación".
Estas "líneas de facturación" las tendrá que recibir mediante un método, al que podemos llamar facturar().

Este atributo, no lo incluiría en el método toString(). Puede llegar a ser muy extenso si al cliente le facturamos muchas ventas. Además el método toString() no está pensado para mostrar TODA la información de un objeto, si no más bien mostrar los datos que consideremos más representativos.
En cambio, si podemos incluirlo en un método mostrarDetalles()

Código: [Seleccionar]

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

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();
}

@Override
public String toString() {
return "[id= " + id + ", nombre= " + nombres + ", apellidos= " + apellidos + ", email= " + email
+ ", telefono= " + telefono + "]";
}

public int getId() {
return id;
}

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

public String getNombres() {
return nombres;
}

public void setNombres(String nombres) {
this.nombres = nombres;
}

public String getApellidos() {
return apellidos;
}

public void setApellidos(String apellidos) {
this.apellidos = apellidos;
}

public String getEmail() {
return email;
}

public void setEmail(String email) {
this.email = email;
}

public int getTelefono() {
return telefono;
}

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

/*
* Retorna un String con las líneas de facturación
* contenidas en el StringBuilder
*/
public String getFacturacion() {
return facturacion.toString();
}

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

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());
}
}

Sobre la clase GestorClientes, veo que has puesto un método y el arreglo como static.
En esta clase, no vamos a necesitar ningún elemento que sea static.

Aquí el arreglo si lo podemos llamar "clientes" en plural, porque va a contener cierta cantidad de objetos Cliente.
Por lo demás no requiere más explicación, solo resta hacer un calco de los métodos que le pusimos a la clase Inventario, adaptándolo a la clase Cliente.
Por ejemplo, para listar clientes ya no preguntaremos de que clase, porque solo hay una.

Código: [Seleccionar]

public class GestorClientes {

private Cliente[] clientes;

public GestorClientes() {
clientes = new Cliente[10];
clientes[0] = new Cliente(17183451, "Roberto", "Torres", "roberto@hotmail.com", 2134121);
clientes[5] = new Cliente(19034211, "Laura", "Juan", "lajuanita@hotmail.com", 3451212);
}

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

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

public Cliente getPorID(int id) {

for (int i = 0; i < clientes.length; i++) {
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].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;
}


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

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

public boolean agregarCliente(Cliente nuevo) {
int libre = buscaPosicionLibrecl();

if (libre == -1)
return false; //No hay espacio para añadir nada
else {
clientes[libre] = nuevo; //Añadimos
return true; //Informamos que todo OK
}
}
}
Vale, pues toca integrar esto en la clase Main.
Lo vemos en el siguiente mensaje.

[Kabuto]

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

Código: [Seleccionar]


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.

[THELUXENTON]

te iba a preguntar el porque utilizaste esto en el codigo de factuar

acturacion.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));

hablo de los %d y %s eso no sabia el porque

[THELUXENTON]

tambien hice las correciones que me dijiste  hice sub menus asi este es el

main

Código: [Seleccionar]

package Main;
import Principal.GestorClientes;
import java.util.Scanner;
import Principal.Cliente;
import Funciones.Inventario;
import Principal.Cocina;
import Principal.Electrodomestico;
import Principal.Lavadora;
import Principal.Refrigeradora;
import Principal.Televisor;

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;

public static void main(String[] args) {
     
      int opcion = 0;
     
      do {
         System.out.println("\nELECTRODOMESTICOS ELECTROHOGAR");
         System.out.println("       MENU DE PRINCIPAL");
         System.out.println("1 = Gestion Inventario");
         System.out.println("2 = Gestion Ventas");
         System.out.println("3 = Gestion Clientes");
         System.out.println("4 = Facturacion del dia");
         System.out.println("0 = Salir");
         System.out.print("Elija la opcion: ");
         opcion = Integer.parseInt(teclado.nextLine());
         
         switch(opcion) {
         case 1:
        gestion();
            break;
         case 2:
        gestionClientes();
                     gestionventas();
            break;
         case 3:
        gestionClientes2();
       
            break;
         case 4:

        //Aqui seria la suma de todas las ventas totales es decir de cliente por cliente porque si un cliente lleva dos cosas debe incluirse en una solo instancia ha alguna forma ?
       
       
        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() {
      System.out.println("\nIndique la clase de electrodomestico que quiere mostrar.");
      System.out.println("Pulse ENTER con el campo vacio para Mostrar todos los electrodomesticos.");
      System.out.print("Clase: ");
      String clase = teclado.nextLine();
     
      if (clase.isBlank())
         inventario.listarTodos();
      else
         inventario.listarPorClase(clase);
   }

      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.getPrecio() * unidades * 1.12;
                 solicitado.setCantidad(solicitado.getCantidad() - unidades);
                 System.out.printf("\nTotal a pagar: %.2f\n", facturar);
                   //Dejamos constancia en la facturacion
                 
                   facturacion.append(String.format(" # ID. Cliente:%d \nCodigo: %s \nNombre: %s \nUnidades vendidas: %d \nImporte: %.2f\n",
                         id, comprador.getNombres(), 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));
                }
             }
          }
       }
     
 
 
       
  private static void facturacion() {
System.out.println("\n\t\tREGISTRO DE FACTURACION\n");
if (totalFacturado == 0)
System.out.println("No se han registrado ventas.");
else {
System.out.println(facturacion.toString());
System.out.printf("Total facturado: %.2f\n", totalFacturado);









}
  }
  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("3 == Listar Inventario");
         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 3:
        listar();
        break;
         case 0:
            System.out.println("\nRegresando a menu principal...");
            break;
         default:
            System.out.println("Opcion equivocada");
         }
      }while(opcion != 0);

  }
  private static void gestionventas() {
      int opcion = 0;
      do {
         System.out.println("\n\t\tGESTION VENTAS\n");
         System.out.println("1 == Realizar una Venta");
         System.out.println("2 == Eliminar Venta");
         System.out.println("3 == Factura total");
         
         System.out.println("0 == Regresar Menu Principal");
         System.out.print("Opcion: ");
         
         opcion = Integer.parseInt(teclado.nextLine());
         
         switch(opcion) {
         case 1:
            venta();
            break;
         case 2:

       
        //Nose como hacer para que elimine un producto agregado
       
       
       
       
        break;
         case 3:
// Aqui quisiera que salga los datos del cliente y lo que ha agregado al carrito y le de el total de su compra
        facturacion();
        break;
         
         case 0:
            System.out.println("\nRegresando a menu principal...");
            break;
         default:
            System.out.println("Opcion equivocada");
         }
      }while(opcion != 0);

  }
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.");
}
}



private static void gestionClientes() {
int opcion = 0;
do {
System.out.println("\n\t\tProceso de Venta\n");
System.out.println("1 == Nuevo Cliente");
System.out.println("2 == Eliminar Cliente");
System.out.println("3 == Listar Clientes");
System.out.println("0 == Continuar");
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("Cedula: ");
int cedula = 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,cedula, 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:



break;
case 0:
System.out.println("\nContinuando a la venta.....");
break;
default:
System.out.println("Opcion equivocada");
}
}while(opcion != 0);
}

private static void gestionClientes2() {
int opcion = 0;
do {
System.out.println("\n\t\tGESTION DE CLIENTES\n");
System.out.println("1 == Agregar Nuevo Cliente");
System.out.println("2 == Eliminar Cliente");
System.out.println("3 == Mostrar Lista de Clientes");
System.out.println("0 == Regresar al 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("Cedula: ");
int cedula = 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,cedula, 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 al Menu Principal.....");
break;
default:
System.out.println("Opcion equivocada");
}
}while(opcion != 0);
}
}







hay algunas opciones vacias que en verdad nose como hacerlas

[Kabuto]

te iba a preguntar el porque utilizaste esto en el codigo de factuar

acturacion.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));

hablo de los %d y %s eso no sabia el porque

Esos  %d y %s son caracteres comodines que se pueden usar construir cadenas con String.format()  o también con System.out.printf().

Esos comodines se sustituyen por las variables que hay separadas con comas, a continuación de la cadena que vamos a imprimir. Es una forma más rápida y cómoda de concatenar varias cadenas con muchas variables.
Un %s indica que será sustituido por un String.
Un %d indica que será sustituido por un valor entero del sistema decimal (el que usamos habitualmente.
Un %f indica que se sustituye por un valor en coma flotante, ya sea un float o un double.

Esos comodines se sustituyen según el orden de las variables que vienen a continuación.
Aquí relaciono con colores cada comodín y la variable que le corresponde:

comprador.facturar(String.format("Codigo: %s Nombre: %s Unidades compradas: %d Importe: %.2f\n",
                     codigo, solicitado.getNombre(), unidades, facturar));

No solo es sustituir, sirve sobre todo para dar formato
Si digo %.2f, estoy pidiendo que el float/double que lo va a sustituir, se muestre con solo dos decimales.

Si digo %20s, estoy diciendo que esa cadena ha de ocupar mínimo 20 caracteres. Si la cadena fuera más corta, el resto de caracteres se rellenará con espacios en blanco hasta sumar 20.

Esto son solo algunos ejemplos. Tienes muchos más por aquí.


Esta opción:

                 
                  break;
               case 4:

                  //Aqui seria la suma de todas las ventas totales es decir de cliente por cliente porque si un cliente lleva dos cosas debe incluirse en una solo instancia ha alguna forma ?
                 
                 
                  break;

Ya está hecha, cada venta se acumula en el atributo totalFacturado

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;

                            //Dejamos constancia en la facturacion
                             
                            facturacion.append(String.format(" # ID. Cliente:%d \nCodigo: %s \nNombre: %s \nUnidades vendidas: %d \nImporte: %.2f\n",
                                  id, comprador.getNombres(), solicitado.getNombre(), unidades, facturar));
                            totalFacturado += facturar;
                            //Y también en la facturación personal del comprador

Sobre eliminar una venta ya hecha....
Olvídalo, al no poder usar ArrayList o bases de datos, nos vamos a encontrar con muchos límites.
Lo lógico sería tener una clase Venta, con algún identificador único para cada venta y poder añadir/eliminar de un ArrayList.

No tenemos nada de eso, las ventas las metemos en un StringBuilder para conseguir algo que se parezca mínimamente a un registro.
Se puede intentar complicarlo todo mucho más...., no se..., quizás haciendo que cada venta registrada, es decir, cada línea del StringBuilder comience por un número correlativo: el 1, el 2, el 3, el 4....
Y elegir que número de línea se quiere eliminar, y probar a ver si algún método de la clase StringBuilder o de la clase String permite eliminarla sin que afecte al resto de la cadena.

Aunque eso sería la menor de las complicaciones, porque luego habría que analizar esa línea que estamos eliminando para:
- identificar al cliente que hizo la compra y modificar su facturación personal.
- identificar el electrodoméstico comprado y corregir sus existencias, pues si se elimina la venta, las unidades vendidas vuelven a estar disponibles.
- identificar el importe que se pagó y restarlo del atributo totalFacturado.

Todo esto puede resultar más fácil con una clase Venta que pudiéramos guardar en ArrayList.
Pero mediante cadenas String..., el código se va a complicar muy innecesariamente..., cuando supongo que probablemente la intención principal del ejercicio, o una de las intenciones principales, es habituarse a manejar arreglos. Y no calentarse el cerebro en inventar formulas para poder usar cadenas String como si fueran registros.


Sobre simular un carrito de manera que en una venta el usuario pueda elegir varios productos para comprar a la vez.
De nuevo la cosa se puede complicar innecesariamente.
Habría que hacer un bucle que se repita hasta que el usuario diga si ha terminado de elegir productos.
En cada elección, pues quizás se pueda registrar esas elecciones como ventas, pero en una facturación "temporal", es decir, un StringBuilder que vaya creciendo con cada elección.
Lo mismo con el total facturado, usar una variable temporal para calcular el total de este proceso.

Cuando por fin diga que ha terminado de elegir productos, ahora sí lo que tenga ese StringBuilder temporal lo transferimos al StringBuilder de facturación de la empresa.
Y el importe total de esa venta, al atributo totalFacturado.
Y habrá que actualizar la facturación de ese cliente también con toda esa información.

Insisto en que al estar limitados con arreglos, también nos limita para muchos procesos. Y buscar la forma de saltar esos límites, puede ser más complicado de lo recomendable.

[THELUXENTON]

hola hice todas las correcciones  creo que ya mismo termino solo queria hacerte una pregunta

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
Codigo: TLV-2338 Nombre: Pentax Advance Unidades compradas: 3 Importe: 2687,66

crees que pueda sumar esos dos importes  y que me aparezca asi

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
Codigo: TLV-2338 Nombre: Pentax Advance Unidades compradas: 3 Importe: 2687,66

El total de lo importes es de :  5375.32

esto en la parte de Listar clientes