Föreläsning 5

Klasser och objekt, introduktion

L&L(3) 4.0, 4.1, 2.6, 5.0
L&L(4, 5) 1.6, 3.1, 3.2, 4.1, 4.2
S kap 2.1, 2.2, 2.5, 2.9, 2.10, 4.5.1, 4.5.2, 9.1, 9.2

Klassdefinitionsmall:
Skapa objekt: Person lisa = new Person(); Person per = new Person(); Person eva = new Person();
- Den första förekomsten av Person indikerar att referensvariabeln lisa/per/eva refererar till ett objekt av 'typen' Person.
- new är en signal för att skapa en ny instans av klassen.
- Den sista förekomsten av Person() indikerar att det den nyskapade instansen ska vara av 'typen' Person.
Varje nytt objekt kommer att ha egenskaperna hos Person-klassen.
Att göra något med ett objekt:
Ett komplett huvudprogram till klassen Person
Allmän form av metoddefinition: modifierare returtyp metodnamn (parameterlista) { // deklaration av lokala variabler // satser return retur_värde; // Av typen returtyp. }
- Modifierare anger metodens synlighet.
- Returtypen kan vara vilken datatyp som helst (int, double, char, String, boolean, ...), kan även vara en klass, då är returvärdet ett objekt av denna klass. (Returtypen kan också vara void, det innebär att metoden inte returnerar 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 beskriver antalet och typen på den information som metoden får. Parameterlistan kan vara tom. Parametrarna i metodhuvudet kallas formella parametrar.
- Metoden returnerar ett värde med return-satsen. Returnsatsen anger vilket värde som skall ges som resultat från metoden och den avslutar metoden. Returvärdets typ skall vara densamma som metodens returtyp.
Metoder som inte returnerar något har returtyp void. Det behövs då ingen returnsats på slutet av metoden.
Med hjälp av parametrarna kan man ge information till metoderna. När man anropar en metod med ett värde, (dvs parameterns typ är int, double, char, boolean ,... kallas det värdeöverföring eller pass-by-value. Det innebär att argumentens värde kopieras till lokala kopior inne i metoden.
Varje metod som skall returnera någonting måste ha (minst) en return-sats.
Det är tillåtet att ha flera return-satser, men detta är ofta dålig programmeringsstil.

Konstruktorer och metoder till klssen Person.

     // Konstruktorer
      public Person() {}
    
      public Person(String n, String a, int å) {
          namn = n;
          adress = a;
          ålder = å;
      }

      // Metoder
      public void fyllaÅr() {   // Instansvariabeln ålder räknas upp
          ålder++;              // Parameter är inte nödvändigt
      }

      public void nyttNamn(String n) {   // Här måste man ha en parameter
          namn = n;                        // så att namnet kan bytas
      }

      public void nyAdress(String a) {   // Här måste man ha en parameter
          adress = a;                      // så att adressen kan bytas
      } 

      public void skrivUt() {
          System.out.println(namn + " är " + ålder +
                             " år och bor i " + adress);
      }

Här kan ni ladda ner hela klassen Person.

Nu skall vi börja titta på en klass för komplexa tal, och hur man kan använda dem för att lösa komplexa andragradsekvationer.


public class CompTest {
  public static void main(String [] arg) {
    Complex a = new Complex();
    Complex b = new Complex();
    Complex c = new Complex();
    Complex t1;
    Complex t2;
    Complex t3;
    Complex t4;
    Complex t5;
    Complex t6;
    Complex t7;
    Complex rot1;
    Complex rot2;
    final Complex noll = new Complex();  

    System.out.println("Välkommen till andragradsprogrammet!");
    System.out.println("Lösning till ekv. a*a*x + b*x + c = 0.");
    System.out.println("a, b och c kan alla vara komplexa tal.");
    System.out.println("Slutar om a, b, och c alla är noll.");
    System.out.print("Ge a som två tal (real- och imaginärdel): ");
    a.läs();
    System.out.print("Ge b som två tal (real- och imaginärdel): ");
    b.läs();
    System.out.print("Ge c som två tal (real- och imaginärdel): ");
    c.läs();

    while(!a.equals(noll) || !b.equals(noll) || !c.equals(noll)) {
      if(a.equals(noll)) {
        System.out.println("Ingen andragradare!");
        System.out.println();
      }
      else {
        t1 = b.div(a.mult(-2));
	t2 = b.mult(b);
	t3 = a.mult(c.mult(4));
        t4 = t2.sub(t3);
	t5 = a.mult(a.mult(4));
	t6 = t4.div(t5);
	t7 = t6.sqrt();
	rot1 = t1.add(t7);
	rot2 = t1.sub(t7);

        System.out.println("Rötterna är " +
           rot1 + " och " + rot2 + " .");
        System.out.println();
      }
    System.out.print("Ge a som två tal: ");
    a.läs();
    System.out.print("Ge b som två tal: ");
    b.läs();
    System.out.print("Ge c som två tal: ");
    c.läs();
    }
  }
}

/*
> java CompTest
Välkommen till andragradsprogrammet!
Lösning till ekv. a*a*x + b*x + c = 0.
a, b och c kan alla vara komplexa tal.
Slutar om a, b, och c alla är noll.
Ge a som två tal: 1 0
Ge b som två tal: 3 3
Ge c som två tal: 0 0
Rötterna är 0.0 och -3.0 - 3.0i .

Ge a som två tal: 0 0
Ge b som två tal: 2 4
Ge c som två tal: 5 6
Ingen andragradare!

Ge a som två tal: 1 0
Ge b som två tal: 3 3
Ge c som två tal: 0 4
Rötterna är -1.0 - 1.0i och -2.0 - 2.0i .

Ge a som två tal: 3 2
Ge b som två tal: -14 -18
Ge c som två tal: 13 52
Rötterna är 4.0 + 3.0i och 2.0 - 1.0i .

Ge a som två tal: 0 0
Ge b som två tal: 0 0
Ge c som två tal: 0 0 
> 

*/

import java.util.Scanner;

class Complex {
  private double re;
  private double im;


  public Complex() {
    re = 0;
    im = 0;
  }

  public Complex(double r, double i) {
    re = r;
    im = i;
  }

  public Complex sqrt() {
    Complex res = new Complex();
    res.re = Math.sqrt((Math.sqrt(re*re + im*im) + re) / 2);
    res.im = Math.sqrt((Math.sqrt(re*re + im*im) - re) / 2);
    return res;
  }
    
  public Complex add(Complex arg) {
    Complex res = new Complex();
    res.re = re + arg.re;
    res.im = im + arg.im;
    return res;
  }

  public Complex sub(Complex arg) {
    Complex res = new Complex();
    res.re = re - arg.re;
    res.im = im - arg.im;
    return res;
  }

  public Complex mult(Complex arg) {
    Complex res = new Complex();
    res.re = re*arg.re - im*arg.im;
    res.im = re*arg.im + im*arg.re;
    return res;
  }

  public Complex mult(double arg) {
    Complex res = new Complex();
    res.re = re*arg;
    res.im = im*arg;
    return res;
  }

  public Complex div(Complex arg) {
    Complex res = new Complex();
    res.re = (re*arg.re + im*arg.im)/(arg.re*arg.re + arg.im*arg.im);
    res.im = (arg.re*im - arg.im*re)/(arg.re*arg.re + arg.im*arg.im);
    return res;
  }

  public void läs() {
    re = scan.nextDouble();
    im = scan.nextDouble();
  }

  public void skriv() {
    Std.out.print(re);
    if (im > 0) {
      System.out.print(" + " + im + "i");
    }
    else if (im < 0) {
      System.out.print(" - " + -im + "i");
    }
  }

  public String toString() {
    if(im > 0) {
      return re + " + " + im + "i";
    }
    else if (im < 0) {
      return re + " - " + -im + "i";
    }
    else {
      return re + "";
    }
  }

  public boolean equals(Complex arg) {
    return re == arg.re && im == arg.im;
  }
}

Initiering av objekt sker mha konstruktorer
- Har samma namn som klassen.
- Har ingen returtyp.
- Finns det flera konstruktorer måste de ha olika parameterlistor, de är överlagrde.
- Om man definierar egna konstruktorer måste man definiera en parameterlöskonstruktor om man vill ha möjligheten att använda en sådan.
Last modified: Wed Nov 8 15:34:08 MET 2006