Java - Programa de login, en cosola. AYUDA!

 
Vista:
sin imagen de perfil

Programa de login, en cosola. AYUDA!

Publicado por anonymous (2 intervenciones) el 16/04/2020 18:54:14
Tengo que hacer este programa pero no tengo idea, el profesor nos da por vistos varios temas.
Por favor si alguien me puede ayudar a resolverlo. Nos dijo que solo lo hiciéramos para consola en este momento y que utilizaramos Herencia y Arraylist para almacenar a los usuarios.

Tener dos tipos de usuarios: Administrador y cliente, cada uno deberá conocer
su clave para poder acceder al sistema y cada usuario tendrá un menú con opciones
disponibles a elegir.

El administrador en el sistema podrá:
Dar de alta productos y categorías de productos.
Dar de alta clientes nuevos.
Consultar las ventas por periodos (puede ser por rango de fechas).

El cliente en el sistema podrá:
Visualizar un catálogo de productos.
Realizar compras de diversos productos.
Consultar las compras que ha realizado
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
-1
Responder

Programa de login, en cosola. AYUDA!

Publicado por Nucho Gonzalez (53 intervenciones) el 16/04/2020 18:59:51
amigo hay varios tutoriales en youtube para hacer eso, tambien en internet, solo es cuestion de investigar!!!

MOLESTA LA GENTE QUE ENTRA SOLO PARA CONSEGUIR CODIGO PARA SU TAREA DE PREPARATORIA! Estudie hermano no sea ARAGAN, investigue!!!!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
-1
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Programa de login, en cosola. AYUDA!

Publicado por Kabuto (1381 intervenciones) el 16/04/2020 23:14:08
No pienses en como resolver TODO el ejercicio.
Piensa en ir resolviéndolo en pequeñas dosis, planteándote objetivos menores.

Olvida de momento lo de los menús, ventas, catálogo de productos....

Intenta hacer un programa que al loguearse un usuario, salga un mensaje en pantalla diciendo: "Eres Administrador" o "Eres Cliente" según el tipo de usuario que se haya logueado.

Para esto previamente hay que pensar que clases se van a necesitar, y parece evidente que se va a necesitar una clase Usuario, que quizás podría ser abstracta, y que tendría los atributos (un ID único, nombre y clave de acceso) y métodos comunes (set y get para nombre, clave..)

De esta clase Usuario, serán herederas las clases Administrador y Cliente.

De ese modo, aun siendo clases distintas, al ser hijas de Usuario, pueden estas todas juntas en un ArrayList<Usuario> (gracias al polimorfismo).
Una vez conseguido eso, se puede pasar a un siguiente objetivo que ya se verá.

Pero por ahora intenta escribir al menos esas tres clases Usuario, Administrador y Cliente.

DA igual si te salen mal o bien, desde aquí te ayudaremos a completar lo que falte o corregir lo que no sea correcto.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
2
Comentar
sin imagen de perfil

Programa de login, en cosola. AYUDA!

Publicado por anonymous (2 intervenciones) el 17/04/2020 00:31:06
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public class Main {
 
	public static void main(String[] args) {
		Administrador a=new Administrador ();
		a.IniciarSesion();
		Cliente c=new Cliente ();
		c.IniciarSesion();
 
	}
}
 
 
 
import java.util.Scanner;
 
public abstract class Usuario {
	public String Nombre;
	public String Apellido;
	public String Email;
	public String Tel;
	public String PassUsuario;
	public String IdUsuario;
 
	Scanner sc = new Scanner(System.in);
 
	public void IniciarSesion() {
 
	System.out.println("Ingresa tu ID de usuario:");
	IdUsuario = sc.nextLine();
	System.out.println("Ingresa tu Contraseña:");
	PassUsuario = sc.nextLine();
 
		if(IdUsuario.equals("LH01") && PassUsuario.equals("ABC123")){
			System.out.println("Inicio de sesión ACEPTADO");
 
		}
		else {
			System.out.println("ERROR AL INICIAR SESIÓN");
		}
	}
 
}
 
 
 
 
public class Administrador extends Usuario{
 
}
 
 
 
 
public class Cliente extends Usuario{
 
}

**Algo así?**
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Programa de login, en cosola. AYUDA!

Publicado por Kabuto (1381 intervenciones) el 18/04/2020 02:06:07
Mmmhh.. no exactamente.
Las entidades que intervienen: Usuario, Administrador, Cliente, Producto... deben modelar únicamente lo referente a ellos mismos.
Estas clases no deberían incorporar menú de opciones ni otras cosas ajenas. Sera otra clase distinta, ya sea la clase main o una clase específica de "gestión", quien pregunte datos de login, datos para registrar, etc..

La clase Usuario podría ser como la que pongo a continuación. Modela todos los atributos y métodos comunes a todos los usuarios: id, clave, nombre, etc..
Así como sus getter y setter. No he puesto setter para el ID usuario, ya que este atributo no debería poder ser modificado bajo ninguna circunstancia. Es el identificador único y principal para cada Usuario.

Además, para que sea un poco más completa, tiene sobreescrito el método equals().
Este método sirve para enseñarle a esta clase como determinar si un objeto es igual, equivalente mejor dicho, a otro objeto con el que se pueda comparar.

Como se supone que en un sistema no pueden existir dos usuarios con el mismo ID, podemos enseñarle a que considere que dos objetos Usuario con el mismo ID (aunque clave, nombre, etc.. sean distintos) son equivalentes.

Esto luego nos ayudará a evitar de forma sencilla que en el ArrayList tengamos objetos Usuario con el mismo ID.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
public abstract class Usuario {
 
	private String IDusuario;
	private String passUsuario;
	private String nombre;
	private String Email;
	private String telef;
 
	//Constructor con los datos mínimos para registrar un usuario
	public Usuario(String ID, String pass) {
		IDusuario = ID;
		passUsuario = pass;
	}
 
	//Constructor con todos
	public Usuario(String ID, String pass, String nombre, String Email, String telef) {
		IDusuario = ID;
		passUsuario = pass;
		this.nombre = nombre;
		this.Email = Email;
		this.telef = telef;
	}
 
	public String getID() {
		return IDusuario;
	}
 
	public String getPass() {
		return passUsuario;
	}
 
	public void setPass(String passUsuario) {
		this.passUsuario = passUsuario;
	}
 
	public String getNombre() {
		return nombre;
	}
 
	public void setNombre(String nombre) {
		this.nombre = nombre;
	}
 
	public String getEmail() {
		return Email;
	}
 
	public void setEmail(String Email) {
		this.Email = Email;
	}
 
	public String getTelef() {
		return telef;
	}
 
	public void setTelef(String telef) {
		this.telef = telef;
	}
 
	@Override
	public boolean equals(Object obj) {
		if (obj instanceof Usuario) {
			Usuario otroUsuario = (Usuario) obj; //Dos usuarios son "iguales" si tienen el mismo ID
			return IDusuario.equals(otroUsuario.IDusuario);
		}
		else
			return false;
	}
 
}

La siguiente clase sería Administrador, que básicamente lo único que hace es heredar de Usuario. No tiene ninguna otra diferencia, en cuanto atributos o métodos.
Sí es importante que tenga constructores equivalentes a los de su superclase madre, como mínimo uno de ellos, aunque yo prefiero poner los dos.
1
2
3
4
5
6
7
8
9
10
11
public class Administrador extends Usuario{
 
	public Administrador(String ID, String pass) {
		super(ID, pass);
	}
 
	public Administrador(String ID, String pass, String nombre, String Email, String telef) {
		super(ID, pass, nombre, Email, telef);
	}
 
}

Ahora la clase Cliente. Tampoco conlleva ninguna diferencia, pero para hacerlo más interesante, le he añadido un atributo exclusivo para los Usuarios Cliente, que no tendrán los Usuario Administrador.
Este atributo representaría una tarjeta bancaria asociada con la que el Cliente hace sus compras. Esto conlleva nuevo getter y setter y un constructor un poco distinto.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Cliente extends Usuario{
 
	private String tarjetaCompra;
 
	public Cliente(String ID, String pass) {
		super(ID, pass);
	}
 
	public Cliente(String ID, String pass, String nombre, String Email, String telef, String tarjeta) {
		super(ID, pass, nombre, Email, telef);
		tarjetaCompra = tarjeta;
	}
 
	public String getTarjetaCompra() {
		return tarjetaCompra;
	}
 
	public void setTarjetaCompra(String tarjetaCompra) {
		this.tarjetaCompra = tarjetaCompra;
	}
 
}

Como ves, ninguna de estas clases piden datos, comprueban login, ni nada. Solo modelan la entidad a la que representan.

Toda la gestión relativa a pedir datos, elegir que menú de opciones mostrar según el tipo de usuario, etc... la podemos hacer en la clase principal main.
Aquí tendremos, de momento, un ArrayList de Usuarios y un objeto Scanner para pedir datos.
Dispondrá de varios métodos para cada menú y posible opción.
De momento solo he puesto los menús para el Administrador, que solo funcionan las opciones de registrar un nuevo Administrador o un nuevo Cliente...., y el menú para el Cliente, que no funciona ninguna de sus opciones.

Cuando se inicia el programa, ocurre algo. No hay usuarios registrados, no tiene sentido que pidamos datos de login, porque no hay nadie registrado.
Lo que hecho es que nada comenzar, solicite el registro de un Administrador.
Luego, ya sí se inicia el menú principal de Login.
Este menú se repetirá hasta que el usuario decida terminar el programa.
La primera vez podrá loguearse el Administrador que hemos registrado al principio, quien verá su menú correspondiente y podrá registrar nuevos usuarios de ambas clases.
Tendrá opción para finalizar sesión y si no cierra el programa, se volverán a pedir datos para un nuevo login.

Aquí el código:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
public class Main{
 
	private static ArrayList<Usuario> usuarios;
	private static Scanner teclado;
 
	public static void main(String[] args) {
		usuarios = new ArrayList<Usuario>();
		teclado = new Scanner(System.in);
		System.out.println("No hay usuarios registrados."
				+ "\nSe ha de registrar al menos un Administrador antes de continuar...");
		registrarAdmin();
		menuLogIn();
	}
 
	private static void menuLogIn() {
		do {
			Usuario userActivo = null;
			System.out.println("\n\tLogin Usuario");
			System.out.println("\t----- -------\n");
			System.out.print("ID usuario: ");
			String id = teclado.nextLine();
			System.out.print("Clave: ");
			String pass = teclado.nextLine();
 
			for (Usuario usr: usuarios) {
				if (usr.getID().equals(id) && usr.getPass().equals(pass)) {
					userActivo = usr;
					break;
				}
			}
 
			if (userActivo == null) //No se ha encontrado ningún usuario con esos datos
				System.out.println("Error en ID Usuario o clave de acceso");
			else {
 
				if (userActivo instanceof Administrador)
					while(menuAdministrador()); //Esto repite su menú hasta que escoja finalizar sesion
				else
					while(menuCliente()); //Si no es Administrador, es un Cliente
 
				System.out.println("\nSesión finalizada.");
			}
 
			System.out.print("¿Desea cerrar el programa?[s/n]:");
 
		}while (teclado.nextLine().toLowerCase().equals("n"));
 
		System.out.println("\n\n\t\t--FIN DEL PROGRAMA--");
	}
 
	private static boolean menuAdministrador() {
		System.out.println("\n\tMenú Administrador");
		System.out.println("\t---- -------------\n");
		System.out.println("[1] -- Registrar Administrador");
		System.out.println("[2] -- Registrar Cliente");
		System.out.println("[3] -- Nueva Categoría de Producto");
		System.out.println("[4] -- Nuevo Producto");
		System.out.println("[5] -- Consultar Ventas por Fechas");
		System.out.println("\n[0] -- FINALIZAR SESIÓN");
		int opc = teclado.nextLine().charAt(0);
		switch(opc) {
		case '0':
			return false; //Fin de este método, sesión termina
		case '1':
			registrarAdmin();
			break;
		case '2':
			registrarCliente();
			break;
		case '3':
			System.out.println("\n...OPCIÓN EN CONSTRUCCIÓN...");
			break;
		case '4':
			System.out.println("\n...OPCIÓN EN CONSTRUCCIÓN...");
			break;
		case '5':
			System.out.println("\n...OPCIÓN EN CONSTRUCCIÓN...");
			break;
		default:
			System.out.println("\nOpción no válida.");
		}
 
		System.out.println("\nPulse ENTER para continuar...");
		teclado.nextLine();
		return true; //Fin de este método, menú sigue ejecutándose
	}
 
	private static boolean menuCliente() {
		System.out.println("\n\tMenú Cliente");
		System.out.println("\t---- -------\n");
		System.out.println("[1] -- Ver catálogo de Productos");
		System.out.println("[2] -- Comprar Productos");
		System.out.println("[3] -- Consultar Mis Compras");
		System.out.println("\n[0] -- FINALIZAR SESIÓN");
		int opc = teclado.nextLine().charAt(0);
		switch(opc) {
		case '0':
			return false;
		case '1':
			System.out.println("\n...OPCIÓN EN CONSTRUCCIÓN...");
			break;
		case '2':
			System.out.println("\n...OPCIÓN EN CONSTRUCCIÓN...");
			break;
		case '3':
			System.out.println("\n...OPCIÓN EN CONSTRUCCIÓN...");
			break;
		default:
			System.out.println("\nOpción no válida.");
		}
 
		System.out.println("\nPulse ENTER para continuar...");
		teclado.nextLine();
		return true;
	}
 
	private static void registrarAdmin() {
		System.out.println("\n\tRegistro Administrador");
		System.out.println("\t-------- -------------\n");
		System.out.print("ID Usuario: ");
		String id = teclado.nextLine();
		System.out.print("Clave Usuario: ");
		String pass = teclado.nextLine();
		System.out.print("Nombre: ");
		String nombre = teclado.nextLine();
		System.out.print("E-Mail: ");
		String email = teclado.nextLine();
		System.out.print("Teléfono: ");
		String telef = teclado.nextLine();
 
		Administrador admin = new Administrador(id, pass, nombre, email, telef);
 
		if (usuarios.contains(admin))
			System.out.println("Usuario rechazado. Ya existe otro con el ID: " + id);
		else {
			usuarios.add(admin);
			System.out.println("Usuario registrado.");
		}
	}
 
	private static void registrarCliente() {
		System.out.println("\n\tRegistrar Cliente");
		System.out.println("\t--------- -------\n");
		System.out.print("ID Usuario: ");
		String id = teclado.nextLine();
		System.out.print("Clave Usuario: ");
		String pass = teclado.nextLine();
		System.out.print("Nombre: ");
		String nombre = teclado.nextLine();
		System.out.print("E-Mail: ");
		String email = teclado.nextLine();
		System.out.print("Teléfono: ");
		String telef = teclado.nextLine();
		System.out.print("Tarjeta compra asociada: ");
		String tarjeta = teclado.nextLine();
 
		Cliente cliente = new Cliente(id, pass, nombre, email, telef, tarjeta);
 
		if (usuarios.contains(cliente))
			System.out.println("Usuario rechazado. Ya existe otro con el ID: " + id);
		else {
			usuarios.add(cliente);
			System.out.println("Usuario registrado.");
		}
	}
 
}

Y esto un ejemplo de su ejecución en pantalla:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
No hay usuarios registrados.
Se ha de registrar al menos un Administrador antes de continuar...
 
	Registro Administrador
	-------- -------------
 
ID Usuario: Kabuto
Clave Usuario: Kabuto
Nombre: KAbuto
E-Mail: kabu@to
Teléfono: 44444
Usuario registrado.
 
	Login Usuario
	----- -------
 
ID usuario: Kabuto
Clave: Kabuto
 
	Menú Administrador
	---- -------------
 
[1] -- Registrar Administrador
[2] -- Registrar Cliente
[3] -- Nueva Categoría de Producto
[4] -- Nuevo Producto
[5] -- Consultar Ventas por Fechas
 
[0] -- FINALIZAR SESIÓN
2
 
	Registrar Cliente
	--------- -------
 
ID Usuario: user
Clave Usuario: user
Nombre: lucas
E-Mail: lucas@com
Teléfono: 5465
Tarjeta compra asociada: VISA-213121
Usuario registrado.
 
Pulse ENTER para continuar...
 
 
	Menú Administrador
	---- -------------
 
[1] -- Registrar Administrador
[2] -- Registrar Cliente
[3] -- Nueva Categoría de Producto
[4] -- Nuevo Producto
[5] -- Consultar Ventas por Fechas
 
[0] -- FINALIZAR SESIÓN
0
 
Sesión finalizada.
¿Desea cerrar el programa?[s/n]:n
 
	Login Usuario
	----- -------
 
ID usuario: user
Clave: user
 
	Menú Cliente
	---- -------
 
[1] -- Ver catálogo de Productos
[2] -- Comprar Productos
[3] -- Consultar Mis Compras
 
[0] -- FINALIZAR SESIÓN
2
 
...OPCIÓN EN CONSTRUCCIÓN...
 
Pulse ENTER para continuar...
 
 
	Menú Cliente
	---- -------
 
[1] -- Ver catálogo de Productos
[2] -- Comprar Productos
[3] -- Consultar Mis Compras
 
[0] -- FINALIZAR SESIÓN
0
 
Sesión finalizada.
¿Desea cerrar el programa?[s/n]:s
 
 
		--FIN DEL PROGRAMA--


Fíjate que en el código antes de registrar un Usuario en el ArrayList, le preguntamos si ya contiene( contains() ) ese mismo Usuario.
Ahí es donde entra en juego el método equals() que le pusimos a la clase Usuario. Sin este método, el contains() del ArrayList no nos daría una respuesta correcta.

Parece que hay mucho código, pero no es tanto, básicamente abultan los menús de opciones.

Lee el código con calma, asegúrate de que entiendes cada método, cada línea, cada instrucción... que comprendes la lógica que se está siguiendo. Lo que no entiendas pregúntalo 5, 10, 100 veces si hace falta...
Y por supuesto cambia, altera, experimenta, lo que no te guste, lo que pienses que podría estar mejor, lo que quieras probar a ver que pasa...


Luego ya se verá como continuar y que nuevas clases vas a necesitar.
Porque supongo que esto no consiste solo en hacer un login y ya está. Supongo que habrá que dar funcionalidad a todas esas opciones que enumera el enunciado para cada tipo de Usuario, ¿no?

Una clase Producto parece evidente. Luego se habla de registrar Categorías de Producto. ¿Debería ser Categoría también una clase? Quizás baste con un listado de String en otro ArrayList.
Se habla de que el Cliente consulte sus compras. ¿Compra debería ser otra clase? ¿La clase Cliente debería tener un ArrayList que acumule a modo de histórico objetos Compra que a su vez contengan una relación de Productos, valor de compra y fecha de la compra?

La fecha parece importante, porque el Administrador debe poder consultar Ventas por periodos de Fechas
¿Ventas sería otra clase?
¿Venta y Compra serían dos clases distintas o quizás puedan ser la misma y simplemente llamarla Transacción o algo similar?

Hay muchas preguntas que hacerse antes de continuar el programa je je.. no es tan fácil, no.

Otra cuestión es saber si has visto en el curso y/o deberíamos implementar una persistencia de datos.
Es decir, ahora mismo, cada vez que el programa termina, se borran los Usuarios registrados, y se borrarán los Productos, Ventas, etc.. que se añadan posteriormente.
Es un fastidio si hay que registrar estos datos cada vez que se prueba el programa.

Habría que pensar en incluir persistencia de datos, es decir, que lo registrado se guarde en disco para no perderlo y recuperarlo en cada ejecución del programa.

O bien, hardcodear a mano en el código unos cuantos Usuarios, Productos, etc.. para que siempre que se arranque el programa, haya unos datos mínimos con los que podre trabajar sin tener que hacer registros.

Bueno, ya habrá
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar