Java: introducció ràpida

De Cacauet Wiki
Salta a la navegació Salta a la cerca

Introducció

Java és un llenguatge compilat que corre sobre una màquina virtual, JVM o Java Virtual Machine amb la intenció de que sigui multiplataforma. És fortament orientat a objectes i s'inspira en C++.

El va desenvolupar Sun Microsystems (els mateixos que VirtualBox i OpenOffice) sota llicència Open Source. El 2011 Sun va ser absorbida per Oracle, companyia que no impulsa les llicències obertes com ho feia Sun, pel que aquests projectes s'han vist ralentits o aturats.

La seva principal fortalesa és que és un llenguatge mols estès, en particular en BBDD i programació web. També es poden desenvolupar aplicacions amb GUI tipus desktop, però al córrer sobre una màquina virtual solen ser més lentes que amb codi natiu.

Amb l'adveniment d'Android també s'ha impulsat més encara a l'utilitzar el SDK com a base per a desenvolupament d'aplicaions mòbils d'aquest SO.


Instal·lació

Distingim:

  • JRE: Java Runtime Environment. Conté la JVM i permet executar codi Java però no porta el codi font.
  • JDK: Java Development Kit. Conté el JRE + el codi font (headres, etc.) que permet desenvolupar.

Per saber quina versió tenim instal·lada podem fer:

$ java --version


Compilació i execució bàsica

Arxius:

  • .java : font
  • .class : codi compilat

Podem compilar des de línia de comandes amb:

$ javac <exemple.java>

Executem amb la VM de Java (sense .class ni res):

$ java <exemple>


Tipatge estàtic

A diferència dels llenguatges de scripting com Python, Ruby o PHP, en Java els tipus de dades son estàtics, és a dir, cal declarar les variables i el seu tipus a priori per poder ser utilitzades.

Per exemple:

int a;        // declaració
a = 10;       // ús de la variable
a = "lalala"; // ERROR de COMPILACIÓ: si l'hem declarat com un integer no podem assignar-li un string o char array.
              //       (sí que podem fer-ho en llenguatges de scripting)


Primer exemple compilable

El programa més senzill de Java el podriem fer així:

class Prova1
{
    public static void main(String []args)
    {
        int nargs = args.length;
        System.out.println("num args: " + nargs);
    }
}

Pren nota d'algunes coses importants:

  • Total orientació a objectes: no hi ha funcions "sueltes". Tot ha d'anar dins d'un objecte.
  • El nom de la classe ha de coincidir amb el de l'arxiu (case sensitive).
  • La classe on iniciarem l'execució ha de tenir un mètode public static void main( String []args ).
  • A la variable args rebem els paràmetres que podem fer-li arribar a l'executable a través de la consola.
    • args és un array de Strings (oju, immutable). Li podem demanar quants elements té amb args.length .

Això ho compilariem i executariem així:

$ javac Prova1.java 
$ java Prova1 hola 3
num args: 2


Tipus bàsics

Els tipus bàsics son (definim i iniciem en una sola línia):

// Sencers (també poden ser unsigned amb el què guanyem 1 bit de signe)
byte  b = 0;          // 8 bits
short s = 3;          // 16 bits
int   i = 133;        // 32 bits
long  l = 1234567890; // 64 bits
// Punt flotant
float  f = 1.3f; // ULL: cal la "f"
double d = 0.11f;
// Char
char c = 'e';              // ULL: calen COMETES SIMPLES
String s = "hola què tal"; // cometes dobles


Arrays, matrius i Strings

De qualsevol d'aquests tipus bàsics podem fer un array o matrius multidimensionals. Son mutables, és a dir, es poden modificar:

int a[] = { 1, 2, 44 };   // definim i assignem valors
int a[] = new int[3];    // creem l'array (reservem memòria) però sense assignar valors
a[2] = 33;                // assignem valor

Fixa't en què per reservar l'espai de memòria hem utilitzat la paraula reservada new.


String

El cas de l'objecte String (immutable) s'ha de distingir clarament del char array (mutable). Es poden transformar l'un en l'altre amb alguns mètodes estàtics de les classes String.

// Strings to char array.
// NOTA: No es pot inicialitzar un char array de cap altra manera
String s = "hola que tal";          // declarem i inicialitzem String (immutable)
char frase[] = s.toCharArray();     // declarem i inicialitzem char array
frase[7] = 'è';                     // modifiquem char array

// en una sola línia
char frase[] = new String("hola que tal").toCharArray();

// Char array to String
String s2 = frase.toString();


Instanciació d'objectes. Punters

Per poder instanciar un objecte (reservar espai de memòria per usar-lo efectivament) sempre ho fem a través d'un punter i cal utilitzar la paraula clau new.

Activity act;         // Declaració: "act" és un punter
act = new Activity(); // instanciem

// en una línia
Activity act = new Activity();

Molt important:

  • Per poder accedir als objectes ho fem SEMPRE amb punters.
  • Quan declarem ("act" en l'exemple) només tenim un punter a null (sense objecte).
  • Per reservar espai de memòria utilitzem new.
  • Els tipus bàsics no cal instanciar-los (perquè son immutables), sempre i quan no siguin arrays.
  • Els arrays SEMPRE cal reservar l'espai de memòria amb new:
    int a[3] = new int[3];


Recol·lecció de basura (garbage collection)

Els llenguatges de baix nivell (d'abstracció) com C++ sempre cal tenir cura d'esborrar els objectes creats. En Java no cal perquè quan un punter deixa d'apuntar a una variable, el sistema ho detecta i l'esborra a través del garbage collector.

Pilota p = new Pilota("basket");    // delcarem punter "p" i hi instanciem una pilota de basket.
// ...utilitzem la pilota de basket i després decidim utilitzar una altra...
p = null;                    // pas opcional. En algun moment la pilota de basket s'esborrarà (però no sabem quan)
p = new Pilota("futbol");    // creem nova pilota de futbol

El què no és tan fàcil és saber QUAN ho farà, de manera que per certes aplicacions crítiques pot interessar llenguatges de més baix nivell, o implementar algunes parts (llibreries) en C++ per després cridar-les des de Java o Python.


Visibilitat de variables

Sobrecàrrega de funcions

Herència, abstracció i interfaces

Polimorfisme