Java

Fra Wikibooks, den frie samling af lærebøger
Gå til: navigation, Søg

Forord[redigér]

Det mest af denne bog er også taget fra http://javabog.dk, med tilladelse.

I denne bog kan du lære tre ting:

  • Programmering. Bogen starter fra grunden af, men har du ikke programmeret før, bør du være rede til at gøre en indsats, dvs. løbende lave en række små programmer, for at øve dig i stoffet. Det forudsættes, at du har kendskab til computere på brugerniveau, dvs. at du uden problemer kan bruge internet, tekstbehandling og andre programmer og problemfrit navigere og flytte og kopiere filer i Windows, Linux eller et andet styresystem. En smule kendskab til matematik er en fordel, men bestemt ikke et krav.
  • Objektorienteret programmering. Bogen arbejder grundigt med begreberne omkring objektorienteret programmering (forkortet OOP) og har mange praktiske eksempler på denne måde at programmere på. Den introducerer og anvender løbende relevante dele af UML-notationen, som er meget anvendt i objektorienteret analyse og design og beslægtede fag.
  • Java. Programmeringssproget Java har en række faciliteter, som kan lette programmeringen meget. Har du - som mange andre - lært Java ved at prøve dig frem, kan det overblik, der præsenteres i denne bog, hjælpe, samtidig med, at hvert kapitel slutter af med at gå i dybden med avancerede emner.

Java[redigér]

Java kan downloades fra http://www.java.com, herfra er der et link til at download den nyeste version af Java hvis du ikke skulle have dette.

Javaudviklingsværktøjer[redigér]

Der findes mange programmer, som kan bruges til udviklingen af Java-programmer.

Følgende programmer er licensfri, dvs. at den fulde funktionalitet står til rådighed:


Følgende programmer koster til dels penge, men der findes også licenser der giver adgang til en begrænset del af funktionaliteterne:

Grundlæggende programmering[redigér]

Lad os se på et simpelt javaprogram, der skriver "Hej verden" og et citat af Storm P. ud til skærmen. Neden under den vandrette linje er vist, hvad der sker, hvis programmet køres:

    // Et simpelt program, der skriver "Hej verden" 
    // og et citat af Storm P. ud til skærmen
    // Denne fil skal have navnet: HejVerden.java
    public class HejVerden
    {
      public static void main (String[] arg)
      {
        System.out.println("Hej Verden!");
        System.out.println("Hvornår smager en Tuborg bedst?");
        System.out.println("Hver gang!");
      }
    }

Resultat på skærm, når det lille program køres.:

    Hej Verden!
    Hvornår smager en Tuborg bedst?
    Hver gang!

Kommentar[redigér]

Kommentarer er dokumentation beregnet på, at gøre programmets kildetekst lettere at forstå for læseren. De påvirker ikke programudførelsen.

De første 3 linjer, der starter med //, er kommentarer:

  • // Et simpelt program, der skriver "Hej verden"
    // og et citat af Storm P. ud til skærmen
    // Denne fil skal have navnet: HejVerden.java
    I dette tilfælde er der beskrevet, hvad programmet gør og hvilket filnavn kildeteksten bør gemmes i.

Kommentarer bliver sprunget over og har ingen indflydelse på programmet Kommentarer bør skrives, så de giver forståelse for, hvordan programmet virker - uden at være tvetydige eller forklare indlysende ting // markerer, at resten af linjen er en kommentar. Den kan også bruges efter en kommando til at forklare, hvad der sker, f.eks.

  • System.out.println("Hej verden!"); // Udskriv en hilsen

Java har også en anden form, som kan være nyttig til kommentarer over flere linjer: Man kan starte en kommentar med /* og afslutte den med */. Al tekst mellem /* og */ bliver så opfattet som kommentarer. Vi kunne altså også skrive

  • /*
    Et simpelt program, der skriver "Hej verden"
    og et citat af Storm P. ud til skærmen
    Denne fil skal have navnet: HejVerden.java
    */

og

  • System.out.println("Hej verden!"); /* Udskriv en hilsen */

Strukturdelen[redigér]

Strukturdelen vil ikke blive ændret i de næste to kapitler og det er ikke så vigtigt, at du forstår, hvad der foregår i første omgang.

Al javakode er indkapslet i en klasse mellem { og } (blokstart og blokslut-parenteser). Beskrivelsen af en klasse er altid indkapslet i en blok bestående af:

    public class HejVerden
    {
      ...
    }

Inde i klassen står der en main-metode med nogle kommandoer i.

    public static void main (String[] arg)
    {
     ...
    }

Indholdet af metoden er altid indkapslet i en blok med { og }.

Programudførelsen starter i metoden:

  • public static void main (String[] arg)

Programkode[redigér]

I main-metoden giver man instruktioner til computeren:

    System.out.println("Hej verden!");
    System.out.println("Hvornår smager en Tuborg bedst?");
    System.out.println("Hvergang!");

Instruktionerne udføres altid en efter en, ovenfra og ned. Hver instruktion afsluttes med et semikolon.

Disse 3 instruktioner skriver 3 strenge ("Hej verden!", ...) ud til skærmen. En streng er en tekst, som computeren kan arbejde med. Strenge er altid indkapslet i "".

Hver instruktion består af et kald til metoden System.out.println, som betyder, at der skal udskrives noget til skærmen og en streng som parameter.

En parameter er en oplysning, som man overfører til metoden. I dette tilfælde hvilken tekst, der skal skrives ud til skærmen.

Vores main-metode kalder altså andre metoder.

Variabler[redigér]

Variabler bruges til at opbevare og ændre data. En variabel kan opfattes som en navngiven papirlap, hvor der til enhver tid kan stå netop én ting.

Variabler skal altid erklæres, dvs. at man skal fortælle computeren, at der skal oprettes en variabel, hvad slags data den skal indeholde og hvad den skal hedde.

En variabel er et navn på et sted i computerens hukommelse, beregnet på at indeholde data af en bestemt type En variabel erklæres ved at skrive datatype variabelnavn; Det er en god vane, at give variablerne sigende navne. Navnene bør starte med et lille bogstav.

Datatyper[redigér]

I Java findes der følgende grundlæggende datatyper, man kalder dem også for de primitive datatyper:

Primitive Datatyper
Datype Beskrivelse Størrelse Objekt variant
long Heltal 64 bit (2s komplement) Long
int Heltal 32 bit (2s komplement) Integer
short Heltal 16 bit (2s komplement) Short
byte Heltal 8 bit (2s komplement) Byte
double Decimaltal 64 bit Double
float Decimaltal 32 bit Float
char Unicode karakter 16 bit Character
boolean Boolsk værdi true/false Boolean

De primitive datatyper er konstante på alle platforme.

Løkker[redigér]

En løkke er en gentaget udførelse af en kommando igen og igen. Hvor mange gange løkken udføres, afhænger af et logisk udtryk.

While[redigér]

while-løkken har formen:

  • while (betingelse) kommando;

Kommandoen udføres igen og igen, så længe betingelsen er opfyldt. Dvs. før kommandoen udføres, undersøges betingelsen og det kontrolleres, at den er opfyldt (se rutediagrammet til højre).

Oftest vil man udføre mere en én kommando og anvender derfor en blok til at samle kommandoerne:

while (betingelse) {
kommando1;
kommando2;
...
}

Her er et eksempel:

    public class Alder4
    {
       public static void main(String[] arg) 
       {
         int alder;
         alder = 15;
         while (alder < 18)
         {
            System.out.println("Du er "+alder+" år. Vent til du bliver ældre.");
            alder = alder + 1;
            System.out.println("Tillykke med fødselsdagen!");
         }
    
         System.out.println("Nu er du "+alder+" år og myndig.");
       }
    }

For[redigér]

for-løkken er specielt velegnet til løkker med en tællevariabel. Den har formen

for (initialisering; betingelse; handling) kommando;
  • initialisering er en (evt.: erklæring og) tildeling af en tællevariabel, f.eks. alder = 15
  • betingelse er et logisk udtryk, der angiver betingelsen for, at løkken skal fortsætte med at blive udført, f.eks. alder < 18
  • handling er typisk en optælling i tællevariablen, f.eks. alder = alder + 1

Det kan indenad læses som "for startværdi, så længe betingelse udfør: kommando og opdatering, f.eks. "for alder = 15, så længe alder < 18 udfør: Skriv "du er.." og tæl alder 1 op".

En for-løkke og en while-løkke supplerer hinanden. De har præcis samme funktion, men for-løkken er mere kompakt og bekvem, når man ønsker at lave en almindelig løkke, der udføres et bestemt antal gange. Dette program gør det samme som Syvtabel-eksemplet, men med en for-løkke:

    public class Syvtabel2
    {
      public static void main(String[] arg) 
      {
        int n;
        for (n=1; n<=10; n=n+1)
          System.out.println(n+" : "+ 7*n);
      }
    }

Med java 5 er der kommet en ny For løkke type: for(Variabel: liste)

    public class foreachtest {
      public static void main(String[] arg) 
      {
        int[] i = {1,2,3,4};
        for (int val: i)
          System.out.println(" V" + val);
      }
    }
    ----------------------------------------
    Resultat
    V1 V2 V3 V4

Det er det nogen kalder for en foreach løkke

Uendelige løkker[redigér]

Hvis programmøren ikke er omhyggelig, kan han komme til at lave en løkke, hvor betingelsen vedbliver at være sand. Så bliver programudførelsen i løkken i al evighed (eller indtil brugeren afbryder programmet).

Lad os f.eks. sige, at programmøren er kommet til at skrive '-' i stedet for '+' i opdateringen af n i for-løkken fra Syvtabel-programmet. Nu vil computeren tælle nedad:

    public class SyvtabelFejl
    {
      public static void main(String[] arg) 
      {
        for (int n=1; n<=10; n=n-1)
          System.out.println(n+" : "+ 7*n);
      }
    }

Objekter[redigér]

Definition af klasser[redigér]

Nedarvning[redigér]

Pakker[redigér]

Avanceret Java[redigér]

Flertrådet programmering[redigér]

Reflektion[redigér]

Udvikling af Applikationer med grafisk brugergrænseflade[redigér]

Til udviklingen af applikationer med en grafisk brugergrænseflade findes der indenfor java forskellige muligheder.

  • AWT - Abstract Window Toolkit

Et bibliotek med klasser, der gør det muligt at skabe simple brugergrænseflader. De første programmer/appletter benyttede udelukkende dette bibliotek.

  • Swing

Et bibliotek af java klasser, hvor det er muligt at skabe mere avancerede brugergrænseflader. Man kan sige at Swing er en overbygning til AWT.

I dette kapitel vil der blive beskrevet, hvordan man ved hjælp af Swing biblioteket udvikler en grafisk brugergrænseflade. Der vil blive beskrevet forskellige temaer med stigende sværhedsgrad.

Vis et vindue[redigér]

Det mest fundamentale ved et grafisk Java program er et vindue. Vi vil starte med et simpelt eksempel på, hvordan man laver et vindue. I vinduet skal der stå: "Vi programmerer Swing"

package simplegui1;

import javax.swing.JFrame;
import javax.swing.JLabel;
 
public class SimpleGui1 {
   //Variabel som definerer et vindue.
   private JFrame frame = new JFrame("Simple GUI");
   
   /** Metode der opretter en instans af SimpleGui1 */
   public SimpleGui1() {
       
       //Her definerer vi vores tekst
       JLabel label = new JLabel("Vi programmerer Swing");
       
       //Her tilføjes teksten til vinduet
       frame.getContentPane().add(label);
       
       //Her bestemmes der hvad der sker når man lukker vinduet.
      
       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       
       //Her startes vinduet        
       frame.setVisible(true);
   }

   //Start metode
   public static void main(String[] args) {
      SimpleGui1 simplegui = new SimpleGui1();     
   }   
}

Hvis ovenstående kopieres ind i en fil kaldet "SimpleGui1.java", kompileres og startes, så skulle der gerne vises et vindue uden menu, men med standard lukke- og maksimere/minimere-knapper.

JFrame klassen benyttes til at lave vinduer med.

JFrame frame = new JFrame("Simple GUI");

Ved definitionen af et vindue, er det vigtigt at fortælle, hvad der sker når vinduet lukkes.

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Denne linje sørger for, at applikationen afsluttes, når der trykkes på vinduets luk-knap. Havde vi udeladt denne linje, ville vinduet blot være blevet skjult, og programmet ville fortsætte kørslen i baggrunden.

Vores vindue vises ved hjælp af følgende metodekald.

frame.setVisible(true);

Til teksten i vores eksempel benytter vi os af JLabel-klassen. En JLabel er en kort tekst eller ikon.

JLabel label = new JLabel("Vi programmerer Swing"); 

Vores JLabel tilføjes til vinduet, dvs. vores JFrame

frame.getContentPane().add(label);

Det er vigtigt at benytte funktionen getContentPane(), da det er sådan at JFrame er baseret på Frame-klassen (java.awt.frame) og at de er ikke fuldt kompatible.

Swing komponenter[redigér]

Der findes mange forskellige komponenter i Swing. I dette kapitel vil de vigtigste blive beskrevet.

JPanel[redigér]

JLabel[redigér]

JTextfield[redigér]

JButton[redigér]

Udlægning af komponenter[redigér]

Til placeringen af komponenter i vinduer, dialoger og paneler benyttes en såkaldt Layoutmanager.
Der findes forskellige layout manager, de fleste er er blevet implementeret i AWT biblioteket.

BorderLayout[redigér]

GridLayout[redigér]

GridbagLayout[redigér]

CardLayout[redigér]

Udvikling af Java Web baserede anvendelser[redigér]

Dette kapitel skal fortælle lidt om de forskellige java web teknologier.

Applets[redigér]

En applet er et lille Javaprogram, som udføres lokalt på brugerens computer.

Webudvikling[redigér]

JSP/Servlets[redigér]

Java Server Faces[redigér]

Struts[redigér]

Frameworks[redigér]

Externe Links[redigér]