Java: introducció ràpida

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

Eclipse IDE

Es recomana utiltizar Eclipse com a IDE, ja que facilita molt el desenvolupament amb llibreries.

Per demanar dades a l'usuari per consola: http://stackoverflow.com/questions/8560395/how-to-use-readline-in-java

• Per consola del SO:

  String input = System.console().readLine()

• En Eclipse utiltiza un d'aquests dos mètodes: (ambdós s'expliquen al link donat més amunt)
  • Scanner
  • BufferedReader

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[] = 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 d'atributs

Hi ha diversos tipus de visibilitat d'atributs:

• public: pot accedir-hi qualsevol objecte extern o intern
• private: només es pot accedir des de la pròpia classe
• protected: pot accedir la pròpia classe i les seves derivades

Sobrecàrrega de mètodes

En C++ i Java podem tenir diversos mètodes amb el mateix nom però amb diferents paràmetres.

Mira't la classe "Cosa":

public class Principal
{
    // incloem la subclasse dintre de Principal
    class Cosa
    {
        // atributs
        public int val = 0;
        // mètode fes_algo sobrecarregat
        public void fes_algo() {
            System.out.println( "Res a fer..." );
        }
        public void fes_algo(String s) {
            System.out.println( "Mostrant: " + s );
        }
    }

    // mètodes de Principal
    public void run()
    {
        Cosa c = new Cosa();
        c.fes_algo();
        c.fes_algo("lalala");
    }
    
    public static void main(String []args)
    {
        // al ser static cal que creem la 1a instància de la classe
        Principal p = new Principal();
        p.run();
    }
}

Fixeu-vos en:

• Inner-class (classe dins d'una altra): No podem posar una altra classe al mateix nivell que Principal (ha de ser el nom de l'arxiu).
• El mètode main és static i això fa que no puguem cridar funcions no-estàtiques.
  • SOLUCIÓ: crear una instància de la classe Principal
  • Referència sobre mètodes static.

Llistes i polimorfisme

...

Threads

Un thread és un fil d'execució independent, similar als processos del sistema operatiu, però dins d'una mateixa tasca.

Llegiu aquest article i feu els exercicis al respecte:

• Threads en Java.
• Exercicis de threads.

Inner classes i atributs

...TODO...