Activitats

Generació de documentació en format javadoc

L’objectiu d’aquesta activitat és generar documentació en format javadoc a partir de comentaris en el codi font Java.

Genereu les classes RegistreNotes i CalculsArrayReals, amb el seu codi tal com s’ha presentat en aquesta unitat per al seu plantejament modular. En aquest cas, la primera ha de pertànyer al package unitat5.apartat1.activitats i la segona a utilitats.arrays.

En tots els seus mètodes, genereu els comentaris que creieu escaients per poder generar la seva documentació en format javadoc. Un cop fet, useu el vostre entorn de treball per generar aquesta documentació.

Classe RegistreNotes.java 

  1. package unitat5.apartat1.activitats;
  2.  
  3. public class RegistreNotes {
  4.  
  5.   /** Mètode principal
  6.    *
  7.    * @param args No usa cap argument
  8.    */
  9.   public static void main(String[] args) {
  10.     RegistreNotes programa = new RegistreNotes();
  11.     programa.inici();
  12.   }
  13.  
  14.   /** Mètode associat al principal, que permet fer invocacions d'altres
  15.    * mètodes.
  16.    *
  17.    */
  18.   public void inici() {
  19.     double[] notes = {2.0, 5.5, 7.25, 3.0, 9.5, 8.25, 7.0, 7.5};
  20.     System.out.println("La nota màxima és " + calcularMaxim(notes) + ".");
  21.     System.out.println("La nota mínima és " + calcularMinim(notes) + ".");
  22.     System.out.println("La mitjana de les notes és " + calcularMitjana(notes) + ".");
  23.   }
  24. }

Classe CalculsArrayReals.java 

  1. package utilitats.arrays;
  2.  
  3. public class CalculsArrayReals {
  4.  
  5.   /** Donat un array de reals, calculeu en quina posició hi ha el valor més baix.
  6.    *
  7.    * @param array Array de reals on fer la cerca
  8.    * @return Posicio on es troba el valor mínim
  9.    */
  10.   public double calcularMaxim(double[] array) {
  11.     double max = array[0];
  12.     for (int i = 1; i < array.length; i++) {
  13.       if (max < array[i]) {
  14.         max = array[i];
  15.       }
  16.     }
  17.     return max;
  18.   }
  19.  
  20.   /** Donat un array de reals, calculeu en quina posició hi ha el valor més alt.
  21.    *
  22.    * @param array Array de reals on fer la cerca
  23.    * @return Posició on es troba el valor màxim
  24.    */
  25.   public double calcularMinim(double[] array) {
  26.     double min = array[0];
  27.     for (int i = 1; i < array.length; i++) {
  28.       if (min > array[i]) {
  29.         min = array[i];
  30.       }
  31.     }
  32.     return min;
  33.   }
  34.  
  35.   /** Donat un array de reals, calculeu la mitjana de tots els valors
  36.    * que conté.
  37.    *
  38.    * @param array Array amb els valors a tractar
  39.    * @return Mitjana de tots els valors
  40.    */
  41.   public double calcularMitjana(double[] array) {
  42.     double suma = 0;
  43.     for (int i = 0; i < array.length; i++) {
  44.       suma = suma + array[i];
  45.     }
  46.     return suma/array.length;
  47.   }
  48.  
  49.  
  50. }

Reutilització de mòduls

L’objectiu d’aquesta activitat és veure com reutilitzar una mateixa classe en diversos programes, quan aquests són en diferents packages.

Genereu els tres petits programes següents, tots ells des de package unitat5.apartat1.activitats:

  • ExponentEnters. Pregunta, individualment, dos valors enters i mostra el resultat d’elevar el primer al segon (operació exponent).
  • MesDecimals. Pregunta, individualment, dos valors reals i diu quin dels dos té més decimals.
  • ExisteixEnter. Pregunta, individualment, un valor enter i un de real i diu si entre els decimals de la representació que usa Java per al valor real està contingut l’enter. Tingueu en compte que Java no pot representar internament qualsevol real (especialment si té molts decimals).

Tots aquests programes han de reutilitzar els mètodes de la classe EntradaTeclat, pertanyent al package unitat5.apartat1.activitats.interficie. Aquesta és la que conté tots els mètodes associats a la lectura de dades usant el teclat. Quan es llegeixi un valor des del teclat, cal controlar tant si el valor escrit pertany al tipus esperat com si s’ha escrit més d’un valor a una sola línia. En tots dos casos, es torna a preguntar fins que s’entri un valor correcte. Per exemple: 

Introdueix un valor enter: xxx
Aquest valor no és un enter. Introduïu un valor enter: 6,7
Aquest valor no és un enter. Introduïu un valor enter: 4 xxx
Has escrit més d'un valor. Introduïu un valor enter: 4 3
Has escrit més d'un valor. Introduïu un valor enter: 
...

Comenteu usant el format javadoc tots els mètodes de les classes, a part de main i inici.

Classe EntradaTeclat.java 

  1. package unitat5.apartat1.activitats.interficie;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class EntradaTeclat {
  6.  
  7.   /** Llegeix un valor enter des del teclat. No para fins a aconseguir-ho.
  8.    *
  9.    * @return Valor enter llegit.
  10.    */
  11.   public int llegirEnter() {
  12.     Scanner lector = new Scanner(System.in);
  13.     int valor = 0;
  14.     boolean llegir = true;
  15.     while (llegir) {
  16.       System.out.print("Introduïu un valor enter: ");
  17.       if (lector.hasNextInt()) {
  18.         valor = lector.nextInt();
  19.         String altres = lector.nextLine();
  20.         if ("".equals(altres)) {
  21.           llegir = false;
  22.         } else {
  23.           System.out.print("Heu escrit més d'un valor. ");
  24.         }
  25.       } else {
  26.         System.out.print("Aquest valor no és un enter. ");
  27.         lector.nextLine();
  28.       }
  29.     }
  30.     return valor;
  31.   }
  32.  
  33.  
  34.   /** Llegeix un valor real des del teclat. No para fins a aconseguir-ho.
  35.    *
  36.    * @return Valor real llegit.
  37.    */
  38.   public double llegirReal() {
  39.     Scanner lector = new Scanner(System.in);
  40.     double valor = 0;
  41.     boolean llegir = true;
  42.     while (llegir) {
  43.       System.out.print("Introduïu un valor real: ");
  44.       if (lector.hasNextDouble()) {
  45.         valor = lector.nextDouble();
  46.         String altres = lector.nextLine();
  47.         if ("".equals(altres)) {
  48.           llegir = false;
  49.         } else {
  50.           System.out.print("Heu escrit més d'un valor. ");
  51.         }
  52.       } else {
  53.         System.out.print("Aquest valor no és un real. ");
  54.         lector.nextLine();
  55.       }
  56.     }
  57.     return valor;
  58.   }
  59. }

Classe ExponentEnters.java 

  1. package unitat5.apartat1.activitats;
  2.  
  3. import unitat5.apartat1.activitats.teclat.EntradaTeclat;
  4.  
  5. public class ExponentEnters {
  6.  
  7.   public static void main(String[] args) {
  8.     ExponentEnters programa = new ExponentEnters();
  9.     programa.inici();
  10.   }
  11.  
  12.   public void inici() {
  13.     EntradaTeclat entrada = new EntradaTeclat();
  14.     int a =  entrada.llegirEnter();
  15.     int b = entrada.llegirEnter();
  16.  
  17.     int res = a;
  18.     for (int i = 1 ; i < b; i++) {
  19.       res = res*a;
  20.     }
  21.  
  22.     System.out.println(a + " elevat a " + b + " és " + res);
  23.   }
  24. }

Classe MesDecimals.java 

  1. package unitat5.apartat1.activitats;
  2.  
  3. import unitat5.apartat1.activitats.interficie.EntradaTeclat;
  4.  
  5. public class MesDecimals {
  6.  
  7.   public static void main(String[] args) {
  8.     MesDecimals programa = new MesDecimals();
  9.     programa.inici();
  10.   }
  11.  
  12.   public void inici() {
  13.     EntradaTeclat entrada = new EntradaTeclat();
  14.     double a =  entrada.llegirReal();
  15.     double b = entrada.llegirReal();
  16.  
  17.     //Recordar que valueOf transforma de valor numèric a text
  18.     String textA = String.valueOf(a);
  19.     String textB = String.valueOf(b);
  20.  
  21.     int numA = numDecimals(textA);
  22.     int numB = numDecimals(textB);
  23.  
  24.     if (numA > numB) {
  25.       System.out.println(a + " té més decimals.");
  26.     } else  if (numB > numA) {
  27.       System.out.println(b + " té més decimals.");
  28.     } else {
  29.       System.out.println("Els dos valors tenen els mateixos decimals.");    
  30.     }
  31.  
  32.  
  33.   }
  34.  
  35.   /** Donat un real en format text, compta els decimals.
  36.    *
  37.    * @param text Text del valor real complet
  38.    * @return Nombre de decimals
  39.    */
  40.  
  41.   public int numDecimals(String text) {
  42.     int coma = text.lastIndexOf(".");
  43.     String decimals = null;
  44.     if (coma == -1) {
  45.      decimals = "";
  46.     } else {
  47.       decimals = text.substring(coma + 1, text.length());
  48.     }
  49.     if ("0".equals(decimals)) {
  50.       return 0;
  51.     } else {
  52.       return decimals.length();
  53.     }
  54.   }
  55.  
  56. }

Classe ExisteixEnter.java 

  1. package unitat5.apartat1.activitats;
  2.  
  3. import unitat5.apartat1.activitats.interficie.EntradaTeclat;
  4.  
  5. public class ExisteixEnter {
  6.  
  7.   public static void main(String[] args) {
  8.     ExisteixEnter programa = new ExisteixEnter();
  9.     programa.inici();
  10.   }
  11.  
  12.   public void inici() {
  13.     EntradaTeclat entrada = new EntradaTeclat();
  14.     int enter =  entrada.llegirEnter();
  15.     double real = entrada.llegirReal();
  16.  
  17.     //Recordar que valueOf transforma de valor numèric a text
  18.     String textEnter = String.valueOf(enter);
  19.     String textReal = String.valueOf(real);
  20.  
  21.     if (textReal.indexOf(textEnter) != -1) {
  22.       System.out.println("El valor enter està contingut.");
  23.     } else {
  24.       System.out.println("El valor enter no està contingut.");
  25.     }
  26.   }
  27.  
  28. }

Tractament modular d'arrays

L’objectiu d’aquesta activitat és generar un programa modular senzill.

Feu un programa modular compost de les dues classes següents:

D’una banda, EditorArrayEnters, pertanyent al package utilitats.arrays. Aquesta classe té com a mínim aquests dos mètodes:

  • int[] inserir(int[] a, int pos, int v), que serveix per inserir el valor v a la posició pos de l’array, desplaçant el valor existent i tots els que hi ha a continuació a la dreta. No s’esborra cap valor. S’avalua al nou array resultant, que tindrà una posició més que l’original.
  • int[] esborrar(int[] a, int pos), esborra el valor a la posició pos. En aquest cas, tots els valors posteriors es desplacen a l’esquerra, de manera que el nou array tindrà una posició menys que l’original.

En tots dos casos, si hi ha cap error (posició invàlida), no es fa res i s’avalua a null.

D’altra banda, ProvesEditor, pertanyent al package unitat5.apartat1.activitats. Aquesta ha de comprovar que els mètodes de la classe anterior funcionen correctament. Per fer-ho, cal que faci les invocacions convenients perquè l’array mostrat tot seguit es converteixi en el que es mostra a continuació. 

des de {1,2,3,4,5,6} a {1,6,7,2,9,8,5}

Per a tots els mètodes, comenteu-los completament en format javadoc.

Classe EditorArrayEnters.java 

  1. package utilitats.arrays;
  2.  
  3. public class EditorArrayEnters {
  4.  
  5.   /** Inseriu un valor a una posició d'un array d'enters, desplaçant el 
  6.    * valor existent i tots els que hi ha a continuació a la dreta. 
  7.    * No s'esborra cap valor.
  8.    * 
  9.    * @param array Array d'enters original
  10.    * @param pos Posició on fer la inserció
  11.    * @param v Valor a inserir
  12.    * @return Nou array d'enters amb el valor inserit. Ara la seva mida s'ha 
  13.    * incrementat en un. Si hi ha un error s'avalua a null.
  14.    */
  15.   public int[]  inserir(int[] array, int pos, int v) {
  16.     if ((pos >= 0)&&(pos < array.length)) {
  17.       int[] nouArray = new int[array.length + 1];
  18.       copiarNPosicions(array, nouArray, pos);
  19.       nouArray[pos] = v;
  20.       for (int i = pos; i < array.length; i++) {
  21.         nouArray[i + 1] = array[i];
  22.       }
  23.       return nouArray;
  24.     } else {
  25.      return null;
  26.     }
  27.   }
  28.  
  29.   /** Esborra un valor a una posició d'un array d'enters, desplaçant els
  30.    * valors sobre la posició eliminada, cap a l'esquerra.
  31.    *
  32.    * @param array Array d'enters original
  33.    * @param pos Posició on fer l'esborrat
  34.    * @return Nou array d'enters amb el valor esborrat. Ara la seva mida s'ha
  35.    * reduït en un. Si hi ha un error s'avalua a null.
  36.    */
  37.   public int[] esborrar(int[] array, int pos) {
  38.     if ((pos >= 0)&&(pos < array.length)) {
  39.       int[] nouArray = new int[array.length - 1];
  40.       copiarNPosicions(array, nouArray, pos);
  41.       for (int i = pos + 1; i < array.length; i++) {
  42.         nouArray[i - 1] = array[i];
  43.       }
  44.       return nouArray;
  45.     } else {
  46.      return null;
  47.     }
  48.   }
  49.  
  50.   /** Donats dos arrays d'enters, copia els N primers valors de l'origen a la
  51.    * destinació, començant per la posició 0.
  52.    *
  53.    * @param origen Array origen
  54.    * @param desti Array destinació
  55.    * @param n Nombre de valors a copiar
  56.    */
  57.   public void copiarNPosicions(int[] origen, int[] desti, int n) {
  58.     for (int i = 0; i < n; i++) {
  59.       desti[i] = origen[i];
  60.     }
  61.   }
  62.  
  63. }

Classe ProvaEditor.java 

  1. package unitat5.apartat1.activitats;
  2.  
  3. import utilitats.arrays.EditorArrayEnters;
  4.  
  5. public class ProvaEditor {
  6.  
  7.   public static void main(String[] args) {
  8.     ProvaEditor programa = new ProvaEditor();
  9.     programa.inici();
  10.   }
  11.  
  12.   public void inici() {
  13.     int[] arrayA = {1,2,3,4,5,6};
  14.     EditorArrayEnters ed = new EditorArrayEnters();
  15.     int[] arrayB = ed.inserir(arrayA, 1, 7);
  16.     //{1,7,2,3,4,5,6}
  17.     arrayB = ed.esborrar(arrayB, 4);
  18.     //{1,7,2,3,5,6}
  19.     arrayB = ed.inserir(arrayB, 1, 6);
  20.     //{1,6,7,2,3,5,6}
  21.     arrayB = ed.esborrar(arrayB, 4);
  22.     //{1,6,7,2,5,6}
  23.     arrayB = ed.esborrar(arrayB, 5);
  24.     //{1,6,7,2,5}
  25.     arrayB = ed.inserir(arrayB, 4, 9);
  26.     //{1,6,7,2,9,5}
  27.     arrayB = ed.inserir(arrayB, 5, 8);
  28.     //{1,6,7,2,9,8,5}
  29.  
  30.     for (int i = 0; i < arrayB.length; i++) {
  31.       System.out.print(" " + arrayB[i]);
  32.     }
  33.     System.out.println();
  34.   }
  35.  
  36. }

Mòdul d'entrada de dades

L’objectiu d’aquesta activitat és afegir uns nous mòduls a un programa ja existent.

Feu un nou programa que aprofiti la classe EditorArrayEnters de l’activitat anterior. Usant els principis de modularitat estudiats en aquesta unitat i documentat qualsevol mètode nou, ara l’usuari ha de poder modificar un array via un menú textual. Per aquest programa, l’array es pot declarar directament dins el codi com una variable ja inicialitzada amb certs valors concrets.

El menú ofereix tres opcions:

  • [I]nserir. Quan l’usuari introdueix el caràcter I, llavors se li pregunta a quina posició i després el valor. Llavors, s’insereix el valor especificat a aquesta posició.
  • [E]sborrar. Quan l’usuari introdueix el caràcter I, llavors se li pregunta a quina posició. Llavors, s’esborra el valor especificat a aquesta posició.
  • [S]ortir. Quan l’usuari introdueix el caràcter S, el programa finalitza.

Les dades sempre es van preguntant una a una i han de comprovar possibles errors. Després d’executar una de les dues comandes que modifiquen l’array, cal mostrar el nou estat de l’array i el menú. Un exemple d’execució podria ser el següent: 

ARRAY = { 1 2 3 4 5 6 }
Tria una opció: [I]nserir        [E]sborrar        [S]ortir
I
Quina posició voleu manipular? -1
Aquesta posició no existeix
Quina posició voleu manipular? ddd
El valor no és enter
Quina posició voleu manipular? 1
Quin valor voleu usar? 7
ARRAY = { 1 7 2 3 4 5 6 }
Trieu una opció: [I]nserir        [E]sborrar        [S]ortir
E
Quina posició voleu manipular? 3
ARRAY = { 1 7 2 4 5 6 }
Trieu una opció: [I]nserir        [E]sborrar        [S]ortir
S

Classe EditorTeclat.java 

  1. package unitat5.apartat1.activitats;
  2.  
  3. import utilitats.arrays.EditorArrayEnters;
  4.  
  5. public class EditorTeclat {
  6.  
  7.   public static void main(String[] args) {
  8.     EditorTeclat programa = new EditorTeclat();
  9.     programa.inici();
  10.   }
  11.  
  12.   public void inici() {
  13.     int[] arrayA = {1,2,3,4,5,6};
  14.     EditorArrayEnters ed = new EditorArrayEnters();
  15.     InterficieUsuari iu = new InterficieUsuari();
  16.  
  17.     boolean executar = true;
  18.  
  19.     while (executar) {
  20.       char op = iu.llegirOpcio(arrayA);
  21.       int pos = 0;
  22.       switch(op) {
  23.         case 'I':
  24.           pos = iu.llegirPosicio(arrayA.length - 1);
  25.           int val = iu.llegirValor();
  26.           arrayA = ed.inserir(arrayA, pos, val);
  27.           break;
  28.         case 'E':
  29.           pos = iu.llegirPosicio(arrayA.length - 1);
  30.           arrayA = ed.esborrar(arrayA, pos);
  31.           break;
  32.         case 'S':
  33.           executar = false;
  34.       }
  35.     }
  36.   }
  37.  
  38. }

Classe InterficieUsuari.java 

  1. package unitat5.apartat1.activitats;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class InterficieUsuari {
  6.  
  7.   /** Mostra l'array i el menú a l'usuari i obté l'opció escollida.
  8.    *
  9.    * @param array Array a mostrar
  10.    * @return El caràcter associat a l'opció triada (I, E o S), o 'X' si incorrecta.
  11.    */
  12.   public char llegirOpcio(int[] array) {
  13.     System.out.print("ARRAY = { ");
  14.     for (int i = 0; i < array.length; i++) {
  15.       System.out.print(array[i] + " ");
  16.     }
  17.     System.out.println("}");
  18.     System.out.println("Tria una opcio: [I]nserir\t[E]sborrar\t[S]ortir");
  19.     Scanner lector = new Scanner(System.in);
  20.     String op = lector.next();
  21.     if (op.length() !=1) {
  22.       System.out.print("Opció incorrecta...");
  23.       return 'X';
  24.     } else {
  25.       char c = op.charAt(0);
  26.       if ((c != 'I')&&(c != 'E')&&(c != 'S')) {
  27.         System.out.print("Opció desconeguda...");
  28.         return 'X';
  29.       }
  30.       return c;
  31.     }
  32.   }
  33.  
  34.   /** Pregunta a l'usuari la posició d'un array. Comprova si està dins el rang
  35.    * correcte o si s'ha escrit realment un enter. Pregunta repetides vegades
  36.    * fins a obtenir un valor correcte.
  37.    *
  38.    * @param max Valor màxim admès
  39.    * @return La posició escrita
  40.    */
  41.   public int llegirPosicio(int max) {
  42.     Scanner lector = new Scanner(System.in);
  43.     boolean pendentLlegir = true;
  44.     int pos = -1;
  45.     String s = null;
  46.     while (pendentLlegir) {
  47.       System.out.print("Quina posició voleu manipular? ");
  48.       if (lector.hasNextInt()) {
  49.         pos = lector.nextInt();
  50.         if ((pos < 0)||(pos > max)) {
  51.           System.out.println("Aquesta posició no existeix");
  52.           lector.nextLine();
  53.         } else {
  54.           pendentLlegir = false;
  55.         }
  56.       } else {
  57.         System.out.println("El valor no és enter");
  58.         lector.nextLine();
  59.       }
  60.     }
  61.     lector.nextLine();
  62.     return pos;
  63.   }
  64.  
  65.   /** Llegeix un enter qualsevol via teclat. Pregunta repetides vegades
  66.    * fins a obtenir un valor correcte.
  67.    *
  68.    * @return El valor llegit
  69.    */
  70.   public int llegirValor() {
  71.     Scanner lector = new Scanner(System.in);
  72.     boolean pendentLlegir = true;
  73.     int val = 0;
  74.     while (pendentLlegir) {
  75.       System.out.print("Quin valor voleu usar? ");
  76.       if (lector.hasNextInt()) {
  77.         val = lector.nextInt();
  78.         pendentLlegir = false;
  79.       } else {
  80.         System.out.println("El valor no és enter");
  81.         lector.nextLine();
  82.       }
  83.     }
  84.     lector.nextLine();
  85.     return val;
  86.   }
  87.  
  88. }

La classe Math

L’objectiu és aprendre a cercar informació a la documentació de l’API del Java.

Estudieu la documentació de la classe Math per veure si hi ha algun mètode que permeti simplificar el programa d’exemple (apartat 1.4.1) per calcular la hipotenusa al teorema de Pitàgores. Modifiqueu el programa perquè usi aquest mètode i comproveu que funciona. 

  1. package unitat5.apartat1.activitats;
  2.  
  3. public class Pitagores {
  4.  
  5.   public static void main(String[] args) {
  6.     Pitagores programa = new Pitagores();
  7.     programa.inici();
  8.   }
  9.  
  10.   public void inici() {
  11.     double base = 4.5;
  12.     double altura = 10;
  13.  
  14.     double hipotenusa = Math.hypot(base, altura);
  15.  
  16.     System.out.println("El valor de la hipotenusa és " + hipotenusa);
  17.   }
  18. }

Anar a la pàgina anterior:
Descomposició en classes i biblioteques
Anar a la pàgina següent:
Exercicis d'autoavaluació