Innholdsoversikt for programutvikling

Dato og tid: bruk av Calendar-klassen

For programmering av dato og tid, har vi i klassebibliotekets pakke java.util klassene Date, Calendar og dens subklasse GregorianCalendar. Et Date-objekt representerer et bestemt tidspunkt i tiden, med en presisjon på millisekund nær. (Internt i klassen er tidspunktet bestemt som et antall millisekunder fra 1. januar 1970.) Opprinnelig hadde denne klassen også to tilleggsfunksjoner. Den tillot tolking av datoer i form av år, måned, dag, time, minutt og sekund. Den tillot også formatering og parsing av datostrenger. Metodene for dette var imidlertid ikke laget slik at det kunne tas hensyn til forskjellige tidssoner og lokale standarder for formatering. Derfor er Date-klassens funksjonalitet for dette nå markert som foreldet. Isteden skal Calendar-klassen brukes til tolking av datoer i form av år, måned, dag, time, minutt og sekund. Til formatering og parsing av datostrenger skal DateFormat-klassen brukes.

Calendar-klassen er en abstrakt basisklasse for konvertering mellom et Date-objekt (som den inneholder) og et sett av int-datafelter slik som YEAR, MONTH, DAY, HOUR, etc. Subklasser av Calendar tolker et Date-objekt i samsvar med reglene i et bestemt kalendersystem. Foreløpig finnes subklassen GregorianCalendar som representerer vår vanlige kalender.

Tilsvarende som for andre klasser der innholdet skal tilpasses lokale forhold, finnes det i Calendar-klassen en static-metode getInstance for å få opprettet og returnert et standardobjekt av vedkommende type. Calendar-klassens metode getInstance returnerer et objekt av type GregorianCalendar som er initialisert til det tidspunkt da det ble opprettet:

  Calendar nå = Calendar.getInstance();

Vi kan bruke set-metoder for å sette verdi for bestemte datafelter.

Eksempel

  nå.set( Calendar.HOUR_OF_DAY, 15 );

For å hente ut verdier fra datafelter kan vi bruke get-metoder.

Eksempel

  int måned = nå.get( Calendar.MONTH ) + 1;

NB! Calendar.MONTH starter på 0.

For å øke eller minke et datafelt, kan vi bruke add-metoden.

Eksempel

  nå.add( Calendar.DAY_OF_MONTH, 5 );

For å minke, øker vi med en negativ verdi. OBS! Eventuell nødvendig økning (eller minking) av Calendar.MONTH vil skje automatisk når dagen endres. Tilsvarende gjelder for alle andre felt.

Det er også mulig å sette verdien for flere felt samtidig.

Eksempel

  nå.set( år, måned, dag );
  nå.set( år, måned, dag, time, minutt );

Parametrene vil bli tolket i den rekkefølge som her er antydet ved navnebruken.

Vi kan også hente ut det Date-objekt som Calendar-objektet inneholder. Og vi kan sette verdi for dette.

Eksempel

  Date tid = nå.getTime();
  Calendar ny = Calendar.getInstance();
  ny.setTime( tid );

Objekter av type GregorianCalendar kan vi også opprette på vanlig måte ved bruk av new-operatoren. Bruker vi default-konstruktøren, vil objektet bli initialisert til det tidspunkt det ble opprettet. Men det finnes også konstruktører med parametre for initialisering av dato (år, måned, dag), og for dato og tidspunkt (år, månded, dag, time, minutt), eventuelt med tilleggsparameter for sekund.

Programeksempel 1: Månedskalender

Vi skal ta for oss et program som viser en månedskalender for den aktuelle måned når programmet blir kjørt. Følgende bilde viser et eksempel. Dagens dato blir vist med uthevet skrift.

Programmet er tilpasset etter et eksempel i boka Core Java av Cay S. Horstmann og Gary Cornell. Det er tilpasset norske forhold. Dessuten blir kalenderen vist på et panel istedenfor på en utskrift i konsollvinduet. Det blir også laget overskrift med månedsnavn og årstall.

Panelet med kalenderen er definert av klassen Maanedskalender som er gjengitt nedenfor. I paintComponent-metoden, som blir kalt opp automatisk hver gang det er behov for å friske opp programvinduet på skjermen, blir tidspunktet oppdatert til det øyeblikk metoden blir utført, slik at vi sikrer oss at kalenderen viser dagens dato riktig. Programmet er skrevet slik at det virker riktig på den lokalitet der det blir installert. Her i Norge får vi riktige navn på dagene og månedene, og som første ukedag får vi mandag. (I USA er det søndag.)

Panelet som viser kalenderen kan legges inn i et hvilket som helst vindu. Testprogrammet Maanedskalendertest er et lite testprogram som bare viser et slikt panel.

  1 import javax.swing.*;
  2 import java.util.Calendar;
  3 import java.util.GregorianCalendar;
  4 import java.util.Date;
  5 import java.text.DateFormatSymbols;
  6 import java.awt.*;
  7
  8 public class Maanedskalender extends JPanel
  9 {
 10   private GregorianCalendar kalender;
 11   private int iDag;
 12   private int måned;
 13   private int førsteUkedag;
 14   private String[] ukedagnavn;
 15   private String[] månedsnavn;
 16   private int mellomrom = 30;
 17   private int linjeavstand = 20;
 18   private int xStart = 20, yStart = 30;
 19   private Font skrivefont = new Font("SansSerif", Font.PLAIN, 16);
 20   private Font iDagfont = new Font("SansSerif", Font.BOLD, 16);
 21
 22   public Maanedskalender()
 23   {
 24     setPreferredSize(new Dimension(250, 190));
 25     kalender = new GregorianCalendar();
 26     iDag = kalender.get(Calendar.DAY_OF_MONTH);
 27     måned = kalender.get(Calendar.MONTH);
 28     //får tak i hvilken dag uka starter med (mandag i Europa)
 29     førsteUkedag = kalender.getFirstDayOfWeek();
 30     ukedagnavn = new DateFormatSymbols().getShortWeekdays();
 31     månedsnavn = new DateFormatSymbols().getMonths();
 32   }
 33
 34   public void paintComponent(Graphics g)
 35   {
 36     super.paintComponent(g);
 37     //Oppdaterer kalenderen til dagens dato:
 38     Date nå = new Date();
 39     kalender.setTime(nå);
 40     //Skal finne innrykket fram til første dato i måneden.
 41     //Setter kalenderen til første dag i måneden:
 42     kalender.set(Calendar.DAY_OF_MONTH, 1);
 43     int ukedag = kalender.get(Calendar.DAY_OF_WEEK);
 44     //Finner innrykk for første linje:
 45     int innrykk = 0;
 46     while (ukedag != førsteUkedag)
 47     {
 48       innrykk++;
 49       kalender.add(Calendar.DAY_OF_MONTH, -1);
 50       ukedag = kalender.get(Calendar.DAY_OF_WEEK);
 51     }
 52     //Nå er ukedag == førsteUkedag
 53     //Skal lage overskrift med måned, år og liste over ukedagene.
 54     g.setFont(iDagfont);
 55     int x = xStart, y = yStart;
 56     String navn = månedsnavn[måned];
 57     navn = navn.replace(navn.charAt(0),
 58             Character.toUpperCase(navn.charAt(0)));
 59     navn = navn + "  " + kalender.get(Calendar.YEAR);
 60     g.drawString(navn, x, y); //skriver ut månedsnavn og årstall
 61     y += linjeavstand;
 62     //skriver ut en linje med dagenes navn
 63     do
 64     {
 65       g.drawString(ukedagnavn[ukedag], x, y);
 66       x += mellomrom;
 67       kalender.add(Calendar.DAY_OF_MONTH, 1);
 68       ukedag = kalender.get(Calendar.DAY_OF_WEEK);
 69     } while (ukedag != førsteUkedag);
 70
 71     //Skal liste ut alle månedens datoer, riktig plassert
 72     //under ukedagene.
 73     g.setFont(skrivefont);
 74     x = xStart + innrykk * mellomrom;
 75     y += linjeavstand;
 76     kalender.set(Calendar.DAY_OF_MONTH, 1);
 77     do
 78     {
 79       int dag = kalender.get(Calendar.DAY_OF_MONTH);
 80       ukedag = kalender.get(Calendar.DAY_OF_WEEK);
 81       String utskrift;
 82       if (dag < 10)
 83       {
 84         utskrift = "  " + dag;
 85       }
 86       else
 87       {
 88         utskrift = "" + dag;
 89       }
 90       if (ukedag == Calendar.SUNDAY)
 91       {
 92         g.setColor(Color.red);
 93       }
 94       if (dag != iDag)
 95       {
 96         g.drawString(utskrift, x, y);
 97       }
 98       else
 99       {
100         g.setFont(iDagfont);
101         g.drawString(utskrift, x, y);
102         g.setFont(skrivefont);
103       }
104       g.setColor(Color.black);
105       x += mellomrom;
106       //går til neste dag
107       kalender.add(Calendar.DAY_OF_MONTH, 1);
108       ukedag = kalender.get(Calendar.DAY_OF_WEEK);
109
110       //starter på ny linje i tilfelle ukestart
111       if (ukedag == førsteUkedag)
112       {
113         x = xStart;
114         y += linjeavstand;
115       }
116     } while (kalender.get(Calendar.MONTH) == måned);
117   }
118 }

Rekkefølge

Når vi har å gjøre med flere forskjellige tidspunkter, kan vi dels være interessert i rekkefølgen for dem reint kronologisk - om et tidspunkt er tidligere enn et annnet tidspunkt. Dels kan vi være interessert i avstanden mellom dem i for eksempel antall dager, timer eller minutter. For å finne ut av dette, har vi flere muligheter.

Rekkefølge for Date-objekter

For å sjekke om Date-objektet representerer et tidligere tidspunkt enn Date-objektet da, kan vi bruke Date-metoden before:

  if ( nå.before( da ) )
    ...          // det er tilfelle at nå er tidligere enn da
  else
    ...          // nå er samtidig med eller seinere enn da

Det finnes en tilsvarende Date-metode after. Date-klassen implementer interface Comparable<Date>. For Date-objekter er det derfor definert en compareTo-metode. Den er implementert til å gi kronologisk rekkefølge. Dersom vi for de to Date-objektene og da skriver instruksjonen

  nå.compareTo( da )

så vil vi få returnert en negativ int-verdi i tilfelle er tidligere enn da, 0 i tilfelle de to tidspunktene er eksakt lik hverandre, og en positiv int-verdi i tilfelle er et seinere tidspunkt enn da.

Rekkefølge for Calendar-objekter

For å finne ut av rekkefølgen for to Calendar-objekter og da har vi flere muligheter. Dersom det bare er rekkkefølgen vi vil sjekke, kan vi skrive slik

  if ( nå.after( da ) )
    ...

eller

  if ( nå.before( da ) )
    ...

Calendar-klassen implementerer interface Comparable<Calendar> med en compareTo-metode som også gir kronologisk rekkefølge. Vi kan derfor bruke compareTo-metode for Calendar-objekter på samme måte som det ovenfor er beskrevet for Date-objekter.

Avstand mellom tidspunkter

Dersom vi er interessert i å finne tidsforskjellen mellom to tidspunkter, kommer det litt an på hvor stor nøyaktighet vi behøver, og om de to tidspunktene er innenfor samme år eller ikke. Avstand i antall dager mellom to Calendar-objekter og da innenfor samme år kan vi finne slik:

  int dagerIAvstand = Math.abs( nå.get( Calendar.DAY_OF_YEAR ) -
                                  da.get( Calendar.DAY_OF_YEAR ) );

Dersom vi ønsker større presisjon, eller de to tidspunktene ikke er innenfor samme år, er det enklest først å finne avstanden i antall millisekunder og så gjøre denne om til antall dager, timer, og eventuelt minutter, sekunder og millisekunder. For avstand mellom de to Calendar-objektene og da blir det slik:

  long avstand = Math.abs( nå.getTime().getTime() -
                              da.getTime().getTime() );
  long enDag = 24 * 60 * 60 * 1000;
  long antDager = avstand / enDag;
  long avstand = avstand % enDag; // rest til fordeling på timer og minutter
  long enTime = 60 * 60 * 1000;
  long antTimer = avstand / enTime;
  // eventuell fortsettelse for også å finne minutter, sekunder og millisek.

Formatering for utskrift

Klassen DateFormat i pakken java.text har som oppgave å gi formatering ved utskrift av datoer og tidspunkter. Klassen har flere forskjellige verktøymetoder som returnerer et DateFormat-objekt som gir forskjellig format ved utskrift. Ved å skrive

  DateFormat df = DateFormat.getInstance();

får vi returnert et DateFormat-objekt som gir standardformatering ved bruk av dets format-metode, slik som 02.03.12 13:57 på det tidspunkt dette skrives. Som parameter i format-metoden må vi bruke et Date-objekt som representerer vedkommende tidspunkt.

Skriver vi

   DateFormat di = DateFormat.getDateInstance();

får vi returnert et DateFormat-objekt som ved bruk av dets format-metode gir formatering som 02.mar.2012.

Skriver vi

   DateFormat ti = DateFormat.getTimeInstance();

får vi returnert et DateFormat-objekt som ved bruk av dets format-metode gir formatering som 14:17:48, altså bare klokkeslett.

Skriver vi

   DateFormat dti = DateFormat.getDateTimeInstance();

får vi returnert et DateFormat-objekt som ved bruk av dets format-metode gir formatering som 02.mar.2012 14:18:53. Ved kall på denne metoden kan vi også legge inn aktuelle parametre som spesifiserer hvordan vi ønsker at dato og klokkeslett skal vises. Skriver vi for eksempel

  DateFormat klokkeformat =
      DateFormat.getDateTimeInstance( DateFormat.LONG, DateFormat.MEDIUM );

så vil bruk av format-metoden gi en formatering som
2. mars 2012 14:20:39. (Første parameter bestemmer format for datoen, andre parameter bestemmer format for klokkeslettet.)

Ønsker vi selv å definere formateringen, kan vi opprette et objekt av type SimpleDateFormat med en formateringsstreng som konstruktørparameter. (Denne klassen er en konkret subklasse til den abstrakte klassen DateFormat.) Skriver vi for eksempel

  SimpleDateFormat sf = new SimpleDateFormat( "dd.MM.yy" );

får vi ved bruk av objektets format-metode en formatering som 02.03.12. Det finnes også andre muligheter.

Et DateFormat-objekt har også en parse-metode som konverterer en datostreng (mottatt som parameter) til et Date-objekt og returnerer dette.

Merknad

Formateringsobjektene som er omtalt ovenfor skal normalt bli initialisert til å bruke de formatene som gjelder på den lokaliteten der java er installert, det vil si etter norsk standard for vårt vedkommende. For å sikre å få formatering etter den standard vi ønsker, kan vi supplere konstruktørene med en ekstra parameter for den lokaliteten som det skal brukes standard for. Dersom vi vil sikre oss å få formatering etter norsk standard, kan vi opprette de formateringsobjektene som er brukt i eksemplene ovenfor på denne måten:

  java.util.Locale norge = new java.util.Locale( "no" );
                   //lokalitetsobjekt for norsk standard
  DateFormat df = DateFormat.getInstance(
                     DateFormat.SHORT, DateFormat.SHORT, norge );
  DateFormat di = DateFormat.getDateInstance(
                                      DateFormat.MEDIUM, norge );
  DateFormat ti = DateFormat.getTimeInstance(
                                        DateFormat.SHORT, norge);
  DateFormat dti = DateFormat.getDateTimeInstance(
                     DateFormat.MEDIUM, DateFormat.SHORT, norge);
  DateFormat klokkeformat = DateFormat.getDateTimeInstance(
                     DateFormat.LONG, DateFormat.MEDIUM, norge );
  SimpleDateFormat sf = new SimpleDateFormat( "dd.MM.yy", norge );

Programeksempel 2

Klassen Calendardemo definerer et brukervindu som vist på følgende bilde.

Øverst til venstre er det lagt inn en digital klokke som viser dato og tid med sekundpresisjon. Til denne brukes et Calendar-objekt tid som initialiseres til det tidspunktet programmet starter opp:

128     tid = Calendar.getInstance();

Det blir opprettet et Timer-objekt klokke som aktiverer ActionListeneren Klokkelytter hvert sekund:

129     klokke = new Timer(tidsintervall, new Klokkelytter());
130     klokke.start();

der tidsintervall er lik 1000 millisekunder. (En kort orientering om bruk av Timer-objekter kan du finne i notatet Hva er en Timer?.) Klokkelytter øker sekundfeltet til tid med 1 og oppdaterer den JLabel som viser dato og tid:

259     public void actionPerformed(ActionEvent e)
260     {
261       tid.add(Calendar.SECOND, 1);
262       tidsviser.setText(klokkeformat.format(tid.getTime()));
263     }

Programmet bruker også de to Calendar-objektene starttid og sluttid. Det er tre knapper for å initialisere starttid: til aktuell tid (ved kall på metoden settAktuellTid), eller til den dato og eventuelt klokkeslett som leses inn fra tekstfelter (ved kall på metode settDato eller settTidspunkt). Når det skal settes verdi for måned, må vi huske på at Calendar-objektets datafelt for måned starter på 0. For å få satt riktig verdi, må vi derfor trekke ifra 1 fra den verdi som leses inn fra tekstfeltet for måned. Dersom det bare leses inn dato, settes klokkeslettet til aktuell tid. I alle disse tre tilfellene settes sluttid til samme verdi som starttid. Begge tider skrives ut i sine tekstfelter nederst i vinduet.

Ved klikk på knappen "Vis sluttid" blir det lest inn et antall dager og et antall timer fra de to tekstfeltene for dette bruk (i tilfelle det er skrevet noe i dem). Starttid settes først lik den verdi sluttid har for øyeblikket. Deretter adderes det innleste antall dager og timer til sluttiden (ved kall på metoden leggTilTid) og verdiene for begge tider skrives ut (ved kall på metoden visTid). Fullstendig programkode, med unntak av main-metode, er gjengitt nedenfor. Driverklasse for programmet finnes i fila Calendartest.java.

Merknad

Den Timer som blir brukt av dette programmet gir ingen garanti for å kjøre med en bestemt frekvens. Den egner seg derfor ikke til for eksempel å programmere en klokke. Se for øvrig merknad i notatet Hva er en Timer?

  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import javax.swing.*;
  4 import java.util.Calendar;
  5 import java.text.DateFormat;
  6
  7 public class Calendardemo extends JFrame
  8 {
  9   private JTextField dagfelt, mndfelt, årfelt, timefelt, minuttfelt,
 10           antdgfelt, anttimefelt, startfelt, sluttfelt;
 11   private JButton aktuelltid, datotid, tidspkttid, visSlutt;
 12   private Calendar starttid, sluttid, tid;
 13   private Knappelytter lytter;
 14   private JLabel tidsviser = new JLabel();
 15   private Timer klokke;
 16   private int tidsintervall = 1000; //antall millisekunder
 17   private DateFormat df = DateFormat.getInstance(); //gir format som 
 18                                              //f.eks. 05.03.12 12:54
 19   private DateFormat klokkeformat = DateFormat.getDateTimeInstance(
 20           DateFormat.LONG, DateFormat.MEDIUM);
 21   //gir format som f.eks. 5. mars 2012 10:46:19
 22
 23   public Calendardemo()
 24   {
 25     super("Demonstrasjon av Calendar-klasse");
 26     dagfelt = new JTextField(2);
 27     mndfelt = new JTextField(2);
 28     årfelt = new JTextField(4);
 29     timefelt = new JTextField(2);
 30     minuttfelt = new JTextField(2);
 31     antdgfelt = new JTextField(2);
 32     anttimefelt = new JTextField(2);
 33     startfelt = new JTextField(30);
 34     startfelt.setEditable(false);
 35     sluttfelt = new JTextField(30);
 36     sluttfelt.setEditable(false);
 37     aktuelltid = new JButton("Sett starttid lik aktuell tid");
 38     datotid = new JButton("Sett starttid lik dato");
 39     tidspkttid = new JButton("Sett starttid lik dato og tidspunkt");
 40     visSlutt = new JButton("Vis sluttid");
 41
 42     lytter = new Knappelytter();
 43     aktuelltid.addActionListener(lytter);
 44     datotid.addActionListener(lytter);
 45     tidspkttid.addActionListener(lytter);
 46     visSlutt.addActionListener(lytter);
 47
 48     JPanel aktuellpanel = new JPanel();
 49     aktuellpanel.setLayout(new BoxLayout(aktuellpanel,
 50             BoxLayout.LINE_AXIS));
 51     aktuellpanel.add(tidsviser);
 52     aktuellpanel.add(Box.createHorizontalGlue());
 53     aktuellpanel.add(aktuelltid);
 54
 55     JPanel datopanel = new JPanel();
 56     datopanel.setLayout(new BoxLayout(datopanel, BoxLayout.LINE_AXIS));
 57     datopanel.add(new JLabel("Dag"));
 58     datopanel.add(dagfelt);
 59     datopanel.add(Box.createRigidArea(new Dimension(10, 0)));
 60     datopanel.add(new JLabel("Måned"));
 61     datopanel.add(mndfelt);
 62     datopanel.add(Box.createRigidArea(new Dimension(10, 0)));
 63     datopanel.add(new JLabel("År"));
 64     datopanel.add(årfelt);
 65     datopanel.add(Box.createRigidArea(new Dimension(10, 0)));
 66     datopanel.add(Box.createHorizontalGlue());
 67     datopanel.add(datotid);
 68
 69     JPanel tidspktpanel = new JPanel();
 70     tidspktpanel.setLayout(new BoxLayout(tidspktpanel,
 71             BoxLayout.LINE_AXIS));
 72     tidspktpanel.add(new JLabel("Time"));
 73     tidspktpanel.add(timefelt);
 74     tidspktpanel.add(Box.createRigidArea(new Dimension(10, 0)));
 75     tidspktpanel.add(new JLabel("Minutt"));
 76     tidspktpanel.add(minuttfelt);
 77     tidspktpanel.add(Box.createRigidArea(new Dimension(10, 0)));
 78     tidspktpanel.add(Box.createHorizontalGlue());
 79     tidspktpanel.add(tidspkttid);
 80
 81     JPanel infopanel = new JPanel();
 82     infopanel.setLayout(new BoxLayout(infopanel, BoxLayout.LINE_AXIS));
 83     infopanel.add(new JLabel("Velg varighet og vis sluttid"));
 84     infopanel.add(Box.createHorizontalGlue());
 85
 86     JPanel dagpanel = new JPanel();
 87     dagpanel.setLayout(new BoxLayout(dagpanel, BoxLayout.LINE_AXIS));
 88     dagpanel.add(new JLabel("Antall dager"));
 89     dagpanel.add(antdgfelt);
 90     dagpanel.add(Box.createRigidArea(new Dimension(10, 0)));
 91     dagpanel.add(new JLabel("Antall timer"));
 92     dagpanel.add(anttimefelt);
 93     dagpanel.add(Box.createRigidArea(new Dimension(10, 0)));
 94     dagpanel.add(Box.createHorizontalGlue());
 95     dagpanel.add(visSlutt);
 96
 97     JPanel startpanel = new JPanel();
 98     startpanel.setLayout(new BoxLayout(startpanel,
 99             BoxLayout.LINE_AXIS));
100     startpanel.add(new JLabel("Starttid"));
101     startpanel.add(startfelt);
102     startpanel.add(Box.createHorizontalGlue());
103
104     JPanel sluttpanel = new JPanel();
105     sluttpanel.setLayout(new BoxLayout(sluttpanel,
106             BoxLayout.LINE_AXIS));
107     sluttpanel.add(new JLabel("Sluttid"));
108     sluttpanel.add(sluttfelt);
109     sluttpanel.add(Box.createHorizontalGlue());
110
111     JPanel c = new JPanel();
112     c.setLayout(new BoxLayout(c, BoxLayout.PAGE_AXIS));
113     c.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
114     setContentPane(c);
115     c.add(aktuellpanel);
116     c.add(Box.createRigidArea(new Dimension(0, 10)));
117     c.add(datopanel);
118     c.add(Box.createRigidArea(new Dimension(0, 10)));
119     c.add(tidspktpanel);
120     c.add(Box.createRigidArea(new Dimension(0, 10)));
121     c.add(infopanel);
122     c.add(Box.createRigidArea(new Dimension(0, 10)));
123     c.add(dagpanel);
124     c.add(Box.createRigidArea(new Dimension(0, 10)));
125     c.add(startpanel);
126     c.add(Box.createRigidArea(new Dimension(0, 10)));
127     c.add(sluttpanel);
128     tid = Calendar.getInstance();
129     klokke = new Timer(tidsintervall, new Klokkelytter());
130     klokke.start();
131     pack();
132     setVisible(true);
133   }
134
135   public void settAktuellTid()
136   {
137     starttid = Calendar.getInstance();
138     sluttid = Calendar.getInstance();
139   }
140
141   public void settDato()
142   {
143     try
144     {
145       int dag = Integer.parseInt(dagfelt.getText());
146       int måned = Integer.parseInt(mndfelt.getText());
147       int år = Integer.parseInt(årfelt.getText());
148       starttid = Calendar.getInstance();
149       starttid.set(år, måned - 1, dag);
150       sluttid = Calendar.getInstance();
151       sluttid.setTime(starttid.getTime());
152     }
153     catch (NumberFormatException e)
154     {
155       JOptionPane.showMessageDialog(this,
156               "Bruk heltallsverdier for dato!");
157     }
158   }
159
160   public void settTidspunkt()
161   {
162     try
163     {
164       int dag = Integer.parseInt(dagfelt.getText());
165       int måned = Integer.parseInt(mndfelt.getText());
166       int år = Integer.parseInt(årfelt.getText());
167       int time = Integer.parseInt(timefelt.getText());
168       int minutt = Integer.parseInt(minuttfelt.getText());
169       starttid = Calendar.getInstance();
170       starttid.set(år, måned - 1, dag, time, minutt);
171       sluttid = Calendar.getInstance();
172       sluttid.setTime(starttid.getTime());
173     }
174     catch (NumberFormatException e)
175     {
176       JOptionPane.showMessageDialog(this,
177               "Bruk heltallsverdier for dato!");
178     }
179   }
180
181   public void visTid(Calendar tid, JTextField sted)
182   {
183     if (tid != null)
184     {
185       sted.setText(df.format(tid.getTime()));
186     }
187     else
188     {
189       sted.setText("Tid ikke satt.");
190     }
191   }
192
193   public void leggTilTid()
194   {
195     try
196     {
197       String input = antdgfelt.getText();
198       int antDager = 0;
199       if (!input.equals(""))
200       {
201         antDager = Integer.parseInt(input);
202       }
203       if (sluttid != null)
204       {
205         sluttid.add(Calendar.DAY_OF_MONTH, antDager);
206       }
207       int antTimer = 0;
208       input = anttimefelt.getText();
209       if (!input.equals(""))
210       {
211         antTimer = Integer.parseInt(input);
212       }
213       if (sluttid != null)
214       {
215         sluttid.add(Calendar.HOUR_OF_DAY, antTimer);
216       }
217     }
218     catch (NumberFormatException e)
219     {
220       JOptionPane.showMessageDialog(this,
221               "Bruk heltallsverdier for dato!");
222     }
223   }
224
225   private class Knappelytter implements ActionListener
226   {
227     public void actionPerformed(ActionEvent e)
228     {
229       if (e.getSource() == aktuelltid)
230       {
231         settAktuellTid();
232         visTid(starttid, startfelt);
233         visTid(sluttid, sluttfelt);
234       }
235       else if (e.getSource() == datotid)
236       {
237         settDato();
238         visTid(starttid, startfelt);
239         visTid(sluttid, sluttfelt);
240       }
241       else if (e.getSource() == tidspkttid)
242       {
243         settTidspunkt();
244         visTid(starttid, startfelt);
245         visTid(sluttid, sluttfelt);
246       }
247       else if (e.getSource() == visSlutt)
248       {
249         starttid.setTime(sluttid.getTime());
250         leggTilTid();
251         visTid(starttid, startfelt);
252         visTid(sluttid, sluttfelt);
253       }
254     }
255   }
256
257   private class Klokkelytter implements ActionListener
258   {
259     public void actionPerformed(ActionEvent e)
260     {
261       tid.add(Calendar.SECOND, 1);
262       tidsviser.setText(klokkeformat.format(tid.getTime()));
263     }
264   }
265 }

Innholdsoversikt for programutvikling

Copyright © Kjetil Grønning, 2012