JDK (Java Development Kit)

    El JDK és l'entorn base mínim per a crear programes en Java. Conté:
     

    • Les llibreries de classes estàndard (compilades i font): java.lang, java.util, java.io, java.net, java.awt, java.applet.
    • El compilador (javac) que produeix el p-code.
    • Un intèrpret d'applets (appletviewer).
    • Un depurador mínim.
    • Un intérpret (java), que permet executar aplicacions (no applets).
    • Un generador de documentació (javadoc).
    • Generadors d'interfície amb C (javap, javah).
    • Un cert número d'exemples instructius d'applets amb les fonts.


    javac compila els programes font fets en java. Les fonts han d'estar grabades en fitxers amb l'extensió .java. javac analitza aquest fitxer .java i produeix tants fitxers .class com classes hi hagin al fitxer .java.

    java pren com a paràmetre el nom d'una classe. Llavors busca un .class corresponent a aquest nom, carrega la classe corresponent i crida al mètode main d'aquesta classe.

    Per exemple java edicRemota www. fisystem. fr 23 78.8
    El primer que farà serà buscar el fitxer edicRemota.class als directoris definits a la variable d'entorn CLASSPATH, carrega la classe corresponent i executa el m+etode main d'aquesta classe passant-li els arguments www. Fisysem. fr , 23 i 78.8. Els arguments són considerats cadenes de caràcters.

    Així doncs, el jdk de Java és l'entorn mínim necessari per crear i executar programes java. Existeixen però, altres plataformes de desenvolupament de programes. Són per exemple el Sunsoft Java Workshop, Symantec Café, Borland debugger for Java, etc.

    Un exemple senzill.

    L'exemple consisteix a mostrar una frase per pantalla. El codi font és el següent:
     
    import java.io.*;

    public class EjemploSimple
     {
      public static void main (String args[ ])
      {
       System.out.println ("Hola, avui fà bon dia");
      }
     }

    El programa font s'ha de guardar al fitxer amb nom EjemploSimple.java.

    La compilació s'inicia amb la comanda javac EjemploSimple.java, que crea fitxers semicompilats (no executables), un per cada classe definida al fitxer font. Aquests nous fitxers portaràn el mateix nom que la classe definida al fitxer font amb l'extensió .class. En el nostre cas es crea el fitxer EjemploSimple.class.

    La execució del programa s'inicia mitjançant la comanda java EjemploSimple. El que estem fent és cridar al nucli java (incorporat amb el jdk), indicant-li quina és la classe mestra de l'aplicació (en el nostre cas EjemploSimple). Així doncs, una vegada s'inicia l'execució del nucli aquest carrega la classe mestra que trobarà al fitxer EjemploSimple.class, i executa el mèetode main d'aquesta classe.

    EjemploSimple.class és una llibrería dinàmica. No conté còdi executable com les llibreries dinàmiques clàssiques, sino codi java, interpretat pel nucli.

    Recorda que has de tenir la variable d'entorn PATH apuntant al directori adient per a que trobi  els fitxers javac i java. Normalment c:\jdk\bin
     

    • Com a C, tot el que segueix a // serà ignorat pel compilador.
    • import java.io.*; Aquesta línia indica que el programa utilitzarà la llibreria estàndard d'E/S de Java. Tot programa utilitza llibreries precompilades. En aquest cas utilitzarà totes les classes del paquet java.io, ja que s'ha indicat *.
    • public class EjemploSimple. Aquesta linia indica que s'esta definint una classe anomenada ejemploSimple. Dins la classe es descriuen les característiques d'aquesta (mètodes i atributs). En aquest exemple només tenim una classe, que es confon amb el programa. La classe no té dades, només un mètode, el mètode main, que és el que el nucli java executarà quan carreguem el programa.

    exercici: Segueix les instruccions de l'exemple anterior per crear i executar el programa EjemploSimple.
     

    Java és orientat a objectes

       
    Dins la programació orientada a objectes, són sobradament coneguts els concpetes:
       
    • classes: mètodes i atributs.
    • Encapsulació.
    • Herència.
    • Polimorfisme.

      •  
    Una classe és una descripció estàtica d'un conjunt d'objectes. I un objecte es pot instanciar a partir de la descripció d'una classe: un objecte és dinàmic, es poden tenir una infinitat d'objectes descrits per una mateixa classe. L'objecte és un conjunt de dades presents a memòria.
       
    D'aquesta manera, una classe finestra, podría instanciar-se tantes vegades com es volgués. Però tots els objectes creats tindríen la mateixa descripció (atributs) i comportament(mètodes). Podem crear objectes gràcies a la paraula new, que reserva l'espai de memòria suficient per a l'objecte. El que fà és cridar al mètode constructor de la classe, que per definició té el mateix nom que la classe. Es poden definir diferents constructors, diferenciats pels paràmetres que els passem en el moment de cridar-los. Si el programador no defineix un mètode constructor, java en defineix un de predeterminat.
       
    La descripció de la classe finestra:
       
      class finestra 
       { 
         String titol; 
         int coordenadax; 
         int coordenaday; 
         int altura; 
         int amplada; 
       }
    Amb aquestes dues instanciacions:
       
      finestra fin1=new finestra("finestra1",10,10,20,20); 
      finestra fin2=new finestra("finestra2",10,10,30,30);
    Provocaria la creació a memòria dels objectes:
       
    Un mètode és una funció que s'executa sobre un objecte. No es pot executar un mètode sense precissar l'objecte sobre el qual s'aplica. Per exemple si volem duplicar el tamany d'una finestra:
       
      Void DuplicarTam( ) 
       { 
         altura=altura*2; 
         amplada=amplada*2;
       }
    Si des de qualsevol altre part del codi volem duplicar el tamany de la finestra fin1:
       
      fin1.DuplicarTam( );
    La encapsulació es basa en la idea de que certs atribbuts i mètodes d'una classe no tenen per què ser coneguts per la resta de classes. Així doncs podem declarar privats alguns atributs i mètodes, que només podràn ser accesibles des de mètodes de la mateixa classe.
       
    Fixem-nos en l'exemple:
       
      class finestra 
       { 
         public int x1, y1; 
         public int h, a; 
       }
    En aquest cas la classe finestra ha declarat els seus atributs públics, per tant qualsevol altra classe que tingui un objecte de la classe finestra, podrà modificar-los directament sense cap restricció.
       
      class pantalla 
       { 
         finestra fin1; 
         void DuplicarTam( ) 
        { 
          fin1.h=fin1.h*2; 
          fin1.a=fin1.a*2; 
        } 
       }
    Però que passaría si volguèssim canviar la definició de la classe finestra afegint dos atributs més x2, y2, per a no tenir que calcular-los cada vegada que volem dibuixar una finestra? Doncs passaría que hauríem de redefinir finestra i redefinir pantalla, perque pantalla utilitza els atributs h, a, que ja no existèixen a finestra. Una solució a aquest problema sería:
       
      class finestra 
       { 
         private int x1, y1,x2,y2; 
         void DuplicarTam( ) 
        { 
         x2=x2+(x2-x1); 
         y2=y2+(y2-y1); 
        } 
       } 
      class pantalla 
       { 
         finestra fin1; 
         void metodeQualsevol( ) 
        { 
          fin1.DuplicarTam( ); 
        } 
       }
    Ara la classe pantalla no pot modificar directament els atributs de la classe finestra però pot utilitzar el mètode DuplicarTam de la classe finestra que li fà la feina. A més a més, per qualsevol modificació de la classe finestra només cal retorcar els mètodes de la classe finestra, no de qualsevol classe que utilitzi un objecte de la classe finestra.
       
    Java propordiona diferents nivells d'encapsulació:
       
    • private
    • private protected
    • protected
    • friendly
    • public

      •  
    La herència és una de les nocions importants del diseny i programació orientada a objectes. És una relació entre classes definides per la paraula clau extends. Quan una classe filla hereda d'una classe mare, significa que:
       
    • Recupera els atributs i mètodes.
    • Un objecte de la classe filla és també un objecte de la classe mare (no recíprocament).

      •  
    La classe que hereda, subclasse, pren els atributs i els mètodes de la superclase, però pot:
       
    • Enriquir-los amb nous atributs i nous mètodes.
    • Redefinir els mètodes.

      •  
    En aquest dibuix s'ha representat una classe mare al voltant de la cual graviten d'altres classes amb diferents relacions amb ella. Recordem que un paquet no és més que un grup de classes (amb o sense relació lógica), agrupades entre si.
       
    Anem a comprovar ara els pels diferents tipus de protecció, quins privilegis d'accés tenen cada classe:
       
    Protecció private: Cap altre classe pot accedir als atributs o mètodes de la classe Mare.
       
    Protecció private protected: La classe només permet l'accés als seus atributs i mètodes a les seves subclasses, estiguin o no al mateix paquet.
       
    Protecció protected: Permet l'accés a les subclasses i a les classes del mateix paquet.
       
    Protecció friendly: Permet l'accés a totes les classes del mateix paquet.
       
    Protecció public: Permet l'accés a totes les classes.
       
       
     Un exemple breu.
       
    Anem a escriu-re una aplicació, que efectui un sondeig entre els usuaris. Aquesta vegada utilitzarem el paquet gràfic de Java, amb un conjunt de classes molt útils per a dibuixar objectes.
       
      import java.awt.*; 

      public class Sondeig extends Frame 
       { 
        //atributs de la classe Sondeig 
        Button si; 
        Button no; 
        Label comentari; 
        Label mostrarResultat; 
        Contador elContador; 
        //mètodes de la classe Sondeig 
        public Sondeig ( ) 
        { 
         elContador=new Contador( ); 
         comentari=new Label("Troba interessant la xarxa Internet ??", Label.CENTER); 
         add("North", comentari); 
         si=new Button("Si"); 
         add("East", si); 
         no=new Button("No"); 
         add("West", no); 
         mostrarResultat=new Label("Sense respostes", Label.CENTER); 
         add("South", mostrarResultat); 
        } 
        public boolean handleEvent(Event evt) 
        { 
         if (evt.id == Event.WINDOW_DESTROY) System.exit(0); 
         else if (evt.target == si) 
         { 
          elContador.Si( ); 
          mostrarResultat.setText(elContador.mostrarContador( )); 
         } 
              else if (evt.target == no) 
         { 
          elContador.No( ); 
          mostrarResultat.setText(elContador.mostrarContador( )); 
         } 
         return super.handleEvent(evt); 
        } 
        public static void main(String args[]) 
        { 
         Sondeig elSondeig =new Sondeig( ); 
         elSondeig.setTitle("Sondeig"); 
         elSondeig.pack( ); 
         elSondeig.show( ); 
        } 
       } 

      class Contador extends Object
       { 
        //atributs
        int numSi; 
        int numNo; 
        int total; 

        //mètodes 
        public Contador ( ) 
        { 
          numSi=0; 
         numNo=0; 
         total=0; 
        } 
        void Si ( ) 
        { 
         numSi++; 
         total++; 
        } 
        void No ( ) 
        { 
         numNo++; 
         total++; 
        } 
        String mostrarContador ( ) 
        { 
         StringBuffer cadena = new StringBuffer( ); 
         cadena.append("si=" + numSi + " no=" + numNo + " " + (numSi*100/total) + "%"); 
         return cadena.toString( ); 
        } 
       } 


       
    Exercici: prova d'executar l'exemple anterior. Recorda que per a fer-ho has d'utilitzar java nomdelaclasseambmain després de compilar totes les classes (javac nomfitxerambclasses.java).
       
    Els applets de Java

    Els applets són una de les particularitats de Java que contribueixen al seu gran èxit. Permeten carregar a través de la xarxa una aplicació portable que s'executarà al seu navegador (no a la màquina servidora de pàgines web).

       
    Diferències entre applet i aplicació:
       
    • Són carregats mitjançant el navegador, y no són executats directament pel núcli Java.
    • Es carreguen a través de la xarxa per mitjà de les pagines html, i no resideixen al disc dur de la màquina que els executa.
    • El seu cicle de vida és diferent. Una aplicació s'executa una vegada, mentres que un applet s'inicialitza i arrenca, i es torna a arrencar cada vegada que l'usuari recarrega la pàgina on es troba l'applet.
    • Per raons de seguretat, tenen menys drets que una aplicació clàssica. De manera predeterminada, a la màquina que els executa, no poden llegir ni escriure fitxers, ni executar programes, ni carregar dll. Només poden comunicar amb el servidor des d'on han surtit.

      •  
    Els applets són cridats a partir d'una font html llegida a distància pel seu navegador. El codi html que indica que ha de carregar-se un applet és el següent:
     
    <APPLET CODE="nom.class" WIDTH=200 HEIGHT=200 ALIGN=MIDDLE> 
    <PARAM NAME=elNom VALUE="Un exemple"> 
    </APPLET>
       
    CODE: Dóna el nom de la classe que s'ha de carregar per a arrencar l'applet.
    WIDTH HEIGHT: Indiquen sobre quin espai es visualitzarà l'applet.
    ALIGN: Indica el tipus d'alineació.
    PARAM NAME: Permet precisar tants paràmetres com es vulgui  a l'applet. Aquests paràmetres es recuperen al cos de l'applet amb el mètode getParameter(String s).

    Els applets no tenen mètode main. Quan el navegador arrenca un applet, busca la classe amb el nom que s'indica a la font html. Aquesta ha d'eheretar de la classe Applet. No es necessari definir un mètode main(), pel contrari, el navegador cridarà automàticament alguns dels mètodes de la classe Applet:

       
    • Constructor de la classe que hereda d'Applet, cridat en primera instància.
    • init(), cridat despres.
    • start(), cridat despres d'init(), i cridat cada vegada que l'applet ha sigut aturat. Això succeeix quan es canvia de pàgina web o es minimitza el navegador.
    • stop(), cridat just en els casos anteriors.
    • destroy(), cridat quan l'usuari abandona el navegador.
    • paint(), cridat cada vegada que s'ha de redibuixar el navegador.

      •  
    Quan creem el nostre applet, hem de redefinir tot o part d'aquests mètodes. paint(), especialment, proporciona el seu aspecte a l'applet. Aquest mètode és cridat passant-li com a paràmetre un objecte Graphics. Aquest és proporciona pel sistema, i el podem utilitzar sense preocupar-nos del seu origen.
       
    Si desitgem cridar a paint() des d'un altre mètode de l'applet, podem fer-ho gràcies al mètode repaint(), que crida a paint() proporcionant-li el paràmetre idoni.
       
       
     Un exemple senzill.
       
    L'exemple consisteix a redefinir els mètodes citats anteriorment fent que per a cadascún d'ells afegeixi el seu nom en una taula d'String, que així conservarà la memòria de les crides efectuades.
     
    import java.applet.*;
    import java.awt.*;
    import java.util.*;

    public class cicle extends Applet
     {
      // la taula on s'enmagatzemaran els noms dels mètodes cridats
      Vector lesCrides = null;

      public void paint(Graphics g)
      {
         int yactual=20;
       g.drawString("Crides als mètodes:", 20, yactual);
       yactual=yactual+15;
       lesCrides.addElement("Paint");
       for (Enumeration e=lesCrides.elements(); e.hasMoreElements(); )
       {
        g.drawString(e.nextElement().toString(), 20, yactual);
        yactual=yactual+15;
       }
      }

     public cicle()//constructor
      {
       lesCrides = new Vector();
       lesCrides.addElement("Constructor");
      }

     public void init()
      {
       lesCrides.addElement("Init");
      }

     public void start()
      {
       lesCrides.addElement("Start");
      }

     public void destroy()
      {
       lesCrides.addElement("Destroy");
      }

     public void stop()
      {
       lesCrides.addElement("Stop");
      }
     }
       
    La plana html que ens permet carregar l'applet, contindrà:
     
    <APPLET CODE="cicle.class" WIDTH=400 HEIGHT=200 ALIGN=MIDDLE> </APPLET>
       
    Ara ja només cal cridar la pàgina, i aquesta ens mostrarà l'applet en funcionament (previa compilació de l'applet javac cicle.java)
       
    Per a depurar un applet, podem utilitzar l'eina appletviewer que ens ofereix jdk. Per a utilitzar-a utilitzarem:
    Appletviewer cicle.html. (suposant que la plana html creada que conté la crida a l'applet es diu cicle.html).

       
    exercici: fixa't en l'exemple del joc Mastermind, per a crear el teu propi joc. Pots utilitzar les mateixes imatges i sons que s'han utilitzat en l'exemple.
       

    Mastermind

       
    En aquest joc les imatges es creen amb les funcions apropiades.
     
      g.fillOval(x,y,r,r), g.setColor(c), g.drawOval(x,y,r,r), fixDisc(g,x+3,y+3,6,Color.white), g.drawArc(x+4,y+4,9,9,-135,180)

      public final class mastermind extends java.applet.Applet
      {
       public void init()
       {
       Creem les imatges (es pot optar per carregar els fitxers amb les imatges ja creades)
       }

       public void clearBoard()  // Reset all variables and prepare for game
       {
        Reiniciem les variables i les figures amb repaint()
       }

       public boolean mouseDown(java.awt.Event evt, int x, int y)
       {
        A partir del events del mouse, realitzem les accions adequades
       }

       public void paint(Graphics g)
       {
       Dibuixem els elements del joc
       }
      }
       

       
    Veure solucions