Introduktion till Objektorienterad programmering

Dynamiska Web-sidor: applets

import java.applet.*;
import java.awt.*;

public class Welcome extends Applet 
{
    
    public void paint( Graphics g)
    {
	g.drawString("Welcome to the World of Internet Programming", 100, 100);
    }

};

javac Welcome.java

<APPLET CODE="Welcome.class" WIDTH=500 HEIGHT=120>
</APPLET>

Nu finns det inte mycket dynamik i texten men Java är speciellt skapat för och därför mycket lämplgt för att generera grafik och användargränssnitt. Mer om det senare.

Det som händer när en Web-läsare hittar ordet APPLET är att Java-programmet (eller snarare den bytekod som genereras av javac) laddas ned till klientmaskinen, d.v.s. den maskin som surfaren sitter vid. Detta kan verka farligt men en applet har mycket begränsade befogenheter och kan inte komma åt klientdatorn (surfarens dator) eller dess disk.

Java är ett objektorienterat programspråk. Vad detta innebär beskrivs i det följande.

Något om objektorienterad analys och design

Som vi har sett är Java ett objektorienterat språk. Vad innebär detta för själva processen "att skapa ett program"? Svaret är att eftersom OOP ser program som en samling av objekt (inte som en samling algoritmer) blir det första steget att bestämma dessa objekt. Detta görs genom att analysera problemet, egentligen utan att man tänker på att programmera i meningen "knappa in kod" eller ens vilket programspråk man skall använda, man beskriver problemet, inte hur man skall lösa det. Nästa steg blir att tänka sig hur programmet kommer att se ut i grova drag (design-fasen), sedan kommer implementationen som bör vara relativt enkel och rättfram om analys och design har gjorts bra, varefter testning av programmet tar vid.

Sammanfattningsvis: Objektorientering är att arbeta med modeller och att ställa problemområdet i centrum. I ett objektorienterat synsätt delas programmering in i fyra faser: analys, design, implementation och testning. Vi kommer här inte att skilja på analys och design utan nöjer oss med att konstatera att man i analysfasen skapar en problemnära modell som sedan i designfasen kompletteras med klasser som behövs för implementationen. Man bör hålla isär de två men i praktiken växlar man ofta mellan nivåerna: en analys följs av en design som ger upphov till förändringar i analysen, etc.

Begrepp och notation i analys och design

De viktigaste begreppen i OOP har grafiska motsvarigheter i OMT-notationen. I analysfasen skapar man en figur med hjälp av dessa.

Klass

Man kan se en klass som ett record eller en datapost med operationer, d.v.s. funktioner som kan påverka klassen eller besvara frågor om den. Funktionerna kallas metoder och klassens data kallas dess attribut. En viktig del av OOP är att inga andra än klassens metoder kan ändra på data i klassens instanser.

En klass ritas som en rektangel (till vänster ).

Attribut och metoder

Arv

I det inledande exempelprogrammet är Applet en klass som finns i Java och Welcome är en sorts Applet.

Arv visas med en triangel med den toppiga sidan uppåt mot basklassen:

Här har vi en superklass (basklass) som innehåller det som är gemensamt för de båda subklasserna, både attribut och metoder.

Det kan finnas klasser som inte är möjliga att instansiera, s.k. abstrakta klasser. En sådan klass tjänar endast som basklass till andra klasser och kan innehålla abstrakta metoder, d.v.s. metoder som inte implementeras i klassen men i de subklasser som kan instansieras (senare i detta avsnitt visar ett exempel på en abstrakt klass).

Association

En association skall vara en fast relation, inte tillfällig. Tillfälliga relationer kan ofta bättre beskrivas som operationer (metoder).

En linje utan siffra eller ring betyder att multipliciteten är exakt 1, en fylld ring betyder många (noll eller fler), en ofylld ring betyder en eller ingen och en eventuell siffra anger alla tillåtna multiplicitetsvärden.

I figuren är associationen mellan Klass_1 och Klass_4 sådan att till varje Klass_1 skall en eller flera Klass_4 vara associerade. Varje instans av Klass_5 är associerad till 1,2,3,4 eller 8 instanser av Klass_2. Varje instans av Klass_3 är associerad till en eller ingen Klass_6, medan varje instans av Klass_6 har många Klass_3-objekt knutna till sig. Klass_3 skulle t.ex. kunna vara personer och Klass_6 yrke (om man nu antar att ingen i dessa arbetslöshetstider är ofin nog att ha flera jobb).

I OMT-notationen används olika sorters cirklar för att poängtera hur många instanser av en klass som kan relateras till en klass. Cirklar kan finnas i båda ändar av relationen. Om man, vilket man kan göra, anger multipliciteten med siffror är cirklarna strängt taget onödiga. I UML har man också tagit bort dem och anger 0.. i stället för fylld cirkel, 0-1 i stället för tom cirkel, o.s.v.

Aggregat

Som framgår av figuren finns det alternativa sätt att visa aggregatsrelationer.

Relationer

Några ord om metodik i analys och design

• Leta fram objekt (och därmed klasser).
• Leta fram relationer (associationer) mellan dessa.
• Komplettera modellen genom scenarier, d.v.s. genom att följa exekveringen av typfall.
• Leta fram operationer och attribut.

Steg ett i analysfasen är att leta efter lämpliga objekt t.ex. genom att göra en lista med alla substantiv i problembeskrivningen (den traditionella algoritmbaserade programmeringstekniken utgår från verben). Först kan man tillåta sig att vara okritisk och ta med "allting", men innan man är klar måste man rensa bort ovidkommande saker och kanske göra de enklaste klasserna till attribut. Regeln är ungefär att de presumtiva klasser som inte behövs utanför en annan klass kan ses som attribut till denna andra klass.

Modellen byggs sedan ut genom att man letar efter associationer och arv. Exakt hur man går till väga är svårt att beskriva i ord. Men det är viktigt att man verkligen hittar arvsrelationer (tänk efter om en klass B är en sorts A) och associationer. Eftersom allting i Java är klasser (det finns inga "vanliga" funktioner) blir det ju inget program om man inte lyckas få sina klasser att hänga ihop.

Sista delen i analysfasen är att förfina sin design genom att lägga till operationer på klasserna. Här, liksom tidigare, är scenarier ett hjälpmedel

Att skapa en objektmodell är oftast ett iterativt arbete, d.v.s ett senare steg kan påverka tidigare modellen som då måste anpassas.

Ett litet exempel

Programmet implementerar en del av ett ritprogram. För att inte det hela ska bli alltför oöverskådligt har inte själva den interaktiva konstruktionen av figurer tagits med utan appletens init-metod skapar ett antal figurer som användaran kan flytta omkring, dels en och en (om man klickar med musen nära centrum av en figur och med musknappen nedtryckt sedan flyttar markören), dels också alla samtidigt (om man klickar någon annanstans). Appleten följer här:

I objektmodellen är Shape-klasserna mer detaljerade än de övriga (det finns ju ingen mening i att lägga in Javas hela klasshierarki ovanför Applet t.ex. - vi anser Applet vara superklass):

Notationen {abstract} kan användas för att särskilt markera att operationen draw är abstrakt och alltså måste implementeras i subklasserna.

De två klasserna MouseAdapter och MouseMotionAdapter hanterar händelserna musklick och musförflyttning (mer om hur detta går till senare).

Hur skulle nu Shape och dess subklasser implementeras i ett icke objektorienterat språk? Det troligaste är något i stil med (i ett tänkt Java-liknande språk där klasserna är enkla records som i Pascal eller C):

class Shape 
{
  int typeOfShape;
  int x,y,size;
  boolean fill;
}

Shape shape[MAXNUMOFSHAPES];

for (int i=0; i < numOfShapes; i++)
  draw( shape[i] );

draw ( Shape shape )
{
  switch (shape.typeOfShape)
  {
    case SQUARE:   drawSquare( x, y, size, fill);
    case TRIANGLE: drawTriangle( x, y, size, fill);
    case CIRCLE:   drawCircle( x, y, size, fill);
  }
}

class Shape 
{
  int x,y,size;
  boolean fill;
  draw();
}

class Triangle extends Shape
{
  draw() { rita triangeln; }
}

class Square extends Shape
{
  draw() { rita kvadraten; }
}

class Circle extends Shape
{
  draw() { rita cirkeln; }
}

Shape shape[MAXNUMOFSHAPES];

for (int i=0; i < numOfShapes; i++)
  shape[i].draw();

De båda kodsnuttarna ovan är inte fullständiga och kan kanske tyckas likvärdiga vid första anblicken. Men anta nu att man får ändrade förutsättningar, t.ex. att man vill kunna rita rektangler eller ellipser. I den funktionsbaserade lösningen krävs nu relativt omfattande ändringar: alla funktioner som utför något - i exemplet endast draw() men många fler funktioner finns sannolikt - måste ändras genom att nya case-satser läggs in. Den objektorientade lösningen däremot tillåter att man lägger in kod för de nya figurerna utan någon ändring alls av existerande kod: Man kan lägga till nya figurer (rektanglar, ellipser, månghörningar, etc) utan att någonting i det redan skrivna behöver ändras eller ens kompileras om.

Lägg märke till att alla typer av figurer (som är subklasser till Shape) kan lagras i variabler av typen Shape. Olika figurer kan sedan "bete sig" olika när en metod anropas - detta kallas polymorfi och är en mycket viktig del av objektorienterad programmering. Programmeraren uppnår denna polymorfi genom att ersätta (eng. override) metoder i basklassen: man skriver helt enkelt en ny metod med samma signatur: samma namn och samma parametrar. Abstrakta metoder måste "ersättas" i subklasserna eftersom de inte är implementerade i basklassen.

En annan mycket stor fördel med OOP-lösningen är att man kan ändra den interna representationen av formerna utan att program som använder Shape-klasserna påverkas. Detta kallas inkapsling (eng. encapsulation) av data.

Fullständigt program

• OOPExempel.java
• Shape.java
• Square.java
• Triangle.java
• Circle.java

Implemenation

Sammanfattning

• Ett OOP-program är ett antal objekt som samverkar genom att be varandra om information eller att be varandra utföra saker - inget objekt skall ändra attributen i objekt av andra klasser (inkapsling av data).
• Arv är en mekanism för återanvänding av kod, subklasser kan sägas vara specialiseringar av basklassen som alltså är en generalisering av subklasserna. Allt som superklassen kan göra kan också subklasserna göra.
• En subklass kan göra en viss operation annorlunda än basklassen. Detta kallas polymorfi (många former).

Grundläggande Java

Varför Java?

• Plattformsoberoende och portabelt - Java-program kompileras till s.k. bytekod som kan interpreteras av en Java-interpretator på vilken dator som helst - detta är en förutsättning för att kunna visa applets på olika sorters datorer.
• Objektorienterat - programmeraren utgår från data. Java har en mängd fördefinierade klasser, uppdelade i paket (packages), t.ex. java.awt för att skapa grafiska användargränssnitt. Klassen Object i paketet java.lang är basklass för samtliga Java-klasser.
• Distribuerat - Java har att paket, java.net, för nätverksprogrammering. Detta innehåller klasser för att skriva klient- och server-applikationer.
• Multithreaded - d.v.s man kan låta flera saker pågå samtidigt i en applikation, flera trådar kan exekveras samtidigt.
• Dynamiskt, klasser laddas in när de behövs.

Det faktum att Java är interpreterat innebär att program i Java inte är lika snabba som t.ex. program i C, men dagens applikationer är nästan alla interaktiva och/eller nätverksbaserade och befinner sig mestadels i väntetillstånd. Dessutom finns till många system numera s.k. just-in-time (förkortningen JIT avser just detta) kompilatorer som kompilerar bytekoden till maskinkod just innan ett program körs.

Grundläggande datatyper

De inbyggda typerna är, med angivande av storlek i bit och default-värde:

 
 boolean    1   false
 char      16   0
 byte       8   0
 short     16   0
 int       32   0
 long      64   0
 float     32   0.0
 double    64   0.0

Klasser och objekt

Vad innehåller ett objekt?

class Circle 
{
  public int r;
  public int x;
  public int y;
  public move( int dx, int dy ) { x += dx; y += dy; }
}

Hur man skapar ett objekt (en instans av en klass)

Skillnaden mellan de inbyggda typerna och referenser är att de förra hanteras by value, d.v.s. en kopia av variabeln överförs vid metodanrop, medan referenserna hanteras by reference, d.v.s endast adressen överförs.

I Java räcker det inte med att deklarera en variabel för att skapa ett objekt, man måste explicit skapa objektet med new:

Circle a;                // skapar tom referens
a = new Circle();        // skapar ett Circle-objekt
Circle b = new Circle(); // skapar både referens och objekt.

String s = "Detta är en sträng";

Variabler existerar bara i det block de deklareras, d.v.s. från deklarationstillfället till nästa }:

{
 Circle a(10);
  {
    Circle b(20);
    b.draw();
  }
 // a finns här, men inte b:
 a.draw(); - ok
 b.draw(); - fel
}

Arrayer

int[] intBuf = new int[1024];
Circle[] circles = new Circle[10];
double[] doubleTabl = { 1.0, 1.5, 2.0, 3.0, 6.0 };
int[][] twoDArray = new int[8][8];

Observera att i Java, till skillnad från C++, kan man direkt dynamiskt allokera flerdimensionella arrayer. Java implementerar multidimensionella arrayer som arrayer av arrayer varför man, liksom i C++ och C, kan skapa ickerektangulära arrayer:

int[][] strange2Darray = { {5,6}, {3}, {3,4,5} }; 
double[][] triangular = new double[10][]; // triangular array: x
for (int i=0;i < 10; i++)                 //                   xx
  double[i] = new double[i+1];            //                   xxx ...

int i = strange2Darray[0][1];
int j = intBuf[123];

Varje array har ett fält, length som talar om hur många element den innehåller:

int[] a = new int[10];
int[][] b = new int[10][5];
int[][][] c = new int[5][6][4];
//
// a.length       = 10
// b.length       = 10
// c.length       =  5
// c[3].length    =  6
// c[3][3].length =  4
//

Generella arrayer

Metoder

Konstruktor

Circle = new Circle();
Circle = new Circle( 10, 100, 150):

class Circle
{
  public Circle( int ir, int ix, int iy )
   { r = ir; x = ix; y = iy; }
  private int r;
  private int x;
  private int y;
}

Om man skriver en metod som heter void finalize() kommer denna att anropas när objektet inte längre refereras men innan objektets minne återlämnas. Oftast behöver man ingen sådan metod men ibland kan man behöva återlämna någon systemresurs som inte Javas skräphanterare tar hand om.

Metoder - och något om attribut

class Rectangle
{
  public Rectangle( int ix, int iy, int iw, int ih)
   { x = ix; y = iy; w = iw; h = ih; }
  public Rectangle( int ix, int iy, int side )
   { x = ix; y = iy; w = side; h = side; }
  public int area()
   { return w * h; }
  private int x;
  private int y;
  private int w;
  private int h;
}

Rectangle r = new Rectangle( 500, 500, 200, 300);
int ytan = r.area();

 public int area() { return this.w * this.h; }

 public Rectangle( int ix, int iy, int side )
   { this(ix,it,side,side); }

public static area( int w, int h )
 { return w*h;}

Även attribut kan vara statiska, i vårt exempel kan man tänka sig att man vill flytta alla rektanglar likadant (translatera dem). Ett sätt att implementera den möjligheten är att deklarera en par klassattribut:

 private static int dx=0;
 private static int dy=0;

Liksom i fallet med konstruktorer kan man överlagra metoder, d.v.s. skriva flera metoder med samma namn men med olika parameteruppsättningar, t.ex. kan man i fallet Rectangle tänka sig en klassmetod som beräknar en kvadrats yta:

public static area( int side)
   { return side*side; }

class Math 
{
  public static final double E  = ...; // konstanten e (2.718...)
  public static final double PI = ...; // konstanten pi (3.142...)
  public static double sin(double a) { .. }
  public static double cos(double a) { .. }
  public static double sqrt(double a) { .. }
  public static double exp(double a) { .. }
  public static double pow(double a, double b) { .. }
}
double a = Math.sqrt( 1.2);
double cirkelyta = 2 * Math.PI * radius;

Operatorer

De operatorer som opererar på referenser (objekt) är (alla utom '+' opererar på samtliga typer av objekt):

(type) - cast operator, se vidare nedan i avsnittet om arv.
+      - med String-objekt som operander - strängsammanslagning
==     - likhet (de båda operanderna refererar samma objekt)
!=     - ej likhet (de båda operanderna refererar ej samma objekt)
=      - tilldelning

Shape a = new Circle();
Circle b = (Circle) a;       
String b = "Kalle " + "Anka";
Circle c;
if (a==b) c = a;              // likhet och tilldelning
if (a!=b) c = new Circle();   // olikhet och tilldelning

if (a.equals(b)) c = a.clone(); // riktig likhet och riktig tilldelning

Strängar

//
// Användning av klassen String.
//
String a = "detta är en sträng ";
int i = 324;
a = a + i;                        // a = "detta är en sträng 324"
String b = a.substring(9, 18);    // b = "en sträng"
String c = a.substring(9);        // c = "en sträng 324" (till slutet)
char d = a.charAt(0);             // d = 'd'
int p1 = a.indexOf('e');          // p1 = 1 (första 'e')
int p2 = a.indexOf("ng");         // p2 = 16 (första "ng")
int l  = a.length();              // l = 22

Klassen String har metoder för konvertering av tal till sträng. Metoderna är överlagringar av varandra och heter

public static String valueOf(typ)

där typ är en av de inbyggda typerna.

Strängar av klassen String får inte ändras. Om man vill kunna ändra i en sträng kan man använda klassen StringBuffer i stället:

//
// Användning av klassen StringBuffer
//
StringBuffer s = new StringBuffer("detta är en sträng ");
int i = 324;
a.append ( i);        // a = "detta är en sträng 324"
a.setCharAt( 0, 'D'); // a = "Detta är en sträng 324"
a.insert(9, "inte "); // a = "Detta är inte en sträng 324"

Typklasser för de inbyggda typerna

För detta ändamål finns i Java till varje inbyggd typ en motsvarande typklass:

TYP      TYPKLASS
boolean  Boolean
byte     Byte
char     Character
double   Double
float    Float
int      Integer
long     Long
short    Short

Typklass( typ v);     // ex: Integer a = new Integer(12);
Typklass( String s);  // ex: Double d  = new Double("123.45");
String toString();    // konvertera till sträng, ex: String a = a.toString();
typ typValue();       // returnerar värdet, ex int i = a.intValue();
boolean equals(typ v);// sant om de två objekten har samma värde.

Integer a = new Integer(10);
String s = "Value of a is " + a;
System.out.println( "Value of a is " +  a );

Konvertering av instanser av egna klasser till strängrepresentation

Satser

Javas satskonsruktioner liknar mycket C++. I detta avsnitt visas med exempel samtliga konstruktioner som finns i språket utom de som har med undantag att göra.

if..else

int i=0;
.
if (i > 0) i++;
else i--;

for

int i;
for (i = 0; i < 10; i++)
 System.out.println( i );
for (int j=5; j >= 0; j--)
 {}
for (int i=0, j=100; i < 100; i++, j-=5)
 {}

Viktigt att veta är att variabler som deklareras i initieringsdelen existerar bara inne i loopen, inte efteråt.

while och do/while

int i = 10;
while (i > 0)
{
  Shape a = firstShape(i);
  if (a != null) 
    do 
     {
       a.do_it(); 
       a = nextShape(a);
     }
  while (a != null);
  i--;
}

switch

switch ( i )
{
  case 1: i += 123; break;
  case 3: i += 456; break;
  case 5: i += 789; break;
  default: i = -1; break;
}

break och continue

Java-program - applikationer och applets

Java är ett generellt programspråk som kan användas också för applikationer utanför Internet. Skillnaden mellan en applet och en applikation ligger i hur och av vem programmen startas: en applet startas av en Web-läsare medan en applikation startas i en speciell metod som heter main. Flera av de klasser som tillsammans utgör en applikation kan innehålla main-metoder: programmet startas i den main som finns i den klass som anges på kommandoraden.

En applet å andra sidan administreras och körs av Web-läsaren. Programmeraren skapar en applet genom att skriva en subklass till Applet och ersätta en eller flera av följande metoder:

 init() - anropas när appleten startas första gången.
 start() - anropas när Web-läsaren öppnar appletens fönster
 stop() - anropas när Web-läsaren byter HTML-sida.
 destroy() - anropas när appleten terminerar.
 paint() - anropas när appleten behöver ritas om.

Mer om hur man använder metoderna kommer i avdelningen om trådar. Metoden paint() är inte appletspecifik utan används av alla GUI-komponenter.

Oavsett om man har skrivit en applet eller en applikation kompileras programmet med javac:

javac myclass.java

Program som applikation och applet

import java.applet.*;
import java.awt.*;

public class WelcomeApplication extends Applet 
{

    public static void main( String[] args )
    {
	WelcomeApplication wapp = new WelcomeApplication();
	Frame frame = new Frame("Welcome");
	frame.add(wapp);
	frame.setSize( 500, 200);
	wapp.init();
	wapp.start();
	frame.show();
    }

    
    public void paint( Graphics g)
    {
	g.drawString("Welcome to the World of Internet Programming", 100, 100);
    }

};

Lägg märke till att main() är en klassmetod (static) som inte returnerar någonting. Argumentet är en array av strängar - de argument som gavs på kommandoraden efter klassens namn. Eftersom ingenting kan returneras från main kan man inte returnera ett värde till systemet den vägen: använd System.exit(n) där n är det du vill returnera om du måste meddela systemet något.

Applikationen ovan saknar någonting viktigt: den går inte att avsluta! Nästa avsnitt handlar om AWT (Abstract Windowing Toolkit) och hur man tar hand om användarens önskemål.

Sidospår: parametrar till applets

<APPLET CODE="filnamn" WIDTH=pixelbredd HEIGHT=pixelhöjd
        CODEBASE=appletdirectory ALIGN=sidplacering>
<PARAM NAME=parameter VALUE=värde>
</APPLET>

Man måste alltid ange CODE, WIDTH och HEIGHT, resten kan utelämnas. CODEBASE skall vara den katalog där appleten ligger, inte sjålva appleten. Om CODEBASE utelämnas används den katalog där det refererande dokumentet finns.

Nyckelordet PARAM kan förekomma många gånger, där varje förekomst svarar mot en parameternamn med värde. Parametrarna kan läsas av appleten, se exemplet Scribble). Metoden getParameter( String par ) returnerar värdet av parametern par i form av en sträng.

Arv

public class Shape
{
    
    public Shape( int ix, int iy, int isize, boolean ifill)
    { x =  ix; y = iy; fill = ifill; }

    protected int x;
    protected int y;
    protected boolean fill;
    public void moveRel( int dx, int dy )
    { x += dx; y += dy; }
    public void print() 
    { System.out.println("pos " + x "," + y); }
}

public class Circle extends Shape
{
    public Circle( int ix, int iy, int r, boolean ifill)
    {
        super(ix, iy, ifill);
        radius = r;
    }
    protected int radius;
    public void print() 
    { System.out.println("Cirkel, pos " + x "," + y); }    
}

Vid arv kedjas konstruktorerna, d.v.s. Shapes konstruktor anropas vid konstruktion av Circle-objekt. Om man vill anropa en annan konstruktor än en utan argument måste detta göras explicit: referensen super betyder en referens till den del av klassen som utgörs av superklassen (jämför this). Precis som this kan super användas för att kvalificera attribut och metoder: detta kan ibland vara nödvändigt, t.ex. om ett attribut i basklassen har samma namn som ett i subklassen.

I exemplet ersätts metoden print() i subklassen. Detta innbär att Circle-referenser och Shape-referenser beter sig olika vid anrop av denna metod. Eftersom Shapes print() ju gör en del av det som Circles gör skulle man kanske vilja använda den. Men om vi skriver print() i Circles print() får vi ett rekursivt anrop. Lösningen heter super:

   public void print()  // i klassen Circle
    { System.out.print("Cirkel,"); super.print(); }    

abstract public class Shape
{
    
    public Shape( int ix, int iy, int isize, boolean ifill)
    { x =  ix; y = iy; fill = ifill; }

    protected int x;
    protected int y;
    protected boolean fill;
    public void moveRel( int dx, int dy )
    { x += dx; y += dy; }
    abstract public void draw(); // Notera ; i stället för { .. }
}

public class Circle extends Shape
{
    public Circle( int ix, int iy, int r, boolean ifill)
    {
        super(ix, iy, ifill);
        radius = r;
    }
    public void draw() { /* do the drawing */ }
    public void setSize( int r ) { radius = r; }
    protected int radius;
}

public class Rectangle extends Shape
{
    public Rectangle( int ix, int iy, int w, int h, boolean ifill)
    {
        super(ix, iy, ifill);
        width = w; height = h;
    }
    public void draw() { /* do the drawing */ }
    public void setSize( int w, int h ) { width = w; height = h; }
    protected int width;
    protected int height;

}

Shape[] shape = new Shape[10];
shape[0] = new Circle( 100, 100, 50, false );
shape[1] = new Rectangle( 200, 100, 50, 100, true );
.
.
.
for (int i=0;i < shape.length; i++)
  shape[i].draw();

// Antag att alla cirklar ska ges storleken 12
for (int i=0;i < shape.length; i++)
  {
    if ( shape[i] instanceof Circle)
      {
        Circle c = (Circle) shape[i]; // cast shape[i] to Circle.
        c.setSize( 12 );
      }
  }

Precis som attribut kan också metoder och klasser deklareras final: en final-deklarerad klass kan inte ärvas och en final-deklarerad metod kan inte ersättas i subklasser. Metoder som är deklarerade private eller static blir också final.

Metoden finalize() används ju för att städa upp efter sig och kan ses som motsatsen till konstruktorn. Till skillnad från den "kedjas" inte finalize, d.v.s. basklassers finalize anropas inte automatiskt.

Som tidigare påpekats är klassen Object basklass til samtliga Java-klasser - detta utan att man behöver ange det med extends. I basklassen finns några metoder som kan vara bra att ersätta i de klasser man skriver själv:

public boolean equals( Object obj);
protected Object clone();
public String toString();

class Circle
{
    public Circle( int ix, int iy, int isize )
    {  x = ix; y = iy; size = isize;  }

    public boolean equals( Object obj )
    { 
       if (obj instanceof Circle)
          {
             Circle c = (Circle) obj;
             return (c.x==x) && (c.y==y) && (c.size==size);
          }
       else return false;
    }
}

Gränssnitt

interface Drawable 
{
  public void draw( Graphics g);
}

class Circle extends Shape implements Drawable
{
    public Circle( int ix, int iy, int isize, boolean ifill)
    {  super(ix, iy, isize, ifill);  }

    public void draw( Graphics g )
    {
	if (fill) g.fillOval(x-size,y-size,size*2,size*2);
	else      g.drawOval(x-size,y-size,size*2,size*2);
    }
}

class Circle implements Cloneable
{
    public Circle( int ix, int iy, int isize )
    {  x = ix; y = iy; size = isize;  }
 
    public Object clone() 
    { return new Circle( ix, iy, isize ); }

}

Paket och skyddsnivåer

package MyShapes;

public class Shape 
{
...
}

Alla attribut och metoder har en (oftast explicit angiven) skyddsnivå som talar om vem som kommer åt den. Om man inte anger någon nivå får variabeln eller metoden s.k. default-nivå, vilket innebär åtkomst för alla metoder i samma paket men ingen annan, t.ex. inte subklasser i andra paket. Om man anger private kommer endast klassens egna metoder åt fältet, public ger fullständig åtkomst för vem som helst. Däremellan finns protected som ger alla i samma paket plus alla subklasser åtkomst och private protected som ger endast subklasser (oavsett paket) åtkomst.

Vilken nivå man skall använda avgörs från fall till fall och beror på hur fältet (attributen eller metoden) skall användas.

Några viktiga paket

import java.awt.*;
import java.awt.Button;

Viktiga paket:

• java.applet klasser för applets
• java.awt klasser för grafik och användargränssnitt.
• java.awt.event klasser för händelsehantering
• java.awt.image klasser för bilder
• java.io klasser för läsning/skrivning
• java.lang klasser för själva Java
• java.math klasser för matematiska funktioner
• java.net klasser för nätverksprogrammering
• java.util klasser med en del vanliga datatyper

Undantag

Undantag som ej fångas skickas vidare till anropande metod. Ett undantag måste fångas av någon metod, annars hamnar det till slut i main()-metoden varvid Java skriver ett felmeddelande och terminerar programmet.

Klassen Throwable är basklass till Error och Exception som alla undantag ärver från. Man kan enklast säga att undantag av typen Error är fatala fel som man knappast skall försöka rädda. De mer intressanta undantagen finns alltså i Exception. Eftersom undantag är Object kan de definiera data och metoder som fångaren kan använda. När man genererar undantag kan man använda sig av de fördefinierade eller man kan definiera egna.

Undantagshanteringen använder de tre nyckelorden throw, catch och try:

// Först ett egendefinerat undantag:
class SquareRootOfNegativeValue extends Exception
{
    public SquareRootOfNegativeValue() { super(); }
    public SquareRootOfNegativeValue(String s) { super(s); }
}

class TestSqrt
{
    private double value;
    public TestSqrt( double a ) { value = a; }
    public double getSqrt()  throws  SquareRootOfNegativeValue
    {
	if (value >= 0) return Math.sqrt( value );
	else throw new SquareRootOfNegativeValue();
    }
    public static void main( String[] args )
    {
	try // koden inom detta block kontrolleras
	    {
		Double a = Double.valueOf( args[0] );
		TestSqrt ts = new TestSqrt( a.doubleValue() );
		ts.getSqrt();
	    }
	catch (SquareRootOfNegativeValue e) 
	    { System.out.println("Negative value");}
	catch (NumberFormatException e)  //  kan kastas av Double.valueOf
	    { System.out.println("Couldn't parse the number"); }
	catch (ArrayIndexOutOfBoundsException e ) // kan kastas av args[0]
	    { System.out.println("No argument"); }
    }
}

int getElement( int[] arr, int index ) throws IndexOutOfBoundsException 
{
  return arr[index];
}

Man kan vilja vara säker på att en metod exekverar en del kod oavsett om try-blocket exekveras färdigt eller ej. Sådan kod kan placeras i ett finally-block som alltid exekveras:

try 
{
 
}
catch (Exception e)
{
}
finally
{ 
// exekveras alltid även om undantag kastats.
}

Java AWT och händelsehantering

(OBS! dessa klasser håller på att ersättas av en ny uppsättning GUI-klasser (Swing) - principerna behålls i denna standard som mest ändrar utseende och namn på existerande komponenter och lägger till en mängd nya. Men plugga alltså inte in detaljerna i AWT eftersom de kommer att förlora i betydelse).

Dessa klasser kan sedan delas in i olika grupper:

• Grafiska hjälpklasser: Graphics, Color, Cursor, Font, Image
• Figurer: Point, Dimension, Polygon, Rectangle
• Själva byggstenarna, arvingar till Component, MenuComponent
  • Enkla knappar och liknande: Button, Label, Choice, Checkbox
  • Text: TextArea, TextField
  • Menyer: MenuBar, Menu, PopupMenu
  • Behållare: Window, Frame, Panel, ScrollPane
  • Rityta: Canvas
  • Andra: List, Dialog, FileDialog
  • Hjälpklasser: Scrollbar
• Layouthanterare: ...Layout.

Ett användargränssnitt består av en behållare (Frame i applikationer, Panel i applets - Applet är en subklass till Panel) som andra komponenter placeras i. Eftersom dessa komponenter i sin tur kan vara behållare (Panels) kan man bygga hur komplicerade gränssnitt som helst.

Exakt hur de olika komponenterna placeras i sin behållare bestäms av en s.k. layout-hanterare: klasserna som har namn som slutar på ...Layout. Man placerar alltså normalt inte komponenterna på fasta positioner (även om detta också är möjligt) eftersom man vill att utformningen skall vara så oberoende som möjligt av fönstersystem. Varje behållare har en layout-hanterare kopplad till sig. Alla layout-hanterarna implementerar gränssnittet LayoutManager. Metoden setLayout(LayoutManager) i Container används för att koppla en layout-hanterare till en behållare - om man skulle vilja placera ut komponenterna själv skall man anropa setLayout med argumentet null.

Behållare och komponenter

Klassen Component har metoder för

• Uppritning: paint(Graphics), update(Graphics), repaint()
• Händelshantering, se nästa avsnitt
• Egenskaper:
  • färg - setForeground(Color), setBackground(Color), Color getForeground, Color getBackground()
  • typsnitt - setFont(Font), Font getFont()
  • storlek - setSize(int w, int h), Dimension getSize()
  • position - setLocation(int x, int y), Point getLocation()

Händelsehantering

Interaktivt styrda program kan inte skrivas enligt det traditionella sekventiella mönstret: initiera, kör algoritmen, avsluta. I stället använder man s.k. händelsestyrd programmering. Händelser är sådant som användaren gör, t.ex. klickar med musen, tar bort ett fönster. I AWT genererar alla sådana händelser ett händelseobjekt som sedan tas om hand av en s.k. lyssnare (Listener). Klasser som har med händelser att göra finns i paketet java.awt.event (AWTEvent ligger i java.awt). De viktigaste händelserna:

Som Java-programmerare behöver man oftast inte hantera händelseobjekten. Några undantg:

• InputEvent: int getModifiers() ger musknapp, shift m.m.
• MouseEvent: int getX(), int getY() ger pekarposition.
• KeyEvent: char getKeyChar() ger tecknet.
• ItemEvent: Object getItem() ger objektet som genererade händelsen

1. Man måste tala om att klassen implementerar ett lyssnargränssnitt:

   public class MyEventHandler implements ActionListener {
   ...
   }
   

2. En instans av klassen MyEventHandler måste skapas och den komponent vars händelser man är intresserad av måste informeras om lyssnaren:

   MyEventHandler oneEventHandler = new MyEventHandler();
   Button b = new Button();
   b.addActionListener( oneEventHandler );
   

3. Kod för att ta hand om händelsen måste skrivas i MyEventHandler:

   public void actionPerformed( ActionEvent event )
   {
    ... gör vad som ska göras
   }
   

I klassen Component finns metoder för att hantera (lägga till och ta bort) lyssnare:

• addFocusListener(FocusListener), removeFocusListener(KeyListener)
• addKeyListener(KeyListener), removeKeyListener(KeyListener)
• addMouseListener(MouseListener), removeMouseListener(MouseListener)
• addMouseMotionListener(MouseMotionListener), removeMouseMotionListener(MouseMotionListener)

• Button, MenuItem, TextField: addActionListener(ActionListener), removeActionListener(ActionListener)
• Choice, Checkbox, List: addItemListener(ItemListener), removeItemListener(ItemListener)
• TextComponent: addTextListener(TextListener), removeTextListener(TextListener)
• Window: addWindowListener(WindowListener), removeWindowListener(WindowListener)

ActionListener

FocusListener

ItemListener

KeyListener

MouseListener

TextListener

WindowListener

Eftersom en lyssnare är ett gränssnitt måste man implementera alla metoder även om man bara är intresserad av en av dem. Vi skall snart se att det finns klasser, s.k. adaptorer, som förenklar detta åt oss.

Layout-hanterare

Exemplet efter de korta beskrivningarna visar hur man använder layout-hanterarna).

FlowLayout

GridLayout

BorderLayout

CardLayout

GridBagLayout

Exempel

Observera att endast tryckningar på knappar i Card-Panelen tas om hand av programmet.

Koden och litet mer information om de olika hanterarna finns här.

Att rita grafik

Program får rita endast på order från systemet; annars kunde konstigheter som att man ritar i icke-existerande fönster inträffa. Ritning fungerar därför så att en komponent begär att få bli ritad genom att anropa metoden repaint(). AWT begär sedan i sin tur att komponenten ska rita sig genom att anropa komponentens update()-metod. Denna metod i sin tur rensar sin rityta och anropar paint().

En fix komponent (som Button) implementerar alltså hela sin grafik i paint()-metoden. Detta gäller de flesta komponenter men om någonting ändras i bilden kan alltså komponenten själv anropa repaint() för att få möjlighet att rita om sig. I animeringar ersätter man också ofta update() med en egen variant. De två metoderna paint() och update() har ett argument: en instans av ett objekt av klassen Graphics som kan ses som den ritmiljö man ritar i. Klassen har metoder för att rita linjer, cirklar, ellipser, skriva text, m.m. Dessutom finns information om hur stor del av fönstret som behöver ritas om.

Grafik kan man rita i flera av AWT-komponenterna men oftast ritar man i instanser av Canvas eller Applet eller (oftare ändå) subklasser till dessa. Det enklaste sättet att rita grafik är att helt enkelt skriva ritinstruktionerna i paint().

Appleten som följer ritar de figurer som klassen Graphics definierar. Det finns också metoder för att rita bilder.

Koden finns här.

Färger

Man kan också skapa egna färger med konstruktorn:

Color( int redvalue, int greenvalue, int bluevalue);
//Exempel, skapa en gråröd färg:
Color mycolor = new Color( 200, 100, 100);
//Exempel, använd röd färg:
g.setColor( Color.red ); // Använd den fördefinierade konstanten

Typsnitt

Font(String name, int style,int size)
// Exempel:
Font myfont = new Font( "Times", Font.BOLD, 12 );

Adaptorer, inre och anonyma klasser

För att minska skrivarbetet finns några s.k. adaptorer, tomma implementationer av lyssnargränssitten, definierade. I stället för att implementera ett gränssnitt kan man skapa en subklass till en adaptor:

import java.applet.*;
import java.awt.*;
import java.awt.event.*;

public class Scribble extends Applet
{
    public int x;
    public int y;
    MyMouseAdapter mma;
    MyMouseMotionAdapter mmma;
    
    private Color stringToColor ( String colstring )
    {
	if (colstring.equals("red")) return Color.red;
	else if (colstring.equals("green")) return Color.green;
	else if (colstring.equals("blue") )return Color.blue;
	else if (colstring.equals("yellow")) return Color.yellow;
	else return Color.white;
    }

    public void init()
    {
       	setBackground( stringToColor( getParameter("colour")) );
	mma = new MyMouseAdapter();
	mmma = new MyMouseMotionAdapter();
	addMouseListener( mma );
	addMouseMotionListener( mmma );
    }

    public class MyMouseAdapter extends MouseAdapter 
    {
	public void mousePressed( MouseEvent e )
	{ x = e.getX(); y = e.getY(); }	
    }

    public class MyMouseMotionAdapter extends MouseMotionAdapter
    {
	public void mouseDragged( MouseEvent e )
	{
	    Graphics g = getGraphics();
	    g.drawLine( x, y, e.getX(), e.getY() );
	    x = e.getX(); y = e.getY();
	}
    }

}

import java.applet.*;
import java.awt.*;
import java.awt.event.*;

public class ScribbleAnonymous extends Applet
{
    public int x;
    public int y;
    
    public void init()
    {
       	setBackground( Color.yellow );
	addMouseListener( 
			 new MouseAdapter() 
			 {
			     public void  mousePressed( MouseEvent e )
				 { x = e.getX(); y = e.getY(); }	
			 }
			 );
	addMouseMotionListener(
			       new MouseMotionAdapter()
			       {
				   public void mouseDragged( MouseEvent e )
				       {
					   Graphics g = getGraphics();
					   g.drawLine(x,y,e.getX(),e.getY());
					   x = e.getX(); y = e.getY();
				       } 
			       }
			       );
    }
    
}

Klassen Thread

En tråds liv

• En tråd skapas med hjälp av en konstruktor
• En tråd startas (eller oftare hamnar i tillståndet "färdig att köras")
• En tråd kan exekveras varefter den hamnar i något av följande tillstånd:
  • färdig att köras (när min tur kommer)
  • sovande
  • suspenderad
  • väntande
  • blockerad (väntande på att en I/O-operation ska bli klar)
• En tråd kan försvinna (eller snarare fås att försvinna)

Klassen Thread implementerar trådar. Dess vanligaste konstruktorer är:

Thread() 
Thread(Runnable)

Viktiga metoder i Thread är

static void sleep(long millis) - söver ner den tråd som exekverar
static void sleep(long millis , int nanos) - söver ner den tråd som exekverar
void start() - startar exekveringen av tråden
void final stop() - stoppar exekveringen av tråden
void final suspend() - stoppar tillfälligt en tråd
void final resume() - startar om en tråd som stoppats med suspend()
static yield() - stoppar tillfälligt den tråd som nu exekverar

Ingen av metoderna ovan ersätts vanligen, man anropar dem vid behov.

Animering

Koden följer här:

import java.applet.*;
import java.awt.*;

public class WelcomeAnimation extends Applet implements Runnable
{
    static final int sleepingTime = 100;
    static final String msg = 
	"Welcome to the World of Internet Programming";
    private Font font;
    private int size = 100;
    private boolean shrinking = true;
    private Thread animator = null;

    public void init() 
    {
	super.init();
	font = new Font("Times", Font.BOLD, 12 );
	setBackground( Color.white );
    }
    
    public void start() // Appletens start(), *ej* trådens
    {
	animator = new Thread( this ); // Skapa en tråd
	animator.start();        
    }

    public void stop() // Appletens stop(), *ej* trådens
    {
	animator.stop();
        animator = null;
    }

    public void paint( Graphics g)
    {
	g.setColor(Color.red);
	g.fillOval(230-size*3/2, 97-size/2, size*3, size);
	if (shrinking)
	    { size -= 2; if (size == 0) shrinking = false;  }
	else
	    { size += 2; if (size == 100) shrinking = true; }
       	g.drawString( msg, 100, 100);		
    }

    
    public void run()
    {
	while (true)
	    {
		repaint();
		try { Thread.sleep(sleepingTime); }
		catch (InterruptedException e) { System.exit(1); }
	    }
    }
    
    public void destroy()
    {
	if ( animator != null ) 
	    {
		animator.stop();
		animator = null; // För att hjälpa skräphanteraren ...
	    }
    }
    
};

Dubbelbuffring

Koden finns här

Ytterligare ett exempel på dubbelbuffring är det tidigare exemplet där koden ser ut så här med dubbelbuffring. I större applikationer kan man uppnå mycket genom att rita om bara den del av appleten som ändrats i stället för att som vi gör i dessa exempel där allt ritas om.

Synkroniseringg

Programmet har tre klasser: SynchronizerDemo, Producer och Consumer varav de båda senare exekverar i varsin tråd och alltså asynkront placerar varor i lagret respektive tar bort dem. För att göra det hela litet mer intressant finns en slumpmässig försening i klasserna. Dessutom kan man suspendera och starta om både producent och konsument. När lagret är fullt och producenten vill lägga in en vara (men alltå måste vänta) visas en röd markering på "producentsidan" och om lagret är tomt och producenten försöker hämta en vara visas motsvarande markering på "konsumentsidan". Lagret visas som en stapel i mitten.

Vi tittar först på valda delar av klassen SynchronizerDemo (de delar som har med den grafiska presentationen utelämnas):

public class SynchronizerDemo extends Applet
{
    final int bufferSize = 20;
    int inStore = 0;
    private Producer producer =  null;
    private Consumer consumer =  null;

 public void init() 
    {
        consumer = new Consumer( this );
        producer = new Producer( this );
    }

    synchronized void get()
    {
        if (inStore == 0)
            {
                setEmpty( true );
                try  { wait(); }
                catch ( InterruptedException e) {}
            }
        if ( (inStore--) == bufferSize )  // Om bufferten var full *innan*
            notify(); // vi tog ett element meddelar vi att nu finns det plats

    }
    
    synchronized void put()
    {
        if (inStore == bufferSize)
            {
                try { wait(); }
                catch ( InterruptedException e) {}
            }
        if ( (inStore++) == 0) // Om bufferten var tom *innan* vi lade dit ett
            notify();     // element meddelar vi att nu finns element att hämta
    }

    public void destroy()
    {
        if ( producer != null ) { producer.stop(); producer = null; }
        if ( consumer != null ) { consumer.stop(); consumer = null; }
    }
}

De andra verktygen för synkronisering är metoderna wait() och notify(). Man anropar wait() i en synkroniserad metod för att låta en annan tråd exekvera så att skälet till att man väntar kan upphävas. notify() är motsatsen till wait(): man väcker upp en väntande tråd efter att något skett med objektet, i vårt fall att lagret inte längre är tomt respektive att det inte längre är fullt. Det objekt som väcks är det som har egenrätt på SynchronizerDemo-instansen just nu, d.v.s. det objekt som startade en synkroniserad metod.

Observera att metoden wait() alltså släpper "låset" på objektet SynchronizerDemo så att producenten eller konsumenten kan uppdatera objektet.

Klasserna Producer och Consumer (även de något förenklade genom att grafiken tagits bort):

class Producer extends Thread
{
    SynchronizerDemo demo;
    long sleepingTime = 500;

    Producer( SynchronizerDemo d ) 
    {
        demo = d;
        start();
    }

    public void run()
    {
        while (true) 
            {
                try { if (Math.random()>0.9) sleep(sleepingTime); }
                catch ( InterruptedException e) {}
                demo.put();
            }
    }
}

class Consumer extends Thread
{
    SynchronizerDemo demo;
    long sleepingTime = 500;

    Consumer( SynchronizerDemo  d)
    {
        demo = d;
        start();
    }

    public void run()
    {
        while (true) 
            {
                try { if (Math.random()>0.9) sleep(sleepingTime); } 
                catch ( InterruptedException e) {}
                demo.get();
            }
    }
}

Konsumenten och producenten är båda arvtagare till Thread och har alltså redan ärvt gränssnittet Runnable genom Thread. Det kanske mest intressanta med klasserna är att ingendera innehåller några konstigheter: all synkronisering sker i klassen SynchronizerDemo. Allt Producer och Consumer gör är att producera och konsumera så fort de kan.

Den fullständiga programkoden visar också hur man kan implementera en ActionListener som ser efter vilken knapp som användaren tryckte på

Multithreading

Ett roligt (?) exempel (som också visar på skillnaden i effektivitet hos några sorteringsalgoritmer) på multithreading finns här

Strömmar

Javas stream-klasser finns i java.io-paketet. Klasserna kan delas upp litet olika beroende på synsätt: en uppdelning kan vara i om man arbetar med tecken eller bytedata (bilder, ljud, etc): i Java är denna uppdelning tydlig:

• klasser vars namn slutar ...Reader läser tecken
• klasser vars namn slutar ...Writer skriver tecken
• klasser vars namn slutar ...InputStream läser bytedata
• klasser vars namn slutar ...OutputStream skriver bytedata

Grundklasserna

Reader: (läser tecken eller arrayer av tecken)
 int read(); // läser ett tecken och returnerar det i en int
 int read( char buf[] ); // läser högst buf.length  tecken, returnerar antalet

InputStream: (läser bytes eller arrayer av bytes)
 int read(); // läser ett tecken och returnerar det i en int
 int read( byte buf[]);// läser högst buf.length bytes, returnerar antalet

Writer: (skriver tecken eller arrayer av tecken)
 int write( int c); // skriver ett tecken (c)
 int write( char buf[] ); // skriver en array (buf.length st.) av tecken

OutputStream: (skriver bytes eller arrayer av bytes)
 int write( int c); // skriver en byte
 int write( byte buf[] ); // skriver en array (buf.length) av bytes

Skrivning till skärmfönster och läsning från tangentbord

Metoder för skrivning:

print( argument ); // skriv argumentet
println( argument ); // skriv argumentet, följt av en newline

Eftersom operatorn + fungerar för strängar kan man skriva ut flera saker i samma print under förutsättning att man börjar med en sträng och de objekt som följer är instanser av klasser med en toString-metod. I Java har man ingen kontroll över hur många siffror som skrivs ut vid utmatning av flyttal t.ex.

Vid läsning måste litet mer jobb till (InputStream innehåller endast de byte-baserade inläsningsmetoderna). Man gör då så att man skapar en InputStreamReader t.ex:

InputStreamReader = new InputStreamReader( System.in );

BufferedReader = new BufferedReader( new InputStreamReader( System.in ));

String readLine()  - läs en rad

Java är inte speciellt bra på denna typ av I/O; förklaringen ligger i att moderna program använder grafiska användargränssnitt och därför inte behöver ha tillgång ett fullständigt utbyggt bibliotek för textmässig läsning och skrivning. Det är ju faktiskt också så att program som inte har råd att krascha inte kan läsa in tal på annat sätt än genom egen parsning och för detta finns stöd i Java.

Textfiler

BufferedReader infile = new BufferedReader( new FileReader("filnamn.ny") );
PrintWriter outfile = new PrintWriter( new FileWriter("filnamn.old") );

De båda instanserna infile och outfile kan nu användas exakt som klasserna i föregående avsnitt.

Ett exempel får avsluta detta avsnitt. Programmet nedan läser en textfil och räknar, dels totala antalet ord, dels också hur många gånger ett antal ord förekommer. Resultatet skrivs till skärmfönstret. Programmer använder en StreamTokenizer för att dela upp text i ord:

import java.io.*;

class Grep
{
    public static void main( String[] args ) throws IOException
    {
	StreamTokenizer infile = 
	    new StreamTokenizer( new FileReader( args[0] ) );
	int numWordsToLookFor = args.length;
	int[] numWords  = new int [ numWordsToLookFor ];
	for (int i=0; i < numWordsToLookFor; i++)
	    numWords[i] =  0;
	while ( infile.nextToken() != StreamTokenizer.TT_EOF )
	    if (infile.ttype == infile.TT_WORD )
		{
		    numWords[0]++; // räknar totala antalet ord
		    for (int i=1; i < numWordsToLookFor; i++)
			if ( infile.sval.equals( args[i] ))
			    numWords[i]++;
		}
	System.out.println( "Totala antalet ord: " + numWords[0] );
	for (int i=1; i<numWordsToLookFor; i++)
	    System.out.println( args[i] + ": " + numWords[i] );
    }
}

java Grep Grep.java infile numWords

Totala antalet ord: 69
infile: 1
numWords: 6

Binärfiler

import java.io.*;

public class FileCopy
{
    public static final int BUFSIZE = 4096;

    public static void copy( String sourceName, String destinationName )
	throws IOException
    {
	FileInputStream source = null;
	FileOutputStream destination = null;
	try
	    {
		source =  new FileInputStream( sourceName );
		destination = new FileOutputStream( destinationName );
		byte[] buffer = new byte[BUFSIZE];
		int numBytesRead;
		while ( ( numBytesRead = source.read(buffer)) != -1)
		    destination.write( buffer, 0, numBytesRead);
	    }
	finally  // vi stänger alltid filerna
	    {
		if (source != null) 
		    { try { source.close(); } catch (IOException e) {} }
		if (destination != null)
		    { try { destination.close(); } catch (IOException e) {} }
		    
	    }
    }

    public static void main( String[] args ) throws IOException
    {
	copy ( args[0], args[1] );
    }
	
}

Mer om hur man använder strömmar, och koordination mellan asynkron input och output, kommer i avsnittet om nätverksprogrammering. I filkopieringsprogrammet ovan läses troligen 4096 bytes varje gång (utom den sista) men om filen ligger på en annan dator någonstans i världen kan man inte vara säker på att så är fallet.