Java - Actualizar contraseña

 
Vista:

Actualizar contraseña

Publicado por Belen (1 intervención) el 29/08/2021 06:58:27
Buenas, tengo el siguente codigo que abre un cerrojo introduciendo una combinacion de tres cifras, y me permite cambiar la combinacion siempre y cuando sepa la antigua, el problema es que deseria que una vez hecho el cambio de la combinacion el mismo se actualize al nuevo valor. Tambien tengo que limitar el nro de cifras a solamente tres
Espero puedad ayudarme
Primera parte
public class Cerrojo {
private int combinacion ;



public Cerrojo(){

}
public Cerrojo(int a){
this.combinacion= a;

}

public int getCombinacion() {
return combinacion;
}

public void setCombinacion(int combinacion) {
this.combinacion = combinacion;
}



}
Segunda Parte
public class CerrojoPrueba {
public static void main(String[] args) {
int nuevaclave;
int claveactual;

System.out.println("Introduzca la combinacion");
Scanner clave= new Scanner(System.in);
nuevaclave= clave.nextInt();
Cerrojo b= new Cerrojo(234);
claveactual=b.getCombinacion();
if(claveactual==nuevaclave){
System.out.println("Se ha abierto el cerrojo");
System.out.println("Desea cambiar la contraseña? presione 1");
int opcion;
opcion= clave.nextInt();
if(opcion==1){
claveNueva(b);



}}}


public static void claveNueva(Cerrojo b){

System.out.println("Introduzca la nueva clave");
Scanner nueva= new Scanner(System.in);
int actual= nueva.nextInt();
b.setCombinacion(actual);
System.out.println(+b.getCombinacion());
}}
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
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

Actualizar contraseña

Publicado por Kabuto (1044 intervenciones) el 30/08/2021 01:20:58
Hola.

Para la combinación, yo usaría un String.
Aunque se usen números para la combinación, cuando no se van a hacer operaciones aritméticas con ellos (ni sumas, ni divisiones, ni nada...) suele ser mejor pedirlos como String y no como int o double.
Porque así nos facilita otras cosas, por ejemplo, comprobar fácilmente si nos han dado tres dígitos o no.

Además, yo haría que sea la propia clase Cerrojo quien reciba mediante métodos las combinaciones y compruebe ella misma si se puede abrir o no el cerrojo, si son válidas, si se puede actualizar o no a una nueva combinación....

Yo haría así la clase Cerrojo. Fíjate que para validar la contraseña uso dos métodos separados.
Uno comprueba si está compuesta de 3 caracteres.
El otro comprueba si con esos 3 caracteres, se puede construir un número o no. Así se podrán rechazar combinaciones que tengan letras, símbolos.. o cualquier cosa que no sean números.

Los métodos para abrir cerrojo y actualizar combinación, son boolean. Devolverán true o false si han tenido éxito o no.

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
public class Cerrojo {
 
	private String combinacion;
 
	public Cerrojo(String cmb){
		if (!tiene3digitos(cmb) || !esNumerica(cmb)) {
			System.out.println("Combinación inválida. Ha de ser de 3 dígitos numéricos");
			System.out.println("Se establecerá combinación por defecto: [0][0][0]");
			combinacion = "000";
		}
		else
			combinacion= cmb;
	}
 
	/*
	 * Comprueba si una combinación está compuesta de 3 digitos
	 */
	private boolean tiene3digitos(String cmb) {
		return cmb.length() == 3;
	}
 
	/*
	 * Comprueba que los dígitos son realmente números
	 * y no letras o símbolos.
	 * Para comprobarlo, se intenta un parseo a Integer.
	 * Si el parseo falla, es porque NO son números
	 */
	private boolean esNumerica(String cmb) {
		try {
			Integer.parseInt(cmb);
			return true; //No ha habido excepcion, es numérica
		}
		catch(Exception e) {
			return false; //Excepcion al no poder parsearse a número, no es numérica
		}
	}
 
	/*
	 * Indica si se puede abrir el cerrojo
	 * con la combinación proporcionada
	 */
	public boolean abrirCerrojo(String cmb) {
		return combinacion.equals(cmb);
	}
 
	/*
	 * Cambia la combinación actual por una nueva.
	 * Se tiene que proporcionar la combinación actual correcta
	 * y una combinación nueva que sea válida.
	 */
	public boolean cambiarCombinacion(String cmb, String nuevaCmb) {
		if (combinacion.equals(cmb)) {
			//Comprobamos si la nueva combinación es válida
			if (tiene3digitos(nuevaCmb) && esNumerica(nuevaCmb)) {
				combinacion = nuevaCmb;
				return true; //Combinación cambiada
			}
			else {
				System.out.println("La nueva combinación no es válida");
				return false;
			}
		}
		else {
			System.out.println("La combinación actual no coincide");
			return false;
		}
	}
 
}

Y ahora, una clase para probar un Cerrojo.
En la prueba comienzo construyendo un Cerrojo con una combinación que no es válida, para comprobar que se rechazan combinaciones incorrectas.

Luego intento abrir cerrojo, ofrezco cambiar la combinación y un último intento otra vez de abrir cerrojo.

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
import java.util.Scanner;
 
public class CerrojoPrueba {
 
	public static void main(String[] args) {
 
		Scanner teclado = new Scanner(System.in);
 
		//Probamos a crear un Cerrojo con una combinación errónea
		Cerrojo crj = new Cerrojo("pelusa");
 
		System.out.println("Prueba a abrir el cerrojo...");
		System.out.print("Dame la combinación: ");
		String combi = teclado.nextLine();
 
		if (crj.abrirCerrojo(combi))
			System.out.println("¡¡Cerrojo abierto!!");
		else
			System.out.println("Combinación incorrecta\n¡¡Cerrojo sigue cerrado!!");
 
		System.out.println("\nPrueba a cambiar la combinación...");
		System.out.print("Dame la combinación ACTUAL: ");
		String actual = teclado.nextLine();
		System.out.print("Dame una combinación NUEVA: ");
		String nueva = teclado.nextLine();
 
		if (crj.cambiarCombinacion(actual, nueva))
			System.out.println("¡¡Combinación cambiada!!");
		else
			System.out.println("No se pudo cambiar la combinación");
 
		System.out.println("\nPrueba otra vez abrir el cerrojo...");
		System.out.print("Dame la combinación: ");
		combi = teclado.nextLine();
 
		if (crj.abrirCerrojo(combi))
			System.out.println("¡¡Cerrojo abierto!!");
		else
			System.out.println("Combinación incorrecta\n¡¡Cerrojo sigue cerrado!!");
 
		teclado.close();
	}
 
}

Al ejecutarlo, en pantalla vemos que funciona todo correctamente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Combinación inválida. Ha de ser de 3 dígitos numéricos
Se establecerá combinación por defecto: [0][0][0]
Prueba a abrir el cerrojo...
Dame la combinación: 123
Combinación incorrecta
¡¡Cerrojo sigue cerrado!!
 
Prueba a cambiar la combinación...
Dame la combinación ACTUAL: 000
Dame una combinación NUEVA: 678
¡¡Combinación cambiada!!
 
Prueba otra vez abrir el cerrojo...
Dame la combinación: 678
¡¡Cerrojo abierto!!
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