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

Hola.

Aquí te dejo un método para generar aleatorios entre dos valores, más un método main() para ponerlo a prueba.
El método recibe dos parámetros:
desde, valor inicial que queda excluido.
hasta, valor final que queda incluido.

Los valores han de pasarse en orden numérico, es decir, si un valor es negativo y el otro positivo, el negativo va primero (en el desde).

public class RandomNeg {

static int generaNumeros(int desde, int hasta) {
return (int)(Math.random()*(hasta-desde+1)+desde);
}

public static void main(String[] args) {
System.out.println("Generando 30 números desde -8 hasta 0...");
for (int i = 0; i < 30; i++)
System.out.println(generaNumeros(-8, 0));

System.out.println("\n----------------------------\n");

System.out.println("Generando 30 números desde -10 hasta 3...");
for (int i = 0; i < 30; i++)
System.out.println(generaNumeros(-10, 3));
}
}

Intento explicarte visualmente el problema.

Mira, este sería el array de Clientes nada más empezar el programa:

| null | null | null | null | null | null | null | null | null | null |

Son 10 posiciones que contienen objetos de la clase Cliente. Y como al principio estos objetos aún no han sido iniciados (todavía no has añadido Clientes) pues comienzan con valor null.

Para añadir Clientes hay que controlar en cual de las 10 posiciones (que van de 0 a 9) se va a registrar el nuevo Cliente. Para controlar esto, podemos usar una variable int que empiece con valor 0, ya que esa sería la primera posición disponible.

int pos = 0;

Bien, vamos a añadir el primer Cliente. Lo haremos donde nos diga la variable pos, es decir, en la posición 0.

clientes[pos] = new Cliente("Cliente_00");
| Cliente _00| null | null | null | null | null | null | null | null | null |

Al añadir un cliente, incrementamos la variable pos:
pos++;
Ahora pos tiene valor 1. De este modo, pos sirve para decirnos cuantos clientes tenemos registrados (ahora mismo solo 1) y también sirve para que el programa sepa en que posición ha de registrar el próximo cliente (en la posición 1 del array).

Guau, aparentemente usando esta lógica, todo es perfecto. Sigamos añadiendo Clientes, vamos a añadir tres clientes más...

| Cliente_00 | Cliente_01 | Cliente_02 | Cliente_03 | null | null | null | null | null | null |

Tras añadir tres clientes, ahora pos tendría valor 4. Es decir, tenemos 4 clientes y el próximo se ha de añadir en la posición 4.
Todo funciona de maravilla.

Pero ahora vamos a "borrar" un cliente.
Si nos piden borrar Cliente_03, no habrá problema. En su posición actual establecemos valor null y a la variable pos le restamos -1.
Para averiguar donde está el cliente llamado "CLiente_03", usamos un bucle


int buscar = 0;
for (int j = 0; j < clientes.length; j++) {
    if (clientes[j].getNombre().equals("Cliente_03"))
        buscar = j; //Si el nombre coincide, hemos encontrado la posición donde hay que borrar
}
clientes[buscar] = null;
pos--;
| Cliente_00 | Cliente_01 | Cliente_02 | null | null | null | null | null | null | null |

Todo queda guay. Variable pos ahora tiene valor 3, porque tenemos 3 Clientes y si añadimos un cliente,  ha de ir en la posición 3.
Sin problemas....

Volvamos al array con todos los clientes:
| Cliente_00 | Cliente_01 | Cliente_02 | Cliente_03 | null | null | null | null | null | null |
Recordamos, aquí pos tiene valor 4

¿Y si el cliente que quieren borrar es Cliente_01?
Bueno, hacemos como antes, ¿no? Buscamos su posición, ponemos valor null y restamos -1 a pos

| Cliente_00 | null | Cliente_02 | Cliente_03 | null | null | null | null | null | null |

Ahora pos tiene valor 3, porque tenemos tres clientes. Pero, aquí es donde viene el problema, si queremos insertar un nuevo cliente, pos dice que ha de ir en la posicion 3
Ouch..!! 

Eso no puede ser, en la posición 3 tenemos a Cliente_03. Si añadimos un nuevo cliente, debería entrar en la posición 1, donde tenemos el valor null del cliente anterior que hemos borrado.
O en todo caso en la posición 4 que está libre....

¿Ves el problema que conlleva usar arrays? Para hacer algo como añadir y "borrar" clientes, hay que buscar una fórmula para saber bien en que posiciones se puede grabar un nuevo cliente.

Usar una variable como estaba haciendo ahora para contar los clientes que se añaden y borran, puede servir, pero tiene el inconveniente de que si se borra un cliente que no es el último existente en el array, ya no sabrá indicarnos la posición correcta donde se ha de guardar.

Esto se puede solventar de distintas formas.
Una forma sería reordenar todos los elementos cada vez que nos pidan borrar un cliente, de forma que los elementos null siempre queden al final.
Así la variable que usemos para contar, siempre apuntará a la primera posición disponible

Otra forma sería no guiarnos por esta variable para añadir clientes, sino que antes de añadir buscamos en el array la primera posición que sea null, y ahí metemos al cliente.

for (int j = 0; j < clientes.length; j++) {
    if (clientes[j] == null)
        clientes[j] = new Cliente("Fulanito");
}

Esta forma es quizás más fácil, pero hay que contemplar la posibilidad de que pasa si ya no quedan posiciones null disponibles porque el array ya está lleno.
Para esto lo más fácil es de nuevo usar una variable contador como hacíamos al principio, solo que esta variable no la usaremos para decidir en que posiciones se guardan clientes.
Solo servirá para saber de formar rápida cuantos clientes tenemos en todo momento.
Porque si resulta que ya tenemos los 10 clientes, no vamos a perder el tiempo en buscar posiciones null, porque no las hay.

if (cuentaClientes == 10)
    System.out.println("No caben más clientes, hay que borrar para poder añadir otro cliente");
else {
    for (int j = 0; j < clientes.length; j++) {
        if (clientes[j] == null)
            clientes[j] = new Cliente("Fulanito");
    }
    cuentaClientes++;  //Aumenta porque hemos añadido nuevo Cliente
}


Perdón si la explicación es demasiado extensa. Espero que se haya entendido.

Intenta tú ahora escribir el código final según tu programa actual. Si no lo consigues, intentaremos ayudarte.
Un saludo.

Hola.

La clase Integer tiene varios métodos estáticos, es decir, métodos que se pueden invocar sin necesidad de crear previamente un objeto de dicha clase.

Uno de ellos es el método parseInt() el cuál recibe como argumento un String y lo parsea (convierte, transforma... llámalo como quieras) a un valor int, si es que es posible.

Invocando este método te ahorras el tener que crear un objeto Integer previamente.
public class ejemplo1 {
public static void main(String[] Args) {
String entradaUsuario = JOptionPane.showInputDialog("Introduzca un número:");
System.out.println("El doble del número introducido es: " + 2 * Integer.parseInt(entradaUsuario) );
}
}

Hola.
Que raro, yo también uso Brackets para hacer mis tonterías en HMTL y JS. Y no tengo ese problema.

¿Donde tienes puesto el alert()? ¿El documento está guardado como .html o . js?

¿Puedes pegar aquí el código donde lo tienes puesto?

Vale.

Notepad++ es solo para Windows. No hay versión Mac que yo sepa.

Pero tienes otras muchas alternativas. Una que me gusta mucho, y que yo también uso en Windows es Brackets: http://brackets.io

Cuando te acostumbras a sus funcionalidades (y eso que yo le doy un uso básico) es toda una gozada

 Hola.
No se que enlace estarás usando, pero desde este no deberías tener problema:
https://www.oracle.com/technetwork/java/javase/downloads/jdk12-downloads-5295953.html

Al entrar en esa página, abajo has de marcar la opción "Accept License Agreement" y luego elegir la versión acorde a tu sistema operativo.

Continuamos.

Ya tenemos las clases, ahora hay que crear el programa principal.
El programa tendrá dos tareas.
La primera, crear automáticamente objetos PERSONA, EMPLEADO, FACTURA, PRODUCTO...

Dichos objetos los guardaremos en alguna colección de datos dinámica, por ejemplo en ArrayList.
Para crear esos objetos, haremos varias funciones donde crearemos objetos de cada clase y las añadiremos a los ArrayList.
Lo primero que hará nuestro main() será llamar a estas funciones para que vayan llenando los ArrayList con datos.

Terminado esto, pasamos a la segunda tarea, que es simplemente mostrar un menú al usuario dentro de un bucle para que elija las opciones que quiera hasta que decida terminar el programa.
El menú tiene que ofrecer consultar EMPLEADOS, PERSONAS(Clientes), y PRODUCTOS
Yo simplemente lo que hago es recorrer el ArrayList correspondiente y mostrar los datos de los objetos que contiene. Gracias a que a cada clase le hemos creado un método toString(), ahora nos va a bastar con un par de líneas de código para cada opción.

Hay otra opción más que ofrecer, que es la de mostrar FACTURAS según la PERSONA/Cliente.
Yo lo que hago es pedir al usuario un número de cédula. Compruebo en el ArrayList si existe una PERSONA con esa cédula.
Si existe, uso esa PERSONA para consultar el ArrayList de FACTURAS. A cada una de ellas le pido que me devuelva la PERSONA asociada y la comparo con la PERSONA que me ha indicado el usuario. Si coinciden (método equals() facilita esta comparación) mando imprimir en pantalla los datos de esa FACTURA y paso a la siguiente.

Y ya está, creo que no es difícil de entender. Aquí dejo mi código y cualquier duda, tan solo tienes que preguntarla.
Un saludo.

public class GestionRestaurante {

static ArrayList<Empleado> empleados = new ArrayList<Empleado>();
static ArrayList<Persona> clientes = new ArrayList<Persona>();
static ArrayList<Producto> productos = new ArrayList<Producto>();
static ArrayList<Factura> facturas = new ArrayList<Factura>();

public static void main(String[] args) {
//Inicializamos datos
crearEmpleados();
crearClientes();
crearProductos();
crearFacturas();
//Comienza el menú principal
Scanner teclado = new Scanner(System.in);
int opcion = 0;
while (opcion != 5) {
System.out.println("\n\t\tOPCIONES");
System.out.println("(1) Consultar Empleados");
System.out.println("(2) Consultar Productos");
System.out.println("(3) Consultar Clientes");
System.out.println("(4) Consultar Facturas por Cliente");
System.out.println("(5) TERMINAR PROGRAMA");
System.out.print("Seleccione opción (1-5): ");
opcion = Integer.parseInt(teclado.nextLine());
switch(opcion) {
case 1:
System.out.println("\n\t\tCONSULTAR EMPLEADOS");
for (Empleado emp: empleados) {
if (emp instanceof Chef)
System.out.println("\nTipo empleado: Chef");
else
System.out.println("\nTipo empleado: Mesero");
System.out.println(emp);
}
break;
case 2:
System.out.println("\n\t\tCONSULTAR PRODUCTOS");
for (Producto prod: productos)
System.out.println("\n" + prod);
break;
case 3:
System.out.println("\n\t\tCONSULTAR CLIENTES");
for (Persona cli: clientes)
System.out.println("\n" + cli);
break;
case 4:
System.out.println("\n\t\tCONSULTAR FACTURAS POR CLIENTE");
System.out.print("\nIndique cédula de cliente: ");
String cedula = teclado.nextLine();
//Buscamos cliente a ver si existe
Persona cliente = null;
for (Persona cli: clientes)
if (cli.getCedula().equals(cedula))
cliente = cli; //Encontrado, lo referenciamos en la variable cliente
//Comprobamos si lo hemos encontrado
if (cliente == null)
System.out.println("No se encontro cliente con cédula: " + cedula);
else {
//Mostramos facturas de esta Persona cliente
System.out.println("\n\tFacturas asociadas al Cliente:");
for (Factura fac: facturas) {
if (fac.getCliente().equals(cliente))
System.out.println(fac);
}
}
break;
case 5:
System.out.println("\n\n\t\tFIN DE PROGRAMA");
break;
default:
System.out.println("\nOpción equivocada, elija entre 1-5");
}
}

teclado.close();

}

static void crearEmpleados() {
empleados.add(new Mesero("CED00", "Ramón", "Espinosa", 850));
empleados.add(new Mesero("CED01", "Susana", "López", 850));
empleados.add(new Chef("CED02", "Carlos", "Santana", 975));
empleados.add(new Chef("CED03", "María", "Reina", 975));
}

static void crearClientes() {
clientes.add(new Persona("CED04", "Federico", "fede@gmail.com"));
clientes.add(new Persona("CED05", "Cristina", "cristi@gmail.com"));
clientes.add(new Persona("CED06", "Raul", "raul@gmail.com"));
}

static void crearProductos() {
productos.add(new Producto("COD000", "Raviolis", "Ravioli, Ternera, Tomate, Salsa Queso",
"Nata", "Italia"));
productos.add(new Producto("COD010", "Pelmeni", "Carne Pollo, Sal, Harina, Aceite Oliva, Huevo",
"Cebolla picada", "Rusia"));
productos.add(new Producto("COD020", "Udon", "Fideos, Aceite, Ajo, Jengibre, Brócoli, Soja",
"Setas Shiitake", "Japón"));
productos.add(new Producto("COD030", "Paella", "Arroz, Gambas, Mejillones, Calamares, Ajo",
"Azafrán", "España"));
//Seteamos el Chef creador para cada producto
productos.get(0).setChefCreador((Chef)empleados.get(2));
productos.get(1).setChefCreador((Chef)empleados.get(3));
productos.get(2).setChefCreador((Chef)empleados.get(2));
productos.get(3).setChefCreador((Chef)empleados.get(3));
}

static void crearFacturas() {
facturas.add(new Factura("FAC000", "07/08/2019", "Efectivo", clientes.get(0), (Mesero)empleados.get(1),
new Detalle(2, productos.get(2))));
facturas.add(new Factura("FAC001", "06/08/2019", "Tarjeta VISA", clientes.get(1), (Mesero)empleados.get(1),
new Detalle(3, productos.get(1))));
facturas.add(new Factura("FAC002", "05/08/2019", "Efectivo", clientes.get(0), (Mesero)empleados.get(0),
new Detalle(4, productos.get(0))));
facturas.add(new Factura("FAC003", "07/08/2019", "PayPal", clientes.get(2), (Mesero)empleados.get(0),
new Detalle(1, productos.get(0))));
facturas.add(new Factura("FAC004", "05/08/2019", "Efectivo", clientes.get(1), (Mesero)empleados.get(1),
new Detalle(3, productos.get(1))));
facturas.add(new Factura("FAC005", "04/08/2019", "PayPal", clientes.get(0), (Mesero)empleados.get(0),
new Detalle(2, productos.get(2))));
facturas.add(new Factura("FAC006", "05/08/2019", "Tarjeta VISA", clientes.get(1), (Mesero)empleados.get(0),
new Detalle(4, productos.get(1))));
facturas.add(new Factura("FAC007", "03/08/2019", "Efectivo", clientes.get(2), (Mesero)empleados.get(1),
new Detalle(2, productos.get(2))));
facturas.add(new Factura("FAC008", "04/08/2019", "Tarjeta VISA", clientes.get(0), (Mesero)empleados.get(0),
new Detalle(3, productos.get(1))));
}

}

En absoluto soy un experto, así que lo único que puedo darte es mi opinión.

Yo creo que no hay que imponerse unas reglas estrictas ni obsesionarse con aplicar la fórmula supuestamente correcta.

Yo también aprendí separando claramente. Hablo de separación totalmente estricta, creaba tres clases (tres archivos .java) llamadas Vista (donde se creaba la GUI), Modelo (donde se tenían los datos, ArrayLists, etc..) y Controlador(hacia de nexo entre las otras dos), más las clases necesarias para crear el resto del programa.
Tenía sus ventajas, pero en general, esa separación tan "excesiva" provocaba escribir muchos más métodos, muchos de los cuáles lo único que hacían era llamar a otro método equivalente declarado en otra clase.
A veces ocurría que la Vista pedía al Controlador, que llamase a un método del Modelo, el cuál a su vez lo que hacía era pedirle al Controlador que llamase a otro método de la Vista...demasiados pasos intermedios...

Con el tiempo fui prescindiendo de esta separación tan estricta ya que no era realmente necesaria para seguir aplicando el patrón MVC, incluso en una única clase se puede aplicar este patrón.
Cada programa es distinto y en cada uno de ellos veía que podía ser más o menos laxo con este patrón, si con ello conseguía que el programa fuese más eficiente e incluso más entendible al leer el código.

En definitiva, si te encuentras casos en los que ganas en eficiencia sin por ello perder eficacia (eficacia y eficiencia son cosas distintas) permitiendo que la Vista y Modelo se mezclen un poquito, pues no pasa nada.

De todos modos, conceptualmente hablando, da igual si Vista y Modelo están estrictamente separados o están totalmente mezclados.
La Vista siempre será lo que el usuario puede ver, la "fachada" del programa.
Y el Modelo siempre será lo que el usuario no puede ver, lo que ocurre internamente "entre bambalinas".

Hola y bienvenido.

El primer consejo para aprender a programar, es tener paciencia para el aprendizaje.
El segundo consejo, el mismo, paciencia...

Insisto en la paciencia porque empezar desde cero en la programación puede ser un poco desesperante. Hay que empezar desde el principio, desde lo más básico... entonces uno puede impacientarse y sentirse frustrado al ver las aplicaciones que se hacen para web, para móviles.... y uno va a estar durante bastante tiempo haciendo cosas muy simples como pedir un número y decir si es primo o no, y cosas así...

Por eso es necesaria la paciencia, el inicio es lento, pero luego la cosa se va acelerando y cada vez se asimilan mejor todos los nuevos conceptos que hay que aprender.

Echa un vistazo a los cursos disponibles


Sobre que lenguaje elegir para empezar.
Lo primero es entender que una cosa es aprender a programar, y otra cosa es aprender un lenguaje.
Son cosas distintas pero que se pueden hacer simultáneamente.

Los fundamentos de la programación son comunes a todos los lenguajes. Todos tienen variables, operadores matemáticos, operadores de comparación, bucles, funciones...
Luego cada lenguaje los implementa a su manera y con sus propias "palabras", pero los fundamentos son los mismos.

Así que lo ideal es empezar con pseudocódigo. Esto no es un lenguaje real de programación, simula ser un lenguaje pero usando palabras "humanas" y simplificándolo todo para que el aprendiz pueda centrarse en aprender programación, sin tener que lidiar las reglas de cada lenguaje.
El pseudocódigo no se compila, no te da un programa real (aunque hay interpretes como PseInt, es algo que escribes en un papel o en un documento de texto plano para simular un programa.

Por ejemplo, queremos hacer un programa que pida la edad por pantalla y diga si el usuario es mayor o menor de edad:
ESCRIBIR "Dime tu edad: "
LEER edad
SI edad < 18 ENTONCES
    ESCRIBIR "Eres menor de edad"
SI NO
    ESCRIBIR "Eres mayor de edad"
Esto es fácil de escribir y de entender. Sin complicaciones ninguna propias de cada lenguaje.
En pocas líneas vemos un ejemplo de mostrar un texto en pantalla, leer un dato en una variable y hacer una toma de decisiones al comparar esa variable con un determinado valor.

Si queremos hacer eso mismo pero en un lenguaje real, por ejemplo Java:

import java.util.Scanner;

public class PedirEdad {

   public void main(String[] args) {
       
        Scanner leerTeclado = new Scanner(System.in);
        System.out.print("Dime tu edad: );
        int edad = leerTeclado.nextInt();
       
        if (edad < 18)
                System.out.println("Eres menor de edad");
        else
                System.out.println("Eres mayor de edad");

        leerTeclado.close();
   }
}
Como ves, en realidad es muy similar, pero se añaden un montón de palabras reservadas y reglas de tipado y de puntuación propias del lenguaje, en este caso Java, que pueden hacer que el aprendiz tenga que invertir más esfuerzo en aprender el lenguaje en lugar de aprender a programar, que es lo primordial.


Por eso es recomendable empezar con pseudocódigo, aunque no sea un lenguaje real, sino un mero ejercicio.

Aunque eso no quita que no se pueda hacer simultáneamente. Una vez en pseudocódigo se ha aprendido a utilizar un nuevo concepto, por ejemplo usar bucles, pues luego se puede mirar de aprender como aplicarlo en un lenguaje "real".

Sobre por cuál lenguaje "real" empezar. En principio sirve cualquiera.
Yo suelo recomendar Java, quizás en parte por cariño al lenguaje  , pero también pienso que tiene características que hacen que sea cómodo aprender con él.
Tiene una serie de librerías oficiales predefinidas, así que todo el mundo usa las mismas instrucciones.
Esto en otros lenguajes no siempre es así, como por ejemplo C/C++ cuyas instrucciones básicas sí son comunes pero luego otras más avanzadas depende de las librerías que tenga cada compilador.

Además en Java hay toneladas de documentación en la red, tanto artículos escritos como vídeos YouTube, y siempre encuentras a alguien que lo conozca y te pueda ayudar con dudas.

Y hablamos de un lenguaje que sigue plenamente vigente y que será la base para que más adelante aprender a programar para Android.

Buenas noches @EsoJ, estuve utilizando el programa echo por ti.
Cuando registras un alumno,  La hora que pones el nombre, añadiendo espacios salta las lecturas del teclado. Eso porque seria?

Porque está usando el método next() para leer los datos, método que solo acepta una palabra.

Para leer más de una palabra hay que usar el método nextLine().

Aún así, esto supondrá otros problemas, porque si previamente se ha leido algún dato numérico con nextInt(), nextDouble() o similar....el próximo nextLine() no funcionará y el programa se lo saltará.

Mi consejo para evitar estos problemas es leer los datos por teclado siempre con el método nextLine().

Ejemplo:
System.out.println("Introduce nombre y apellidos:")
String datos = entradaTeclado.nextLine();
Y si lo que necesitamos son datos numéricos, también usamos nextLine(), pero parseando el valor leído al tipo de dato que necesitemos.

Ejemplos:
System.out.println("Introduce edad:")
int edad = Integer.parseInt(entradaTeclado.nextLine());
System.out.println("Introduce temperatura:")
double tempe= Double.parseDouble(entradaTeclado.nextLine());

De este modo, se evitan problemas inherentes al funcionamiento interno de la clase Scanner.