Beware before!! Observera att lösningarna till dessa uppgifter kanske inte alltid är de
allra bästa. Några behöver definitivt en översyn!/PHe
Grupp 2 Johan Nilsén- Erik Sundberg Markus Nordstrand- Jonny Heinonen
3.10
public int returnBig(int x, int y)
{
if(x >= y)
return x;
return y;
}
3.12
import java.io.*; import java.random.*;
public class produkt
{
static int kvalitet;
static String colour;
public produkt(String c, int k)
{
kvalitet = k;
colour = c;
}
public static void main(String args[]) {
BufferedReader in =
new BufferedReader(new InputStreamReader(System.in));
String oneLine;
try{
System.out.println("Ange färg -> ");
oneLine = in.readLine();
produkt p;
p = new produkt(oneLine, ge_kvalitet());
System.out.println("Färg :" + produkt.colour);
System.out.println("Kvalitet :" + produkt.kvalitet);
}
catch (Exception e) { }
}
public static int ge_kvalitet()
{
return SimpleRandom.randInt(1,3);
}
}
3.17
/**
* DetPi.java
**/
import random.*;
class DetPi
{
public static void main(String [] args)
{
System.out.println("\n*************Determine pi*************\n");
int hits = 0, shoots = 10000;
double x, y;
for(int i=0; i<shoots; i++)
{
//Shoot
x = SimpleRandom.randReal(0,1);
y = SimpleRandom.randReal(0,1);
//Pythagoras
if(Math.sqrt(Math.pow(x,2) + Math.pow(y,2)) < 1)
hits++;
}
//Area == r*r*pi /4 == (hits/shoots)*1
double pi = (4*hits)/(double)shoots;
System.out.println("Av " + shoots + " \"skott\" träffade " + hits + "\"måltavlan\"");
System.out.println("Pi = " + pi);
}
}
Noggrannhet:
gränsvärdessatsen.
Konfidensintervall = 95% ger
my=Xm 1.96 * s / Vn , där s = standardavvikelse och n = antal testkörningar
Felet = (1.96 * s / Vn) / Xm
3.23
Egna antaganden vi gjort:
Vi använder bara en hamnkran, men inga större ändringar behövs för att lägga till flera.
Vi har gjort ytterligare en klass, Result, för att hantera utskrifterna som skall göras efter varje timme.
Bara last från de båtar som är helt färdiglossade räknas med vid varje timme.
Vi har lagt in diverse konstanter som finns med mest för att kunna testa programmet.
/**
* Inl3_23.java
**/
import sim.*;
public class Inl3_23
{
public static void main (String[] args)
{
//Det måste finnas en kran innan man börjar skicka in båtar
HarbourCrane harbourCrane = new HarbourCrane();
CargoShipGenerator cargoShipGenerator = new CargoShipGenerator(harbourCrane);
Scheduler.activate(cargoShipGenerator);
Scheduler.run_simulation();
}
}
/**
* CargoShipGenerator.java
**/
import java.util.*;
import sim.*;
import random.*;
public class CargoShipGenerator extends Prosess
{
private HarbourCrane crane;
public CargoShipGenerator(HarbourCrane h) {
super(); crane = h;
}
public void body() {
while(Scheduler.clock <= crane.getTimeLimit())
{
//Skapa och aktivera en ny båt
Scheduler.activate(new CargoShip(crane));
//Vänta en slumpmässig tid
Scheduler.hold(SimpleRandom.randInt(5, 35));
}
//Vänta länge tills alla båtar är klara
Scheduler.hold(100000);
terminate();
}
}
/**
* CargoShip.java
*
**/
import java.util.*;
import sim.*;
import random.*;
public class CargoShip extends Prosess
{
private static int nrOfShips = 0;
private int shipNr;
public static Vector lq = new Vector();
private HarbourCrane crane;
private int myLoad;
public CargoShip(HarbourCrane h)
{
super();
crane = h;
myLoad = SimpleRandom.randInt(2, 10);
nrOfShips++;
shipNr = nrOfShips;
System.out.println("Båt nr " + shipNr + " skapad med: " + myLoad + " tons last!");
}
public int getLoad()
{
return myLoad;
}
public void body()
{
//Lägg till båten i kön
lq.addElement(this);
//Om båten ligger först i kön så aktivera kranen
//annars väntar båten på sin tur
if(lq.size() == 1)
{
Scheduler.activate(crane);
}
else
{
Scheduler.passivate();
}
//Vänta den tid det tar att lossa
Scheduler.hold(myLoad*crane.getUnloadTime());
System.out.println("Båt nr " + shipNr + " färdiglossad!");
//Aktivera kranen igen för att se om fler båtar finns i kön
Scheduler.activate(crane);
terminate();
}
}
/**
* HarbourCrane.java
*
* Inlämningsuppgift 3.23
**/
import sim.*;
public class HarbourCrane extends Prosess
{
private int totalLoad;
private final int unloadTime = 5; //Tid som krävs för att lossa ett ton
private final int timeLimit = 480; //Hur länge ska simuleringen pågå
private Result myResult;
public HarbourCrane()
{
super();
totalLoad = 0;
}
public int getTotalLoad()
{
return totalLoad;
}
public int getUnloadTime()
{
return unloadTime;
}
public int getTimeLimit()
{
return timeLimit;
}
public void body()
{
//Skapa ett resultatobjekt
myResult = new Result(this);
Scheduler.activate(myResult);
while(true)
{
//Om det finns båtar i kö så ta hand om dessa
while(!CargoShip.lq.isEmpty())
{
//Ta första båten i kön
CargoShip myShip = (CargoShip) CargoShip.lq.firstElement();
Scheduler.activate(myShip);
Scheduler.passivate();
totalLoad += myShip.getLoad();
//När båten har lossats, ta bort den ur kön
CargoShip.lq.removeElementAt(0);
}
//Om simuleringstiden och kön tom är slut så avbryt
//annars väntar kranen på nästa båt
if(Scheduler.clock > timeLimit)
{
break;
}
else
{
Scheduler.passivate();
}
}
terminate();
}
}
/**
* Result.java
**/
import sim.*;
public class Result extends Prosess
{
private HarbourCrane crane;
public Result(HarbourCrane h)
{
super();
crane = h;
}
public void body()
{
int hours = 0;
while(!crane.terminated())
{
//Skriv ut totalt lossad last efter varje timme
Scheduler.hold(60);
hours++;
System.out.println("Efter " + hours + " timmar har kranen lossat " +
crane.getTotalLoad() + " ton.");
}
terminate();
}
}
3.25
Felen i koden är bl.a. Initeringen kommer efter koden.
Den byter riktning två gånger i rad i loopen (först och sist) vilket gör att bara bilar från en riktning får
grönt hela tiden.
Ifall det hela tiden kommer bilar kommer den aldrig att byta riktning vilket medför en enorm kö i den
andra riktningen.
Grupp 4 Bahadori- Hellström - Al-Saadi - Norberg
3.9
import java.io.*;
public class nr1{
static public void main(String[] arg)
throws IOException
{
double x;
BufferedReader in=new BufferedReader(
new InputStreamReader(System.in));
String str;
System.out.println("Ange talet X: ");
System.out.flush();
str=in.readLine();
x=Double.valueOf(str).doubleValue();
resPrint(x);
}
static public void resPrint(double x){
System.out.println("Resultatet blev: " + x);
}
}
3.11
import sim.*;
public class spy{
public void spion(String str){
System.out.println(str + " " + Scheduler.clock);
}
}
import java.io.*;
public class nr2{
public static void main(String[] args){
spy s=new spy();
s.spion("Hejsan");
s.spion("Hejsan");
s.spion("Hejsan");
s.spion("Hejsan");
}
}
3.21
import sim.*;
import random.*;
public class cust{
private int antalVaror;
private int nummer;
public int getAntalVaror(){return antalVaror;};
public int getNummer(){return nummer;};
public cust(int n){
nummer=n;
antalVaror=SimpleRandom.randInt(1,1000);
}
}
import java.io.*;
import sim.*;
import java.util.*;
public class nr3{
public static void main(String[] args){
Vector qu=new Vector();
int i;
cust t;
for(i=0;i<9;i++){
qu.addElement(new cust(i+1));
}
for(i=0;i<9;i++){
t=(cust)qu.elementAt(i);
System.out.println(t.getNummer() + " " + t.getAntalVaror());
}
}
}
3.26c
class kylvara{
private double temp;
String namn;
public void setTemp(double t){temp = t;}
public double getTemp(){return temp;}
public String getName(){return namn;}
public kylvara(String name,double t){namn=name;temp=t;}
}
import java.io.*;
import java.util.*;
public class nr4{
static Vector varor=new Vector();
static Vector varningar=new Vector();
static public double maxtemp=10;
public static void main(String[] args){
int i;
varor.addElement(new kylvara("1",23));
varor.addElement(new kylvara("2",3));
varor.addElement(new kylvara("3",5));
varor.addElement(new kylvara("4",10));
varor.addElement(new kylvara("5",11));
varor.addElement(new kylvara("6",7));
varor.addElement(new kylvara("7",3));
varor.addElement(new kylvara("8",13));
check_temp();
}
public static void check_temp(){
int i;
kylvara k;
double temp;
double medel;
medel=0;
for(i=0;i<varor.size();i++){
k=(kylvara)varor.elementAt(i);
temp=k.getTemp();
medel+=temp;
if(temp>maxtemp){
varningar.addElement(new warning(temp,k));
}
}
medel/=varor.size();
System.out.println("Antal varningar: " + varningar.size());
System.out.println("Medel = " + medel);
}
}
class warning{
private double temp;
private kylvara varuref;
warning(double t,kylvara vara){
temp=t;
varuref=vara;
System.out.println("Varning!! Temperatur=" + temp);
}
public double getTemp(){return temp;}
public kylvara getVaruref(){return varuref;}
}
3.15
import sim.*;
import random.*;
public class bilgenerator extends Prosess{
public trafikljus t;
public bilgenerator(trafikljus tr){
t=tr;
System.out.println("Ny bilgenerator");
}
public void body(){
int persbilnr=0;
int lastbilnr=0;
while(Scheduler.clock<trafikljus.stopTime){
int slump=SimpleRandom.randInt(1,5);
if(slump==1){
Scheduler.activate(new lastbil(++lastbilnr,t));
}else{
Scheduler.activate(new personbil(++persbilnr,t));
}
Scheduler.hold(5);
}
Scheduler.passivate();
terminate();
}
}
import sim.*;
import random.*;
import java.util.*;
import java.io.*;
public class lastbil extends Prosess{
private trafikljus t;
private int i;
public lastbil(int n,trafikljus tr){
i=n;
t=tr;
System.out.println("Ny lastbil " + i + " vid tiden " + Scheduler.clock);
}
public void body(){
if((t.green==false) || t.antalIKo>0){
t.antalIKo++;
t.bilqueue.addElement(this);
Scheduler.passivate();
t.antalIKo--;
}
System.out.println("Lastbil nr " + i + " kör vid tiden " +Scheduler.clock);
Scheduler.passivate();
terminate();
}
}
import sim.*;
public class main{
public static void main(String[] args){
trafikljus tl=new trafikljus();
Scheduler.activate(tl);
Scheduler.run_simulation();
}
}
import sim.*;
import random.*;
import java.io.*;
import java.util.*;
public class personbil extends Prosess{
private trafikljus t;
private int i;
public personbil(int n,trafikljus tr){
i=n;
t=tr;
System.out.println("Ny personbil " + i + " vid tiden " + Scheduler.clock);
}
public void body(){
int slump;
if((t.green==false) || t.antalIKo>0){
t.antalIKo++;
t.bilqueue.addElement(this);
Scheduler.passivate();
t.antalIKo--;
}
slump=SimpleRandom.randInt(1,100);
if(slump<=50){
System.out.println("Bil nr " + i + " kör rakt fram vid tiden "
+Scheduler.clock);
}else if((slump>50) && (slump<=80)){
System.out.println("Bil nr " + i + " svänger åt vänster vid tiden "
+Scheduler.clock);
}else{
System.out.println("Bil nr " + i + " svänger åt höger vid tiden "
+Scheduler.clock);
}
Scheduler.passivate();
terminate();
}
}
import sim.*;
import random.*;
import java.util.*;
import java.io.*;
public class trafikljus extends Prosess{
public Vector bilqueue=new Vector();
static public final int stopTime=200;
public boolean green;
public int antalIKo=0;
public trafikljus(){
System.out.println("Nytt trafikljus");
}
public void body(){
int delay;
Prosess bil;
green=true;
bilgenerator bg=new bilgenerator(this);
Scheduler.activate(bg);
while(Scheduler.clock<stopTime){
Scheduler.hold(40);
green=(!green);
if(green==true){
System.out.println("Grönt ljus!");
delay=0;
while(!bilqueue.isEmpty()){
delay++;
bil=(Prosess)bilqueue.firstElement();
bilqueue.removeElementAt(0);
Scheduler.reactivate(bil,delay);
}
}
else System.out.println("Rött ljus!");
}
Scheduler.passivate();
terminate();
}
}
Bilgenerator
Personbil
start
start
bilen
Aktivera en ny
bil eller lastbil
Kolla om rött ljus eller kö
inte tom ställs i kön
aktiverad
Slumpa körning
50% raktfram
30% vänster
20% höger
Vänta (5)
Kolla slut_tid
slut
Lastbil
start
Kolla om rött ljus
eller kö inte tom
ställs i kön
Simulering
Trafilkljus
Aktiverad
Start av
simulering
Kör raktfram
start
slut
Aktivera
nytrafikljus
Ny bilgenerator
Grupp 3 Molén - Schuber - Bäckström - Nilsson
3.8
En vector är ungefär som ett fält, skillnaden är att den är dynamisk. Alltså man behöver inte i förväg definiera
hur stor den skall vara utan det bestäms under exekveringen. Till klassen vector finns fördefinierade metoder
som hanterar vectorer. Exempel på detta är b la size(), addElement().
3.13
public class person
{
private String namn;
private String kön;
public static get_Namn();
public static get_Kön();
};
public class anställd extends person
{
private String Titel;
private static get_Titel();
};
public class pensionär extends person
{
private String Hobby;
private static get_Hobby();
};
3.19
public Type slumpa(vector v)
{
int slumpen = randInt(0, (v.size()-1))
Type t = (Type) v.elementAt(slumpen);
return Type;
}
3.26 b
Man allokerar minne vid behov vid exekveringen. I Java så använder man new operatorn, som man då skapar ett
nytt objekt dynamiskt.
import
import
import
import
import
java.io.*;
java.util.*;
java.text.*;
random.*;
sim.*;
class busstur
{
public static buss bussen;
public busstur() {}
public static void main(String args[])
{
Scheduler.reset();
System.out.println("Simulation starts: " +
Scheduler.clock);
Scheduler.activate(bussen=new buss());
Scheduler.run_simulation();
System.out.println("Simulation stops: " +
Scheduler.clock);
}
}
class buss extends Prosess
{
public static Vector[] stationsq=new Vector[10];
public static int index;
static {
index=0;
for(int i=0; i<10; i++)
{
stationsq[i]=new Vector();
}
}
public static Vector getstationsq()
{
return stationsq[index];
}
buss( )
{
}
public void body()
{
NumberFormat nf = NumberFormat.getInstance();
nf.setMaximumFractionDigits(2);
int antal;
for(index=0; index<9; index++)
{
antal=SimpleRandom.randInt(1,10);
for(int j=0; j<antal; j++)
{
passbuss b=new passbuss(0.25,this);
stationsq[index].addElement(b);
}
}
index=0;
int d;
System.out.println("Bussen startar sin tur " +
nf.format(Scheduler.clock));
d=SimpleRandom.randInt(3,5);
Scheduler.hold(d);
System.out.println("Bussen framme vid staion: " +
(index+1) + " tiden :" +
nf.format(Scheduler.clock));
while(index<9)
{
passbuss p=(passbuss)stationsq[index].elementAt(0);
Scheduler.activate(p);
Scheduler.passivate();
System.out.println("Bussen lämnar staion: " +
(index+1) + " tiden :" +
nf.format(Scheduler.clock));
d=SimpleRandom.randInt(3,5);
System.out.println("Från station "+(index+1)+
" till station " +( index+2 )+
" tar det: " + nf.format(d)+
" minuter");
Scheduler.hold(d);
index++;
}
for(int s=0; s<9; s++)
{
for(int t=0; t<stationsq[s].size();t++)
{
passbuss p=
(passbuss)stationsq[s].elementAt(t);
stationsq[9].addElement(p);
}
}
System.out.println(
"Antal Passagerare vid slutstation: "
+ stationsq[9].size());
System.out.println("Framme efter: " +
(nf.format((Scheduler.clock))));
terminate();
}
}
class passbuss extends Prosess
{
public double pastigstid;
public static buss bus;
public static int ind=0;
public Vector passagerare;
passbuss(double a,buss b)
{
pastigstid=a;
bus=b;
}
public void body()
{
passagerare=bus.getstationsq();
Scheduler.hold(pastigstid);
ind++;
if(ind!=passagerare.size())
{
passbuss p=(passbuss)passagerare.elementAt(ind);
Scheduler.activate(p);
}
if(ind==passagerare.size())
{
ind=0;
Scheduler.activate(bus);
}
terminate();
}
}
F:\sim>java busstur
Simulation starts: 0.0
Bussen startar sin tur 0
Bussen framme vid staion: 1 tiden :3
Bussen lõmnar staion: 1 tiden :4,25
FrÕn station 1 till station 2 tar det: 4 minuter
Bussen lõmnar staion: 2 tiden :8,5
FrÕn station 2 till station 3 tar det: 4 minuter
Bussen lõmnar staion: 3 tiden :13,75
FrÕn station 3 till station 4 tar det: 4 minuter
Bussen lõmnar staion: 4 tiden :19,25
FrÕn station 4 till station 5 tar det: 3 minuter
Bussen lõmnar staion: 5 tiden :24,5
FrÕn station 5 till station 6 tar det: 3 minuter
Bussen lõmnar staion: 6 tiden :27,75
FrÕn station 6 till station 7 tar det: 4 minuter
Bussen lõmnar staion: 7 tiden :34
FrÕn station 7 till station 8 tar det: 5 minuter
Bussen lõmnar staion: 8 tiden :40,25
FrÕn station 8 till station 9 tar det: 3 minuter
Bussen lõmnar staion: 9 tiden :45,5
FrÕn station 9 till station 10 tar det: 3 minuter
Antal Passagerare vid slutstation: 50
Framme efter: 48,5
Simulation done
Simulation stops: 48.5
Flödesdiagram för klassen Buss
Start
klassen busspass
Start
Bussen aktiverar
passagerare
Tar första ur kön vid första
station,
väntar passiv
Passageraren lägger sig i sin
kö och aktiveras
Aktiverar passagerare
Siste man ur kön aktiverar
bussen,
Bussen gör hold i
antalet tidsenheter det tar till
nästa station
Efter 9 stationer
Bussen tömmer alla köer och
lägger in dom i sin egen,
Bussen terminerar
Efter att alla stigit på
Aktiveras bussen
Grupp 1 Aspelin - Lindberg - Ohlsson - Linderkers
/**
* Cell.java
* Uppgift 3.26d
* @author Studenter Högskolan Dalarna Dec 1999
*/
import sim.*;
import random.SimpleRandom;
class Cell extends Prosess
{
// Cellens generations tillhörighet
private int generation;
// cellens livstid tills den delar sig eller terminerar
private double lifeTime;
// Antalet celler som finns i detta prov
public static int number = 0;
// maximala antalet generationer som en cell kan bli för att kunna dela sig:
private final static int genMax = 4;
// Konstruktor
public Cell( int gen )
{
lifeTime = SimpleRandom.normal(4,0.25); // Cellens livstid normalfördelat
generation = gen;
// Cellens generation
number ++;
// Räknar upp antalet celler
}
public void body()
{
// Tills simuleringstiden är slut
while( (Scheduler.clock + lifeTime) < CellSim.closeTime )
{
// kontroll av generation
if( generation < genMax )
{
if( generation==0 )
{
// Väntar slumpad tid för att sedan skapa en ny cell ( placeras i HL )
Scheduler.hold(lifeTime);
// Skapar en ny cell av generation 0
Scheduler.activate( new Cell ( 0 ) );
}
else // ej av generation 0
{
// Väntar slumpad tid för att sedan skapa en ny cell ( placeras i HL )
Scheduler.hold(lifeTime);
// Skapar en ny cell med generationsvärdet plus ett
Scheduler.activate( new Cell( generation + 1 ) );
}
// Skapar och aktiverar en ny cell
Scheduler.activate( new Cell( generation + 1 ) );
// Räknar ned antalet celler
number--;
// cellen "modern" terminerar
terminate();
}
else
// Om cellen inte kan generera några nya celler
{
Scheduler.hold( lifeTime );
number--;
terminate();
//Räknar ned antalet celler
}
}
// Cellen terminerar
terminate();
}
} // end class Cell
/**
* CellReport.java
* Uppgift 3.26d
* @author Studenter Högskolan Dalarna Dec 1999
*/
import sim.*;
import random.*;
class CellReport extends Prosess
{
// Tiden mellan att antalet celler skrivs ut i huvudprogrammet
private double outprintTime;
// Konstruktor
public CellReport(double op)
{
outprintTime = op;
}
public void body()
{
// Genererar första cellen
Scheduler.activate( new Cell(0) );
// Skriver ut antalet celler tills simuleringen är avslutad med tidsintervallet
// outprintTime
while( Scheduler.clock + outprintTime <= CellSim.closeTime )
{
// Rapportören läggs i HL för att skriva ut igen efter en outprintTime
Scheduler.hold( outprintTime );
System.out.println(" Number of cells created: " + Cell.number + "\tat: " + Scheduler.clock);
}
// simuleringen är slut och CellReport termineras
terminate();
}
}
/**
* CellSim.java
* Uppgift 3.26d
* @author Studenter Högskolan Dalarna Dec 1999
*/
import sim.*;
import java.util.*;
class CellSim
{
public static double closeTime; // Total tid för simuleringen
public CellSim()
{ }
static public void main(String argv[])
{
closeTime = 120; // Totala simuleringstiden "hårdkodad"
Scheduler.reset();
System.out.println( "Simulation starts at: " + Scheduler.clock );
Scheduler.activate( new CellReport(3) );
// Skrivs ut var 3:e tidsenhet
Scheduler.run_simulation();
Scheduler.clock = closeTime;
System.out.println( "Simulation stops at: " + Scheduler.clock);
System.out.println( "Number of cells when simulation ends: " + Cell.number);
}
}
// Körningsexempel i filen Körningsex.txt
E:\java CellSim
Simulation starts at: 0.0
Number of cells created: 1 at: 3.0
Number of cells created: 2 at: 6.0
Number of cells created: 4 at: 9.0
Number of cells created: 6 at: 12.0
Number of cells created: 8 at: 15.0
Number of cells created: 16 at: 18.0
Number of cells created: 16 at: 21.0
Number of cells created: 13 at: 24.0
Number of cells created: 16 at: 27.0
Number of cells created: 16 at: 30.0
Number of cells created: 16 at: 33.0
Number of cells created: 13 at: 36.0
Number of cells created: 16 at: 39.0
Number of cells created: 16 at: 42.0
Number of cells created: 15 at: 45.0
Number of cells created: 17 at: 48.0
Number of cells created: 16 at: 51.0
Number of cells created: 16 at: 54.0
Number of cells created: 15 at: 57.0
Number of cells created: 10 at: 60.0
Number of cells created: 16 at: 63.0
Number of cells created: 16 at: 66.0
Number of cells created: 8 at: 69.0
Number of cells created: 16 at: 72.0
Number of cells created: 16 at: 75.0
Number of cells created: 15 at: 78.0
Number of cells created: 17 at: 81.0
Number of cells created: 16 at: 84.0
Number of cells created: 16 at: 87.0
Number of cells created: 21 at: 90.0
Number of cells created: 18 at: 93.0
Number of cells created: 16 at: 96.0
Number of cells created: 16 at: 99.0
Number of cells created: 16 at: 102.0
Number of cells created: 15 at: 105.0
Number of cells created: 16 at: 108.0
Number of cells created: 16 at: 111.0
Number of cells created: 16 at: 114.0
Number of cells created: 16 at: 117.0
Number of cells created: 16 at: 120.0
Number of cells created: 16 at: 123.0
Simulation done
Simulation stops at: 125.0
Number of cells created: 17
3.14
import java.io.*;
class Person
{
private String name;
private Person mother;
private Person father;
public Person(String namn, Person mor, Person far)
{
name=namn;
mother=mor;
father=far;
}
public Person(String namn, Person mor)
{
name=namn;
mother=mor;
}
public Person(String namn)
{
name=namn;
}
public void Report()
{
System.out.println("namn: " + name);
if(mother!=null)
{
System.out.println(name + "s mor har ");
mother.Report();
}
if(father!=null)
{
System.out.println(name + "s far har ");
father.Report();
}
}
}
import java.io.*;
class PersonTest
{
public static void main(String [] args)
{
Person mormor=new Person("Ingeborg");
Person mor=new Person ("Inga",mormor);
Person far=new Person("Inge");
Person kalle=new Person("Kalle",mor,far);
kalle.Report();
}
}
3.18
/** ***********************************************************************
* Queue.java - Inlämningsuppgift 3.18 grupp 1 : Simulering 5p
*
* UPPGIFT 3.18:
* Skriv en funktion i Java som med hjälp av Vector klassen ställer
* ett objekt av en klass "först" i en lista. Exempel på ett anrop: FirstIn(Vara)
* @author Mikael Ohlsson : [email protected]
* D3Pt 1999-12-06
************************************************************************* */
import java.io.*; // System.out
import java.util.Vector; // Vector
/** Exempelklassen Queue en lagerlista.
* För att programmet skall fungera krävs att klassen Vara finns.
* Använder sig av den fördefinierade klassen Vector som finns i
* java.util.Vector
*/
class Queue {
/** Vektorn lager */
private static Vector lager = new Vector(4);
/** Den vitala funktionen som ställer ett objekt av godtycklig typ först
* i listan lager. Enda argumentet är Objektet som skall ner i lagret.
* Funkar om man anropar inom den egna klassen.
*/
public static void FirstIn(Object thing) {
lager.insertElementAt(thing,0); // lägger till först i listan/vektorn
}
/** Den vitala funktionen i annan skepnad där man är tvingad att specificera
* vilken vector som objectet skall läggas in i.
* Tar två argument: Objektet och Vectorn
* Funkar för anrop från klasser utifrån.
*/
public static void FirstIn(Object thing, Vector theQueue) {
theQueue.insertElementAt(thing,0); // lägger till först i listan/vectorn
}
/**
* Test program för FirstIn()
*/
public static void main (String [] a){
lager.addElement(new Vara(2,"Towels"));
System.out.println("\nAdding 2 Towels into lager!");
lager.addElement(new Vara(10,"Soap"));
System.out.println("Adding 10 Soaps into lager! ");
System.out.println("\n Lager now contains:");
System.out.println("Object no 1: " + lager.elementAt(0));
System.out.println("Object no 2: " + lager.elementAt(1));
System.out.println("\nAdding 12 Mugs first in the lager list! ");
FirstIn(new Vara(12, "Mugs"), lager);
System.out.println("\n Lager now contains:\nObject no 1: " + lager.elementAt(0));
System.out.println("Object no 2: " + lager.elementAt(1));
System.out.println("Object no 3: " + lager.elementAt(2));
} /* end main */ } // end class
/** ************ Körnings exempel **************
* Adding 2 Towels into lager!
* Adding 10 Soaps into lager!
*
* Lager now contains:
* Object no 1: Quantity: 2 Specification: Towels
* Object no 2: Quantity: 10 Specification: Soap
*
* Adding 12 Mugs first in the lager list!
*
* Lager now contains:
* Object no 1: Quantity: 12 Specification: Mugs
* Object no 2: Quantity: 2 Specification: Towels
* Object no 3: Quantity: 10 Specification: Soap
*
* Process Exit...
*/
/** ************************************************************
* Vara.java
* Inlämningsuppgift 3.18 grupp 1 : Simulering 5p
*
* Klassen Vara testklass till Queue
*
* @author Mikael Ohlsson : [email protected]
* D3Pt 1999-12-06
************************************************************** */
class Vara {
private int quantity;
private String type;
/** Konstruktor */
public Vara(int q, String arg) {
quantity = q;
type = arg;
}
/** Överlagrad toString() */
public String toString() {
return("Quantity: " + quantity + " Specification: " + type);
}
}
3.7
3.7
Klassen Vector i Java definierar en viss typ av liststrukturer.
Hur ser de ut? Vad är beståndsdelarna och hur är de
organiserade?
Klassen Vector implementerar ett fält av objekt där objekten kan nås via
index. Fältet kan öka och minska i storlek efter behov för att man ska kunna
lägga till och ta bort objekt efter att vektorn skapats.
Medlemsvariabler:
int capacityIncrement
int elementCount
Object [] elementData
- är hur mycket vektorn ska öka med när
storleken behöver ökas.
- är antalet komponenter i vektorn.
- är fältet där vektorns komponenter lagras.
Konstruktorer:
- ger en tom vektor med ett fält för 10
komponenter och standardökningen satt
till noll.
Vector(int initialStorlek)
- ger en tom vektor med ett fält för
initialStorlek komponenter och ökning
noll.
Vector(int initialStorlek,int storleksökning) - ger en tom vektor med ett fält för
initalStorlek komponenter och ökningen
storleksökning.
Vector()
Metoder:
void addElement(Object obj)
void insertElementAt(Object obj, int index)
void setElementAt(Object obj, int index)
void removeElementAt(int index)
Object elementAt(int index)
int Size()
boolean isEmpty()
- lägger till obj sist i fältet.
- sätter in obj på index.
- ersätter objektet på index med obj.
- tar bort objektet på index.
- returnerar objektet på index.
- returnerar antalet objekt som finns i
vektorn.
- returnerar true om vektorn är tom.
Star
t
Initiera och
skriv ut
( aktivera
CellReport )
Skapa en
CellRepor
t
Kör simuleringen
till closeTime
Skriver ut
simulerings
resultatet
Slut
Star
t
Skapa
urcellen
Är
simuleringstiden
slut?
Ja
Terminerar
Nej
Gör hold till
nästa
utskrift
Skriv ut antalet celler
just nu samt tid.
Slu
t
Star
t
Är
simuleringstiden
slut?
Ja
Nej
Ja
Är
generation större
än genMax
?
Nej
Gör hold() på
cellen
Gör hold() på
cellen
Är
cellen av
generation 0
?
Nej
Skapar ny cell av
generation + 1
Ja
Skapar ny cell av
generation 0
Skapar ny cell av
generation + 1
Cellen
terminerar()
Slut
