Java - Ayuda con POO en java

 
Vista:
sin imagen de perfil

Ayuda con POO en java

Publicado por pedro (3 intervenciones) el 08/09/2022 00:28:01
Buenas tardes soy estudiante de ingenieria en sistemas y tengo que hacer un programa que cree contraseñas aleatorias de 8 digitos y tiene que determinar si la contraseña es segura o insegura, se considera que es segura si tiene mas de 2 mayusculas una minuscula y 5 numeros pero no me sale, solo me genera 61 contraseñas y aumenta un caracter en cada una este es mi codigo llevo dos dias y no puedo podrian explicarme como puedo hacer para que solo se genere una contraseña de 8 digitos muchas gracias




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
package codigo;
import java.security.SecureRandom;
 
public class Password {
    private char longitud[] = new char[8];
    private int contraseña;
    private char may[]= new char[]{'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
    private char min[]= new char[]{'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
    private int num[]= new int[]{1,2,3,4,5,6,7,8,9,0};
    private boolean con = true;
        public Password(){
 
        }
 
        public Password(int contraseña){
 
        }
 
 
        public void esFuerte(int i){
            int a=0,b=0,c=0;
            this.contraseña = i;
            for(i = 0;i<may.length;i++){
                    a+=1;
                if(i>2){
 
                }
            for(i = 0;i<min.length;i++){
                if(i>=1){
                   b+=1;
                }
            for(i = 0;i<num.length;i++){
                if(i>5){
                    c+=1;
                }
 
            }
            }
            }
            contraseña = a+b+c;
            if(contraseña>=8){
                this.con = true;
            }else{this.con = false;}
 
 
            }
 
        public void Ciclo(int contraseña){
            this.contraseña = contraseña;
            for(int i  = longitud.length;i<contraseña;i++){
            contraseña = longitud[i];
        }
            }
 
        public void Conseg(){
 
            if(con==true){
                System.out.println("La contraseña es segura");
            }
            if(con==false){
                System.out.println("La contraseña No es segura");
            }
 
}
        public void generarPasword(){
 
                final String cad = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz123456789";
                StringBuilder sb = new StringBuilder();
 
                for(int i = 0;i<cad.length();i++){
                double aleatorio = Math.random()*cad.length();
                int posicion = (int) aleatorio;
                char letra =cad.charAt(posicion);
                sb.append(letra);
 
                this.contraseña = letra;
                    System.out.println("Password: " + sb.toString()+" "+sb.length());
            }
 
        }
        public int getContraseña(){
            return contraseña;
        }
        public char[] getLongitud(){
           return longitud;
        }
        public void setLongitud(char[] longitud){
           this.longitud = longitud;
        }
        }

b31e0701cd6a37b07cd0463e45709984
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

Ayuda con POO en java

Publicado por adivino (6 intervenciones) el 08/09/2022 01:09:46
Las cosas se pueden realizar de muchas maneras.

Pero si usted ya de antemano, sabe que una contraseña segura es aquella que posee 2 mayúsculas, y una minúscula y 5 números, pues diseñe una rutina que vaya verificando que eso se cumpla.

En un for que itere dos veces, saque las 2 mayúsculas de may[], luego saque aleatoriamente una minúscula de min[] y finalmente genere un aleatorio entre 0 y 9 con int valorDado = Math.floor(Math.random()*10+1), sobra el num[];

Lo que vaya arrojando lo va concatenando en una variable y así garantiza que la clave es segura y cumple con los criterios.
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

Ayuda con POO en java

Publicado por Kabuto (1381 intervenciones) el 08/09/2022 01:57:33
Primero comentar que el enunciado es incorrecto.
Esta condición:
1
se considera que es segura si tiene mas de 2 mayusculas una minuscula y 5 numeros pero no me sale
es IMPOSIBLE que se cumpla.
La contraseña ha de tener 8 dígitos exactos, así que se compone de 5 números (5 dígitos), y 1 una minúscula (6 dígitos), y SOLO 2 mayúsculas (8 dígitos)

No podemos exigir MÁS DE 2 mayúsculas, porque entonces sobrepasaríamos los 8 dígitos...


Sobre como enfocar este programa.
Yo haría una clase con dos métodos estáticos:
uno que genere la contraseña y la retorne como String.
otros que reciba un String e indique si es una contraseña segura o no.

Declararía como atributos tres Strings que representarían los tres conjuntos (sets) de caracteres que pueden componer una contraseña, es decir, las letras mayúsculas, las minúsculas y los números.

Para generar, escogemos al azar uno de esos tres sets, y luego al azar extraemos un carácter del set escogido.
Este proceso lo repetimos 8 veces y así obtenemos un password de 8 letras.

Para comprobar, recorremos el String, carácter a carácter, y comprobamos a que set pertenece.
Usaremos tres contadores, uno por cada set.
Así luego al final podemos comprobar si tenemos los caracteres correctos para considerar una contraseña como "segura"

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
import java.util.Random;
 
public class Password {
 
	//Sets de caracteres disponibles con los que construir contraseñas
	private static final String MAYUSCULAS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	private static final String MINUSCULAS = "abcdefghijklmnopqrstuvwxyz";
	private static final String NUMEROS = "0123456789";
 
	/**
	 * Genera una contraseña aleatoria con 8 caracteres de longitud.
	 * La contraseña se compone de letras mayúsculas, minúsculas y números.
	 *
	 * @return Cadena String con la contraseña generada aleatoriamente.
	 */
	public static String generar() {
 
		StringBuilder password = new StringBuilder();
		Random azar = new Random();
 
		for (int i = 0; i < 8; i++) {
 
			//Generamos un random entre 0 y 2 para elegir entre uno de los tres sets disponibles
			switch(azar.nextInt(3)) {
			case 0: //Mayúsculas
				password.append(MAYUSCULAS.charAt(azar.nextInt(MAYUSCULAS.length())));
				break;
			case 1: //Minúsculas
				password.append(MINUSCULAS.charAt(azar.nextInt(MINUSCULAS.length())));
				break;
			case 2: //Números
				password.append(NUMEROS.charAt(azar.nextInt(NUMEROS.length())));
			}
		}
		//Contraseña generada, la retornamos
		return password.toString();
	}
 
	/**
	 * Recibe una contraseña como argumento y evalua si se considera
	 * como "segura".
	 * Una contraseña es segura si se compone de 2 mayúsculas, 1 minúscula
	 * y 5 números.
	 *
	 * @param password String con la contraseña a evaluar
	 * @return Verdadero si es "segura", Falso en caso contrario.
	 */
	public static boolean esSegura(String password) {
 
		int cMayus = 0, cMinus = 0, cNum = 0;
 
		//Recorremos cada caracter para comprobar a que set pertenece
		for (int i = 0; i < password.length(); i++) {
			Character caracter = password.charAt(i);
 
			if (MAYUSCULAS.contains(caracter.toString()))
				cMayus++;
			else if (MINUSCULAS.contains(caracter.toString()))
				cMinus++;
			else
				cNum++;
		}
 
		return (cMayus == 2 && cMinus == 1 && cNum == 5);
	}
}

Luego, ponemos a prueba esta clase.
Generamos una contraseña, la mostramos en pantalla y evaluamos si es "segura" o no.

Podemos usar un bucle donde preguntemos al usuario si quiere generar otra contraseña o no, así el elige cuando terminar el programa de prueba.
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
import java.util.Scanner;
 
public class Prueba {
 
	public static void main(String[] args) {
 
		Scanner teclado = new Scanner(System.in);
 
		String generar = "si";
 
		while (generar.equals("si")) {
 
			String password = Password.generar();
			System.out.println("\nContraseña generada: " + password);
			System.out.print("¿Es segura?: ");
			System.out.println(Password.esSegura(password)?"SI":"NO");
 
			System.out.print("\n¿Generar otra?(si/no): ");
			generar = teclado.nextLine().toLowerCase();
		}
 
		teclado.close();
		System.out.println("\n\t\tFIN DE PROGRAMA");
	}
 
}

Lo cierto es que las probabilidades de que nos genere una contraseña "segura", es baja:
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
Contraseña generada: U6IBNr0a
¿Es segura?: NO
 
¿Generar otra?(si/no): si
 
Contraseña generada: 777Id2D0
¿Es segura?: SI
 
¿Generar otra?(si/no): si
 
Contraseña generada: 24sY2r54
¿Es segura?: NO
 
¿Generar otra?(si/no): si
 
Contraseña generada: URLiuw1W
¿Es segura?: NO
 
¿Generar otra?(si/no): si
 
Contraseña generada: Hl7fy7Z1
¿Es segura?: NO
 
¿Generar otra?(si/no): si
 
Contraseña generada: znq51uM8
¿Es segura?: NO
 
¿Generar otra?(si/no): no
 
		FIN DE PROGRAMA

Pero bueno, el programa que nos piden no es un "generador de contraseñas seguras".
Lo que nos piden es un "generador de contraseñas" y que luego además pueda comprobar si una contraseña es "segura" o no.

Si algo no se ha entendido, solo tienes que preguntar.

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