JAVA Plan wykładu

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
1
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
2
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
3
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
4
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
5
JAVA – pierwszy program
pliki *.JAVA kompilacja pliki *.CLASS (kod bajtowy Javy)
// Prog1.java
//
public class Prog1 {
interpretacja przez JVM(Java Virtual Machine)  procesor
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
a tak było w C++
pliki *.CPP kompilacja pliki *.EXE (wynikowy kod binarny, maszynowy)procesor
Podstawy języka
6
JAVA – typy podstawowe
typy do reprezentacji liczb całkowitych
byte
short
int
long
rozmiar 1 bajt ,
rozmiar 2 bajty,
rozmiar 4 bajty,
rozmiar 8 bajtów,
min –128 max 127
min –215 max 215-1
min –231 max 231-1
min –263 max 263-1
typ kopertowy (obiektowy) Byte;
Short
Integer
Long
typy do reprezentacji liczb rzeczywistych
float
double
rozmiar 4 bajty,
rozmiar 8 bajtów,
min 1.4E-45 max 3.4E38
min 4.9E-324 max 1.7E308
Float
Double
rozmiar 2 bajty,
min Unicode 0 max Unicode 216-1
Char
-
-
Boolean
typ znakowy
char
typ logiczny
boolean
-
Podstawy języka
7
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 class Prog2 {
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
wartości domyślne:
boolean
: false
char
: ’\u0000’
byte
: (byte) 0
short
: (short) 0
int
:0
long
: 0l
float
: 0.0f
double
: 0.0d
Uwaga – w wyniku kompilacji powstają dwa pliki: Variables.class i Prog2.class
Podstawy języka
8
JAVA – zasięg zmiennych, stałe, literały, znaki specjalne
public class Prog3 {
public static void main(String arg [])
{
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
Podstawy języka
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
9
JAVA – typy kopertowe
public class Prog4 {
public static void main(String arg [])
{
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
10
JAVA - operatory
priorytety operatorów
public class Prog5 {
public static void main(String arg [])
{
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
}
Podstawy języka
.
[]
()
++
--
!
*
/
%
+
-
<<
>>
>>> (przes.bitów)
<
>
<= >=
==
!=
&
bitowe AND
^
bitowe XOR
|
bitowe OR
&&
logiczne AND
||
logiczne OR
?:
wyrażenie warunkowe
instanceof
new
= +=
-= *= /= %= ^=
&= |= <<= >>= >>>=
11
JAVA – operatory, rzutowanie
public class Prog7 {
Dla argumentów typu logicznego operatory bitowe działają
tak samo jak logiczne ale nie ulegają skracaniu
public static void main(String arg []) {
int a, x =2, y = 5;
a = x>y ? x:y; System.out.println("a = " + a);
public class Prog6 {
public static void main(String arg [])
{
int a =0, x =2, y = 5, z = 4;
} } // Prog7
public class Prog8 {
public static void main(String arg []) {
double d1 = 3.4, d2;
int
x = 1;
char c = 'k' ;
if( (x>y) && (++z < 5) ) a++;
System.out.println("z = " + z); //-> 4
// 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);
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
// 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
12
JAVA – instrukcje pętli, instrukcja if i switch
import java.util.*;
public class Prog9 {
public static void main(String arg [])
{
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++);
// 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;
i = 0;
do {
System.out.print(i++);
System.out.println();}
while (i < n);
}
} // Prog9
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
Podstawy języka
13
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
14
JAVA – instrukcje break i continue
import java.util.*;
public class Prog11 {
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:
public class Prog12 {
public static void main(String arg [])
{
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(" dobrze "); break;
default: System.out.println(" b.dobrze "); break;
}
System.out.println(" i po do..while = " + i); //-> 3
}
} // Prog12
}
} // Prog11
Podstawy języka
15
JAVA – etykiety?
public class Prog14 {
public class Prog13 {
public static void main(String arg [])
{
boolean b = false;
int x =0 ,n = 4;
public static void main(String arg []) {
int n = 3;
out:
for(int i =1 ; i< n; i++)
{
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
for( int j =0; j < n; j++)
{
if (j == 1) continue out;
System.out.println("i:j ="+i+":"+j);
}
} //i
}
} // Prog14
/*
-> 1 : 0
}
} // Prog13
-> 2 : 0 */
Podstawy języka
16
JAVA – tablice zmiennych typów podstawowych
import java.util.*;
public class Prog15 {
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
Podstawy języka
17
JAVA – tablice wielowymiarowe
import java.util.*;
public class Prog17 {
public class Prog16 {
public static void main(String arg []) {
int [][] a = new int [2][3];
// a jest referencją do tablicy
public static void main(String arg []) {
int [][] a = new int [2][3];
for (int i = 0; i < a.length; i++) {
for (int i = 0; i < a.length; i++)
for (int j = 0; j < a[i].length; j++) a[i][j] = i*j;
for (int j = 0; j < a[i].length; j++)
System.out.print(" a["+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}
= " + a[i][j]);
System.out.println();
} // elementy tablic są
// wypełniane wart. domyślnymi
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;
}} // Prog16
// -> {0,0,0}
}
// -> {0,0,0}
} // Prog17
// b jest ustawiona na to samo co a
Podstawy języka
18
JAVA – tablice wielowymiarowe
import java.util.*;
public class Prog18 {
public static void main(String arg []) {
int [][][] a = new int [2][3][4];
//int a [][][] = new int [2][3][4]; tak też można
Random r = new Random();
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
19
JAVA – tablice obiektów
import java.util.*;
public class Prog19 {
public static void main(String arg []) {
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]);
Byte [] b = {new Byte((byte)3),new Byte((byte)5),new Byte((byte)7)};
for (int i = 0; i < b.length; i++) System.out.println(" b["+i+"] = " + b[i]);
// -> 0,1,2,3,4
// inny sposób inicjalizacji
//-> 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
Random r = new Random();
Double [] c = new Double [Math.abs(r.nextInt()) % 100];
System.out.println(" length of c = " + c.length); }
} // Prog19
Podstawy języka
20
JAVA - tablice obiektów
import java.util.*;
public class Prog20 {
public static void main(String arg []) {
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
21
JAVA - tablica jako zwracany rezultat metod
public class ArrayTest {
public static void main(String arg [])
public static int [] returnArray1(int n) {
{
int [] a = new int [n];
int n=5;
for(int i = 0; i < n; i++)
int [] b = ArrayTest.returnArray1(n);
a[i] = i;
for(int i = 0; i <n ; i++)
return a; }
public static Integer [] returnArray2(int n) {
System.out.print(b[i]);
// -> 0,1,2,3,4
Integer [] a = new Integer [n];
Integer [] c = ArrayTest.returnArray2(n);
for(int i = 0; i < n; i++)
for(int i = 0; i <n ; i++)
a[i] = new Integer(i);
System.out.print(c[i]);
return a; }
// -> 0,1,2,3,4
public short [] returnArray3(int n) {
ArrayTest test = new ArrayTest();
short [] a = new short [n];
short [] d = test.returnArray3(n);
for(int i = 0; i < n; i++)
for(int i = 0; i <n ; i++)
a[i] = (short)i;
System.out.print(c[i]);
return a; }
// -> 0,1,2,3,4
} } // ArrayTest
Podstawy języka
22
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)
Podstawy języka
public class Prog21 {
public static void main(String arg [])
{
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;
}
} // Prog21
// dostęp do pola static
23
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
}
public class Prog22 {
public static void main(String arg [])
{
// Alfa a = new Alfa(1);
Alfa a = Alfa.makeAlfa(1);
// a.r = 5;
System.out.println(a.showAlfa());
a.changeAlfa(2);
System.out.println(a.showAlfa());
}
} // Prog22
// konstruktor prywatny, brak dostępu
// wywołanie metody statycznej
zmienna prywatna brak dostępu
Podstawy języka
24
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() {}
}
// jednostka kompilacji Prog24.java
public class Prog24 {
public static void main(String arg []) {
/*
private class Beta{
Beta() {}
}
Beta b = new Beta();
b.show();
} } // Prog24
protected class Teta{
Teta() {}
}
*/
/* jednostka kompilacji w tym samym katalogu
o nazwie Beta.java */
public class Beta {
Beta() {}
public class Prog23 {
public static void main(String arg []) {}
} // Prog23
void show() {System.out.println("Beta");}
} // Beta
Podstawy języka
25
JAVA – pakiety
// plik : kb.ath.library.AlfaP.java
// określenie pakietu w pierwszej lini
// import kb.ath.library.Alfa;
package kb.ath.library;
import java.util.*;
import kb.ath.library.*; // importuje wszystkie publiczne z \library
// Alfa chroniona, nie ma dostepu
import kb.ath.library.AlfaP; // importuje klase AlfaP
public class Prog25{
class Alfa{
double r;
Alfa() { r = Math.random();}
}
public static void main( String [] arg) {
// Alfa a = new Alfa();
// Alfa jest chroniona poza pakietem
AlfaP a = new AlfaP();
public class AlfaP {
private Alfa a;
public AlfaP () {a = new Alfa();}
public double giveAlfa() { return a.r; }
}
double d = a.giveAlfa();
System.out.println(d);
}
} // Prog25
Podstawy języka
26
JAVA – pakiety
// plik : kb.ath.library.AlfaP.java
// określenie pakietu w pierwszej lini
// plik : kb.ath.library.Beta.java
package kb.ath.library;
public class Beta{
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; }
}
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();
Podstawy języka
}} // Prog26
27
JAVA –dokumentacja kodu, rodzaje znaczników
/** komentarz opisujacy klasę*/
public class Nic{
Znaczniki dokumentowania klas:
@see odwołanie do innej klasy
@version informacja o wersji
/** komentarz do zmiennej */
public int i;
/** komentarz do konstruktora, metody */
Public Nic() {}
}
Można osadzać HTML
/**
*<pre>
*System.out.println(new Date());
*<pre>
*/
@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
28
JAVA – dokumentacja: przykład
/** Klasa BoxArray jest kolekcja
/** Funkcja skladowa putBox z jednym parametrem
*@param x typu Box wstawia obiekt przesłany
* obiektów typu Box
* z mozliwością zbierania i przeglądania
przez argument do kolekcji
* @author Krzysztof Brzozowski
@see Box
* @author kbrzozowski.pb.bielsko.pl
@return brak
* @version 1.0
@exception brak zgłaszanych wyjątków
*/
*/
public class BoxArray{
public void putBox(Box x) {array [ile] = x; ile++; }
/** Pole ile określa aktualny stan kolekcji */
/** Funkcja wypisująca zawartość obiektu Box pod
pozycja i w kolekcji
public int ile =0;
/** Pole array określa referencje do tablicy obiektów Box */
@param i typu int
@see Box
public Box [] array;
/** Konstruktor klasy BoxArray z jednym parametrem
*/
@param n określa maksymalny rozmiar kolekcji
public void showBox(int i)
*/
{System.out.println(" n w Box nr. " + i + " = " +
array[i].n); } }
public BoxArray(int n) {array = new Box [n];}
Podstawy języka
29
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
Podstawy języka
30
JAVA – dokumentacja
Podstawy języka
31
JAVA – dokumentacja, część ogólna
Podstawy języka
32
JAVA – dokumentacja, część szczegółowa
Podstawy języka
33