Mostra la font per a DAM-M3-UF4. Sintaxi

torna [[ M3 - Programació ]]

== Estructura i organització ==

=== Paquets ===


Un paquet és un conjunt de classes organitzades i relacionades que es veuen unes a les altres i que comparteixen recursos.

Un paquet són una agrupació de classes relacionades funcionalment. El SDK de Java proporciona gran quantitat de paquets de codi obert que cal conèixer per estalviar-nos temps i esforços.

* '''java.lang''', conté les funcions pròpies del llenguatge. '''Aquest no cal importar-lo''', ja que el compilador considera que l’importem cada cop que fem un programa.
* '''java.util''', amb tot d’utilitats addicionals.
* '''java.text''', amb utilitats de format i manipulació de textos.
* '''java.math''', amb funcions matemàtiques.
* '''java.io''', amb rutines d’entrada i sortida
* '''java.net''', amb utilitats de xarxa.
* '''java.applet''', per a construir applets.
* '''java.awt''', per a gràfics i interfícies gràfiques d’usuari (GUI).
* '''java.sql''', classes per a accedir a bases de dades.

Per importar un paquet i poder usar les classes que conté cal indicar el ''paquet.*''

Els punts en els noms dels paquets indiquen la estructura de directoris on es troben les classes.

Es recomanable crear les nostres classes '''sempre''' en algun paquet

<pre>
package dam.m3.uf4;

public class Radi {
    ....
}
</pre>

=== Llibreries ===


Les llibreries a Java es troben comprimides normalment en fitxers ''.jar''. Una vegada totes les funcions d’una llibreria estan finalitzades i no cal compilar-les més, el fitxer ''.jar'' generat el podem distribuir i incorporar fàcilment als nostres programes o a d’altres.

Java proporciona la utilitat ''jar' per crear aquestes llibreries. La sintaxi és la següent

<pre>
 $jar cvf nomllibreria.jar directori
</pre>

Aquesta instrucció crea una llibreria ''nomllibreria.jar'' amb el contingut del directori



=== Compilació i execució. Terminal ===

La variable d’entorn '''CLASSPATH''' indica els directoris on el compilador espera trobar els paquets i classes definits. Per defecte només cerca al directori actual. (Al treballar amb Eclipse no cal definir-la, ho gestiona automàticament)


La variable CLASSPATH pot apuntar a un directori o a un fitxer, i pot contenir múltiples entrades separades per “;”:

* Per a .class en packets sense nom (Sense la declaració package). CLASSPATH ha de contenir el nom del directori
* Per a .class en paquets amb nom. CLASSPATH ha de contenir el nom del 	directori principal del paquet
* Per llibreries .jar o .zip. CLASSPATH ha de contenir el nom del fitxer

Per compilar un programa que utilitza una llibreria jar sense definir CLASSPATH

<pre>
$javac –cp c6.jar ExSample.java
</pre>

Per executar el programa sense definir CLASSPATH

<pre>
$java –cp .;c6.jar ExSample // El . per referenciar el fitxer ExSample.class 
</pre>

També es pot definir el CLASSPATH

<pre>
$set CLASSPATH=.;c6.jar

$java ExSample
</pre>

== Sintaxis ==

=== El primer programa ===

<pre>
import java.io.*;

public class PrimerPrograma {

    public static void main(String[] args) {

        System.out.println("(''Text qualsevol'')"); // Display the string.

    }

}
</pre>

* A Java tot el codi va dins de les classes (Funcions + Dades)
* Per determinar on comencen i acaben les estructures (classe, funcions, estructures de control) s’utilitzen els caràcters { }
* La classe principal ha de tenir el mateix nom que el fitxer que la conté (Case sensitive)
* La paraula ''import'' indica els recursos externs que usem dins el nostre programa (API de java o recursos propis)
* Les aplicacions d'escriptori (No Applets per exemple), dins de la classe principal sempre tenen la funció '''main'''. Aquesta és la funció per on entra el programa a l’execució. La capçalera de la funció és '''obligatòriament''' la de l'exemple.
* Per finalitzar qualsevol instrucció cal posar “;”
* Java distingeix majúscules i minúscules

=== Comentaris ===

Els comentaris en Java poden ser

* De una línia i comencen per "//", es poden col·locar a qualsevol lloc i marquen tot el que segueix fins al final de línia com un comentari
* De bloc, delimitats per "/*  .....   */".
* De Javadoc, mostrar informació quan es genera la documentació, delimitats per "/** ....... */"

=== Declaració de variables i assignació ===

La declaració de variables és OBLIGATÒRIA, a diferència d'altres llenguatges com PHP o VB

Els '''tipus de dades primitius''' són:

* byte . Nombres enters "molt curts" de 8 bits.
* short . Nombres enters "curts" de 16 bits.
* int . Nombres enters de 32 bits.
* long . Nombres enters "llargs" de 64 bits.
* float . Nombres reals de 32 bits. Precisió simple.
* double . Nombres reals de 64 bits. Precisió doble.
* char . Caràcters de 16 bits (UNICODE).
* boolean . Valors de veritat o falsedat: només pot ser  '''true''' o  '''false''' (Paraules reservades).

'''Observar que tots comencen amb minúscules!!!!!''', a diferència de les classes que sempre comencen amb majúscules.

La declaració de variables

<pre>
tipus_de_dada nom_variable [= valor_inicial];
</pre>

Per exemple

<pre>
        int i;
        double radi, sup;
        boolean repetidor;
        int k = 3;
</pre>

La operació d’''assignació'' es realitza amb el símbol "=" (No confondre amb la operació de comparació "= =")

Per exemple

<pre>
        int i, j;
        i = 3;
        j = i;
        j = j * 4 + 3;
        j += 5; // Equivalent a j = j + 5.
</pre>


Abans de fer servir qualsevol variable cal inicialitzar-la, directe o indirectament

Per exemple, el següent codi genera diversos errors

<pre>
        boolean a;
        if (a == true) System.out.println("true");
        else  System.out.println("false");
        String b;
        System.out.println(" ----" + b + "----- ");
        int c;
        System.out.println(c);
</pre>


=== Visibilitat ===

Una variable només és accessible

* Dins del fragment de codi delimitat per { } on està declarada
* Si és un paràmetre d'un mètode (veure mètodes més endavant), dins el propi mètode

Per exemple, el següent codi genera errors

<pre>
        int a;
        if (true) {
            int d;
        }
        a = 1;
        d = 4;    //Error
</pre>

=== Constants ===

La declaració de constants en Java, s'associa a conceptes de OO.

De moment només cal saber que cal definir les constants fora de les funcions (però dins de la classe)

<pre>
static final tipus_de_dada NOM_CONSTANT [= valor_inicial];
</pre>

Per exemple

<pre>
public class Radi {

    static final double PI = 3.1416; //Fora del main

    public static void main(String[] args) {

        double radi, perimeter;

        radi = 3.3;
        perimeter = radi * PI * 2.0;

        System.out.println("El perimetre es : " + perimeter);
    }
}
</pre>

=== Cadenes de caràcters. String ===

Java proporciona la classe String pel tractament de text. (No és un tipus simple, és una classe).

* Operació "+" per concatenar.

I els següents mètodes d'utilitat per exemple

* Text.length(): Longitud d’una cadena de text
* Text.substring(index inici, index final): Obté un tros d’una cadena
* Text.equals("Altre Text"): Compara dos textos

Per exemple

<pre>
        String textemeu;
        textemeu = "Bon";
        textemeu += " dia";
       
        System.out.println(textemeu.length()); // Escriu la longitud del text, 7
        System.out.println(textemeu.substring(1,3)) ;// Escriu “on”
        System.out.println(textemeu.equals("Bon deia")); // Escriu false
</pre>

http://docs.oracle.com/javase/6/docs/api/java/lang/String.html

Per al tractament de text es poden fer servir alguns '''caràcters especials''':

{| cellspacing="0" cellpadding="7" border="1"
|-
| '''''Caràcter'''''
| '''''Significat'''''
|-
| \b
| Retrocés
|-
| \t
| Tabulació
|-
| \n
| Salt de línia
|-
| \'
| Cometes simple
|-
| \"
| Cometes normals
|}

=== Operadors ===

{| cellspacing="0" cellpadding="7" border="1"
|-
| colspan="2" | '''''Matemàtics'''''
| colspan="2" | '''''Lògics'''''
|-
| +
| Suma
| &&
| AND
|-
| -
| Resta
| &#124; &#124;
| OR

			

<br />			
|-
| * 			
| Producte
| !
| NOT
|-
| /
| Divisió
| colspan="2" | '''''Relacionals'''''
|-
| %
| Mòdul
| = = 			
| Igual
|-
| '''''++'''''
| Increment
| != 			
| Diferent
|-
| --
| Decrement
| >, <
| Més gran que, Menor que
|-
| '''''Text'''''
| <br />			
| >=, <= 			
| Més gran o igual que, Menor o igual que
|-
| +
| Concatenació
| instanceof
| ''obj instanceof cls'' 			 és  			true  si, 			i només si l'objecte 			 obj  deriva 			de la classe 			 cls.
|}

.

=== Vectors ===

Un vector o matriu és un conjunt d’elements del mateix tipus que s’identifiquen per la seva posició.

Per '''declarar''' vectors a Java la sintaxi és la següent

''Tipus[] nom;''

A més, no hi prou amb declarar les variables, el compilador necessita conèixer la mida o longitud dels vectors per poder reservar l’espai necessari, així cal un segon pas per ''' inicialitzar''' els vectors.

<pre>
        int [] vec;

        vec = new int[4]; // Vector de 4 enters

        String[] paraules = {"Hola", "Adeu"};
</pre>


Finalment si volem '''fer referència''' als elements del vector cal que indiquem quin és l’element, tenint en compte que el primer element sempre és el 0.

<pre>
        int [] vec;

        vec = new int[4]; // Vector de 4 enters

        vec[0] = 1; // Primer element del vector
        vec[3] = 7; // Últim element del vector
</pre>

.

=== Modularitat. Mètodes ===

Les funcions són mètodes que retornen un valor

La Declaració de '''funcions'''

<pre>
   public [static] Tipus nomFuncio(paràmetres)
   {
      instruccions;

      return expressió;
   }
</pre>

On la declaració de paràmetres és una llista del tipus

<pre>Tipus variable, Tipus variable, ..., Tipus variable</pre>

* ''static'' ho farem servir per mètodes de classe.

Les accions són mètodes que no retornen cap valor

La Declaració '''d'accions''' o procediments

<pre>
   public [static] void nomAccio(paràmetres)
   {
      instruccions;
   }
</pre>


Els mètodes es defineixen dins la classe

<pre>
public class Radi {

    static final double PI = 3.1416; //Fora del main

    public static void main(String[] args) {
        System.out.println("El perimetre es : " + funcioPerimetre(3.3));
       
        accioPerimetre(3.3);
    }
   
    public static double funcioPerimetre(double radi) {
        double perimeter = radi * PI * 2.0;
        return perimeter;      
    }
   
    public static void accioPerimetre(double radi) {
        double perimeter = radi * PI * 2.0;
        System.out.println("El perimetre es : " + perimeter);
    }
}
</pre>


==== Pas de paràmetres ==== 


* Els paràmetres de tipus simples (int, double, char, boolean) es passen sempre per valor.
* Els tipus compostos (vectors, matrius i objectes en general) es passen sempre per referència. Una excepció és String que funciona com un tipus simple (per valor).

<pre>
public class PasParametres {
    public static void main(String[] args) {
        int sim = 3;
        pasValor(sim);
        System.out.println("El valor de sim és: " + sim);  // Mostra 3
       
        String text = "Sense canviar";
        pasString(text);
        System.out.println("El valor de text és: " + text); // Mostra "Sense canviar"
       
        int[] vec = new int[1];
        vec[0] = 3;
        pasReferencia(vec);
        System.out.println("El valor de vec [0]: " + vec[0]); // Mostra 7
    }
    public static void pasValor(int a) {
        a = 7;
    }
    public static void pasString(String s) {
        s = "Canviat";
    }
    public static void pasReferencia(int[] b) {
        b[0] = 7;
    }
}
</pre>

=== Estructures de Control ===

====  Condicionals ====

{| cellspacing="0" cellpadding="7" border="1"
|-
| valign="TOP" colspan="2" | '''''Condicionals'''''
|-
| if (''Condició '') {<br />    <''Instruccions>''<br />} ''[ ''else {<br />    <''Instruccions>''<br />}'' ]''
| switch( ''< expressió >'' ) {<br />    case valor1:<br />        <''Instruccions>''<br />        break;<br />    case valor2:<br />        <''Instruccions>''<br />        break;<br />    ''[''default:<br />        <''Instruccions>]''<br />}
|}

Per exemple, para atenció a l'ús (o no) dels blocs { }


<pre>
        int opcio;
        opcio = 0;   

        if (opcio == 0) System.out.println("Has introduït 0");
        else {
            if (opcio == 1) System.out.println("Has introduït 1");
            else System.out.println("????");
        }
       
       
          switch(opcio) {
            case 0: System.out.println("Has introduït 0");
                     break;
            case 1: System.out.println("Has introduït 1");
                     break;
            default: System.out.println("????");
        }
</pre>

==== Bucles ====

{| cellspacing="0" cellpadding="7" border="1"
|-
| valign="TOP" colspan="2" | '''''Iteració'''''
|-
| do {<br />    <''Instruccions>'';

} while ( ''<Condició>'' );
| while ( <''Condició''> ) {

<''Instruccions>'';<br /> }
|-
| valign="TOP" colspan="2" | for ( ''<inicialització>''; ''<acabament>''; ''<iteració>'' ) {<br />    <''Instruccions>'';<br />}
|}

<pre>
public class ExFor {
    public static void main(String[] args) {
        System.out.println("Inici Bucle for");
        for ( int i=0; i<10; i++) {
            System.out.println("Valor de i: "+i);
        }
       
        System.out.println("Inici Bucle while");
        int i = 0;
        while ( i < 10 ) {
            System.out.println("Valor de i: "+i);
            i++;
        }
       
        System.out.println("Inici Bucle do while");
        i = 10;
        do {
            i--;
            System.out.println("Valor de i: " + i);
        } while (i > 0);
    }
}
</pre>

El tractament de matrius és anàleg, només cal parar atenció al control de longitud

<pre>
        int [][] mat;
        mat = new int[4][2]; // Matriu 4 files i 2 columnes

        for (int i=0;i<mat.length;i++) { // Informar matriu
            for (int j=0;j< mat[0].length;j++) {
                mat[i][j] = i + 3;
                System.out.print(mat[i][j]);
                System.out.print(" ");
            }
            System.out.println();
        }
</pre>

==== Break and Continue ====

Aquestes dues instruccions permeten controlar l’execució de bucles.

'''break''' atura el bucle i surt, mentre que '''continue''' passa a la següent iteració

En general aquestes estructures compliquen la lectura del codi i no es fan servir.

..

=== Entrada i Sortida bàsica ===

De moment ens limitarem a l’entrada/sortida de dades des de la línia de comandes en cru (sense les classes d'utilitat habituals per aquestes operacions).

De manera automàtica a qualsevol programa estan oberts tres canals

{| cellspacing="0" cellpadding="7" border="1"
|-
| ''System.in''
| Entrada de dades pel dispositiu estàndard d’entrada
|-
| ''System.out''
| Sortida de dades pel dispositiu estàndard de sortida
|-
| ''System.err''
| Sortida d’errors
|}

==== Sortida ====

Per mostrar informació a la línia de comandes es fan servir les operacions de la classe ''System.out ''que ja s’han fet servir.

''print(): ''Escriptura sense salt de línia

''println(): ''Escriptura amb salt de línia al final

==== Entrada per Consola ====

Per entrar informació des de la línia de comandes es fan servir les operacions de la classe ''System.in ''.

''read(): ''Lectura d'un caràcter

El següent exemple mostra com llegir una cadena de caràcters des de consola

<pre>
    public static void main(String[] args) throws IOException {
        System.out.println("Llegir fins a ENTER...");
        char caracter;
        String strEntrada = "";
        while ((caracter = (char) System.in.read()) != '\n') {
            strEntrada = strEntrada + caracter;            
        }
        System.out.println("strEntrada = " + strEntrada);
    }
</pre>

==== Entrada Per Paràmetres ====

L'entrada per paràmetres consisteix en introduir dades al programa quan s'executa com a paràmetres de l'execució

Per a l’entrada des de consola es pot fer servir el pas de paràmetres de la funció ''main(String[] args)'' que es recuperen des del programa a través del vector ''args[index]''.

<pre>
        int opcio;
        opcio = Integer.parseInt(args[0]);   
       
          switch(opcio) {
            case 0: System.out.println("Has introduït 0");
                     break;
            case 1: System.out.println("Has introduït 1");
                     break;
            default: System.out.println("????");
        }
       
Per a l'execució del programa cal indicar aquest atribut

~$java Programa 0

Has introduït 0


</pre>



== Convencions Programació Java ==

http://www.oracle.com/technetwork/java/codeconv-138413.html

http://checkstyle.sourceforge.net/   Aplicació per validar els estàndards