Diferència entre revisions de la pàgina «ASIX-M3-UF2-A1»

De wikiserver
Dreceres ràpides: navegació, cerca
Línia 1: Línia 1:
 +
 +
==Descomposició funcional==
 +
 +
:*L’objectiu serà resoldre el problema general com a una suma de subproblemes més petits.
 +
 +
:*La solució a cada subproblema s’anomena subrutina o subprograma, i a Java, mètode.
 +
 +
:*Permet la reutilització del codi, facilita la seva lectura i el seu manteniment.
 +
 +
:*Escriure codi més genèric facilita la seva reutilització.
 +
 +
'''Disseny descendent'''
 +
 +
:*El mètode del disseny descendent consisteix en descompondre el problema a resoldre en altres més senzills. A aquests se'ls aplica el mateix procediment fins arribar a problemes prou petits que podem resoldre directament.
 +
 +
:*Refinament de l’algorisme (stepwise refinement) és com es coneix aquest procediment de descomposició.
 +
 +
:*Representació en forma d'arbre:
 +
 +
::- Cada node és un mòdul, o problema, o solució hipotètica.
 +
::- Cada subarbre depenent d'aquest node es fa servir per a la resolució d'aquest subproblema.
 +
::- El node del nivell més alt és el problema de partida.
 +
::- L’algorisme serà correcte si la solució que es dóna a cada nivell ho és.
 +
::- El programa es pot construir de sota a dalt creant primer procediments que resolguin els mòduls de detall que, un cop comprovats seran utilitzats per altres procediments més generals fins a arribar a la creació del programa.
 +
 +
[[Imatge:m3uf2_disseny_modular_1.png |600px|center| Disseny modular]]
 +
 +
==Reutilització de subproblemes resolts==
 +
 +
:*La descomposició mitjançant disseny descendent permet reaprofitar la solució de subproblemes idèntics, o força semblants.
 +
 +
:*Qualsevol subproblema d’un nivell donat pot ser part de qualsevol subproblema d’un nivell superior. Per remarcar
 +
 +
[[Imatge:m3uf2_disseny_modular_2.png |600px|center| Disseny modular]]
 +
 +
:*En descompondre un problema, s'ha d'intentar fer-ho de manera que es forci l’aparició de subproblemes repetits, i així la seva resolució es pot reaprofitar en diversos llocs.
 +
 +
==Aplicació correcta del disseny descendent==
 +
 +
Diferents persones poden arribar a conclusions diferents sobre com dur a terme la descomposició. Entre totes les solucions diferents possibles, algunes es poden considerar millors que d’altres. De fet, res impedeix, partir d'una solució concreta i aplicar refinaments que la millorin.
 +
 +
Criteris per a l'avaluació de la descomposició:
 +
 +
:*Si un problema que sembla a priori força complex es descompon en molts pocs nivells, potser val la pena fer una segona ullada. Inversament, si un problema no massa complex té massa nivells, potser s’ha anat massa lluny en la descomposició.
 +
 +
:*Veure si el nombre de passes incloses a cadascun dels subproblemes no és excessivament gran i és fàcil de seguir i entendre. En cas contrari, potser encara faria falta aplicar nous nivells de descomposició.
 +
 +
:*Repassar que els noms assignats als subproblemes siguin autoexplicatius i expressin clarament la tasca que estan resolent. Sense ni tan sols llegir les seves passes, caldria entendre perfectament què s’assoleix en resoldre’ls. En cas contrari, potser la descomposició no està agrupant conjunts de passes realment relacionades entre elles.
 +
 +
:*Si absolutament cap dels subproblemes és reutilitzat enlloc, especialment en descomposicions en molts nivells, és molt possible que no s’hagi triat correctament la manera de descompondre alguns subproblemes.
 +
 +
:*Vinculat al punt anterior, l’aparició de subproblemes molt semblants o idèntics, però tractats per separat en diferents llocs, també sol ser indici que no s’està aplicant la capacitat de reutilitzar subproblemes correctament.
 +
 +
===Declaració de mètodes===
 +
 +
S’anomena '''mètode''' a un conjunt d’instruccions amb un objectiu comú que es declaren de manera explícitament diferenciada dins del codi font mitjançant una etiqueta o identificador. 
 +
 +
:*En el mètode principal, anomenat '''main''', és resol el problema general (o sigui, tot el programa).
 +
 +
:*Invoca un mètode implica executar les seves instruccions.
 +
 +
:*Declaració bàsica d’un mètode:
 +
<source lang="java">
 +
public void nomMetode() {
 +
   
 +
  //Aquí dins aniran les seves instruccions
 +
  //...
 +
}
 +
</source>
 +
 +
:*La declaració s'ha de fer entre les claus que identifiquen l’inici i fi de fitxer (public class NomClasse { ... }) i fora del bloc d’instruccions mètode principal, o qualsevol altre mètode. Normalment, se sol fer immediatament a continuació del mètode principal.
 +
 +
'''Exemple 1:'''
 +
<source lang="java">
 +
public class LlibreQualificacions {
 +
 +
  public void mostrarMissatge(){
 +
 +
    System.out.println( "Benvingut al llibre de qualificacions!" );
 +
  } // fi del mètode
 +
}
 +
</source>
 +
 +
===Canvis en el mètode principal en declarar altres mètodes===
 +
 +
:* Tot el codi que aniria normalment dins el bloc d’instruccions del mètode principal s’ubica en un nou mètode auxiliar, i dins el mètode principal simplement s’invoca aquest nou mètode.
 +
 +
'''Exemple 2:'''
 +
<source lang="java">
 +
public class LlibreQualificacions {
 +
 +
  public static void main(String[] args) {
 +
 +
    mostrarMissatge();
 +
    System.out.println("Final");
 +
  }
 +
 
 +
  public static void mostrarMissatge(){
 +
    System.out.println( "Benvingut al llibre de qualificacions!" );
 +
  } // fi del mètode
 +
}
 +
</source>
 +
 +
:*La crida fa que el mètode '''mostrarMissatge''' realitzi la seva tasca. Quan el mètode '''mostrarMissatge''' completa la seva tasca, el mètode main continua la seva execució.
 +
 +
===Accessibilitat de variables dins una classe===
 +
 +
:*Els diferents mètodes serveixen per processar una informació comuna a tots. Això implica que han de poder manipular i compartir algunes de les variables definides per resoldre el problema.
 +
 +
:*Àmbit d’una variable: donada una variable, només es considerarà declarada des de la línia on s’ha fet fins a trobar la clau tancada següent (}). Per tant, les variables definides dins d'un mètode només són accessibles per ell.
 +
 +
:*Qualsevol dada que hagi de ser accedida en més d’un subproblema per tal de resoldre’l, caldrà declarar-la com una variable global.
 +
 +
:*'''Variable global''': és una variable que pot ser accedida des de qualsevol instrucció dins un mateix fitxer de codi font. El seu àmbit és tot el fitxer i per tant, es podran accedir des de qualsevol mètode.
 +
 +
:*'''Variable local''': és una variable accessible en un bloc concret de codi.
 +
 +
===Declaració d'un mètode amb un paràmetre===
 +
 +
:*Un mètode pot requerir un o més paràmetres que representen la informació addicional que
 +
necessita per realitzar la seva tasca.
 +
 +
:*La crida a un mètode proporciona valors (anomenats arguments) para cadascun dels paràmetres d'aquest mètode.
 +
 +
:*'''Exemple:''' El mètode '''mostrarMissatge''', de la classe '''LlibreQualificacions''', mostra el nom del curs com a part del missatge de benvinguda. El nou mètode '''mostrarMissatge''' requereix un paràmetre que representa el nom del curs a imprimir en pantalla.
 +
 +
<source lang="java">
 +
public class LlibreQualificacions {
 +
 +
  public static void main(String[] args) {
 +
 +
    Scanner entrada = new Scanner(System.in);
 +
    System.out.println("Escriu el nom del curs");
 +
    String curs = entrada.nextLine();
 +
    System.out.println("");
 +
    mostrarMissatge(curs);
 +
  }
 +
 +
  public static void mostrarMissatge(String nomCurs) {
 +
 
 +
    System.out.println("Benvingut al llibre de qualificacions del curs " + nomCurs);
 +
  } // fi del mètode
 +
}
 +
</source>
 +
 +
'''Més sobre els arguments i els paràmetres'''
 +
 +
:*La llista de paràmetres del mètode, s'ha d'especificar entre els parèntesis que van després del nom del mètode i separats per una coma.
 +
 +
:*La llista de paràmetres pot contenir qualsevol nombre de paràmetres, fins i tot cap. Els parèntesis buits després del nom del mètode indiquen que un mètode no requereix paràmetres.
 +
 +
:*Cada paràmetre ha d’especificar un tipus i un identificador.
 +
 +
:*En l'instant en què es crida al mètode, el valor de l'argument en la crida s'assigna al paràmetre corresponent en l'encapçalament del mètode.
 +
 +
:*El cos del mètode utilitza el paràmetre per accedir al valor.
 +
 +
:*El nom de la variable de paràmetre pot ser igual o diferent al nom de la variable d'argument.
 +
 +
:*El nombre d'arguments en la crida a un mètode ha de coincidir amb el nombre de paràmetres en la llista de paràmetres de la declaració del mètode que es va cridar.
 +
 +
:*Els tipus dels arguments en la crida al mètode han de ser “consistents amb” els tipus dels paràmetres corresponents a la declaració del mètode.
 +
 +
:*Errors de compilació:
 +
 +
::-Si el nombre d'arguments en la crida a un mètode no coincideix amb el nombre de paràmetres la declaració del mètode.
 +
::-Si els tipus dels arguments en la crida a un mètode no són consistents amb els tipus dels paràmetres corresponents a la declaració del mètode compilació.
 +
 +
==Declaració de mètodes amb múltiples paràmetres==
 +
 +
'''Exemple:'''
 +
 +
:*El mètode '''main''' crida al mètode '''determinarMaxim''' per produir els resultats del programa.
 +
:*El mètode '''determinarMaxim''' demana tres nombres i crida al mètode '''màxim''' passant-li tres paràmetres double (x, y i z) per a que aquest trobi quin és el màxim.
 +
:*El mètode '''màxim''' rep tres paràmetres double (x, y i z) i retorna un valor double amb el valor màxim del tres paràmetres.
 +
 +
<source lang="java">
 +
public class BuscadorMaxim {
 +
 +
  public static void main(String args[]) {
 +
 +
    determinarMaxim();
 +
  }
 +
 +
  public static void determinarMaxim() {
 +
 +
    Scanner entrada = new Scanner(System.in);
 +
    System.out.print("Escriu tres valors decimals separats per espais: ");
 +
    double numero1 = entrada.nextDouble();
 +
    double numero2 = entrada.nextDouble();
 +
    double numero3 = entrada.nextDouble();
 +
    double resultat = maxim(numero1, numero2, numero3);
 +
    System.out.println("El màxim és: " + resultat);
 +
  }
 +
 +
  public static double maxim(double x, double y, double z) {
 +
 
 +
    double valorMaxim = x;
 +
    if (y > valorMaxim) {
 +
      valorMaxim = y;
 +
    }
 +
    if (z > valorMaxim) {
 +
      valorMaxim = z;
 +
    }
 +
    return valorMaxim;
 +
  }
 +
}
 +
</source>
 +
 +
==Notes sobre com declarar i utilitzar els mètodes==
 +
 +
Hi ha tres formes de cridar a un mètode:
 +
 +
:'''1.''' Utilitzant el nom d'un mètode per si sol per cridar a un altre mètode de la mateixa classe, com maxim( numero1, numero2, numero3)
 +
:'''2.''' Utilitzant una variable que conté una referència a un objecte, seguida d'un punt (.) i del nom del mètode per cridar a un mètode de l'objecte al que es fa referència, com a buscadorMaxim.determinarMaxim().
 +
:'''3.''' Utilitzant el nom de la classe i un punt (.) per cridar a un mètode static d'una classe, com Integer.parseInt().
 +
 +
'''Notes:'''
 +
 +
:*Un mètode static només pot cridar directament a altres mètodes static de la mateixa classe (és a dir, usant el nom del mètode per si solament) i solament pot manipular de manera directa camps static en la mateixa classe.
 +
 +
:*Per accedir als membres no static de la classe, un mètode static ha d'usar una referència a un objecte d'aquesta classe.
 +
 +
Existeixen tres formes de tornar el control a la instrucció que crida a un mètode:
 +
 +
:*Si el mètode no retorna un resultat el control torna quan:
 +
 +
::- el flux del programa arriba a la clau dreta de finalització del mètode.
 +
::- s'executa la instrucció return.
 +
 +
:*si el mètode retorna un resultat el control torna quan::
 +
 +
::- s'executa la instrucció return expressió; avalua l'expressió i després retorna el resultat al mètode que va fer la crida.
 +
 +
'''Errors:'''
 +
 +
:*De sintaxi:
 +
 +
::-Declarar un mètode fora del cos de la declaració d'una classe, o dins del cos d'un altre mètode.
 +
::-Ometre el tipus de valor de retorn a la declaració.
 +
::-Col·locar un punt i coma després del parèntesi dret que tanca la llista de paràmetres de la declaració d'un mètode.
 +
 +
:*De compilació:
 +
 +
::-Tornar a declarar el paràmetre d'un mètode com una variable local en el cos d'aquest mètode.
 +
::-Oblidar retornar un valor d'un mètode que ha de retornar un valor.
 +
::-Retornar un valor inconsistent a un mètode que especifica un tipus de valor de retorn diferent de void.
 +
::-Retornar un valor d'un mètode el tipus del qual de valor de retorn s'hagi declarat com void.
 +
 +
==Exemples==
 +
 +
:*Mètode sense paràmetres que no retorna res:
 +
<source lang="java">
 +
public static void saludaATots(){
 +
 +
  System.out.println("Hola");
 +
}
 +
</source>
 +
:*Mètode sense paràmetres que retorna un valor:
 +
<source lang="java">
 +
public static String retornaSalutacio(){
 +
 +
  return "Hola";
 +
}
 +
</source>
 +
:*Mètode amb paràmetres que no retorna res:
 +
<source lang="java">
 +
public static void saludaAAlgu(String nom){
 +
 +
  System.out.println("Hola "+nom);
 +
}
 +
</source>
 +
:*Mètodes amb paràmetres que retorna un valor:
 +
<source lang="java">
 +
public static double cub(double x) {
 +
 +
  return x * x * x;
 +
}
 +
 +
public static int producte ( int a , int b){
 +
  return a*b;
 +
}
 +
</source>
 +
 +
 +
 
'''Programació Modular i Paquets en Python'''
 
'''Programació Modular i Paquets en Python'''
  

Revisió del 12:55, 27 des 2020

Descomposició funcional

  • L’objectiu serà resoldre el problema general com a una suma de subproblemes més petits.
  • La solució a cada subproblema s’anomena subrutina o subprograma, i a Java, mètode.
  • Permet la reutilització del codi, facilita la seva lectura i el seu manteniment.
  • Escriure codi més genèric facilita la seva reutilització.

Disseny descendent

  • El mètode del disseny descendent consisteix en descompondre el problema a resoldre en altres més senzills. A aquests se'ls aplica el mateix procediment fins arribar a problemes prou petits que podem resoldre directament.
  • Refinament de l’algorisme (stepwise refinement) és com es coneix aquest procediment de descomposició.
  • Representació en forma d'arbre:
- Cada node és un mòdul, o problema, o solució hipotètica.
- Cada subarbre depenent d'aquest node es fa servir per a la resolució d'aquest subproblema.
- El node del nivell més alt és el problema de partida.
- L’algorisme serà correcte si la solució que es dóna a cada nivell ho és.
- El programa es pot construir de sota a dalt creant primer procediments que resolguin els mòduls de detall que, un cop comprovats seran utilitzats per altres procediments més generals fins a arribar a la creació del programa.
Disseny modular

Reutilització de subproblemes resolts

  • La descomposició mitjançant disseny descendent permet reaprofitar la solució de subproblemes idèntics, o força semblants.
  • Qualsevol subproblema d’un nivell donat pot ser part de qualsevol subproblema d’un nivell superior. Per remarcar
Disseny modular
  • En descompondre un problema, s'ha d'intentar fer-ho de manera que es forci l’aparició de subproblemes repetits, i així la seva resolució es pot reaprofitar en diversos llocs.

Aplicació correcta del disseny descendent

Diferents persones poden arribar a conclusions diferents sobre com dur a terme la descomposició. Entre totes les solucions diferents possibles, algunes es poden considerar millors que d’altres. De fet, res impedeix, partir d'una solució concreta i aplicar refinaments que la millorin.

Criteris per a l'avaluació de la descomposició:

  • Si un problema que sembla a priori força complex es descompon en molts pocs nivells, potser val la pena fer una segona ullada. Inversament, si un problema no massa complex té massa nivells, potser s’ha anat massa lluny en la descomposició.
  • Veure si el nombre de passes incloses a cadascun dels subproblemes no és excessivament gran i és fàcil de seguir i entendre. En cas contrari, potser encara faria falta aplicar nous nivells de descomposició.
  • Repassar que els noms assignats als subproblemes siguin autoexplicatius i expressin clarament la tasca que estan resolent. Sense ni tan sols llegir les seves passes, caldria entendre perfectament què s’assoleix en resoldre’ls. En cas contrari, potser la descomposició no està agrupant conjunts de passes realment relacionades entre elles.
  • Si absolutament cap dels subproblemes és reutilitzat enlloc, especialment en descomposicions en molts nivells, és molt possible que no s’hagi triat correctament la manera de descompondre alguns subproblemes.
  • Vinculat al punt anterior, l’aparició de subproblemes molt semblants o idèntics, però tractats per separat en diferents llocs, també sol ser indici que no s’està aplicant la capacitat de reutilitzar subproblemes correctament.

Declaració de mètodes

S’anomena mètode a un conjunt d’instruccions amb un objectiu comú que es declaren de manera explícitament diferenciada dins del codi font mitjançant una etiqueta o identificador.

  • En el mètode principal, anomenat main, és resol el problema general (o sigui, tot el programa).
  • Invoca un mètode implica executar les seves instruccions.
  • Declaració bàsica d’un mètode:
public void nomMetode() {
     
  //Aquí dins aniran les seves instruccions
  //...
}
  • La declaració s'ha de fer entre les claus que identifiquen l’inici i fi de fitxer (public class NomClasse { ... }) i fora del bloc d’instruccions mètode principal, o qualsevol altre mètode. Normalment, se sol fer immediatament a continuació del mètode principal.

Exemple 1: 

public class LlibreQualificacions {

  public void mostrarMissatge(){

    System.out.println( "Benvingut al llibre de qualificacions!" );
  } // fi del mètode
}

Canvis en el mètode principal en declarar altres mètodes

  • Tot el codi que aniria normalment dins el bloc d’instruccions del mètode principal s’ubica en un nou mètode auxiliar, i dins el mètode principal simplement s’invoca aquest nou mètode.

Exemple 2: 

public class LlibreQualificacions {

  public static void main(String[] args) {

    mostrarMissatge();
    System.out.println("Final");
  }
   
  public static void mostrarMissatge(){
    System.out.println( "Benvingut al llibre de qualificacions!" );
  } // fi del mètode
}
  • La crida fa que el mètode mostrarMissatge realitzi la seva tasca. Quan el mètode mostrarMissatge completa la seva tasca, el mètode main continua la seva execució.

Accessibilitat de variables dins una classe

  • Els diferents mètodes serveixen per processar una informació comuna a tots. Això implica que han de poder manipular i compartir algunes de les variables definides per resoldre el problema.
  • Àmbit d’una variable: donada una variable, només es considerarà declarada des de la línia on s’ha fet fins a trobar la clau tancada següent (}). Per tant, les variables definides dins d'un mètode només són accessibles per ell.
  • Qualsevol dada que hagi de ser accedida en més d’un subproblema per tal de resoldre’l, caldrà declarar-la com una variable global.
  • Variable global: és una variable que pot ser accedida des de qualsevol instrucció dins un mateix fitxer de codi font. El seu àmbit és tot el fitxer i per tant, es podran accedir des de qualsevol mètode.
  • Variable local: és una variable accessible en un bloc concret de codi.

Declaració d'un mètode amb un paràmetre

  • Un mètode pot requerir un o més paràmetres que representen la informació addicional que

necessita per realitzar la seva tasca.

  • La crida a un mètode proporciona valors (anomenats arguments) para cadascun dels paràmetres d'aquest mètode.
  • Exemple: El mètode mostrarMissatge, de la classe LlibreQualificacions, mostra el nom del curs com a part del missatge de benvinguda. El nou mètode mostrarMissatge requereix un paràmetre que representa el nom del curs a imprimir en pantalla.
public class LlibreQualificacions {

  public static void main(String[] args) {
 
    Scanner entrada = new Scanner(System.in);
    System.out.println("Escriu el nom del curs");
    String curs = entrada.nextLine();
    System.out.println("");
    mostrarMissatge(curs);
  }

  public static void mostrarMissatge(String nomCurs) {
  
    System.out.println("Benvingut al llibre de qualificacions del curs " + nomCurs);
  } // fi del mètode
}

Més sobre els arguments i els paràmetres

  • La llista de paràmetres del mètode, s'ha d'especificar entre els parèntesis que van després del nom del mètode i separats per una coma.
  • La llista de paràmetres pot contenir qualsevol nombre de paràmetres, fins i tot cap. Els parèntesis buits després del nom del mètode indiquen que un mètode no requereix paràmetres.
  • Cada paràmetre ha d’especificar un tipus i un identificador.
  • En l'instant en què es crida al mètode, el valor de l'argument en la crida s'assigna al paràmetre corresponent en l'encapçalament del mètode.
  • El cos del mètode utilitza el paràmetre per accedir al valor.
  • El nom de la variable de paràmetre pot ser igual o diferent al nom de la variable d'argument.
  • El nombre d'arguments en la crida a un mètode ha de coincidir amb el nombre de paràmetres en la llista de paràmetres de la declaració del mètode que es va cridar.
  • Els tipus dels arguments en la crida al mètode han de ser “consistents amb” els tipus dels paràmetres corresponents a la declaració del mètode.
  • Errors de compilació:
-Si el nombre d'arguments en la crida a un mètode no coincideix amb el nombre de paràmetres la declaració del mètode.
-Si els tipus dels arguments en la crida a un mètode no són consistents amb els tipus dels paràmetres corresponents a la declaració del mètode compilació.

Declaració de mètodes amb múltiples paràmetres

Exemple:

  • El mètode main crida al mètode determinarMaxim per produir els resultats del programa.
  • El mètode determinarMaxim demana tres nombres i crida al mètode màxim passant-li tres paràmetres double (x, y i z) per a que aquest trobi quin és el màxim.
  • El mètode màxim rep tres paràmetres double (x, y i z) i retorna un valor double amb el valor màxim del tres paràmetres.
public class BuscadorMaxim {

  public static void main(String args[]) {

    determinarMaxim();
  }

  public static void determinarMaxim() {

    Scanner entrada = new Scanner(System.in);
    System.out.print("Escriu tres valors decimals separats per espais: ");
    double numero1 = entrada.nextDouble();
    double numero2 = entrada.nextDouble();
    double numero3 = entrada.nextDouble();
    double resultat = maxim(numero1, numero2, numero3);
    System.out.println("El màxim és: " + resultat);
  }

  public static double maxim(double x, double y, double z) {
  
    double valorMaxim = x;
    if (y > valorMaxim) {
      valorMaxim = y;
    }
    if (z > valorMaxim) {
      valorMaxim = z;
    }
    return valorMaxim;
  }
}

Notes sobre com declarar i utilitzar els mètodes

Hi ha tres formes de cridar a un mètode:

1. Utilitzant el nom d'un mètode per si sol per cridar a un altre mètode de la mateixa classe, com maxim( numero1, numero2, numero3)
2. Utilitzant una variable que conté una referència a un objecte, seguida d'un punt (.) i del nom del mètode per cridar a un mètode de l'objecte al que es fa referència, com a buscadorMaxim.determinarMaxim().
3. Utilitzant el nom de la classe i un punt (.) per cridar a un mètode static d'una classe, com Integer.parseInt().

Notes:

  • Un mètode static només pot cridar directament a altres mètodes static de la mateixa classe (és a dir, usant el nom del mètode per si solament) i solament pot manipular de manera directa camps static en la mateixa classe.
  • Per accedir als membres no static de la classe, un mètode static ha d'usar una referència a un objecte d'aquesta classe.

Existeixen tres formes de tornar el control a la instrucció que crida a un mètode:

  • Si el mètode no retorna un resultat el control torna quan:
- el flux del programa arriba a la clau dreta de finalització del mètode.
- s'executa la instrucció return.
  • si el mètode retorna un resultat el control torna quan::
- s'executa la instrucció return expressió; avalua l'expressió i després retorna el resultat al mètode que va fer la crida.

Errors:

  • De sintaxi:
-Declarar un mètode fora del cos de la declaració d'una classe, o dins del cos d'un altre mètode.
-Ometre el tipus de valor de retorn a la declaració.
-Col·locar un punt i coma després del parèntesi dret que tanca la llista de paràmetres de la declaració d'un mètode.
  • De compilació:
-Tornar a declarar el paràmetre d'un mètode com una variable local en el cos d'aquest mètode.
-Oblidar retornar un valor d'un mètode que ha de retornar un valor.
-Retornar un valor inconsistent a un mètode que especifica un tipus de valor de retorn diferent de void.
-Retornar un valor d'un mètode el tipus del qual de valor de retorn s'hagi declarat com void.

Exemples

  • Mètode sense paràmetres que no retorna res:
public static void saludaATots(){

  System.out.println("Hola");
}
  • Mètode sense paràmetres que retorna un valor:
public static String retornaSalutacio(){

  return "Hola";
}
  • Mètode amb paràmetres que no retorna res:
public static void saludaAAlgu(String nom){

  System.out.println("Hola "+nom);
}
  • Mètodes amb paràmetres que retorna un valor:
public static double cub(double x) {

  return x * x * x;
}

public static int producte ( int a , int b){
  return a*b;
}


Programació Modular i Paquets en Python

La programació modular consisteix en dividir un programa gran i/o complex en subprogrames més petits o simples, aconseguint fer-lo més comprensible i manejable. Per això, s'implementen funcions, classes i mòduls.

Funció

Funcions

  • Bloc de codi amb un nom associat.
  • Pot rebre zero o més arguments com a entrada.
  • Por retornar un valor i/o realitzar una tasca.
  • L'us de funcions permet fer una programació estructurada:
  • modularització: segmentar un programa complex en mòduls més simples facilitant la programació i la depuració.
  • reutilització: una mateixa funció es pot utilitzar des de diferents punts d'un programa i també des de diferents programes.
  • Python disposa de moltes funcions integrades i permet la creació de funcions per part dels programadors.
  • Sintaxi:
def nomFuncio(arg_1, arg_2, ..., arg_n):
    ...
    return value
  • Els arguments es passen per valor: si canvien el seu valor dins de la funció, no canvien "a fora".
  • Per modificar variable no locals a la funció, cal definir-les com a globals en la primera línia.
def nomFuncio(arg_1, arg_2, ..., arg_n):
    global var_1, var_2
    ...
    return value
Exemple senzill:
>>> def salutacio(nom):
...     print("Hola "+ nom + "!")
...
>>> salutacio("Pep")
Hola Pep!


Mòduls

Moduls

__init__

  • Un mòdul és un arxiu amb un codi independent i una determinada funcionalitat.
  • Pot ser utilitzat per qualsevol aplicació.
  • Es poden utilitzar mòduls propis de python, de tercers o propis.
  • Conté funcions, classes, definicions, ...
  • Per poder utilitzar un mòdul s'ha d'importar prèviament.
import modul    # 'modul': nom del mòdul a importar
  • Si volem importar només algunes parts del mòdul:
from modul import funcio_1, funcio_2   # 'funcio_x': funcions del mòdul.
Paquets
  • S'utilitza per organitzar els mòduls.
  • Pot contenir mòduls i altres paquets.
  • Per tractar un directori com a paquet cal que contingui el fitxer __init.py__
  • __init.py__ pot:
  • estar buit.
  • contenir codi d'inicialització del paquet.
  • contenir el conjunt de variables __ALL__. 
jocCombat /
|-__init__.py
|-regles /
    |-__init__.py
    |-monedes.py
    |-lluitador.py
    |-bestiari.py
    |-combat.py
|-interficie /
    |-__init__.py
    |-entradaTeclat.py
    |-sortidaPantalla.py
  • Es poden importar submòduls individualment:
>>>import jocCombat.regles.lluitador                # Càrrega el mòdul lluitador
>>>jocCombat.regles.lluitador.danyar(lluitador, 2)  # Cal fer referència al nom complert
  • Es pot importar el submòul:
>>>from jocCombat.regles import lluitador           # Càrrega el mòdul lluitador
>>>lluitador.danyar(lluitador, 2)                   # No cal utilitzar el prefix del paquet
  • Es poden només les funcions que necessitem:
  • Es pot importar el submòul:
>>>from jocCombat.regles.lluitador import danyar    # Càrrega la funció lluitador
>>>danyar(lluitador, 2)                             # Utilitzem directament la funció
  • La forma from jocCombat import * importaria tots els submòduls:
  • En general, no és recomanable.
  • Pot ser massa lent.
  • Pot tenir efectes no desitjats.
  • Es pot definir una llista anomenada __all__ amb els mòduls que s'importaran quan s'utilitzi import *-
  • Per exemple, si l'arxiu jocCombat/regles/__init__.py conté el codi:
__all__ = ["llluitador", "bestiari"]
  • Aleshores: 
>>>from jocCombat.regles import *    # només s'importaran els mòduls de la llista __all__
Obtingut de «http://wikiserver.infomerce.es/index.php?title=ASIX-M3-UF2-A1&oldid=14712»