Dades i Variables

name: portada
class: portada-slide, center, middle

# Programació
## Dades i Variables

.footnote[Joan Puigcerver Ibáñez]

---
layout: true
class: regular-slide
.right[.logo[![logoMislata](/itb/images/logo_mislata.png)]]

---
# .blue[Dades]
- Un programa pot manipular i processar dades
- Tipus de dades simples (primitives):
	- Números enters (.blue[int])
	- Números reals o decimals (.blue[double],.blue[float])
	- Verdader o fals, booleà (.blue[boolean])
	- Lletres o caràcters (.blue[char])

---
# .blue[Integer] - Nombre enter

- Valor numèric, positiu o negatiu, sense cap decimal.
  - 35
  - 203920
  - 0
  - -3222
- Identificador: .blue[int]
- Utilitza 32 bits de memòria, per tant, pot emmagatzemar nombres en el rang _-2.147.483.648_ a _2.147.483.647_ (-2^31 to 2^31-1)
- Si necessitem nombres més grans, podem utilitzar .blue[long], amb 64 bits.

---
# .blue[Integer] - Exemple

```
/**
 *  Prints 4
 */
public static void main(String[] args) {
    System.out.println(4);
}
```

- Tip: escriu _sout_+Tab al intellij

---
# .blue[Integer] - Operacions
- Suma
	- `4 + 5`
- Resta
	- `6 - 3`
- Multiplicació
	- `4 * 6`
- Divisió (entera)
	- `11 / 2 -> 5`
- Mòdul (residu)
	- `11 % 2 -> 1`

---
# .blue[Integer] - Operacions

- Podem usar encadenar operacions i usar parèntisis
	- `(33 + 4) * (3 - 9)`
- Les prioritats entre operacions són les mateixes que en les matemàtiques convencionals.
    - `2 * 3 + 4 = 4 + 2 * 3 = 10`
- En cas d'empat, es resolen d'esquerra a dreta.
    - `5 * 3 / 4 ≠ 3 / 4 * 5`

---
# .blue[Integer] - Operacions - Exemple

```
/**
 *  Prints 4+5
 */
public static void main(String[] args) {
    System.out.println(4+5);
}
```

---
# .blue[Variable]

.center[.large[Contenidor (caixa) on hi podem guardar temporalement una dada.]]

---
# .blue[Variable]
- Abans de poder utilitzar una variable .blue[s'ha de declarar]
- Per declarar una variable hem de definir:
	- Tipus
	- Identificador (o nom)
- També podem assignar-li un valor inicial (o no).

```
// <tipus> nomVariable = <valorInicial>;
int boxCounter = 0; // amb valor inicial
int maxHeight; // sense valor inicial
```

---
# .blue[Variable] - Identificador
- El identificador ha de ser descriptiu

.center[
![](img/boxes_naming_good.png)
![](img/boxes_naming_bad.png)
]

---
# .blue[Variable] - Identificador
- Guia d'estil (_Java_)
	- .blue[lowerCammelCase]
		- Primer caràcter mínuscula
		- Majúscula la primera lletra de cada paraula
		- Ex.:
			- _boxNumber, pacientBirthDate, country_

---
# .blue[Integer] - Operacions - Exemple amb variables

```
/**
 *  Prints 4+5
 */
public static void main(String[] args) {
	int firstValue = 4;
	int secondValue = 5;
	int totalValue = firstValue + secondValue;
    System.out.println(totalValue);
}
```

---
# .blue[Integer] - Input
Podem preguntar-li al usuari del programa que introdueixi dades per processar-les.

Per llegir-les utilitzarem l'objecte .blue[Scanner].

```
/**
 *  Reads a int from the input and prints it.
 */
public static void main(String[] args) {
	// Prepare to read values from input.
    Scanner scanner = new Scanner(System.in);
    // Reads an int
    int userInputValue = scanner.nextInt();
    System.out.println(userInputValue);
}
```

---
# .blue[Integer] - Operacions
- Increment variable
    - __variable++__
- Decrement variable
	- __variable--__

---
# .blue[Exercicis]
- [Exercici IntDoubleMe](exercicis/01_exercicis_variables.html#enters)

- [Exercici IntSum](exercicis/01_exercicis_variables.html#enters)

---
# .blue[Double] - Nobre real
## double
- valor numèric, positiu o negatiu, amb decimals.
>>> 35.23, 203920.23, 0.0, -3222.342
- Identificador: .blue[double]

---
# .blue[Double] - Operacions

Podem fer les mateixes operacions que amb enters excepte el mòdul.
- Suma
	- `4.2 + 5.3`
- Resta
	- `6.234 - 3.0`
- Multiplicació
	- `4.32 * 6.43`
- Divisió
	- `11.2 / 2.1`

---
# .blue[Double] - Input
També podem preguntar a l'usuari per un nombre decimal.

```
import java.util.Scanner;
import java.util.Locale;

/**
 *  Reads a double from the input and prints it.
 */
public static void main(String[] args) {
	// Prepare to read values from input.
    Scanner scanner = new Scanner(System.in).useLocale(Locale.US);
    // Reads an double
    double userInputValue = scanner.nextDouble();
    System.out.println(userInputValue);
}
```

* .blue[Locale]: La notació per decimals pot variar depenent de la zona en la qual ens trobem.

Per exemple, a ES normalment s'escriuen els decimals amb __coma__,
mentre que a US o UK s'utilitza el __punt__. Locale és la configuració de la localització. Si no s'especifica, utilitzarà la del sistema per defecte.

???
Comentari Mateu: posar aquí el locale???

---
# .blue[Boolean] - booleà
- Valor de tipus lògic per tal d’establir certesa o falsedat. Té 2 valors possibles:
	- .blue[true] (cert)
	- .blue[false] (fals)
- Identificador: .blue[boolean]

---
# .blue[Boolean] - exemple

```
/**
 *  Prints true
 */
public static void main(String[] args) {
    System.out.println(true);
}
```

---
# .blue[Boolean] - Operacions
- Quines operacions podem fer amb booleans?

---
class: center
# .blue[Boolean] - Operacions
## Taules de la veritat

NOT (.blue[!])

| A | NOT |
| :-: | :-: |
| 0 | __1__ |
| 1 | __0__ |

???
Notes Mateu: caular taula de veritat der and i or. Mirar traspas originals.

---
class: center
# .blue[Boolean] - Operacions
## Taules de la veritat

AND (.blue[&&]) .whitespace[ ] OR (.blue[||])

| A | B | AND | OR |
| :-: | :-: | :-: | :-: |
| 0 | 0 | __0__ | __0__ |
| 0 | 1 | __0__ | __1__ |
| 1 | 0 | __0__ | __1__ |
| 1 | 1 | __1__ | __1__ |

---
# .blue[Boolean] - Operacions - Exemple

```
/**
 *  Prints true && false
 */
public static void main(String[] args) {
    boolean testAnd = true && false;
    System.out.println(testAnd);
}
```

---
# .blue[Integers] - Comparacions
Produeixen un resultat booleà.
- Igual que (.blue[==])
	- `3 == 2 //false`
- Diferent que (.blue[!=])
- Major que (.blue[>])
- Menor que (.blue[<])
- Major o igual que (.blue[>].blue[=])
- Menor o igual que (.blue[<=])

---
# .blue[Exercicis]
- [Exercici IsLegalAge](exercicis/01_exercicis_variables.html#boolean)

- [Exercici IsGreater](exercicis/01_exercicis_variables.html#boolean)

---
# .blue[Char] - Caràcter
- Unitat fonamental de text usada en qualsevol alfabet, un nombre o un signe de puntuació o exclamació.
	- S'escriuen entre 'cometes simples'

>>> 'a', 'C', '9', '?'

- Identificador: .blue[char]

---
# .blue[Char] - operacions
- igual (==)
  - 'a' == 'c'
- diferent
  - 'a' != 'c'

- Codificació UTF-16
	- Cada caràcter es representa amb un número
	- https://asecuritysite.com/coding/asc2
	- \>, <, >=, <=, +, -

---
# Números .blue[grans]
- Podem escriure un enter
	- 123123123
	- 123_123_321
- Prova el següent codi

```
int worldPopulation =  7_800_000_000;
```

---
# .blue[Long]
- int
	- -2.147.483.648 a 2.147.483.648
- long
	- -9.223.372.036.854.775.808 a 9.223.372.036.854.775.808

```
long worldPopulation =  7_800_000_000l;
```

---
# .blue[Float]
- double
	- real de precisió doble
- float
	- real de precisió simple

```
System.out.println(0.12345678901234567890);
System.out.println(0.12345678901234567890f);

System.out.println(123_456_789_123_456_789.0);
System.out.println(123_456_789_123_456_789.0f);
```

---
# .blue[Conversió] entre tipus
- Podem convertir un valor entre diferents tipus amb un cast
	- (int) 6.7
- Si no es perd informació amb la conversió, aquesta es pot realitzar automàticament.

```
int intFromFloat = (int) 34.6;
int intFromFloat2 = (int) 34f;

// algunes conversions el cast no és obligatori
double floatFromInt = 342;
int intFromChar = 'a';
long longFromInt = 34;
```

---
# .blue[String]
- Cadena de caràcters
	- S'escriuen entre ""
- No és un tipus base
	- L'estudiarem en profunditat més endavant
- Exemples:

```
System.out.println("Hola!");
System.out.println("Resultat: 5");
System.out.println("Una línia\nDues Línies\nTres Línies");
System.out.println("Una contrabarra: \\\\");
```

---
# String - .blue[0peracions]
- Contactenar (+)
  - "Hola"+" a tothom"
  - "Resultat: "+ 3
- Comparar
  - No podem usar == per comprar Strings
  - Usarem equals
  ```
text.equals("SomeText")
  ```
- Per llegir un String des de la terminal s'utilitza:
  - scanner..blue[next()]: Llegeix la següent paraula.
  - scanner..blue[nextLine()]: Llegeix la següent línia.

---
# .blue[Imprimir] per pantalla
- Per mostrar informació per la consola, s'utilitza la sortida estàndar (__sout__): .blue[System.out]

- __System.out..blue[println](String text)__: Imprimeix el _text_ amb un salt de línia (__\n__) al final.
- __System.out..blue[print](String text)__: Sols imprimeix _text_, sense salt de línia.
- __System.out..blue[printf](String format, ... _variables_ )__: Imprimeix amb format.
  - [Documentació](https://docs.oracle.com/javase/tutorial/java/data/numberformat.html)