Del 1
Uppgift 1 (6p) En enkel klass
import java.util.Scanner;
public class Vindkraft { private String namn;
private double genStorlek, radie;
// Standardkonstruktor public Vindkraft() {
namn = "Windpower";
genStorlek = 15;
radie = 8;
}
// ¨Overlagrad konstruktor
public Vindkraft( String inNamn, double inGen, double inRadie) { namn = inNamn;
genStorlek = inGen;
radie = inRadie;
}
// Ber¨aknar producerad energi under ett tidsintervall public double prodEnergi(double tid, double medelVind) {
return (radie * genStorlek * tid * medelVind);
}
// Returnerar en str¨ang som inneh˚aller instansvariablernas v¨arden.
public String toString() {
return ("Namn: " + namn +"\nRotorradie: " + radie +
"\nGeneratorstorlek: " + genStorlek);
}
public static void main(String[] args) { double tid, vindHastighet, energi;
// Skapa ett vindkraftverk
Vindkraft vind = new Vindkraft("Vestas", 20, 9);
// Skriv ut information System.out.println(vind);
// L¨as in tid och vindhastighet
Scanner scan = new Scanner(System.in);
System.out.print("Ge tiden: ");
tid = scan.nextDouble();
System.out.print("Ge vindhastighet: ");
vindHastighet = scan.nextDouble();
// Ber¨akna energi
energi = vind.prodEnergi(tid, vindHastighet);
// Skriv ut energin
System.out.println(energi + " kWh energi har producerats");
} }
Uppgift 2 (totalt 6p) Vad g¨ or koden
uppgift a (1p)
Vektorn ¨ar (3.0, 3.0) Vektorn ¨ar (3.0, 3.0)
a=bg¨or att a och b refererar till samma objekt. b.change(3,3); ¨andrar v¨arde p˚a instansvariablerna f¨or objektet. a.skrivUt(); b.skrivUt(); ger samma utskrift eftersom a och b refererar till samma objekt.
uppgift b (1p)
Villkor tv˚a ¨ar sant
D˚a == anv¨ands vid j¨amf¨orelse av objekt unders¨oks om referenserna ¨ar lika, dvs i den f¨orsta if-satsen om a och b refererar till samma objekt, vilket de inte g¨or.
Tv˚a objekt ¨ar inte ”lika” bara f¨or att de har samma v¨arden p˚a instansvari- ablerna.
uppgift c (1,5p) else
((a-b)==2)¨ar true allts˚a ¨ar !((a-b)==2) false. flag ¨ar ocks˚a false. F¨or logiskt eller g¨aller att false or false ger resultatet false.
uppgift d (1p) 1.0 3.0 4.0 6.0
Observera att heltalsdivision g¨ors. I f¨orsta varvet ber¨aknas 3/2 som ger resul- tatet 1 (int). Resultatet av heltalsdivisionen lagras i variabeln svar. Eftersom svar¨ar en double blir utskriften 1.0 och inte 1.
uppgift e (1,5p)
****
i=4
***
i=3
**
i=2
* i=1 i=0
Den inre for-loopen utf¨ors i g˚anger. print ger ej radbrytning men det g¨or println.
Uppgift 3 (7p)
S¨ okning och sortering
5 13 9 3 1 12 Utg˚angsl¨age 5 9 3 1 12 13 1:a iterationen 5 3 1 9 12 13 2:a iterationen 3 1 5 9 12 13 3:de iterationen 1 2 5 9 12 13 4:de iterationen
I den f¨orst iterationen:
5 och 13 j¨amf¨ors, byte sker ej 13 och 9 j¨amf¨ors, byte sker 13 och 3 j¨amf¨ors, byte sker 13 och 1 j¨amf¨ors, byte sker 13 och 12 j¨amf¨ors, byte sker
Nu har det st¨orsta talet, dvs 13, bubblat hela v¨agen upp til den sista platsen.
Algoritm (i stigande ordning)
1 Bubbel-arrayen ¨ar hela arrayen.
2 J¨amf¨or parvis v¨arden som ligger intill varandra i Bubbel-arrayen, dvs arr[i]
j¨amf¨ors med arr[i+1], f¨or alla i. Om de ligger p˚a fel inb¨ordes plats, dvs arr[i+1] mindre ¨an arr[i], s˚a byter de plats med varandra, annars l˚at vara.
3 Nu finns det st¨orsta elementet l¨angst till h¨oger i Bubbel-arrayen. Om element bytte plats, ”Krymp” bubbel-arrayen med ett element fr˚an h¨oger och g˚a till steg 2.
Deluppgift c.) En l¨osning bland m˚anga:
// Linj¨ar s¨okning. Vi s¨oker igenom arrayen f˚ar en sida // till den andra.
public static int linearSearch(int [] searchArray, int key) { int i=0;
// While-satsen avbryts n¨ar vi hittar nyckeln.
while((i < searchArray.length) && (key != searchArray[i])) i++;
// Om index i har r¨aknats upp // till storleken av arrayen // ¨ar s¨okningen misslyckad if (i == searchArray.length)
return -1;
else
return i;
}
Uppgift 4 (6p)
Utv¨ ardering av polynom
//metod f¨or att ber¨akna polynomets v¨arde i punkten x public double evaluera(double x){
return a*Math.pow(x,4)+b*Math.pow(x,3)+c*Math.pow(x,2)+d*x+e;
}
I ber¨akningen av polynomets v¨arde anv¨ands instansvariablerna.
Mainmetod i frist˚aende klass public class TestPolynomial{
public static void main(String[] args){
Polynom4 poly = new Polynom4(3.2, -5.1, 0, -1, 9);
double resultat1, resultat2;
resultat1=poly.evaluera(7);
resultat2=Math.sqrt(resultat1);
System.out.println("Polynomets v¨arde ¨ar i punkten sju ¨ar "+resultat1);
System.out.println("Roten ur detta v¨arde ¨ar "+resultat2);
} }
Konstruktorn har 5 inparametrar, vilket vi m˚aste t¨anka p˚a n¨ar Polynom4- objektet skapas. F¨or att anv¨anda matematikfunktioner skriver man Math.funktionens namn, exempelvis Math.sqrt. Math ligger i paketet java.lang och det paketet importeras automatiskt. Om man ¨and˚a vill importera paketet ska import-satsen INTE ligga inne i en metod.
Uppgift 5 (7p)
Objektorienterad analys av ett bibliotekssystem
UML-diagram som visar klasser och metoder som beh¨ovs (en l¨osning bland m˚anga.). N˚agra viktiga egenskaper som b¨or vara med: en huvudklass f¨or sj¨alv biblioteket, en med personer och en eller flera f¨or olika media. Biblioteksklassen b¨or ha arrayer av de andra klasserna som instansvariabler. Person b¨or ha en instansvariabel som talar om vad personen l˚anat och mediaklassen b¨or ha en instansvariabel som talar om vem som l˚anat ett mediaexemplar. Man kan ocks˚a ha en klass som hanterar tiden, ¨aven om det saknas i det aktuella f¨orslaget.
Uppgift 6 (8p)
SJ:s nya biljettsystem
Metoden tidsSkillnad i klassen Tidpuinkt.
public double tidsSkillnad(Tidpunkt t){
//anrop av metoden ser ut som t1.tidsSkillnad(t2) och d˚a // ber¨aknas t1-t2. (t1 och t2 objekt av typ Tidpunkt) double svar;
svar=timme-t.timme; //skillnad i timmar
svar=svar+(minut-t.minut)/60.0; //skillnad i minuter
//obs delar med 60.0 annars blir det heltalsdivision.
return svar;
}
Vi antar i denna l¨osning att SJ inte har n˚agra t˚ag som passerar dygnsgr¨ansen.
Metoden vinst i klassen Tagresa.
public double vinst(double grad){
double vinsten=0;
double reslangd; //anger resans l¨angd i timmar double personalkostnad;
reslangd=ankomsttid.tidsSkillnad(avgangstid);
//ber¨aknar kostnad f¨or l¨oner
personalkostnad=forare.getTimlon()*reslangd;
for(int i=0; i<konduktor.length; i++){
personalkostnad=personalkostnad+konduktor[i].getTimlon()*reslangd;
}
//pga skatter ¨ar totala personalkostnaden 2*l¨onekostnaden personalkostnad=personalkostnad*2;
for(int i=0; i<vagnar.length; i++){
//ber¨aknar vinst per vagn
vinsten=vinsten+vagn.vinst(grad, biljettpris, reslangd);
}
vinst=vinst-personalkostnad;
return vinst;
}
Slutligen metoden vinst i klassen Vagn som ber¨aknar vinsten f¨or en t˚agvagn.
public double vinst(double grad, double biljettpris, double reslangd){
double vinsten;
double saldaBiljetter;
saldaBiljetter=grad*antalPlatser;
//Bortser h¨arifr˚an att man egentligen ej kan s¨alja halva biljetter
if(studentvagn)
vinsten=saldaBiljetter*biljettpris/2.0; //halva priset f¨or studenter else
vinsten=saldaBiljetter*biljettpris;
//drar bort kostnaden f¨or vagnen vinsten=vinsten-reslangd*timkostnad;
return vinsten;
}
