JAVA - plan wykładu

Podstawy języka 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

Podstawy języka 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...

Podstawy języka 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ą....

Podstawy języka 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

Podstawy języka 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

Podstawy języka 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

Podstawy języka 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 –215 max 215-1 Short

int rozmiar 4 bajty, min –231 max 231-1 Integer

long rozmiar 8 bajtów, min –263 max 263-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 216-1 Char

typ logiczny

boolean - - - Boolean

Podstawy języka 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

Podstawy języka 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

Podstawy języka 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

Podstawy języka 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

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

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

Podstawy języka 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 class Prog8 { 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

Podstawy języka 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



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 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

Podstawy języka 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

Podstawy języka 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.*;




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

Podstawy języka 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



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 */

Podstawy języka 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


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

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

}

} // Prog15

Podstawy języka 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}


}} // Prog16



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

Podstawy języka 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

Podstawy języka 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


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

Podstawy języka 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

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

Podstawy języka 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

Podstawy języka 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

Podstawy języka 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



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

Podstawy języka 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

Podstawy języka 27

JAVA – pakiety

// plik : kb.ath.library.AlfaP.java

// określenie pakietu w pierwszej lini


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


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

Podstawy języka 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

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); } }

Podstawy języka 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

Podstawy języka 31

JAVA – dokumentacja

Podstawy języka 32

JAVA – dokumentacja, część ogólna

Podstawy języka 33

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

Documents

JAVA - plan wykładu