5  Tipus de dades i operadors en Java

Objectius:

  • Declarar i inicialitzar variables en Java amb el tipus adequat.
  • Conèixer els tipus primitius (int, double, boolean, char) i la classe String.
  • Escriure literals de cada tipus correctament.
  • Definir constants amb final.
  • Fer servir els operadors aritmètics, relacionals, lògics i d’assignació de Java.
  • Entendre les conversions de tipus i el càsting.

5.1 Declarar variables en Java

En pseudocodi n’hi havia prou amb escriure edat ← 25.

Java és més estricte: abans de fer servir una variable, l’has de declarar indicant el tipus d’informació que guardarà.

La forma general és:

tipus nom = valor;

Exemples:

int edat = 25;              // Un enter
double alcada = 1.68;       // Un número amb decimals
String nom = "Marta";       // Un text
boolean esSoci = true;      // Cert o fals

Pots declarar primer i assignar després:

int edat;        // declaració (la caixa existeix, buida)
edat = 25;       // assignació (hi posem un valor)
NotaPer què cal indicar el tipus?

Dir el tipus per endavant permet a Java reservar la memòria justa i detectar errors abans d’executar.

Si declares int edat i intentes guardar-hi "vint", el compilador t’avisa de seguida. És una xarxa de seguretat.

AlertaError típic: fer servir una variable sense declarar-la

En Java no pots escriure edat = 25; si abans no has dit int edat;. Obtindràs l’error “cannot find symbol”.

Cada variable necessita una declaració amb el seu tipus.

5.2 Els tipus primitius

Java té vuit tipus primitius, però sobretot utilitzarem:

Tipus Guarda Exemple de literal Mida
int Números enters 42, -7, 0 32 bits
double Números amb decimals 3.14, -0.5, 100.0 64 bits
boolean true o false true, false —
char Un sol caràcter 'a', '?', '7' 16 bits
NotaAnalogia: el tipus és la mida de la caixa

Pensa en els tipus com caixes de mides diferents.

  • Un int és una caixa preparada per a números sencers.
  • Un double és més gran perquè hi cap la part decimal.
  • Un boolean és minúscula: només hi cap un interruptor engegat/apagat.

Tries la caixa segons què hi vols guardar.

Existeixen altres tipus primitius numèrics (long per a enters molt grans, float per a decimals de menys precisió, byte, short), però amb int i double en tindràs prou durant molt de temps.

Literals

Un literal és un valor escrit directament al codi. La forma d’escriure’l depèn del tipus, i cal respectar-la:

int quantitat = 100;          // Enter: cap punt decimal
double preu = 19.95;          // Decimal: amb punt (no coma!)
boolean actiu = true;         // Només true o false, en minúscula
char inicial = 'M';           // Caràcter: cometes SIMPLES
String ciutat = "Girona";     // Cadena: cometes DOBLES
AlertaError típic: la coma decimal

En Java (i en programació en general) els decimals s’escriuen amb punt, no amb coma: 3.14, mai 3,14.

La coma té un altre significat (separar valors). Si escrius 3,14, Java ho interpreta com dues coses diferents i falla.

5.3 La classe String

El text no és un tipus primitiu: és un objecte de la classe String. Per això String s’escriu amb majúscula inicial, a diferència d’int o double.

De moment tracta’l com un tipus més per guardar text; els objectes els treballarem més endavant.

String salutacio = "Hola";
String nom = "Ada Lovelace";

Amb l’operador + pots concatenar cadenes:

String nom = "Ada";
String cognom = "Lovelace";
String complet = nom + " " + cognom;   // "Ada Lovelace"

Els String tenen molts mètodes útils (llargada, majúscules, cerca…). Els anirem veient a mesura que els necessitem:

String paraula = "programació";
System.out.println(paraula.length());         // 11 (nombre de caràcters)
System.out.println(paraula.toUpperCase());    // PROGRAMACIÓ

5.4 Constants amb final

Una constant és un valor que no ha de canviar mai. En Java, es declara afegint la paraula final davant del tipus. Per convenció, el nom va en MAJÚSCULES amb guions baixos:

final double IVA_GENERAL = 0.21;
final int DIES_SETMANA = 7;
final double PI = 3.14159;

Si intentes canviar una constant, el compilador t’ho impedeix:

final int MAXIM = 100;
MAXIM = 200;              // ERROR de compilació: cannot assign a value to final variable
ConsellQuan fer servir una constant

Sempre que un valor fix aparegui més d’un cop, o sigui un “número màgic” el significat del qual no és evident. preu * IVA_GENERAL s’entén millor que preu * 0.21, i si l’IVA canvia el modifiques en un sol lloc.

5.5 Operadors aritmètics

Els operadors en Java són els mateixos que vam veure amb pseudocodi:

Operador Operació Exemple Resultat
+ Suma 4 + 3 7
- Resta 4 - 3 1
* Multiplicació 4 * 3 12
/ Divisió 10.0 / 4 2.5
% Mòdul (residu) 10 % 3 1


El mòdul del pseudocodi és el símbol % en Java. La resta és igual.

El parany de la divisió entera

Aquí hi ha una trampa important. Quan divideixes dos enters, Java fa una divisió entera: descarta els decimals.

int a = 10;
int b = 4;
System.out.println(a / b);        // 2   (no 2.5!)
System.out.println(10.0 / 4);     // 2.5 (un dels dos és double)

10 / 4 dona 2 perquè tots dos són int i el resultat també ha de ser int. Perquè surti 2.5, almenys un dels operands ha de ser double.

AlertaError típic: la mitjana que surt malament

Un clàssic: calcular una mitjana amb enters i obtenir un valor sencer erroni. (7 + 8) / 2 amb enters dona 7, no 7.5.

Solució: fes que algun valor sigui double, per exemple (7 + 8) / 2.0.

Ús de l’operador mòdul

El residu és molt útil. Dos usos habituals:

// Saber si un número és parell
int n = 8;
boolean esParell = (n % 2 == 0);        // true

// Obtenir l'última xifra d'un número
int codi = 1234;
int ultima = codi % 10;                 // 4

5.6 Operadors d’assignació

A part de =, Java ofereix dreceres per modificar una variable a partir del seu valor actual.

Drecera Equival a Efecte
x += 5 x = x + 5 Suma 5 a x
x -= 5 x = x - 5 Resta 5 a x
x *= 2 x = x * 2 Multiplica x per 2
x /= 2 x = x / 2 Divideix x entre 2
x++ x = x + 1 Incrementa x en 1
x-- x = x - 1 Decrementa x en 1


Els operadors ++ i -- els faràs servir constantment als bucles.

int punts = 10;
punts += 5;    // punts val 15
punts++;       // punts val 16

5.7 Operadors relacionals i lògics

Serveixen per construir condicions, que donen sempre un boolean.

Fixa’t en els canvis de símbol respecte al pseudocodi:

Pseudocodi Java Significat
= == Igual a
≠ != Diferent de
> > Més gran que
< < Més petit que
≥ >= Més gran o igual
≤ <= Més petit o igual


I els operadors lògics (I, O, NO del pseudocodi):

Pseudocodi Java Dona true quan…
I && Totes dues parts són certes
O \|\| Almenys una part és certa
NO ! Inverteix el valor


Exemple:

int edat = 20;
boolean teCarnet = true;
boolean potConduir = (edat >= 18) && (teCarnet == true);   // true
boolean capFestiu = false || true;                          // true
boolean noPlou = !false;                                    // true
AlertaError típic: confondre = amb ==

Aquest és l’error més important d’aquest capítol. = assigna un valor; == compara dos valors.

  • edat = 18 posa 18 dins d’edat;
  • edat == 18 pregunta si edat val 18.

Dins d’una condició, sempre vols ==. Confondre’ls és una font infinita de bugs.

5.8 Conversions de tipus i càsting

De vegades cal passar un valor d’un tipus a un altre. Hi ha dos casos:

  • Conversió automàtica
  • Conversió manual

Conversió automàtica (implícita)

Quan el tipus destí és més gran i no es perd informació, Java ho fa sol.

Per exemple, un int cap dins d’un double sense problema:

int enters = 5;
double decimals = enters;    // 5.0, conversió automàtica

flowchart LR
    A["int<br/>(caixa petita)"] -->|"automàtic<br/>no es perd res"| B["double<br/>(caixa gran)"]
    B -.->|"càsting obligatori<br/>es perden decimals"| A

Conversió manual (càsting)

Quan el tipus destí és més petit i es pot perdre informació, Java t’obliga a demanar-ho explícitament, escrivint el tipus entre parèntesis. Això és el càsting:

double preu = 19.95;
int preuSencer = (int) preu;    // 19  (es perd el .95, es trunca)

El càsting d’un double a int no arrodoneix: talla els decimals. 19.95 es converteix en 19, no en 20.

AlertaError típic: perdre decimals sense adonar-se’n

Un càsting a int sempre trunca cap avall.

Si vols arrodonir un decimal, no facis càsting: fes servir Math.round(), que sí que arrodoneix al més proper. (int) 2.9 dona 2, però Math.round(2.9) dona 3.

Conversió de text a número

Quan llegeixes text i necessites un número, o a l’inrevés, hi ha mètodes específics:

String textNombre = "42";
int nombre = Integer.parseInt(textNombre);       // text -> int: 42

double d = Double.parseDouble("3.14");           // text -> double: 3.14

int edat = 19;
String textEdat = String.valueOf(edat);          // int -> text: "19"

5.9 Un exemple resum

Vegem un programa que fa servir variables, constants, operadors i conversions. Calcula el preu final d’una compra amb IVA:

import java.util.Scanner;

public class CalculadoraIva {

    public static void main(String[] args) {
        final double IVA_GENERAL = 0.21;      // constant
        Scanner lector = new Scanner(System.in);

        System.out.print("Preu sense IVA: ");
        double preuBase = lector.nextDouble();

        System.out.print("Unitats: ");
        int unitats = lector.nextInt();

        double subtotal = preuBase * unitats;       // aritmètica
        double impostos = subtotal * IVA_GENERAL;
        double total = subtotal + impostos;

        System.out.println("Subtotal: " + subtotal + " EUR");
        System.out.println("IVA (21%): " + impostos + " EUR");
        System.out.println("TOTAL: " + total + " EUR");

        lector.close();
    }
}

Aquí veus tots els conceptes junts:

  • Una constant: IVA_GENERAL.
  • Tipus double,int.
  • Operadors aritmètics.
  • Sortida amb concatenació.

Aquesta és l’estructura típica d’un programa senzill: llegir dades, calcular, mostrar resultats.

5.10 Resum

  • En Java cal declarar cada variable amb el seu tipus abans de fer-la servir: tipus nom = valor;.
  • Els tipus primitius bàsics són int (enters), double (decimals), boolean (true/false) i char (un caràcter). El text és la classe String.
  • Els literals tenen forma pròpia: decimals amb punt, char amb cometes simples, String amb cometes dobles.
  • Les constants es declaren amb final i en MAJÚSCULES.
  • Els operadors aritmètics inclouen % (mòdul). Compte amb la divisió entera: 10 / 4 dona 2.
  • == compara, = assigna: no els confonguis. Els operadors lògics són &&, ||, !.
  • Les conversions poden ser automàtiques (a un tipus més gran) o manuals amb càsting (int), que trunca els decimals.