1 / 33

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

hamlet
Download Presentation

JAVA - plan wykładu

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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 pliki *.JAVAkompilacja pliki *.CLASS (kod bajtowy Javy) interpretacja przez JVM(Java Virtual Machine)  procesor // 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 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) wartości domyślne: boolean : false char : ’\u0000’ byte : (byte) 0 short : (short) 0 int : 0 long : 0l float : 0.0f double : 0.0d 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 Uwaga – w wyniku kompilacji powstają dwa pliki: Variables.class i Prog2.class Podstawy języka

  9. JAVA – zasięg zmiennych, stałe, literały, znaki specjalne 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 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

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

  11. JAVA - operatory priorytety operatorów . [] () ++ -- ! instanceof new * / % + - << >> >>> (przes.bitów) < > <= >= == != & bitowe AND ^ bitowe XOR | bitowe OR && logiczne AND || logiczne OR ?: wyrażenie warunkowe = += -= *= /= %= ^= &= |= <<= >>= >>>= 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

  12. JAVA – operatory, rzutowanie public class Prog7 { 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 Dla argumentów typu logicznego operatory bitowe działają tak samo jak logiczne ale nie ulegają skracaniu public class Prog6 { public static void main(String arg []) { 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 Podstawy języka

  13. JAVA – instrukcje pętli, instrukcja if i switch 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 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++); i = 0; do { System.out.print(i++); System.out.println();} while (i < n); } } // Prog9 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 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: System.out.println(" dobrze "); break; default: System.out.println(" b.dobrze "); break; } } } // Prog11 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(" i po do..while = " + i); //-> 3 } } // Prog12 Podstawy języka

  16. JAVA – etykiety? public class Prog14 { 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 */ public class Prog13 { public static void main(String arg []) { 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 Podstawy języka

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

  18. JAVA – tablice wielowymiarowe public class Prog17 { 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 import java.util.*; public class Prog16 { public static void main(String arg []) { 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 Podstawy języka

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

  20. 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]); // -> 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 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

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

  22. JAVA - tablica jako zwracany rezultat metod public static void main(String arg []) { 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 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; } Podstawy języka

  23. JAVA – klasy, pola i metody 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; // dostęp do pola static } } // Prog21 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

  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 } public class Prog22 { public static void main(String arg []) { // 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 // 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 - 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 class Prog23 { public static void main(String arg []) {} } // Prog23 Podstawy języka

  26. JAVA – pakiety // 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 // plik : kb.ath.library.AlfaP.java // określenie pakietu w pierwszej lini packagekb.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; } } Podstawy języka

  27. JAVA – pakiety // 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 // 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.*; 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 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 /** 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> */ Podstawy języka

  29. JAVA – dokumentacja: przykład /** 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); } } /** 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];} 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.javaBoxArray.java Podstawy języka

  31. JAVA – dokumentacja Podstawy języka

  32. JAVA – dokumentacja, część ogólna Podstawy języka

  33. JAVA – dokumentacja, część szczegółowa Podstawy języka

More Related