JAVA - plan wykładu

(1)

JAVA - plan wykładu

Zakres wykładu

• Podstawy języka JAVA w wersji 2

• JAVA 2 w praktyce

• Aplety

• Servlety

• Java Server Pages

LITERATURA

Thinking in Java, Bruce Eckel Helion 2001

Java 2 dla każdego, Laura Lemay i Rogers CadenHead, Helion 2000

Java Servlet - programowanie...., Hunter Jason, Crawford William, Helion 2002

Java Servlet i Java Server Pages.., Hall Marty, Helion 2002

(2)

JAVA – jak to się stało (nie tak dawno w SUN Microsystem)

1990- James Gosling opracowuje język (Oak - dąb) w ramach projektu Green do programowania małych urządzeń elektronicznych które miały się komunikować między sobą, stąd założenia: mały ,stabilny(bezpieczny) i przenośny

1994 – zmiana nazwy Oak na JAVA

1994 – przeglądarka sieciowa HotJava pozwalająca na uruchomienie apletów JAVA,

1995 – interpreter JAVA (Java 1.0) dołączony do Netscape Navigator

1997 – Java1.1 z technologią składników JavaBeans,

1998 – Java 2

Bezpłatny pakiet Java Development Kit dostępny na stronach http://java.sun.com

inne pakiety programistyczne: Symantec Visual Cafe, Borland Jbuilder, IBM Visual Age for Java...

(3)

JAVA – Java kontra C++

• ograniczenia ułatwiające zrozumienie kodu np. nie można przysłaniać zmiennych,

• usunięto wskaźniki, uproszczono zarządzanie pamięcią (brak destruktorów, automatyczne odśmiecanie),

• usunięto niektóre konstrukcje np. typedef, preprocesor i jego instrukcje, goto, struct, niektóre zmodyfikowano,

• usunięto możliwość przeciążania operatorów,

• brak możliwości wielokrotnego dziedziczenia wprost, wprowadzenie implementacji interfejsów,

• brak funkcji i zmiennych poza definicjami klas,

• wynikiem kompilacji jest kod pośredni (bajtowy) a nie maszynowy jak w C++ co oznacza niezależność od platformy sprzętowej,

• java generuje bezpieczny i objętościowo mały kod wynikowy co jest zaletą w sieci,

• java posiada narzędzia do pracy w sieci (najpopularniejszy i najczęściej wykorzystywany język programowania).

wady ? spokojnie, też się znajdą....

(4)

JAVA – konfiguracja środowiska

JAVA 2 Software Development Kit dla Windows 95/98

w autoexec.bat : PATH folder\bin;%PATH%

PATH C:\JDK\bin; %PATH%

jeżeli istnieje SET CLASSPATH=

dopisz

SET CLASSPATH=.;folder\lib\tools.jar;%CLASSPATH%

JAVA 2 Software Development Kit dla Windows NT/2000

Wybierz Panel Sterowania  System  Środowisko  zmienna PATH

(5)

JAVA – środowisko JAVA 2 SDK 1.4

Katalog \ bin\ między innymi:

•javac – kompilator

•java – interpretator z konsolą

•javaw – interpretator bez konsoli,

•javadoc – generator dokumentacji

•appletviewer – interpretator apletów,

•jar – zarządzanie plikami archiwów,

•jdb - debager

(6)

JAVA – pierwszy program

// Prog1.java //

public class Prog1 {

public static void main ( String arg [] ) { System.out.println(" Java is fun ");

}

} // class Prog1

• plik o nazwie Prog1.java zawiera klasę o nazwie Prog1, wielkości liter są rozróżniane

• klasa od której następuje uruchomienie zawiera statyczną i publiczną funkcję main której parametry są parametrami wywołania programu

Kompilacja

javac Prog1.java  kompilator generuje plik Prog1.class

Uruchomienie java Prog1

pliki *.JAVA kompilacja pliki *.CLASS (kod bajtowy Javy)

interpretacja przez JVM(Java Virtual Machine)  procesor

a tak było w C++

pliki *.CPP kompilacja pliki *.EXE (wynikowy kod binarny, maszynowy)procesor

(7)

JAVA – typy podstawowe

typy do reprezentacji liczb całkowitych

byte rozmiar 1 bajt , min –128 max 127 typ kopertowy (obiektowy) Byte;

short rozmiar 2 bajty, min –2¹⁵ max 2¹⁵-1 Short

int rozmiar 4 bajty, min –2³¹ max 2³¹-1 Integer

long rozmiar 8 bajtów, min –2⁶³ max 2⁶³-1 Long

typy do reprezentacji liczb rzeczywistych

float rozmiar 4 bajty, min 1.4E-45 max 3.4E38 Float

double rozmiar 8 bajtów, min 4.9E-324 max 1.7E308 Double

typ znakowy

char rozmiar 2 bajty, min Unicode 0 max Unicode 2¹⁶-1 Char

typ logiczny

boolean - - - Boolean

(8)

JAVA – typy podstawowe (wartości domyślne)

Zmienne obiektowe typów podstawowych są automatycznie inicjalizowane wartościami domyślnymi

class Variables {

boolean bo; // zmienne obiektowe o dostępie przyjaznym double du;

}

public static void main(String arg []) {

Variables v = new Variables(); //obiekt klasy Variables System.out.println(" boolean = " + v.bo);

System.out.println(" double = " + v.du);

char ch; // zmienne lokalne byte bt;

//System.out.println(" lokalne char = " + ch); // błąd kompilacji }

} // Prog2

Uwaga – w wyniku kompilacji powstają dwa pliki: Variables.class i Prog2.class

wartości domyślne:

boolean : false

char : ’\u0000’

byte : (byte) 0

short : (short) 0

int : 0

long : 0l

float : 0.0f

double : 0.0d

(9)

JAVA – zasięg zmiennych, stałe, literały, znaki specjalne

final int r = 5; // stała typu int long x = 200l + 10L; // L,l - wymusza long // float t = 3.14; błąd bo literały typu rzeczywistego // są domyślnie typu double float f = 3.14f; // F,f - wymusza float float d = (float)2.71d; // D,d - wymusza double

{

int y; /* zmienne x,f,d i y sa dostępne */

String s = new String ("Java\u2122");

System.out.print( s + '\n‘ );

//int x; przesłanianie niedozwolone

}

/* zmienna y jest niedostępna referencja s jest niedostępna */

System.out.print("\" koniec w cudzysłowie \"");

}

} // Prog3

wybrane znaki specjalne

\n nowy wiersz

\t tabulator

\b backspace

\r powrót karetki

\f wysunięcie strony

\\ backslash

\’ apostrof

\” cudzysłów

\liczba liczba w notacji ósemkowej

\xliczba liczba w notacji szesnastkowej

\uliczba znak w standardzie Unicode

(10)

JAVA – typy kopertowe

int x = 5, i = 10; float f = 3.14f; boolean b = false;

Integer t1 = new Integer(i); //obiekt typu Integer Integer t2 = new Integer(5);

Float f1 = new Float(f);

Boolean b1 = new Boolean(true);

x = t1.intValue();

i = t2.intValue(); /* pobranie wartości typu int z obiektu Integer */

f = f1.floatValue() + 3.1f;

b = b1.booleanValue();

System.out.println(" t1 = " + t1.intValue());

System.out.println(" t2 = " + t2.intValue());

System.out.println(" f1 = " + f1.floatValue());

System.out.println(" b1 = " + b);

if (arg.length > 1) { // tylko jeżeli istnieją argumenty wywołania programu

x = Integer.parseInt(arg[0]); /* metoda klasy Integer zamienia obiekt klasy String na wartość typu int */

f = Float.parseFloat(arg[1]);

System.out.println(x + ” ”+ f);

} }}//Prog4

(11)

JAVA - operatory

Box b1 = new Box(); // konstruktor domyślny ma nawiasy ! Box b2 = new Box();

b1.i = 5; b2.i = 5;

System.out.println(b1.i== b2.i ); // -> true

System.out.println(b1 == b2 ); // -> false (porównuje referencje) System.out.println(b1.equals(b2)); // -> false (porównuje referencje)

Integer i1 = new Integer(5);

Integer i2 = new Integer(5);

System.out.println(i1 == i2 ); // -> false (porównuje referencje) System.out.println(i1.equals(i2)); // -> true (tu działa dobrze) }

} // Prog5

class Box { // kolejność klas jest bez znaczenia

int i; // konstruktor domyślny jest generowany automatycznie }

priorytety operatorów

. [] ()

++ -- ! instanceof

new

* / %

+ -

<< >> >>> (przes.bitów)

< > <= >=

== !=

& bitowe AND

^ bitowe XOR

| bitowe OR

&& logiczne AND

|| logiczne OR

?: wyrażenie warunkowe

= += -= *= /= %= ^=

&= |= <<= >>= >>>=

(12)

JAVA – operatory, rzutowanie

Dla argumentów typu logicznego operatory bitowe działają tak samo jak logiczne ale nie ulegają skracaniu

int a =0, x =2, y = 5, z = 4;

if( (x>y) && (++z < 5) ) a++;

System.out.println("z = " + z); //-> 4

if( (x>y) & (++z < 5) ) a++;

System.out.println("z = " + z); //-> 5

}

} // Prog6

Uwaga: nie można rzutować na typ logiczny jak i zmiennych tego typu

public static void main(String arg []) { int a, x =2, y = 5;

a = x>y ? x:y; System.out.println("a = " + a);

} } // Prog7

public static void main(String arg []) { double d1 = 3.4, d2;

int x = 1;

char c = 'k' ;

// konwersja rozszerzająca

d2 = x; // można niejawnie i jawnie

d2 = (double)x; System.out.println(" d2 from int = " + d2);

d2 = c; System.out.println(" d2 from char = " + d2);

// konwersje z obcięciem – można tylko jawnie x = (int)d1; System.out.println(" x = " + x);

c = (char)d1; System.out.println(" c = " + c);

}

} // Prog8

(13)

JAVA – instrukcje pętli, instrukcja if i switch

int n = 5;

for(int i = 0; i < n; i++) System.out.println(i);

int i = 0; // wcześniej i było lokalne while(i < n) System.out.println(i++);

i = 0;

do {

System.out.print(i++);

System.out.println();}

while (i < n);

}

} // Prog9

import java.util.*; // import bibliotek public class Prog10 {

public static void main(String arg []) { Random r = new Random();

int n, i = r.nextInt() % 21; // wymuszenie liczby < 21 if (i < 0) n = 0;

else if (i < 5) n = 1;

else if (i < 10) n = 2;

else if (i < 15) n = 3;

else n = 4;

switch (n) {

case 1: System.out.println(" i < 5 "); break;

case 2: System.out.println(" i < 10 "); break;

case 3: System.out.println(" i < 15 "); break;

case 4: System.out.println(" i < 21 ");

default: if (i == 20) System.out.println( "i==20");

else if (i < 0 ) System.out.println( "i < 0"); }} } //Prog10

(14)

JAVA – podstawowe biblioteki

java.lang – podstawowa, domyslnie importowana dla każdej klasy

java.applet – zawiera klasy potzrzebne do tworzenia apletów

java.awt (Abstract Window Toolkit) – zestaw niezależnych od platformy systemowej klas do projektowania aplikacji w środowisku graficznym

java.io – klasy implementujące operacje wejścia i wyjściia

java.net – klasy służace do operacji wejścia i wyjścia w sieci Internet na niskim poziomie,

java.util – zbiór przydatnych klas np. klasa Date

import java.util.*; // import zbioru klas ale tylko tych z których korzysta nasza aplikacja import java.util.Date; // import konkretnej klasy

(15)

JAVA – instrukcje break i continue

int i = 0, n = 6;

while (i < n) { i++;

if ( i == 3) continue; // dla i == 3 pominie System.out.println(i); } // tą linie

System.out.println(" i po while = " + i); // -> 6

i = 0;

do { i++;

if ( i == 3) break;

System.out.println(i);

} while (i < n);

System.out.println(" i po do..while = " + i); //-> 3 }

} // Prog12 import java.util.*;

public static void main(String arg []) { Random r = new Random();

int n = Math.abs(r.nextInt() % 6);

switch (n) { // inaczej niż w C++

case 0: System.out.println( " ? "); break;

// case 1,2 : System.out.println(" słabo "); break;

// case 3,4 : System.out.println(" dobrze "); break;

case 1:

case 2: System.out.println(" słabo "); break;

case 3:

case 4: System.out.println(" dobrze "); break;

default: System.out.println(" b.dobrze "); break;

} }

} // Prog11

(16)

JAVA – etykiety?

boolean b = false;

int x =0 ,n = 4;

out: // etykieta bezpośrednio przed instrukcja for(int i =1 ; i< n; i++)

{

for( int j =0; j < n; j++) {

x = i*j;

if (j == 2)

{ b = true; break out; } // wyskok poza i }

} //i

System.out.println("x = " + x); // x-> 2 }

} // Prog13

public static void main(String arg []) { int n = 3;

out:

for(int i =1 ; i< n; i++) {

for( int j =0; j < n; j++) {

if (j == 1) continue out;

System.out.println("i:j ="+i+":"+j);

} } //i }

} // Prog14 /*

-> 1 : 0 -> 2 : 0 */

(17)

JAVA – tablice zmiennych typów podstawowych

import java.util.*;

public static void main(String arg []) { // można napisać String [] arg

int [] a = new int [10]; // a jest referencją do tablicy analogicznie można napisać int a [] = new int [10];

for (int i = 0; i < a.length; i++) a[i] = i;

for (int i = 0; i < a.length; i++) System.out.println(" a["+i+"] = " + a[i]); // -> 0,1,2,3,4,5,6,7,8,9

int [] b = {3,5,7}; // inny sposób inicjalizacji

for (int i = 0; i < b.length; i++) System.out.println(" b["+i+"] = " + b[i]); //-> 3,5,7

b = a; // b jest ustawiona na to samo co a

for (int i = 0; i < b.length; i++) System.out.println(" b["+i+"] = " + b[i]); //-> 0,1,2,3,4,5,6,7,8,9

Random r = new Random();

double [] c = new double [Math.abs(r.nextInt()) % 100];

System.out.println(" length of c = " + c.length);

}

} // Prog15

(18)

JAVA – tablice wielowymiarowe

import java.util.*;

int [][] a = new int [2][3]; // a jest referencją do tablicy

for (int i = 0; i < a.length; i++)

for (int j = 0; j < a[i].length; j++) a[i][j] = i*j;

for (int i = 0; i < a.length; i++) { for (int j = 0; j < a[i].length; j++)

System.out.print(" a["+i+"]["+j+"] = " + a[i][j]); // -> {0,0,0}

System.out.println(); } // -> {0,1,2}

int [][] b = { {3,5,7},{2,4,1} }; // inny sposób inicjalizacji for (int i = 0; i < b.length; i++) {

for (int j = 0; j < b[i].length; j++)

System.out.print(" b["+i+"]["+j+"] = " + b[i][j]); // -> {3,5,7}

System.out.println(); } // -> {2,4,1}

b = a; // b jest ustawiona na to samo co a }} // Prog16

public static void main(String arg []) { int [][] a = new int [2][3];

for (int i = 0; i < a.length; i++) { for (int j = 0; j < a[i].length; j++) System.out.print(" a["+i+"]["+j+"]

= " + a[i][j]);

System.out.println();

} // elementy tablic są

// wypełniane wart. domyślnymi

// -> {0,0,0}

} // -> {0,0,0}

} // Prog17

(19)

JAVA – tablice wielowymiarowe

import java.util.*;

int [][][] a = new int [2][3][4]; //int a [][][] = new int [2][3][4]; tak też można

int [][][] b = new int [2][][];

for (int i =0 ; i < b.length; i++) b[i] = new int [3][];

for (int i =0 ; i < b.length; i++) for (int j =0 ; j < b[i].length; j++) b[i][j] = new int [2];

double [][] c = new double [Math.abs(r.nextInt()) % 100][Math.abs(r.nextInt()) % 100];

// długości c[i] są takie same

double [][] d = new double [Math.abs(r.nextInt()) % 100][];

for (int i = 0; i < d.length; i++)

d[i] = new double[Math.abs(r.nextInt()) % 100];

// długości d[i] są losowe } } // Prog18

(20)

JAVA – tablice obiektów

import java.util.*;

Byte [] a = new Byte [5]; // a jest referencją do tablicy obiektów typu Byte

for (int i = 0; i < a.length; i++) a[i] = new Byte((byte)i);

for (int i = 0; i < a.length; i++) System.out.println(" a["+i+"] = " + a[i]); // -> 0,1,2,3,4

Byte [] b = {new Byte((byte)3),new Byte((byte)5),new Byte((byte)7)}; // inny sposób inicjalizacji for (int i = 0; i < b.length; i++) System.out.println(" b["+i+"] = " + b[i]); //-> 3,5,7

Byte [] d = new Byte [] {new Byte((byte)3), new Byte((byte)5), new Byte((byte)7)}; // inny sposób inicjalizacji

for (int i = 0; i < d.length; i++) System.out.println(" d["+i+"] = " + d[i]); //-> 3,5,7

b = a; // b jest ustawiona na to samo co a

for (int i = 0; i < b.length; i++) System.out.println(" b["+i+"] = " + b[i]); //-> 0,1,2,3,4

Double [] c = new Double [Math.abs(r.nextInt()) % 100];

System.out.println(" length of c = " + c.length); } } // Prog19

(21)

JAVA - tablice obiektów

import java.util.*;

Integer [][] a = new Integer [5][3]; // a jest referencją do tablicy dwuwymiarowej obiektów typu Integer

for (int i = 0; i < a.length; i++)

for (int j = 0; j < a[i].length; j++) a[i][j] = new Integer(i*j);

// inny sposób inicjalizacji

Integer [][] b = { {new Integer(0), new Integer(1)}, {new Integer(3), new Integer(4)}, {new Integer(6), new Integer(7)} };

// inny sposób inicjalizacji

Integer [][] c = new Integer[][] { {new Integer(0), new Integer(1)}, {new Integer(3), new Integer(4)}, {new Integer(6), new Integer(7)} };

} } // Prog20

(22)

Podstawy języka 22

JAVA - tablica jako zwracany rezultat metod

public class ArrayTest {

public static int [] returnArray1(int n) { int [] a = new int [n];

for(int i = 0; i < n; i++) a[i] = i;

return a; }

public static Integer [] returnArray2(int n) { Integer [] a = new Integer [n];

for(int i = 0; i < n; i++) a[i] = new Integer(i);

return a; }

public short [] returnArray3(int n) { short [] a = new short [n];

for(int i = 0; i < n; i++) a[i] = (short)i;

return a; }

int n=5;

int [] b = ArrayTest.returnArray1(n);

for(int i = 0; i <n ; i++)

System.out.print(b[i]); // -> 0,1,2,3,4

Integer [] c = ArrayTest.returnArray2(n);

for(int i = 0; i <n ; i++)

System.out.print(c[i]); // -> 0,1,2,3,4

ArrayTest test = new ArrayTest();

short [] d = test.returnArray3(n);

for(int i = 0; i <n ; i++)

System.out.print(c[i]); // -> 0,1,2,3,4 } } // ArrayTest

(23)

JAVA – klasy, pola i metody

import java.util.*;

class Box {

int n =100; // możemy nadawać wartości static int i; // zmienna statyczna, będzie = 0 Box() {i++;} // przeciążenie, konstruktory Box(int n ) { this.n = n; i++; }

}

class BoxArray{

int ile = 0;

Box [] array;

BoxArray(int n) {array = new Box [n];}

void putBox(Box x) {array [ile] = x; ile++; } void showBox(int i)

{System.out.println(" n w Box nr. " + i + " = " + array[i].n); } }

Uwaga! Brak identyfikatora dostępu określa dostęp jako przyjazny (w ramach pakietu)

System.out.println("Ilosc obiektow Box = " + Box.i); //dostęp do pola static

//BoxArray a = new BoxArray(); // błąd

BoxArray a = new BoxArray(5);

Box x = new Box(); //!!! konstr. domyślny

a.putBox(x);

for (int i = 1; i < 4; i++) a.putBox(new Box(i));

a.showBox(0);

a.showBox(3);

int y = a.array[0].i; // dostęp do pola static }

} // Prog21

(24)

JAVA –pola i metody- dostęp

class Alfa{ Uwaga! Dostęp do metod i pól należy definiować przed każdym składnikiem private int r;

private Alfa(int r) {this.r = r;} // konstruktor prywatny

// metoda makeAlfa musi być statyczna public static Alfa makeAlfa(int x) { return new Alfa(x);}

public void changeAlfa(int x){r = x;}

public int showAlfa() {return r;} // return zwrot }

// Alfa a = new Alfa(1); // konstruktor prywatny, brak dostępu Alfa a = Alfa.makeAlfa(1); // wywołanie metody statycznej

// a.r = 5; zmienna prywatna brak dostępu

System.out.println(a.showAlfa());

a.changeAlfa(2);

System.out.println(a.showAlfa());

}

} // Prog22

(25)

JAVA – klasy, pola i metody

- w jednym pliku tylko jedna klasa może być publiczna

- tylko klasa wewnętrzna może mieć dostęp chroniony lub prywatny wewnątrz pakietu - klasy w obrębie tego samego katalogu traktowane są jak z jednego pakietu

class Alfa{

Alfa() {}

}

/*

private class Beta{

Beta() {}

}

protected class Teta{

Teta() {}

}

*/

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

} // Prog23

// jednostka kompilacji Prog24.java public class Prog24 {

public static void main(String arg []) { Beta b = new Beta();

b.show();

} } // Prog24

/* jednostka kompilacji w tym samym katalogu o nazwie Beta.java */

public class Beta { Beta() {}

void show() {System.out.println("Beta");}

} // Beta

(26)

JAVA – pakiety

// plik : kb.ath.library.AlfaP.java // określenie pakietu w pierwszej lini

package kb.ath.library;

import java.util.*;

class Alfa{

double r;

Alfa() { r = Math.random();}

}

public class AlfaP { private Alfa a;

public AlfaP () {a = new Alfa();}

public double giveAlfa() { return a.r; } }

// import kb.ath.library.Alfa; // Alfa chroniona, nie ma dostepu import kb.ath.library.AlfaP; // importuje klase AlfaP

import kb.ath.library.*; // importuje wszystkie publiczne z \library

public class Prog25{

public static void main( String [] arg) {

// Alfa a = new Alfa(); // Alfa jest chroniona poza pakietem AlfaP a = new AlfaP();

double d = a.giveAlfa();

System.out.println(d);

}

} // Prog25

(27)

JAVA – pakiety

// plik : kb.ath.library.AlfaP.java // określenie pakietu w pierwszej lini

package kb.ath.library;

import java.util.*;

class Alfa{

double r;

Alfa() { r = Math.random();}

}

public class AlfaP { private Alfa a;

public AlfaP () {a = new Alfa();}

public double giveAlfa() { return a.r; } }

// plik : kb.ath.library.Beta.java package kb.ath.library;

public class Beta{

private Alfa a;

public Beta() {a = new Alfa();} // Alfa już nie jest chroniona public double giveAlfa() { return a.r;} // dostęp w ramach pakietu } // Beta

import kb.ath.library.*;

import kb.ath.library.Beta;

public class Prog26{

public static void main( String [] arg) { AlfaP a = new AlfaP();

double d = a.giveAlfa();

Beta b = new Beta();

d = b.giveAlfa(); }} // Prog26

(28)

JAVA –dokumentacja kodu, rodzaje znaczników

/** komentarz opisujacy klasę*/

public class Nic{

/** komentarz do zmiennej */

public int i;

/** komentarz do konstruktora, metody */

Public Nic() {}

}

Można osadzać HTML

/**

*<pre>

*System.out.println(new Date());

*<pre>

*/

Znaczniki dokumentowania klas:

@see odwołanie do innej klasy

@version informacja o wersji

@author informacja o autorze

@since wskazanie wersji kodu od której dana własność jest dostępna

Znaczniki dokumentowania zmiennych:

@see

Znaczniki dokumentowania metod:

@see

@param nazwa_parametru opis parametru

@return opis zwracanego typu, rezultatu

@throws nazwa_klasy_wyjątku opis kiedy i dlaczego może wystąpić

@deprecated stosowany do oznaczenia nie zalecanych właściwości wypartych przez nowe i przeznaczonych do usunięcia w

przyszłości

(29)

Podstawy języka 29

JAVA – dokumentacja: przykład

/** Klasa BoxArray jest kolekcja * obiektów typu Box

* z mozliwością zbierania i przeglądania * @author Krzysztof Brzozowski * @author kbrzozowski.pb.bielsko.pl * @version 1.0

*/

public class BoxArray{

/** Pole ile określa aktualny stan kolekcji */

public int ile =0;

/** Pole array określa referencje do tablicy obiektów Box */

public Box [] array;

/** Konstruktor klasy BoxArray z jednym parametrem @param n określa maksymalny rozmiar kolekcji */

public BoxArray(int n) {array = new Box [n];}

/** Funkcja skladowa putBox z jednym parametrem *@param x typu Box wstawia obiekt przesłany przez argument do kolekcji

@see Box @return brak

@exception brak zgłaszanych wyjątków */

public void putBox(Box x) {array [ile] = x; ile++; }

/** Funkcja wypisująca zawartość obiektu Box pod pozycja i w kolekcji

@param i typu int @see Box

*/

public void showBox(int i)

{System.out.println(" n w Box nr. " + i + " = " + array[i].n); } }

(30)

JAVA – dokumentacja: przykład

import java.util.*;

/** Klasa Box jako skrytka */

public class Box { int n=100;

/** Pole i typu int określa ilość obiektów klasy */

public static int i; // zmienna statyczna Box() {i++;} // przeciążenie, konstruktor Box(int n ) { this.n = n; i++; }

}

: javadoc –version –author Box.java BoxArray.java

allclasses-frame.html

allclasses-noframe.html

Box.html

BoxArray.html

deprecated-list.html

help-doc.html

index.html

index-all.html

overview-tree.html

packages.html

(31)

JAVA – dokumentacja

(32)

JAVA – dokumentacja, część ogólna

(33)

JAVA – dokumentacja, część szczegółowa