Diferència entre revisions de la pàgina «M3 - Programació estructurada / Continguts UF1: Visualització i entrada de les dades en Java»

Revisió de 18:16, 27 set 2020

Visualització i entrada de les dades en Java

La veritat és que no té cap sentit que un programa dugui a terme el processament d’unes dades si aquesta tasca després no té cap repercussió en el sistema d’entrada/sortida.

Sobretot tenint en compte que un cop el programa finalitza, tots els valors tractats s’esborren de la memòria. El mínim que pot fer és mostrar el resultat de la tasca per pantalla, de manera que l’usuari que l’ha posada en marxa sap quin ha estat el resultat de tot plegat.

Hi ha moltes maneres d’entrar o mostrar les dades a l’usuari, només cal veure les interfícies gràfiques dels sistemes moderns, però aquí veureu la més simple: cadenes de text en pantalla o per teclat.

Instruccions de sortida de dades per pantalla

Cada llenguatge de programació té les seves pròpies instruccions per visualitzar dades per pantalla. Si bé la idea general pot tenir certes similituds, la sintaxi pot ser totalment diferent. Per tant, cal tenir en compte que les descripcions se centren exclusivament en com funciona el llenguatge Java.

Principalment, Java proporciona dues instruccions per mostrar dades a la pantalla:

//Mostra a la pantalla el resultat d’avaluar l’expressió //x//.

System.out.print(x);

//Fa el mateix, però al final afegeix un salt de línia.

System.out.println(x);

Quan escriviu amb el teclat, el text es va mostrant en el mateix ordre com aneu cridant les instruccions de sortida per pantalla. No es pot demanar un posicionament absolut a qualsevol lloc de la pantalla. Per tant, cada instrucció començarà a escriure immediatament després d’on l’ha deixada la instrucció anterior.

Un dels aspectes més importants de representar dades per pantalla és que aquest perifèric només tracta amb text. O sigui, conjunts de caràcters en Java (char). Per tant, en el procés de sortida a la pantalla tota dada que es vol mostrar ha de patir una transformació des de la representació original fins al conjunt de caràcters que la representen en format text.

D’enter a text

Suposeu que tenim una variable de tipus enter en Java (int), en què hi ha emmagatzemat el valor 1309. Això internament es representa amb el valor binari: 0000010100010100.

Ara bé, per la pantalla el que s’haurà de mostrar són els 4 caràcters (char) ’1’, ’3’, ’0’, ’9’. És a dir, s’ha d’ordenar al sistema d’entrada/sortida per pantalla que mostri els quatre valors de la representació en binari:

• ’1’: 000000000000000000110001
• ’3’: 000000000000000000110011
• ’0’: 000000000000000000110000
• ’9’: 000000000000000000111001

Per tant, si es vol escriure un enter, caldria un pas de transformació previ a representar-lo en diferents caràcters individuals. Pel que fa a aquest tipus d’instruccions, un dels grans avantatges de Java, com a llenguatge de nivell alt en relació amb altres llenguatges de nivell més baix, és que les dues instruccions bàsiques de què disposa poden acceptar qualsevol expressió que en ser avaluada resulti en qualsevol tipus primitiu, sigui quin sigui (enter, real, booleà o caràcter).

Automàticament s’encarreguen elles mateixes de transformar el valor emmagatzemat en la seva representació en format text, i la mostren per pantalla.

A mode d’exemple, en fer:

//Mostra diferents expressions simples per pantalla.
public class MostrarExpressions {

  public static void main(String[] args) {
    //Mostra el text "3" per pantalla.
    System.out.println(3);
    //Mostra el text "a" per pantalla.
    System.out.println(’a’);
    //Mostra el text "3.1416" per pantalla.
    double x = 3.1416;
    System.out.println(x);
    //Mostra el text "true" per pantalla.
    boolean a = true;
    boolean b = false;
    System.out.println((a||b)&&(true)); } }

Si executem es mostra per pantalla el següent:

3

a

3.1416

true

Tipus de dada avançats: cadenes de text

En molts casos, segurament no en tindreu prou només escrivint la representació textual d’un tipus de dada simple. Us agradaria escriure una frase sencera de l’estil “El resultat obtingut és...”. És a dir, escriure blocs de text. Partint d’aquesta necessitat, si reflexioneu una mica, potser arribareu a la conclusió que el tipus de dada caràcter no és gaire útil, ja que per mostrar frases llargues, amb el que heu vist fins al moment, caldria fer-ho caràcter per caràcter, de manera molt molesta. En realitat, el tipus de dada caràcter no se sol usar directament, sinó que els llenguatges de programació l’usen com a base per generar un nou tipus de dada més avançat que serveixi per processar text.

√ Una cadena de text (String) és un tipus de dada que permet representar qualsevol seqüència de caràcters de longitud arbitrària.

Per referir-nos a una dada de tipus cadena de text, l’escrivim entre cometes dobles (”).

Aneu amb molt de compte, ja que no és el mateix ’a’ que “a”. La primera és un literal que representa una dada de tipus caràcter i la segona és de tipus cadena de text.

Operadors de les cadenes de text

En contraposició dels tipus primitius, no es pot generalitzar en parlar d’operacions de cadenes de text. Cada llenguatge en pot oferir de diferents (o cap). En el cas del Java, les cadenes de text accepten l’operador suma (+), de manera que es poden generar expressions de la mateixa manera que es pot fer amb els tipus primitius. En aquest cas, el resultat d’aplicar-lo en una operació entre cadenes de text és que aquestes es concatenen. Es genera una nova cadena de text formada per la unió de cadascun dels operands de manera consecutiva.

Caràcters de control

En alguns llenguatges de programació, com en Java, hi ha un conjunt de literals dins dels caràcters que són especialment útils dins de les cadenes de text, ja que permeten representar símbols o accions amb un significat especial. Aquests s’anomenen seqüències d’escapament i sempre es componen d’una contrabarra (\) i un caràcter addicional. La taula mostra una llista dels més habituals:

Entrada simple de dades per teclat

Explicar l’entrada de dades per teclat quan tot just s’ha començat a aprendre a programar usant Java té un seguit de complicacions, ja que per entendre exactament la sintaxi de cada instrucció usada cal conèixer nombrosos conceptes que encara no s’han explicat. A més a més, per acabar-ho de complicar, també hi intervé l’aspecte de llenguatge orientat a objectes de Java. Per aquest motiu, de moment n’hi ha prou que simplement aprengueu les instruccions des d’un punt de vista purament pràctic i funcional, però sense haver de saber exactament què està passant o quina sintaxi concreta s’està usant.

Per llegir dades de teclat cal usar una biblioteca, un conjunt d’extensions a les instruccions disponibles per defecte en el llenguatge. Per usar alguna de les extensions disponibles en una biblioteca, cadascuna identificada amb un nom, primer cal importar-la. Llavors, el primer que es fa és inicialitzar l’extensió, assignant-li un identificador, i a partir de llavors ja la podeu usar dins del vostre codi font.

import java.util.Scanner;
public class EntradaValors {

  public static void main(String[] args) {

   //S’inicialitza la biblioteca.
   Scanner lector = new Scanner(System.in);

   //Es posa un missatge inicial.
   System.out.println("Anem a sumar dos nombres enters");

   System.out.print("Escriu un nombre i pitja la tecla de retorn: ");
   //Es llegeix un valor enter per teclat.
   int primerEnter = lector.nextInt();
   //S’espera que es pitgi la tecla de retorn.
   lector.nextLine();

   //Es torna a fer...
   System.out.print("Torna a fer-ho: ");
   int segonEnter = lector.nextInt();
   lector.nextLine();

   //Fem l’operació.
   int resultat = primerEnter + segonEnter;

   //Imprimeix el resultat per pantalla!
   //S’usa l’operador suma entre una cadena de text i un enter
   System.out.println("La suma dels dos valors és " + resultat + ".");

  }
}

Un cop l’extensió està inicialitzada (en aquest cas, només es fa un sol cop), el programa està preparat per llegir dades de diferents tipus des del teclat. De moment, n’hi ha prou que aprengueu com podeu llegir dades d’una en una, usant diferents línies de text per entrar cada dada individual. Per fer-ho, cal alternar les instruccions de lectura enumerades a la taula següent, segons el tipus de dada que es vol llegir des del teclat, i la instrucció lector.nextLine();, tal com es veu a l’exemple.

Per no haver d’entrar en detalls, podeu considerar que cadascuna de les instruccions de la taula es comporta exactament igual que una expressió que com a resultat avalua la dada introduïda pel teclat. La instrucció mateixa és la que s’encarrega de transformar el text escrit, una cadena de text, en una dada del tipus corresponent. Normalment, tota dada llegida serà assignada a alguna variable prèviament declarada. Si us resulta més còmode, es pot fer en una sola línia com en el codi d’exemple, assignant el valor llegit directament com a part de la inicialització de la variable. Usant aquest procediment, si en una mateixa línia s’introdueix text amb més d’una dada, només es llegeix la primera de totes. La resta s’ignora.