Uppgift 1 (2 poäng) Utgå från följande klassdefinition : public class TempKlass public String uttext; public static int svar; LÖSNINGSFÖRSLAG TILL TENTAMEN PROGRAMMERINGSMETODIK MOM2 - JAVA, 4P. 991122 public TempKlass(String uttext, int svar) this.uttext = uttext; this.svar = svar; //constructor TempKlass // class TempKlass Vad skrivs ut när följande applikation exekveras? public class MainKlass public static void main(string[] args) TempKlass gaia = new TempKlass("Vad blir 6*9? ",54); TempKlass terra = new TempKlass("Vad blir 6*7? ",42); System.out.println(gaia.utText+" "+gaia.svar); System.out.println(terra.utText+" "+terra.svar); // main // class MainKlass Attributet svar är deklarerad static vilket innebär att den delas av samtliga objekt av denna klass. TempKlass gaia = new TempKlass ("Vad blir 6*9? ",54); sätter svar till 54 och TempKlass terra = new TempKlass("Vad blir 6*7? ",42); 1(9)
sätter svar till 42. Eftersom svar delas av alla objekt ( här gaia och terra) så ger båda utskrifterna naturligtvis 42. Uppgift 2 (2+1=3 poäng) I din konstruktor till en Bil-klass står det public Bil super(); a) Vad betyder satsen super() i detta sammanhang? Kan den förekomma någon annanstans i konstruktorn och i så fall var? super() betyder att en konstruktor i superklassen anropas, om detta skall ske måste denna sats komma först i konstruktorn. b) Lite längre ner i klassen står följande:.. super.ritaut();.. Vad innebär denna sats? Här anropas ritaut i superklassen, super behövs eg. bara om den aktuella klassen har en egen metod ritaut. Uppgift 3 (3 poäng) Man brukar tala om objektorienteringens tre grundprinciper, vilka är de? Förklara varje princip kortfattat. Objektorienteringens tre huvudprinciper: Arv en form av specialisering, en klass ärver attribut och egenskaper av en basklass och lägger till egna. Operationer tillåtna på objekt av basklassen är också tillåtna på objekt av någon sub-klass. Inkapsling Data i ett klass skyddas från okontrollerad åtkomst av andra klasser. Endast klassens egna metoder har direkt tillgång till attributen. Polymorfism kallas ibland dynamisk bindning, betyder att objektets typ (och inte referensens) avgör vilken metod som skall anropas. Ett exempel är omdefinierade metoder i klasshierarkier där samma metodnamn förekommer på olika nivåer. Uppgift 4 (3 poäng) I UML(Unified Modelling Language) finns tre typer av relationer mellan klasser. Beskriv kortfattat varje relationstyp och hur den implementeras i Java. 2(9)
UML:s tre typer av relationer mellan klasser: Arv - beskriver ett är en -förhållande, dvs ett objekt av en subklass är också ett objekt av basklassen, t.ex. en bil är ett fordon. Implementeras i Java med arv (extends). Association en förbindelse mellan två klasser som är tillfällig i tiden och som kan ändras, ett känner till -förhållande, exvis en passagerare känner till sin biljett men har den inte för evigt. Implementeras i Java med referenser. Aggregat en förbindelse mellan två klasser som är beständig. En klass består av en eller flera andra klasser, t.ex. en våning är en del av ett hus. Implementeras i Java med referenser. Uppgift 5 (2+4=6 poäng) Följande program läser in ett antal heltal och beräknar medelvärdet av dessa. Som programmet ser ut nu kan det uppstå s.k. undantag (exceptions) på två ställen. a) Ange vid vilka tillfällen och var i koden undantagen kan uppstå. Tre typer av undantag kan faktiskt uppstå, dels IOException som måste tas om hand (därav throws i main-satsen), dels ArithmeticException och NumberFormatException som kan ignoreras (men uppstår undantaget så avslutas programmet). IOException kan kastas av metoden readline i klassen BufferedReader, om det blir något fel vid inläsningen (normalt händer detta med filer som saknas osv.). NumberFormatException kastas av Integer.parseInt om argumentet inte går att konvertera till ett heltal. ArithmeticException kastas vid olika aritmetiska fel, exempelvis division med noll. b) Modifiera koden så att undantagen hanteras på lämpligt sätt. Många tänkbara lösningar finns till denna deluppgift, här visas en enkel lösning som inte försöker rädda situationen vid inmatningsfel utan avslutar programmet med ett felmeddelande. import java.io.*; public class Uppgift5 //=========================================================== // Läser ett antal heltal från användaren, summerar dem och // beräknar medelvärdet. 3(9)
//=========================================================== public static void main (String[] args) throws IOException try BufferedReader stdin = new BufferedReader (new InputStreamReader (System.in)); System.out.println("Ge ett heltal, avsluta med 0 : "); int tal = Integer.parseInt (stdin.readline()); int antal = 0; double summa = 0.0; while (tal!= 0) antal = antal + 1; summa = summa + tal; System.out.println("Ge ett tal, avsluta med 0 : "); tal = Integer.parseInt (stdin.readline()); System.out.println ("Medelvärde : "); try System.out.println (summa/antal); catch (ArithmeticException ex) System.out.println ("Medelvärde kan ej beräknas"); catch (IOException ex) System.out.println("Något fel har uppstått med Stdin"); catch (NumberFormatException ex) System.out.println("Du måste mata in ett heltal!"); // method main // class Uppgift5 Uppgift 6 (2+2+1=5 poäng) Fakultet beräknas som en följd av multiplikationer t.ex. 5! = 5 4 3 2 1 För ett godtyckligt naturligt tal n definieras n!=n (n-1) 1 Detta kan formellt formuleras på följande sätt : 4(9)
n! = 1 n = 0 n (n 1)! n > 0 a) Implementera en rekursiv metod som returnerar n!, där n ges som parameter. public static int rfac(int n) if (n == 0 n == 1) return 1; else return n*rfac(n-1); //rfac b) Implementera n! med en iterativ metod. public static int ifac(int n) int nfac = 1; for (int i = 1; i<=n; i++) nfac = i*nfac; return nfac; //ifac c) Beskriv för- och nackdelarna med en rekursiv metod jämfört med en iterativ. Uppgift 7 (2+3=5 poäng) a) Skriv en klass Bok som innehåller attributen titel, sidantal och publiceringsår. Ett objekt av klassen Bok skall kunna skapas på två sätt: Bok b = new Bok(); skall ge en bok med 194 sidor, titel Programming Pearls och publiceringsår 1989. Bok b = new Bok( Things That Make Us Smart, 290, 1993); skall ge en bok med angiven titel, sidantal och publiceringsår. Det skall också finnas en metod public void skrivut() som skriver ut all information om boken. b) Skriv en subklass till Bok som heter Roman. Klassen skall innehålla ett nytt attribut, boolean lyckligtslut. Skriv två konstruktorer till denna klass på samma sätt som för Bok. Överlagra metoden skrivut så att rätt metod anropas i följande satser: 5(9)
Bok b1 = new Bok(); Bok b2 = new Roman("Tre män I en båt", 311, 1978, true); b1.skrivut(); b2.skrivut(); // skall skriva ut info om en Bok // skall skriva ut info om en Roman Förslag till lösning som maximerar utnyttjandet av redan skriven kod: import java.io.*; class Uppgift7 public static void main(string args[]) Bok b1 = new Bok(); Bok b2 = new Roman("Tre män i en båt", 311, 1978, true); b1.skrivut(); b2.skrivut(); class Bok private String titel; private int sidantal; private int publår; // Konstruktor för klassen Bok public Bok(String titel, int sidantal, int publår) this.titel = titel; this.sidantal = sidantal; this.publår = publår; // Defaultkonstruktor, utnyttjar den andra konstruktorn public Bok() this("programming Pearls", 194, 1989); // Utskrift av attributen public void skrivut() System.out.println("Titel = " + titel); System.out.println("Sidantal = " + sidantal); System.out.println("Publiceringsår = " + publår); class Roman extends Bok private boolean lyckligtslut; 6(9)
// Konstruktor för klassen Roman, utnyttjar basklassens konstruktor public Roman(String titel, int sidantal, int publår, boolean lyckligtslut) super(titel, sidantal, publår); this.lyckligtslut = lyckligtslut; // Deafultkonstruktor, obs i uppgiften gavs inte någon titel för default-roman -> valfri public Roman() this("ronja Rövardotter", 236, 1981, true); // Skriv ut en roman, utnyttjar så mycket som möjligt av redan skriven kod public void skrivut() super.skrivut(); if (lyckligtslut) System.out.println("Lyckligt Slut!"); Uppgift 8 (1+1+1+2+2+2+2+2=13 poäng) a) public Object getfirst() // returnerar det första objektet i listan. return head.getvalue(); // method getfirst b) public Object getlast() // returnerar det sista objektet i listan. return tail.getvalue(); // method getlast c) public int getlength() // returnerar antalet element i listan. return length; // method getlength d) public void appendel(object el) //lägger till ett element sist i listan if (getlength() == 0) head = new ListNode(el); tail = head; 7(9)
else tail.next = new ListNode(el); tail = tail.next; length++; // method appendel e) public Object atindex(int index) //returnerar objektet med det angivna indexet. ListNode temp = head; for (int i = 1; i <= index; i++) temp = temp.getnext(); return temp.getvalue(); // method atindex f) public void insertat(object el,int index) //skjuter in elementet på angiven plats i listan och utökar därmed listan. if ( index <= 1 ) // Insert as first element of the list head = new ListNode(el, head); length++; else if ( index >= getlength()) // Insert as last element of the list appendel(el); else ListNode before = head; for (int i = 1; i < index-1; i++) before = before.getnext(); //Now before is positioned at index-1 ListNode after = before.getnext(); before.next = new ListNode(el, after); length++; // method insertat 8(9)
g) public Object[] toarray() //går igenom listan och returnerar ett fält av Object med motsvarande innehåll. Object[] temparray = new Object[getLength()]; ListNode temp = head; for (int i = 1; i <= length; i++) temparray[i-1] = temp.getvalue(); temp = temp.getnext(); return temparray; // method toarray h) Visa med en figur vad som händer i följande kodavsnitt ListNode head = null; int n = 5; head for (; n>=0; n--) head = new ListNode(new Integer(n),head); head n=5 5 head n=4 4 5 head n=0 0 1 2 3 4 5 9(9)