Föreläsning 5, X1, Q2,Fri, ht09: metoder

Metoder

• Metoder beskriver de operationer man vill kunna göra på objekten. När ett Javaprogram exekveras agerar objekten aktivt genom sina metoder. Det händer saker när en metod anropas för ett visst objekt.
  
• Metoderna i en klass är även en hjälp att strukturera klassen så att den består av mindre delar. Programmet blir på så vis mer lättläst och koden blir också lättare att felsöka.
  
• Om varje metod har en specifik uppgift blir metoderna även enklare att återanvända.
  

• Modifierare anger metodens synlighet, se föreläsning 5.
• Returtypen kan vara vilken datatyp som helst ( int, double, char, String,..), kan även vara objekt av egendef. klass. Returtypen kan även vara void, det innebär att metoden inte kommer returnera något värde, bara utföra något.
• Metodnamnet följer samma regler som namnet på variabler. Metoder kan ha samma namn om de har olika signatur, dvs skiljar sig i paramaterantal och/eller typ (överlagring).
• Parameterlistan = indata Beskriver antalet och typen på det indata som behövs. Parameterlistan kan vara tom. Parametrar kallas även argument.
• Returvärdet = utdata om något skickas tillbaka! Metoden returnerar ett värde med return-satsen. Returnsatsen anger vilket värde som ska ges som resultat från funktionen och den avslutar funktionen. Returvärdets typ bör vara den samma som funktionens returtyp. Se till att den anropande satsen även tar emot det som returneras!
• En metod känns igen på parenteserna! Exempel: b1.sättIn(2000); //b1 är ett BankKonto-objekt tolkas som anrop av en metod med namnet sättIn som finns i b1:s klass, dvs i klassen BankKonto.
  b1.sättIn; tolkas som att sättIn är en instansvariabel i b1:s klass.
  
• Variabeltyp måste anges i metodhuvudet men får inte anges i metodanropet.
  
• Det är tillåtet att ha flera retur-satser, men det rekommenderas inte. Bara en retur-sats kommer att exekveras. Flera värden kan inte returneras m h a flera retur-satser. Exempel: ... if (längd > 1.50) return true; else return false;

• Metoden:
  • metodhuvudet:
    - parametrar
    - returtyp
  • returvärde
• metodanrop från main och från annan metod i samma klass:
  • parameterlistan
  • mottagande av eventuellt värde
• Konstruktorer
• Metoderna get och set.
• Metoden toString

I. Parametrar.

• Att skriva metoder:
  Vi ska titta på några metoder i klassen BankKonto.
  
  Exempel 1. Metoden saldoBesked använder bara klassens instansvariabler. Ingen information "utifrån" behövs, dvs inga parametrar.

      public void saldoBesked() {
          System.out.print("Kontoinnehavare: " + namn);
          System.out.println("Saldot på kontot är: " + saldo);
      }
  

  Exempel 2. Jämför metoden sättIn som har en parameter. Metoden behöver veta hur mycket som skall adderas till saldot.

      public void sättIn(double summa) {
          saldo = saldo + summa;
          System.out.println("Nytt saldo: " + saldo);
      }
  

  FRÅGA:
  1. Vad händer om man tar bort parametern? Vilken sats i koden blir fel?
  2. Föreslå ett alternativ sätt att skriva metoden sättIn.
  
  Exempel 3. En metod med flera parametrar:

      public void geVärden(String nyttNamn, int nyttNr, double s) {
          namn = nyttNamn;
          nr = nyttNr;
          saldo = s;
      }
  

  FRÅGA: Varför behöver inte namn, nr och saldo vara i parameterlistan? Vad händer om man sätter dit dem?
  
  
  
• Att anropa (använda) metoder:
  Exempel 1. Antag att vi i en main-metod skapat ett objekt b1 av typen BankKonto. Anropet av metoden saldoBesked kommer att se ut så här:

     b1.saldoBesked();
  
  

  Typiskt metodanrop:
  objekt.metod(ev. parametrar)
  Parenteserna är signaturen för att det är en metod.
  
  Exempel 2. Titta på metoden sättIn ovan. double summa anger den formella parametern. När metoden anropas i main-metoden, använder man en aktuell parameter:

     b1.sättIn(500);
  

  500 är en aktuell parameter. En aktuell parameter kan även vara en variabel:

     System.out.print("Hur mycket vill du sätta in? ");
     double sum = scan.nextDouble();
     b1.sättIn(sum);
  

  OBS1! Typen (double) är aldrig med vid anropet.
  OBS2! Namnet på den aktuella variabelparametern (här sum) behöver inte vara samma som namnet på den formella parametern (här summa).
  
  Exempel 3. Anrop av metod med flera parametrar:

      b1.geVärden("Pia Larsen", 112233, 3000.0);
  

  OBS! Ordningen på de aktuella parametrarna måsta överensstämma med ordningen på de formella. Det går alltså inte att skriva b1.geVärden(112233, 3000.0, "Pia Larsen");

II. Returtyp och returvärde.

• I klassen Math finns metoden sin. Den används t ex så här:

  System.out.println("Ange vinkeln:");
  double v = scan.nextDouble();
  double x = Math.sin(v);
  System.out.println("sinus för vinkel " + v + " blir " + x);
  

  Metoden sin tar en parameter (här v), beräknar sinus för v, och returnerar ett värde. Det returnerade värdet tas emot i variabeln x och skrivs sedan ut.
  
  Om metoden returnerar ett värde kan värdet tas emot i en variabel eller skrivas ut direkt. Metoden anropas i så fall i en utskriftssats. Exempel:

  System.out.println("Mata in ett tal:");
  double x = scan.nextDouble();
  System.out.println("Roten ur " + x + " blir " +  Math.sqrt(x));
  

  
  Exempel 4. Klassen BankKonto har en metod årsRänta() som kan anropas så här (om vi skapat ett objekt b1):

  double utdelning = b1.årsRänta();
  system.out.println("Årsräntan blir: " + utdelning);
  

  Metoden returnerar alltså ett värde. Metoden ser ut så här:

   public double månadsRänta() { 
       double r; //lokal variabel
  
       r = (räntesats*saldo)/12;
       return r; //OBS! Metoden returnerar ett värde till anropande metod!
   }
  

  Två saker i metoden anger att den returnerar värde:
  a. Den avslutas med ordet return
  b. Returtypen är INTE void. I det här fallet är den av typen double.
  FRÅGA: Varför just double? Varför inte String?
  
  Exempel 5. Titta på exemplet nedan:

      public double räntaPåRänta(int antalÅr) {//både parameter och returvärde
         saldo = Math.pow((1+räntesats),antalÅr)*saldo;
         return saldo;
      }
  
  

  FRÅGA: Diskutera vilket/vilka av följande alternativ som passar om man vill anropa metoden räntaPåRänta med objektet b1. Motivera!
  1. b1.räntaPåRänta(3);
  2. int s = b1.räntaPåRänta();
  3. b1.räntaPåRänta();
  4. System.out.println(b1.räntaPåRänta());
  5. double s = b1.räntaPåRänta(5);
  6. System.out.println(b1.räntaPåRänta(2));
  
  Exempel 6: Anropa en metod i en annan (icke-static) metod.
  Metoden årsSaldo beräknar och skriver ut saldot efter ett år med hjälp av metoden saldoBesked(), dvs vi anropar en metod från en annan metod i samma klass. Objektet behöver inte anges, det är underförstått det anropande objektet! public void årsSaldo() { //inga parametrar behövs, //bara instansvariabler används saldo += saldo*räntesats; saldoBesked(); //eftersom vi anropat metoden årsSaldo med objektet b1, //kommer även metoden saldoBesked() att anropas för //samma objekt. //Alternativt skrivsätt: this.saldoBesked(); } I main: b1.årsSaldo();
  Exempel 7. Titta på följande FELAKTIGA kod:
  public double räntan() { / double r = saldo*räntesats; double s = saldo*(1+ räntesats); return r; return s; //Kommer aldrig att exekveras!! } Det är tillåtet att ha flera retur-satser, men det rekommenderas inte. Bara en retur-sats kommer att exekveras. Flera värden kan inte returneras m h a flera retur-satser. Exempel på korrekt kod:

     ... 
     if (längd > 1.50) 
         return true; 
     else 
         return false;
  

  
  Exempel 8. En void-metod får inte returnera något värde, men får innehålla satsen return; Exempel:

      public void taUt(double summa) {
          if (summa > saldo) {
             System.out.println("Otillräckligt saldo.");
             return; //stoppar exekveringen av resten av metoden
          {
          saldo = saldo - summa;
          System.out.println("Nytt saldo: " + saldo);
      }
  

  
  Exempel 9. main-metoden kan ligga i samma fil som klass som används av main-metoden. Titta på klassen Person.
  
  

  III. Speciella metoder: Konstruktorer

  Se exemplet klassen Person2. När programmet körs skapas objekten vid instruktionen new. Exempel:

    Person bybo = new Person();
  

  Om man skriver ut objektet med metoden skrivUt() kommer namnet och adressen att vara tomma och åldern vara 0. Det vore bra att kunna skriva Person per = new Person("Per Al", "Storg 1 Bvik", 21); Det förutsätter att det finns en metod som används när objekten skapas som har tre parametrar. Metoder som används när objekt skapas kallas konstuktorer.
  • konstruktor-metoderna används bara när objekt skapas!!!!
  • en konstruktor har ingen returtyp, inte ens void.
  • man kan skriva flera konstruktorer, bara parameterlistorna skiljer sig åt.
  • en konstruktor med tom parameterlista kallas default-konstruktor eller standardkonstruktor. Den brukar ofta ge standardvärden till instansvariablerna. Exempel: public Person() {//OBS! Ingen returtyp, inte ens void namn = "Anonym"; adress = "Bostadslös"; ålder = 20; //Om man vill ge ett värde. Instansvariabler nollställs //annars automatiskt! } Standardkonstruktorn är ofta tom, vilket betyder att instansvariablerna nollställs eller sätts till null automatiskt! Exempel: public Person() //instansvariabler nollställs eller sätts till null automatiskt! {}
  • En konstruktor med en eller flera parametrar kallas överlagrad konstruktor eller extrakonstruktor. Exempel: public Person(String n, String a, int å) { namn = n; //ge värdet som följer med i parameterlistan till objektets instansvariabel adress = a; ålder = å; }
  • om man skriver en överlagrad konstruktor bör man även skriva en defaultkonstruktor (god regel).
  • skriver man ingen konstruktor "får" skapas det ändå en defaultkonstruktor automatiskt. Om man skriver en överlagrad konstruktor men ingen standardkonstruktor skapas ingen sådan automatiskt.

  IV. Speciella metoder: get- och set-metoder

  Eftersom main-metoden inte kan komma åt instansvariablerna direkt utan bara genom klassens metoder brukar man skriva speciella metode för åtkomst och ändring av instansvariablerna. De kan heta vad som helst, men standardnamn är get för åtkomst och set- för ändring.
  
  
  • set-metoder:
    Metoderna heter ofta setInstansvariabel, returtyp void och nya värdet skickas som paremeter.
    
    Exempel: public void setRäntesats(double nyRäntesats) { räntesats = nyRäntesats; } public void setNamn(String nyttNamn) { namn = nyttNamn; } I main: ... double nyRsats; String nyttNamn; System.out.println("Ange ny räntesats: "); nyRsats = scan.nextDouble(); b1.setRäntesats(nyRsats); System.out.println("Ange kontoinnehavare: "); nyttNamn = scan.nextLine(); b1.setNamn(nyttNamn);
  • get-metoder:
    Metoderna heter ofta getInstansvariabel, returtyp är samma som instansvariabelns typ. Ingen parameter.
    
    Exempel: public double getRäntesats() {//tom parameterlista return räntesats; //returnerar attributet } public String getNamn() { return namn; } I main: ... //värdet av instansvariabeln kan tas emot i lokal variabel double rSats = b1.getRäntesats(); System.out.println("Kontot har räntesatsen " + rSats); //... eller värdet av instansvariabeln kan tas emot och skrivs ut direkt i en utskriftssats System.out.println("Kontoinnehavare: " + b1.getNamn()); Ett exempel med get- och set-metoder är klassen Personen.java.
    
  
  
  

  V. Speciella metoder: toString-metoden

  I klassen Person finns en metod skrivUt() man kan anropa för objekt av klassen Person. Metoden skriver ut instansvariablerna, och kan anropas från t ex main-metoden: gun.skrivUt(); Ofta vill man ändå kunna skriva ut ett objekt med System.out.println(objekt);. Hur skriver man ut ett helt objekt? Om man har skapa ett objekt vore det bra om man kunde skriva ut det på något vettigt sätt, t ex Person per = new Person("Pelle Ek", "Storg 5, Uppsala", 16); //Skapa objektet per System.out.println(per); //Jag vill ha en snygg utskrift av objektets information (instansvaraibler) Om man skriver så får man en nonsensutskrift, t ex:
  Person@13e754f
  Man ska göra en toString-metod:
  public String toString() { //OBS! metoden har typen String, //dvs ska returnera en sträng, en text. //Här instansieras ett objekt av klassen String. //Man bestämmer själv hur utskriften ska se ut return ...; // objektet returneras } I klassen Person kan toString-metoden se ut exempelvis så här: public String toString() { //skapa ett String-objekt, det kan heta vad som helst, t ex skriv: String skriv = namn + " är " + ålder + " år" + " och bor på " + adress + "."; return skriv; // objektet returneras } I main: ... Person per = new Person("Pelle Ek", "Storg 5, Uppsala", 16); System.out.println(per); ger utskriften:
  Pelle Ek är 16 år och bor på Storg 5, Uppsala.
  
  Man kan designa toString-metoden som man vill. Ett till exempel: public String toString() { String ut = "Namn: " + namn + "\n"; ut += "Adress: " + adress + "\n"; ut += "Ålder: " + ålder; return ut; } ger utskriften:
  Namn: Pelle Ek
Adress: Storg 5, Uppsala
Ålder: 16

toString-metoden anropas (ofta) inte med sitt namn utan från print- eller println-metoderna om parametern är ett objekt System.out.println(p1); dvs när man anropas print- eller println-metoderna med ett objekt som parameter. Observera att även om man har en toString-metod så går det att använda println()- och print()-metoderna på vanliga varabler och strängar: System.out.println("Ränta på kontot är: " + ränta);

  VI. Sammanfattning

  • Metoder beskriver de operationer man vill kunna göra på objekten.
  • Metoder är en hjälp att strukturera koden i "lämpliga" delar.
  • Varje metod bör ta hand om en avgränsad uppgift. Metoderna blir då
    • lättlästa
    • lättare att debugga (avlusa, hitta och rätta fel i)
    • lättare att återanvända
  • En metod känns igen genom parenteserna efter metodnamnet, och börjar med en liten bokstav.
  • Parameterlistan = indata till metoden, returnvärde = utdata från metoden.
  • Skilj på formella och aktuella parametrar.
  • Alla metoder utom konstruktorerna måste ha en returtyp (double, void,...)
  • Konstruktorerna får inte ha returtyp, och måste heta samma sak som klassen
  • En void-metod får inte returnera något värde (men får innehålla satsen return;)
  • Typiskt metodanrop i main: objekt.metod(ev. parametrar);
  • Vid anrop (t ex i main) av metod som returnerar ett värde: TA EMOT RETURVÄRDET t ex i en variable eller i en utskrift. Ex:
    tal = b.beräkna();
System.out.println("Räntan blir:" + b.årsränta();
    förutsätter att metoderna beräkna() och årsränta() returnerar värden.
  • toString()-metoden kommer (automagiskt) att anropas när man skriver ut ett objekt med print-metoderna. Antag att b1 är ett objekt av typen BankKonto: System.out.println(Bankkonto 1: " + b1);

  ---

  Anna Eckerdal
  Last modified: Mon Nov 16 16:30:34 MET 2009