Java - Ayuda a comprender parte de código

 
Vista:

Ayuda a comprender parte de código

Publicado por IRENE (7 intervenciones) el 10/09/2021 13:06:03
Hola compañeros tengo que hacer un ejercicio de documentación de código con javadoc y hay un método dentro de la clase que no entiendo muy bien es el siguiente:

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
// método  que recibe como parámetro un array con un máximo de 10 medidas en Libras
	//y las convierte a gramos
	 public static final double[] pound2G (double[] arrayPound) throws ArrayTooLongException {
		 // estructura de selección"if" que comprueba que el array no sea mayor de 10 en caso verdadero
		 // lanzará la excepción
		 if (arrayPound.length>TAM_MAX_ARRAYS) {
			 // mensaje de excepción personalizado
			 throw new ArrayTooLongException("Array de pounds demasiado longo");
		 }
		 //creación de array de tipo double tamaño 10
		 double[] arrayG = new double[TAM_MAX_ARRAYS];
 
		 //CICLO FOR QUE ASIGNA "0.0" A TODAS LAS POSICIONES DEL ARRAY
		 for (int i=0; i<arrayG.length; i++) {
			 arrayG[i]=0;
		 }
		 // FOR QUE RECORRE ARRAY ENVIADO COMO PARÁMETRO Y SI ES MAYOR QUE 2 "CONTINUE
                 // DE LO CONTRARIO LE ASIGNA EL VALOR AL ARRAY "arrayG"
		 for (int i=0;i<arrayPound.length;i++) {
			 double cantidadeG = arrayPound[i]*POUND2G;//convierte libras en gramos
			 if (cantidadeG > 2) {continue;
			 }else {
				 arrayG[i] = cantidadeG;}
			 }
	 return arrayG;
	 }
No entiendo por que hay un for que asigna "0" a todos los valores del array
Y el for que recorre el array que recibe como parámetro y le dice que si es mayor de 2 "continue" de lo contrario se lo asigna al array "arrayG"
No entiendo por que hace eso con que fin, gracias
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

Ayuda a comprender parte de código

Publicado por Kabuto (1044 intervenciones) el 11/09/2021 12:07:40
Hola.

Lo de asignar valor 0 es para asegurarse de que la variable, o el conjunto de variables (un array en este caso), queda inicializada con un valor "neutro" y controlado por el programador.

En Java no suele ser necesario hacerlo con arrays de tipo primitivo: int, double, byte, float... porque al inicializar el array, automáticamente ya adoptan valor 0.

Mira, si pruebas a ejecutar este código tan sencillo:

1
2
3
4
5
6
7
public static void main(String[] args) {
 
        double unaVariable;
        System.out.println("Valor de una variable: " + unaVariable);
 
 
    }

Verás que obtienes un error quejándose de que "unaVariable" no ha sido inicializada.
De ahí la necesidad de darle un valor inicial, el que sea. Si no necesitamos que comience con un valor en concreto, la costumbre es darle valor 0

1
2
3
4
5
6
7
public static void main(String[] args) {
 
        double unaVariable = 0;
        System.out.println("Valor de una variable: " + unaVariable);
 
 
    }

Si hacemos el mismo experimento con un array, podemos comprobar que NO es necesario inicializar los elementos a ningún valor, porque de hecho eso ya ocurre automáticamente al inicializar el array.

1
2
3
4
5
6
7
8
public static void main(String[] args) {
 
        double[] arrayG = new double[10];
 
        for (int c = 0; c < arrayG.length; c++)
            System.out.println("Posicion [" + c + "]: " + arrayG[c]);
 
    }

Al ejecutar esto, veremos en pantalla que todos los elementos ya tienen valor 0.0 , sin que hayamos tenido que dárselo nosotros:
1
2
3
4
5
6
7
8
9
10
Posicion [0]: 0.0
Posicion [1]: 0.0
Posicion [2]: 0.0
Posicion [3]: 0.0
Posicion [4]: 0.0
Posicion [5]: 0.0
Posicion [6]: 0.0
Posicion [7]: 0.0
Posicion [8]: 0.0
Posicion [9]: 0.0

Como ves, no es necesario inicializar a 0 cuando se trata de un array de primitivos. Pero mucha gente lo hace, por seguir "buenas costumbres" o por lo que sea... Así que no te extrañe cuando lo veas.

Por cierto, he subrayado lo de primitivos porque sería distinto si se tratase de un array de objetos. En este caso, es necesario inicializar los elementos del array.
Puede que aún no hayas tratado el tema de Programación Orientada a Objetos (POO) pero da igual, lo que voy a mostrarte se entiende enseguida.

Si ese mismo array de double(tipo primitivo) lo cambiamos por un array de Double(clase Double) y NO hacemos ninguna inicialización:
1
2
3
4
5
6
7
8
public static void main(String[] args) {
 
        Double[] arrayG = new Double[10]; //Ya no es array de primitivos, es un array de clase Double
 
        for (int c = 0; c < arrayG.length; c++)
            System.out.println("Posicion [" + c + "]: " + arrayG[c]);
 
    }

Al ejecutar, veremos que tenemos valores "nulos":
1
2
3
4
5
6
7
8
9
10
Posicion [0]: null
Posicion [1]: null
Posicion [2]: null
Posicion [3]: null
Posicion [4]: null
Posicion [5]: null
Posicion [6]: null
Posicion [7]: null
Posicion [8]: null
Posicion [9]: null

Así que en este caso, hay que inicializa a 0.0.
Y además no vale con poner simplemente 0.
Un 0 es un int, así que no es aceptable para inicializar un objeto de clase Double.
Si ejecutamos esto:
1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args) {
 
        Double[] arrayG = new Double[10]; //Ya no es array de primitivos, es un array de clase Double
 
        //Se requiere inicialiación previa
        for (int c = 0; c < arrayG.length; c++)
            arrayG[c] = 0; //Esto dará error, por ser un int
 
        for (int c = 0; c < arrayG.length; c++)
            System.out.println("Posicion [" + c + "]: " + arrayG[c]);
 
    }
Tendremos una excepción (un error)

1
2
3
4
Main.java:12: error: incompatible types: int cannot be converted to Double
            arrayG[c] = 0; //Esto dará error, por ser un int
                        ^
1 error

Hay que darle específicamente un valor double, ya sea usando decimales: 0.0

1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args) {
 
        Double[] arrayG = new Double[10]; //Ya no es array de primitivos, es un array de clase Double
 
        //Se requiere inicialiación previa
        for (int c = 0; c < arrayG.length; c++)
            arrayG[c] = 0.0; //Proporcionamos un valor double
 
        for (int c = 0; c < arrayG.length; c++)
            System.out.println("Posicion [" + c + "]: " + arrayG[c]);
 
    }

O poniendo una d al final de la cifra, una abreviatura para indicar que es double: 0d
1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args) {
 
        Double[] arrayG = new Double[10]; //Ya no es array de primitivos, es un array de clase Double
 
        //Se requiere inicialiación previa
        for (int c = 0; c < arrayG.length; c++)
            arrayG[c] = 0d; //Proporcionamos un valor double
 
        for (int c = 0; c < arrayG.length; c++)
            System.out.println("Posicion [" + c + "]: " + arrayG[c]);
 
    }

Hay que decir, que habrá ocasiones en las que nos interese tener los valores null en el array.
Por ejemplo, yo puedo crear un array de 10 elementos pero luego no se cuantos valores voy a recibir para guardar en ese array, puede que reciba solo tres o cuatro.
Imaginemos que recibo cuatro notas de alumnos, y los guardo en un array que previamente he inicializado a 0

Si yo luego quiero distinguir entre los valores que son notas de alumnos, y los que no, voy a tener un problema.. porque los 0.0 que tiene el array no voy a saber si son notas de alumnos mediocres que han suspendido o si son los 0.0 con los que yo inicialicé al principio.

En cambio, si hubiera dejado los valores null, ahora ya si podría distinguir cuáles son las notas recibidas. Todo lo que NO sea null, es una nota que he recibido para guardar.

Resumiendo:
- Para arrays de primitivos no es necesario inicializar a valor 0 (al menos en Java) pero no es raro que la gente lo haga, e incluso podría ser considerado como "buena costumbre":
- Para arrays de objetos de clase, sí es necesaria la inicialización, de lo contrario nos encontraremos con valores null, aunque habrá situaciones que nos venga bien tener esos valores null disponibles.



Sobre tu segunda pregunta acerca de esta parte del código:
1
2
3
4
5
6
7
8
// FOR QUE RECORRE ARRAY ENVIADO COMO PARÁMETRO Y SI ES MAYOR QUE 2 "CONTINUE
                 // DE LO CONTRARIO LE ASIGNA EL VALOR AL ARRAY "arrayG"
		 for (int i=0;i<arrayPound.length;i++) {
			 double cantidadeG = arrayPound[i]*POUND2G;//convierte libras en gramos
			 if (cantidadeG > 2) {continue;
			 }else {
				 arrayG[i] = cantidadeG;}
			 }


Creo que la intención es hacer un "filtrado" de los resultados. Parece que a este método SOLO le interesan los valores que NO superen los 2 gramos.
Los que superan los 2 gramos, son descartados. El resto, son recogidos en el array que luego se retornará.
¿El motivo de hacer este filtrado? Bueno, eso ya se supone que será un requisito que ha de cumplir el programa.
Quizá el programa ha de tener un método que proporciones los valores de hasta 2 gramos, y luego otro método que proporcione los valores entre 2 y 4 gramos, y otro que busque los valores entre 4 y 8 gramos, etc...


Si algo no ha quedado claro, pregunta otra vez.
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