Java Technologijos

VILNIAUS TECHNIKOS UNIVERSITETAS
5LPDQWDV%HOHYLþLXV
JAVA TECHNOLOGIJOS
Mokomoji knyga
Vilnius 2005
5LPDQWDV %HOHYLþLXV Java technologijos. Mokomoji knyga. Vilnius: Technika,
2005. 190 p.
/HLGLQ\MHQDJULQ¡MDPDJava programavimo kalba ir jos technologijos. Trumpai

DSåYHOJLDPDNDOERVVLQWDNV¡DNFHQWXRMDPLMRVVNLUWXPDLQXR&VLQWDNV¡V,ãVDPLDL
QDJULQ¡MDPRV Java WHFKQRORJLMRV NOLHQWLQ¡PV $:7 LU Swing NODVLÐ SDNHWDL LU
seUYHULQ¡PV javax.servlet ir javax.servlet.http NODVLÐ SDNHWDL SURJUDPRPV NXUWL
7UXPSDLDSåYHOJLDPRVJavaBeans, JSP, RMI ir CORBA technologijos.
0RNRPRML NQ\JD VNLULDPD LQIRUPDWLNRV LU WHFKQRPDWHPDWLNRV VWXGLMÐ
SURJUDPÐ VWXGHQWDPV -L WXU¡WÐ EÌWL QDXGLQJD LU JUHWLPÐ VWXGLMÐ NU\SþLÐ
PDJLVWUDQWDPV QRULQWLHPV VXVLSDåLQWL VX REMHNWLQLR SURJUDPDYLPR SDJULQGDLV LU
internetui skirtomis programavimo technologijomis.
/HLGLQ³UHNRPHQGDYR9*78)XQGDPHQWLQLÐPRNVOÐIDNXOWHWRVWXGLMÐNRPLWHWDV
ReFHQ]DYRSURIKDELOGU5ýLHJLVLUGRFGU'0DåHLND
9*78OHLG\NORVÄ7HFKQLND³PRNRPRVLRVOLWHUDWÌURVNQ\JD
ISBN 9986-05-859-0 5%HOHYLþLXV

 VGTU leidykla „Technika“, 2005
2
TURINYS
3UDWDUP¡ 5
²YDGDV 6
Trumpa Java istorija 9
3DJULQGLQLDLNDOERVEUXRåDL 10
Java programavimo instrumentai 11
1. JAVA ELEMENTAI 13
1.1. Kalbos konstrukcijos 13
1.2.2EMHNWÐNÌULPDVLUGDUEDVVXMDLV 13
1.3. Primityvieji duomenys 14
1.4.,GHQWLILNDWRULÐPDWRPXPRVULW\V 15
1.5..ODV¡V 16
1.6.6WDWLQLDLNODVLÐODXNDLLUPHWRGDL 17
1.7.9HLNVPÐRSHUDWRULDL 17
1.8.,ãYHVWLV³SXOW 18
1.9.3DSUDVþLDXVLÐDXWRQRPLãNRVSURJUDPRVLUNOLHQWLQ¡V
programos pDY\]GåLDL 19
2. JAVA6,17$.6 ,â6$0,$8 23
2.1.6O\JRVRSHUDWRULDL 23
2.2. Selektorius 23
2.3. Ciklai 24
2.3.1.&LNOÐå\P¡MLPDV&LNOÐQXWUDXNLPDV 25
2.4. Metodas – konstruktorius. Konstruktoriaus ir metodo
perkrovimas 26
2.5.5DNWDåRGLVthis 30
2.6.2EMHNWÐQDLNLQLPDV 31
2.7.3UDGLQLÐUHLNãPLÐVN\ULPDV 32
2.8.3UDGLQLÐUHLNãPLÐSULHVN\UDPDV\YDPV 33
2.9.9DUGÐODXNÐPHWRGÐLUNODVLÐVO¡SLPDV 34
2.9.1. Paketai 34
/DXNÐLUPHWRGÐVO¡SLPDV 36
.ODVLÐVO¡SLPDV 37
2.10. .RGRIUDJPHQWÐNDUWRMLPDVNRPSR]LFLMDLUSDYHOGLPXPDV 37
2.10.1. 6LQWDNV¡.RQVWUXNWRULÐY\NG\PDV 37
2.10.2. .\ODQW\VLVWLSÐSHUWYDUN\PDV 40
2.10.3. 5DNWDåRGLVfinal ir paveldimumas 40
2.11. Polimorfizmas 41
2.12. %HVLOHLGåLDQW\VLVWLSÐSHUWYDUN\PDV 44
2.13. $EVWUDNþLRVLRVNODV¡VLUPHWRGDL 45
2.14. 6VDMÐNODV¡V 46
2.15. 9LGLQ¡VNODV¡V 48
2.16. .ODLGÐDSGRURMLPRPHFKDQL]PDV 51
2.16.1. Operatoriai try ir catch 52
2.16.2. Operatorius throw 53
2.16.3. Operatorius throws 54
2.16.4. Operatorius finally 55
.DLNXULRVYLGLQ¡VJava išimtys 55
3
2.17. ²YHVWLHVLULãYHVWLHVVLVWHPRVSDJULQGDL 57
2.18. 6DYLDQDOL]¡VVLVWHPD 62
2.19. Vykdymo srautai 65
2.19.1 SraXWRVLQWDNV¡ 66
6UDXWÐVLQFKURQL]DYLPDV7DUSVUDXWLQLDLU\ãLDL 73
2.20. Kolekcijos 75
2.20.1. .ROHNFLMÐKLHUDUFKLMD 76
2.20.2. Collection kolekcijos 77
2.20.3. Map OHQWHO¡V 83
2.20.4. Collections NODV¡VDOJRULWPDL 84
3. JAVA TECHNOLOGIJOS 86
3.1..OLHQWLQ¡VSURJUDPRVSwing technologija 86
%HQGURVLRVåLQLRVDSLHNOLHQWLQHVSURJUDPDV 86
.OLHQWLQ¡VSURJUDPRVDUFKLWHNWÌUD 88
²Y\NLÐDSGRURMLPRVLVWHPD 89
.OLHQWLQLÐSURJUDPÐSDY\]GåLDL 93
3.1.5. Baziniai grafiniai komponentai 98
.RPSRQHQWÐLãG¡VW\PRNRQWHLQHU\MHWYDUN\NO¡V 100
3.1.7. Kai kurie Swing komponentai 101
.OLHQWLQLÐSURJUDPÐDUFK\YDYLPDV 109
3.2. Java Beans technologija 110
3.3. Bazinis tinklinis programavimas 112
5\ã\VWDUSGYLHMÐNRPSLXWHULÐWLQNOH 112
3.3.2. Ryšys tarp HTTP serverio ir kliento 120
3.4.6HUYHULQ¡VSURJUDPRV 122
%HQGURVLRVåLQLRVDSLHVHUYHULQHVSURJUDPDV 122
6HUYHULQ¡VSURJUDPRVJ\YDYLPRFLNODV 124
3.4.3. Servlet $3,VVDMÐNODV¡VNODV¡VLUPHWRGDL 125
3.4.4. JSP technologija 133
3.5. RMI technologijos pagrindai 134
3.6.%HQGURVLRVåLQLRVDSLH&25%$WHFKQRORJLM 137
/,7(5$7Ë5$ 141
35,('$,3URJUDPÐSDY\]GåLDLLUVDYDUDQNLãNRGDUERXåGXRW\V 142
4
3UDWDUP¡
Java technologijos konspekte aiškinamos remiantis programavimo kalba Java

EHLZZZSXVODSLÐNÌULPRNDOED+70/.RQVSHNWHSDDLãNLQDPDJavaVLQWDNV¡NLHN
MRV UHLNLD NOLHQWLQ¡PV LU VHUYHULQ¡PV SURJUDPRPV applets, servlets) rašyti bei
JavaBeans LU 50, WHFKQRORJLMRPV +70/ VLQWDNV¡ WUXPSDL SULPHQDPD NLHN MRV
UHLNLDNXULDQW+70/GRNXPHQWXVLãNXULÐSDOHLGåLDPRVNOLHQWLQ¡VSURJUDPRV
3DVNDLWÐ NRQVSHNW VXGDUR WU\V GDO\V 3LUPRMRMH GDO\MH WLN SDURGRPL
SDSUDVþLDXVLÐJava aplikacLMÐLUNOLHQWLQLÐSURJUDPÐSDY\]GåLDLEHLSDDLãNLQDPDNDLS
veikia šios programos. Antroji dalis skirta Java VLQWDNVHL 7UHþLRMRMH GDO\MH
QDJULQ¡MDPRV Java LQWHUQHWLQ¡V WHFKQRORJLMRV ,ãVDPLDL QDJULQ¡MDPRV NOLHQWLQLÐ
SURJUDPÐ LU JUDILQLÐ YDUWRWRMR VVDMÐ Wechnologija Swing VHUYHULQLÐ SURJUDPÐ LU
bazinio tinklinio programavimo technologijos, o JSP, JavaBeans, RMI ir CORBA
WHFKQRORJLMÐ – pateikti tik pagrindai. Prieduose yra visus svarbesnius teiginius ar
WHFKQRORJLMDV LOLXVWUXRMDQþLÐ SURJUDPÐ WHNVWDL EHL VDYDUDQNLãNR GDUER XåGXRW\V
SLUPLHVLHPV SDY\]GåLDPV – WLN SURJUDPÐ DQDOL]HL Y¡OHVQLHPV – ir programoms
SHUWYDUN\WLEHLLãSO¡VWL
.RQVSHNWH QDXGRWL OLHWXYLãNL WHUPLQDL .DGDQJL NDL NXULH Lã MÐ OLHWXYLÐ NDOED
GDUQ¡UD³VLWYLUWLQ
ãDOLDVNOLDXVWHOLXRVHSDWHLNLDPLLURULJLQDOÌVDQJOLãNLWHUPLQDL
.DG EÌWÐ SDSUDVþLDX VNDLW\WL NRQVSHNW YLVÐ Java SURJUDPÐ WHNVWDL SDWHLNWL
NXUV\YX $LãNLQDQW WHNVWH SURJUDPÐ YHLNLP LU WHLNLDQW SURJUDPRV GDOLV RSHUDWRULDL
SDNHWÐYDUGDLDUSURJUDPRV³YDLULÐREMHNWÐLGHQWLILNDWRriai taip pat išskiriami kursyvu.
Kursyvu išskirti ir visi HTML sakiniai, parametrai bei IDL kalbos operatoriai.
Kadangi Java VDYRYLGLQLÐREMHNWÐYDUGÐVLVWHPRMHGDåQLDXVLDLYDUWRMDSLOQXV
DQJOLãNXV åRGåLXV SURJUDPÐ EHL MÐ PHWRGÐ LU ODXNÐ YDUGDL GDåQLDXsiai yra angliški.
.DGQHUHLN¡WÐLãNUDLS\WLOLHWXYLãNÐåRGåLÐLUVLHNLDQWUDã\ERVYLHQWLVXPRSURJUDPÐ
NRPHQWDUDLWDLSSDWSDUDã\WLDQJOLãNDL7LNSUDGLQLXRVHSDSUDVWXRVHSDY\]GåLXRVH– ne
VDYDUDQNLãNRVH SURJUDPRVH R SURJUDPÐ IUDJPHQWXRVH NXU NRPHQWDUXRse
SDDLãNLQDPL VLQWDNV¡V GDO\NDL – NRPHQWDUDL SDUDã\WL OLHWXYLãNDL $LãNX WDL VO\JLQLV
GDO\NDV QRULQW WRN³ IUDJPHQW ³NRPSRQXRWL ³ YHLNLDQþL SURJUDP WHNWÐ YDUWRWL WLN
DQJOÐNDOE
.DLNXULHSURJUDPÐSDY\]GåLDLVXQHGLGHOLDLVSDNHLWLPDLVSDLPWLLã%Eckelio
DU31DXJKWRQRLU+6FKLOGWRNQ\JÐåUOLWHUDWÌURVVUDã3ULHãWRNLXVSDY\]GåLXV
VNOLDXVWHOLXRVHQXURG\WRVLG¡MRVDXWRULÐSDYDUG¡V
5
²9$'$6
Java – šiuo metu, matyt, pati populiariausia programavimo kalba. Ja galima

NXUWL WLHN VDYDUDQNLãNDV DXWRQRPLãNDV SURJUDPDV WLHN WLQNOX SHUVLXQþLDPDV LU
LQWHUQHWR QDUã\NOLÐ Y\NGRPDV SURJUDPDV – klientines programas (angl. applets).
Pagrindinis Java pranašumas, palyginti su kitomis programavimo kalbomis, yra jos
QHSULNODXVRPXPDVQXRNRPSLXWHULÐWLSR1HSULNODXVRPXPDVSDVLHNLDPDVDSGRURMDQW
Java SURJUDP GYLHP HWDSDLV SLUPLDXVLD M NRPSLOLXRMDQW ³ QXR NRPSLXWHULR WLSR
QHSULNODXVRP YDGLQDPM³ EDLWLQ³ NRG YLUWXDOLDL Java PDãLQDL R SDVNXL ã³ NRG
interpretuojant. Tai lemia ir Java WUÌNXPXV – šios programos našumas pasiekia tik
kelis procentus analogiškos C++ programos našumo.
Java ODLNRPD UHYROLXFLQLX SURJUDPDYLPR åLQJVQLX SLUPLDXVLD G¡O Java
SURJUDPDYLPR JDOLP\ELÐ LQWHUQHWH NDOEDQW WLHN DSLH NOLHQWLQ³ WLHN DSLH VHUYHULQ³
SURJUDPDYLP 3DJULQGLQ¡ NOLHQWLQLÐ-VHUYHULQLÐ VLVWHPÐ LG¡MD – centralizuotas
LQIRUPDFLMRV EDQNDV \UD VHUYHU\MH ³ NXU³ JDOL NUHLSWLV JUXS¡ NOLHQWLQLÐ NRPSLXWHULÐ
ServeryMH VDXJRPRV LQIRUPDFLMRV SRN\þLDL JUHLWDL SULHLQDPL NOLHQWLQLDPV
NRPSLXWHULDPV 3URJUDPLQ
³UDQJ NRPSLXWHU\MH-VHUYHU\MH OHLGåLDQþL SULH MR
prisijungti kompiuteriams-NOLHQWDPV YDGLQVLPH VHUYHULX R DQDORJLãN SURJUDPLQ

³UDQJQXWROXVLXRVHNRPSLXWHULXRVe – klientu. Serverio realizacija labai kebli, nes jis
WXULDSGRURWLGDXJHO³YLHQXPHWXDWHLQDQþLÐNOLHQWÐXåNODXVÐWDLSSDWOHLVWLNOLHQWDPV
³UDã\WLLQIRUPDFLM³VHUYHULRVDXJ\NODSVDXJRWLLQIRUPDFLMXåUDã\PRPHWX%HWR
kompiuteriai sistemoje gali EÌWLVNLUWLQJÐDUFKLWHNWÌUÐLUYDOGRPLVNLUWLQJÐRSHUDFLQLÐ
VLVWHPÐ26,QWHUQHWRGDO³–WLQNOZZZWDLSSDWJDOLPDODLN\WLNOLHQWLQH-serverine
VLVWHPD WLN GDU VXG¡WLQJHVQH QHV þLD YLVL NRPSLXWHULDL JDOL DWOLNWL WLHN NOLHQWR WLHN
serverio funkcijas (pDY\]GåLXLXåVDNDQWQDUã\NOHSUHNHVLQWHUQHWLQ¡MHSDUGXRWXY¡MH
Klientinis programavimas. Pirmosios sistemos serveris – QDUã\NO¡
IXQNFLRQDYRPDåGDXJWDLSVHUYHULVJHQHUXRMDVWDWLQLXVZZZSXVODSLXVQDUã\NOHLRãL
JDOL MXRV SDURG\WL 3XVODSLÐ NÌULPR NDOEa HTML (angl. Hyper-Text Markup
Language SDODLNR SDSUDVþLDXVLXV LQIRUPDFLMRV VXULQNLPR PHFKDQL]PXV WHNVWLQLXV
ODXNXV VUDãXV Y¡OLDY¡OHV LU SDQ NXULH OHLGåLD DWOLNWL GX YHLNVPXV LãWULQWL IRUPRV
duomenis (resetLUSDVLÐVWLVXULQNWXVGXRPHQLVVHUYHUiui apdoroti (submit). Serveryje
ãL XåNODXV DSGRURMD YLVÐ ZZZ VHUYHULÐ SDODLNRPD VVDMD &*, Common Gateway
Interface IDNWLãNDL WDL \UD VHUYHULR SURJUDPLQ¡V ³UDQJRV GDOLV 8åNODXVRV WHNVWDV
6
QXURGR &*, N GDU\WL VX DWVLÐVWDLV GXRPHQLPLV -XRV JDOL DSGRroti pati CGI
SURJUDPD NXUL GDåQLDXVLDL UDãRPD Perl kalba, tiesiogiai skirta tekstui apdoroti arba
peradresuoti kitai kompetentingai programai.
'DXJ ZZZ VHUYHULÐ LU ãLXR PHWX IXQNFLRQXRMD &*, SDJULQGX -Ð SDJULQGLQLV
WUÌNXPDV – našumo problemos. Šios probOHPRV VSUHQGLPR EÌGDV – programavimas
NOLHQWR PDãLQDL SDYHGDQW QDUã\NOHL YLV ³PDQRP GDUE NOLHQWR SXV¡MH 9LHQDV Lã
NOLHQWLQLR SURJUDPDYLPR EÌGÐ – SO¡WLQLÐ PRGXOLÐ QDUã\NO¡PV plug-ins) rašymas.
3O¡WLQ\V VXWHLNLD QDUã\NOHL SDSLOGRPDV IXQNFLMDV QXR WR PRmento, kai jis yra
³GLHJLDPDV )DNWLãNDL SO¡WLQLDL DWY¡U¡ NHOL NXUWL QDXMDV NOLHQWLQLR SURJUDPDYLPR
kalbas –YDGLQDPVLDVVFHQDULMÐNDOEDV7RNLDNOLHQWLQ¡SURJUDPDWLHVLRJ³WHUSLDPD³
+70/ SXVODS³ R M DSGRURMDQWLV PRGXOLV DXWRPDWLãNDL VXDNW\YLQDPDV SHUåLÌULQW
SXVODS³ /DELDXVLDL SDSOLWXVL VFHQDULMÐ NDOED PDW\W \UD JavaScript, palaikoma tiek
Internet Explorer, tiek Netscape NavigatorQDUã\NOLÐ7RNVVSUHQGLPDV\UDJUHLWDVLU
GDåQLDXVLDL QDXGRMDPDV JUDILQ¡PV YDUWRWRMR VVDMRPV *8, Graphical User
InterfaceSDWREXOLQWL/DLNRPD%(FNHOLVNDGWDLSLãVSUHQGåLDPD% klientinio
SURJUDPDYLPRXåGDYLQLÐ
/LNXVLHPV XåGDYLQLDPV GDEDU SRSXOLDULDXVLDV VSUHQGLPR ³UDQNLV \UD Java,
WXULQWLYLVDVVFHQDULMÐJDOLP\EHVLUHVDQWLYLVDYHUW¡GDXJLDVUDXW¡SURJUDPDYLPRkalba
VXLãSO¡WRWRPLVED]LQLRWLQNOLQLRSURJUDPDYLPRVVDMRPLVLãVNLUVW\WRVNDLþLDYLPREHL
U\ãLR VX GXRPHQÐ ED]¡PLV VVDMRPLV .OLHQWLQLV SURJUDPDYLPDV Java – tai
YDGLQDPÐMÐ NOLHQWLQLÐ SURJUDPÐ applets UDã\PDV .OLHQWLQ¡ SURJUDPD – paprastai
QHGLGHO¡SURJUDPDY\NGRPDQDUã\NO¡VYLGXMH3URJUDPD³NHOLDPDNDLSZZZSXVODSLR
GDOLV -³ VXDNW\YLQXV Y\NGRPD SURJUDPD âLÐ SURJUDPÐ SDWUDXNOL VDY\E¡ –
nepriklausomumas nuo kompiuterio platformos. Programos apdorojamos dviem
HWDSDLV SLUPLDXVLD NRPSLOLXRMDPRV ³ EDLWNRG EÌWHQW EDLWNRGDV LU QHSULNODXVR QXR
NRPSLXWHULR DUFKLWHNWÌURV EÌWHQW MLV VLXQþLDPDV WLQNOX QDUã\NOHL R M³ LQWHUSUHWXRMD
virtuali Java mašina (JVM, Java Virtual MachineNXULSDODLNRGDXJXPDQDUã\NOLÐ
-HLNOLHQWLQ
SURJUDPVXGDURNHOLPRGXOLDLNODV¡VWDLMRVLXQWLPXLWLQNOXSDJUHLWLQWL
YLVL PRGXOLDL VXJODXGLQDPL ³ YLHQ YDGLQDPM -$5 Java ARchive ULQNPHQ LU ML
VLXQþLDPD 6DXJXPR VXPHWLPDLV NOLHQWLQ¡V SURJUDPRV WXUL JULHåWXV DSULERMLPXV
darbui su klientinio kompiuterio ištekliais: pavyzGåLXLWRNLDSURJUDPDQHWXULSULHLWLHV
WHLVLÐSULHNOLHQWLQLRNRPSLXWHULRNLHWRMRGLVNRQHLVNDLW\WLQHL³UDã\WL
.LWDV NOLHQWLQLR SURJUDPDYLPR ³UDQNLV \UD Microsoft ActiveX technologija,
OHLGåLDQWL SULMXQJWL SURJUDPLQLXV PRGXOLXV SULH ZZZ SXVODSLR LU MXos vykdyti.
7
7HFKQRORJLM SDODLNR Internet Explorer ir Netscape Navigator QDUã\NO¡V ActiveX –
savarankiški programiniai komponentai, kuriami kompanijos Microsoft (MsSDVLÌO\WD
technologija COM (Common Object Model WROLDX Y\VWDQþLD REMHNWLQLR
programavimRLG¡MDV.RPSRQHQWDLJDOLEÌWLY\NGRPLWLNNLWÐDSOLNDFLMÐ-NRQWHLQHULÐ
YLGXMH LU SUDWXUWLQD MÐ IXQNFLQHV JDOLP\EHV 7RNLÐ NRQWHLQHULÐ SDY\]GåLDL \UD Ms
Visual Basic, Ms Access, Ms Internet Explorer ,ã NRPSRQHQWÐ NDLS Lã VWDW\ELQLÐ
EORNÐ JDOL EÌWL PRQWXRMDPRV LU NLWRV DSOLNDFLMRV 7DUNLPH NDWDORJÐ PHGåLXL
DWYDL]GXRWLNXULRMHQRUVJUDILQ¡MHDSOLNDFLMRMHJDOLPDUDVWLLUSDQDXGRWLGDXJHOLRILUPÐ
platinamus ActiveXNRPSRQHQWXVWDLSVXWDXSDQWSURJUDPXRWRMRODLN
²+70/SXVODS³WRNLHNRPSRQHQWDL³YHGDPLVDNLQyje <OBJECT!WXULQþLDPH
SDUDPHWUXV &/6,' XQLNDOLDP NRPSRQHQWR LGHQWLILNDYLPR QXPHULXL ³G¡WL LU
<CODEBASE> – komponento rinkmenos URL (Uniform Resource Locator, unikalus
rinkmenos adresas tinkle) adresui.
3DJULQGLQ¡SUREOHPDQDXGRMDQWActiveX komponentus HTML dokumentuose,
\UD NOLHQWR NRPSLXWHULR VDXJXPR XåWLNULQLPDV -HL NOLHQWLQ¡V SURJUDPRV G¡O VDYR
SULJLPWLHV QHJDOL SDGDU\WL åDORV NOLHQWXL WDL ActiveX NRPSRQHQWDL WXUL SULHLJ SULH
NOLHQWR NRPSLXWHULR DWPLQWLHV 6DXJXP VWHQJLDPDVL XåWLNULQWL QDXGRMDQW
NRPSRQHQWDPV VNDLWPHQLQLXV SDUDãXV ²GLHJLDQW QDXM NRPSRQHQW ³ NRPSLXWHU³
QDUã\NO¡GLDORJRODQJHXåNODXVLDYDUWRWRMRDUNRPSRQHQWUHLNLD³NHOWLDUQH/DQJH
QXURGRPDNDVVXNÌU¡NRPSRQHQWNDVSODWLQDNDVQXVWDW¡NRPSRQHQWRDXWHQWLãNXP
(viena tokiÐ RUJDQL]DFLMÐ LãGXRGDQþLÐ DXWHQWLãNXPR VHUWLILNDWXV \UD VeriSign,
www.verisign.com 0DW\W NLHNYLHQDP \UD WHN
PDW\WL WRNLXV ODQJXV ³GLHJLDQW
programas Windows genties OS.
Serverinis programavimas. .OLHQWÐ XåNODusos serveryje apdorojamos tam
tikromis programomis, tradiciškai CGI ir Perle 7DþLDX ZZZ-VHUYHULDL JDOL EÌWL
rašomi ir Java WRNLRV SURJUDPRV YDGLQDPRV VHUYHULQ¡PLV SURJUDPRPLV DQJO
servlets), ir naudojant Java serverinius puslapius (JSP, Java Server Pages).
3DJULQGLQLV WRNLÐ VSUHQGLPÐ SUDQDãXPDV \UD VHUYHULR QHSULNODXVRPXPDV QXR
NRPSLXWHULÐWLSR
6DYDUDQNLãNÐ SURJUDPÐ UDã\PDV -DYD Java – patogi programuoti kalba.
Teigiama, kad JavaSDUDã\WLSURJUDPJDOLPDGDXJJUHLþLDXQHL&NDOED(VPLQLV
Java trÌNXPDV ãLRMH VULW\MH – QDãXPDV *DOLPL SUREOHPRV VSUHQGLPR EÌGDL \UD WDP
WLNURV SDJUHLWLQDQþLRV WHFKQRORJLMRV hotspot JDOLP\E¡ QDXGRWL SURJUDPRMH NLWRPLV
NDOERPLVSDUDã\WXVPRGXOLXVJDOLP\E¡DWVLVDN\WLQHSULNODXVRPXPRQXRNRPSLXWHULÐ
8
DUFKLWHNWÌURV LU NRPSLOLXRWL SURJUDP WDP WLNULHPV NRPSLXWHULÐ WLSDPV 6SDUþLDL
HYROLXFLRQXRMDQWNDOEDLNLHNYLHQDDXNãWHVQ¡JavaYHUVLMDWDPSDYLVJUHLWHVQ¡
Trumpa Java istorija
1991 m. Sun Microsystems SUDG¡MR SURMHNW Green VNLUW EXLWLQ¡MH

elektronikoje naudojamiemV PLNURSURFHVRULDPV YDOG\WL 3URMHNWR UH]XOWDWDV WXU¡MR
EÌWL SURJUDPDYLPR NDOED QHSULNODXVDQWL QXR SURFHVRULDXV WLSR LU WLQNDQWL ³YDLULÐ
JDPLQWRMÐ WHFKQLNDL YDOG\WL 1HSDY\NXV SURMHNWR UHDOL]XRWL & NDOED SUDG¡WD NXUWL
nauja programavimo kalba Oak (1995 mSHUYDUG\WD³Java.DOERVNÌULPRJUXS¡MH
dirbo J. Goslingas (vadovas), P. Naughtonas, Ch. Warthas, E. Frankas ir
06KHULGDQDV 3LUPRML NDOERV YHUVLMD SDVLURG¡ P 3R NHOHULÐ PHWÐ SURMHNWDV
GreenXåVLEDLJ¡QHV¡NPHRMDPHGLUE
åPRQ¡V³NÌU¡Javasoft NRPSDQLMNXULWROLDX
W
V¡NDOERVWREXOLQLPRGDUEXV
.DLS WLN WXR PHWX SDSOLWR LQWHUQHWR ZZZ WLQNODV ³VLNÌU¡ Netscape
Communications NRPSDQLMD .DGDQJL LQWHUQHWDV VXVLGHGD Lã GDXJ\E¡V VNLUWLQJRV
DUFKLWHNWÌURVNRPSLXWHULÐVXVNLUWLQJDLVSURFHVRULDLVLUYDOGRPÐVNLUWLQJÐRSHUDFLQLÐ
VLVWHPÐYLHQDDNWXDOLDXVLÐSUREOHPÐWDPSDLQWHUQHWXLVNLUWÐSURJUDPÐPRELOXPDV7D
SDWLSURJUDPDWXULEÌWL³Y\NGRPDLUIntel, Macintosh81,;NRPSLXWHULÐWLSDPVâLRV
SULHåDVW\VO¡P¡NDGJavaLãSUDGåLÐVXNXUWDSDQDãLRPVSUREOHPRPVVSU
VWLEXLWLQ¡MH
HOHNWURQLNRMHSDVXNR³WRNLÐSDWSUREOHPÐVSUHQGLPLQWHUQHWH
$XWRULDL VXWHLN¡ Java GDXJHO³ & LU & NDOEÐ EUXRåÐ NDG GDXJHOLV ãLRPLV
NDOERPLVSURJUDPXRMDQþLÐåPRQLÐQHVXQNLDLJDO¡WÐ³VLVDYLQWLQDXMNDOE7DþLDXNDL
kurie gilumLQLDLNDOERVPHFKDQL]PDLYLVLãNDLVNLUWLQJLWRG¡ONODLGLQJD\UDQXRPRQ¡
kad Java –WDL&LQWHUQHWLQ¡YHUVLMD%HWRJavaLUQ¡UDVNLUWDNRQNXUXRWLVX&LU
JDOLDXVLDL M SDNHLVWL WDL YLVÐ SLUPD QXR NRPSLXWHULÐ DUFKLWHNWÌURV QHSULNODXVRPD
SURJUDPÐLQWHUQHWXLNÌULPRNDOED
'DEDUNHOLRVSDVWDERVG¡OJava ir JavaScriptNDOEÐNDGSDQDãLDLVNDPEDQW\V
SDYDGLQLPDL QHVXGDU\WÐ ³VSÌGåLR MRJ WDL JLPLQLQJRV NDOERV Netscape
Communications VXNÌU¡ QHVXG¡WLQJ VFHQDULMÐ NDOE LiveScript OHLGåLDQþL ³WHUSWL
nesud¡WLQJDV SURJUDPDV WLHVLRJ ³ +70/ GRNXPHQWR WHNVW LU LãSO¡VWL VWDQGDUWLQHV
+70/JDOLP\EHV7DLJLWRNLDNDOED\UDJODXGåLDLVXVLMXVLVX+70/NDOEDLUJDOLEÌWL
9
vykdoma tik su naršykle. Panašios yra Visual Basic Script, AppleScript VFHQDULMÐ
kalbos. Paplitus Java, Sun Microsystems sutikus, Netscape Communications
SHUYDUGLMR VDYR NDOE ³ JavaScript. Taigi Java ir JavaScript JHQH]¡ \UD YLVLãNDL
skirtinga.
3DJULQGLQLDLNDOERVEUXRåDL
1. Java – objektiškai orientuota kalba. Visi Java programos duomenys yra

objektai, išskyrus tik primityviuosius aritmetinius, simbolinius ir loginius
GXRPHQLV 7DþLDX LU WRNLHPV GXRPHQLPV \UD NODV¡V – kevalai, kad
SULUHLNXVEÌWÐJDOLPDMDLVRSHUXRWLNDLSREMHNWDLV
2. *ULHåWDLWLSL]XRWDNDOED.LHNYLHQDVREMHNWDVWXULJULHåWDLQXVWDW\WWLS
3. 9LHQNDPLHQLV SDYHOGLPXPDV 'DXJ\ELQLR SDYHOGLPXPR NXU³ SDODLNR
C++, JavaNDOERMHQ¡UD7DPWLNUSDQDãXPVXDQDORJLãND&JDOLP\EH
XåWLNULQD WLN VVDMÐ NODVLÐ SDþLÐ DEVWUDNþLDXVLÐ NODVLÐ PHFKDQL]PDV
Visos JavaNODV¡VSDYHOGLNODV¡VObject savybes.
4. Java SDWL VNLULD GLQDPLQ
DWPLQW³ REMHNWDPV LU SDWL M LãODLVYLQD NDL
REMHNWDVQHEHWXULQ¡YLHQRV³VDYHQXNUHLSWRVURG\NO¡VNLWDLS– nuorodos).
âLXRV YHLNVPXV DWOLHND PHFKDQL]PDV ÄãLXNãOLÐ ULQNWXYDV³ garbage
collector), tam tikrais momentais peråLÌU¡GDPDV SURJUDPRV XåLPDP
DWPLQW³ 3DþLRV URG\NO¡V SURJUDPXRWRMXL Q¡UD SULHLQDPRV 2EMHNWDL
GLQDPLãNDL VDXJRPL DWPLQWLHV VULW\MH YDGLQDPRMH ÄNUÌYD³ heap). Toks
atminties mechanizmas – viena iš JavosO¡WXPRSULHåDVþLÐ
5. Java WXUL SDWRJÐ REMHNWLãNDL RULHQWXRWR VWLOLDXV PHFKDQL]P SURJUDPRV
Y\NG\PR NODLGRPV DSGRURWL 9LVRV WRNLRV NODLGRV JDOL EÌWL DSGRURWRV
SDþLRVSURJUDPRV
6. Java –GDXJLDVUDXW¡NLWDLS–GDXJLDJLM¡multi-threadedNDOEDOHLGåLDQWL
UDã\WLSURJUDPDVYLHQXPHWXY\NGDQþLDVNHOLVVUDXWXVWRje pat programos
DGUHVLQ¡MHHUGY¡MH<UDVUDXWÐVLQFKURQL]DYLPRLUWDUSVUDXWLQLREHQGUDYLPR
JDOLP\E¡V
7. 1HSULNODXVRPXPDV QXR NRPSLXWHULÐ SODWIRUPRV Java programos
DSGRURMDPRV GYLHP HWDSDLV NRPSLOLXRMDPRV ³ WDUSLQ³ NRG – EDLWNRG
10
(baitkodas nepriklauso nuo kompiuterio platformos), o šis
interpretuojamas virtualios Java mašinos JVM.
8. Saugumas. Java NOLHQWLQ¡V SURJUDPRV QHWXUL SULHLWLHV SULH NOLHQWLQLR
NRPSLXWHULRDWPLQWLHVVDNRPDNDGMLHY\NGRPLQDUã\NO¡VÄVP¡OLRG¡å¡MH³
– yra tam net specialus angliškas terminas sandboxing<UDLUÄSDWLNLPÐ³
VNDLWPHQLQLX SDUDãX DSUÌSLQWÐ NOLHQWLQLÐ SURJUDPÐ QHWXULQþLÐ WRNLÐ
ULERMLPÐ 3DQDãLDL QLHNR NHQNVPLQJR VHUYHULR PDãLQDL QHJDOL SDGDU\WL LU
ÄQHSDWLNLPRV³VHUYHULQ¡VSURJUDPRV
Java programavimo instrumentai
KompiOLDWRULÐ LQWHUSUHWDWRULÐ Java ED]LQHV NODVHV NOLHQWLQLÐ SURJUDPÐ

SHUåLÌU¡MLPREHQDUã\NO¡VSDJDOERV³UDQN³SURJUDPRVGRNXPHQWDFLMRV+70/IRUPDWH
³UDQN³ LU NLWDV SULHPRQHV JDOLPD QHPRNDPDL SDUVLVLÐVWL Lã www.javasoft.com
tinklapio. Šiuo metu Windows aplinkai platinamas paketas J2SE SDK 5.0 (Java 2
Standard Edition, Software Development Kit PDåGDXJ 0% DSLPWLHV 7R SDWLHV
komplekto su integruota programavimo terpe NetBeans apimtis – jau per 90 MB.
Norint kurti LUGHULQWLVHUYHULQHVSURJUDPDVWHNVSDUVLVLÐVGLQWLJHURNDLGLGHVQ³SDNHW
J2EE 1.4 SDK (Java 2 Enterprise Edition) – per 110 MB apimties. Šiame pakete yra
Sun serveris – NRQWHLQHULV VHUYHULQ¡PV SURJUDPRPV ³UDQNLV MRPV GHULQWL LU GDXJ\E¡
NLWÐSULHPRQLÐ
9LHQR DU NLWR SDNHWR ³GLHJLPR LQVWUXNFLMD SDWHLNLDPD PLQ¡WDPH WLQNODS\MH
3DWLNULQWL ³GLHJLP JDOLPD OHLGåLDQW WDPH SDþLDPH SDNHWH DEMO DSODQNH HVDQþLDV
demonstracines programas. Jei kompiuteryje nepavyks paleisti kompiliatoriaus,
interpretatoriaus ar kOLHQWLQLÐSURJUDPÐSHUåLÌURV³UDQNLRWLQNDPDLSDJDOLQVWUXNFLMDV
SDSLOG\NLWHVDYRNRPSLXWHULR26DSOLQNRVNLQWDPM³PATH bei CLASSPATH.
3DJULQGLQLDL³UDQNLDLEHNXULÐQH³PDQRPDVãLVSDVNDLWÐNXUVDV\UDãLH
- javac –NRPSLOLDWRULXV³EDLWNRG
- java – interpretatorius, JVM - Java virtuali mašina;
- appletviewer – NOLHQWLQLÐ SURJUDPÐ SHUåLÌURV EH QDUã\NO¡V SDJDOERV
³UDQNLV
- servletrunner –VHUYHULQLÐSURJUDPÐSDOHLGLPR³UDQNLV
11
âLÐ³UDQNLÐQDXGRMLPDVDSUDã\WDVWHNVWH
Kurse naudosime Java NODVHVLããLÐNODVLÐSDNHWÐ
- java.lang –ED]LQLÐNDOERVNODVLÐSDNHWDV
- java.io – Javos³YHVWLHVLULãYHVWLHVNODVLÐSDNHWDV
- java.util –SDJDOELQLÐJavaNODVLÐSDNHWDV
- java.awt, java.awt.event – Java³Y\NLÐDSGRURMLPRNODVLÐSDNHWDL
- java.net –NODVLÐGDUEXLVXWLQNOXUHDOizuoti paketas;
- javax.swing –SDNHWDVJUDILQ¡PVYDUWRWRMRVVDMRPVNXUWL
- javax.servlet, javax.servlet.http – SDNHWDL VHUYHULQLÐ SURJUDPÐ NÌULPR
NODV¡PV
12
1. J A V A E L E M E N T A I
âLDPH VN\ULXMH SDWHLNLDPD HOHPHQWDULÐ åLQLÐ DSLH SURJUDPDYLP Java, kad

EÌWÐ JDOLPD VXSUDVWL SDSUDVþLDXVLXV VDYDUDQNLãNÐ SURJUDPÐ LU NOLHQWLQLÐ SURJUDPÐ
SDY\]GåLXV
1.1. Kalbos konstrukcijos
Kalbos konstrukcijos sudaroPRVLãOHNVHPÐ–VLPEROLÐJUXSLÐWXULQþLÐ

HOHPHQWDULUHLNãP

- LGHQWLILNDWRULÐ–NODV¡PVPHWRGDPVNODVLÐODXNDPVDUNLQWDPLHVLHPV
³YDUG\WL.RQVWUXRMDPLLãPDåÐMÐLUGLGåLÐMÐUDLGåLÐVNDLWPHQÐVLPEROLÐ
LUB6NDLWPHQ\VQHJDOLSUDG¡WLLGHQWLILNDWRriaus;
- UDNWLQLÐåRGåLÐ
- OLWHUDOÐ–VLPEROLÐJUXSLÐGXRPHQÐUHLNãP¡PVSHUGXRWLNLWRVHNDOERVHMLH
GDåQDLYDGLQDPLÄNRQVWDQWRPLV³
- RSHUDFLMÐåHQNOÐ
- VNLUWXNÐ– () [] {} ; , . ;
- NRPHQWDUÐ–HLOXWLQLDLNRPHQWDUDLSUDGHGDPLQXREHWNXULRVHLOXW¡VYLHWRV
raãRPLSRVLPEROLÐ.HOLÐHLOXþLÐNRPHQWDUDLDSLPDPLWRNLDLV
NRPHQWDUÐVNOLDXVWDLV NRPHQWDUÐHLOXW¡V */.
2EMHNWÐNÌULPDVLUGDUEDVVXMDLV
Java – „gryna“ objektiškai orientuoto programavimo (OOP) kalba. Pagrindinis

kodo elementas – NODV¡ WLHVLRJLQH SUDVPH SURJUDPRV DUED PRGXOLR VYRNÐ NDOERMH
Q¡UD 7DþLDX NDUWDLV SDVNDLWÐ NXUVH YLV NRPSLOLDYLPXL DWLGXRGDP NRG WLNVOXV
terminas – kompiliavimo vienetas) vadinsime programa.
Viskas, išskyrus primityviuosius duomenis, kode yra objektai: ir
pURJUDPXRWRMR VXNXUWL QDXML GXRPHQÐ WLSDL – NODV¡V LU SURJUDPRV Y\NG\PR PHWX
JHQHUXRMDPRVLãLPW\VLUSURJUDPRVY\NG\PRO\JLDJUHWÌVVUDXWDL,USULPLW\YLHVLHPV
GXRPHQLPV \UD NODV¡V-NHYDODL NDG EÌWÐ JDOLPD MDLV PDQLSXOLXRWL NDLS LU YLVDLV
objektais.
ObjektRLGHQWLILNDWRULXVLãHVP¡V\UDURG\NO¡QXRURGD³REMHNW3DY\]GåLXL
String s; –VXNXULDPDURG\NO¡³StringWLSRREMHNWMLQHQXWDLN\WD³MRN³
REMHNW WRG¡O WXUL UHLNãP
null LU MDL QHJDOLPD SDVLÐVWL MRNLR
pranešimo – bus deklaruota kompiliavimo klaida.
String s = new String( “abc” ); – þLD RSHUDWRULXV new VXNXULD LU SDW³
REMHNW LU QXWDLNR URG\NO
³ REMHNWR
DWPLQWLHVVULWLHVSUDGåL
String s = “abc”; – šiam vidiniam Java GXRPHQÐ WLSXL

galimas toks supaprastinimas.
13
Visi objektai saugomi kompiuterio operatyviosios atminties srityje heap.
.RPSLOLDWRULXVQHåLQRQHLNRNLHREMHNWDLEXVVXNXUWLNRGRY\NG\PRPHWXQHLNLHNMÐ
bus. Atmintis objektams skiriama dinamiškai, kodo vykdymo metu operatoriaus –
metodo-konstruktoriaus new pagalba. Tai – lanksti VLVWHPDWDþLDXO¡WD
,ãSURJUDPRVQH³PDQRPDNUHLSWLV³NRPSLXWHULRUHJLVWULQ
DWPLQW³SURFHVRULDXV
YLGXMHDU³G¡NOLQ
DWPLQW³stackRSHUDW\YLRMRMHDWPLQW\MH7DþLDXNRPSLOLDWRULXVJDOL
VXG¡WL³G¡NOLQ
DWPLQW³URG\NOHV³REMHNWXV
Jei objektas ar kuris nors jo laukas yra statinis – deklaruotas su
modifikatoriumi static MLV GHGDPDV ³ YDGLQDPM VWDWLQ
RSHUDW\YLRVLRV DWPLQWLHV
WDOS\NO – YLVR NRGR Y\NG\PR PHWX GXRPHQLXL VNLUWRML DWPLQWLV \UD DSLEU¡åWRMH
operatyviosios atminties vietoje.
1.3. Primityvieji duomenys
Java WXULWRNLXVSULPLW\YLXRVLXVGXRPHQÐWLSXVSDYDGLQLPDVGXRPHQVLOJLV

HVPLQ¡VFKDUDNWHULVWLNRVNODV¡V-kevalo pavadinimas):
Loginiai boolean 1B Boolean
Simboliniai char 2B Unicode simboliai Character

åUwww.unicode.org)
Aritmetiniai: kitimo diapazonas

sveikieji byte 1B –128 – +127 Byte
short 2B –32768 – +32767 Short
int 4B ~–2*10e9 – ~+2*10e9 Integer
long 8B ~–9*10e18 –
~+9*10e18 Long
realieji float 4B pagal IEEE754
standart Float
double 8B pagal IEEE754
VWDQGDUW Double
9LVLDULWPHWLQLDLGXRPHQ\VWXULåHQNO
6WDQGDUWDV ,((( UHDOL]XRWDV GDXJHO\MH SURJUDPDYLPR NDOEÐ QXVWDWR
WRNLDVUHDOLÐMÐVNDLþLÐFKDUDNWHULVWLNDVYLHQJXERWLNVOXPRGXRPHQÐWLNVOXPDV yra 6–
7 reikšminiai skaitmenys, kitimo diapazonas yra iki ~+/–H PDåLDXVLD VNLUWLQJD
QXR PDãLQRV QXOLR UHLNãP¡ \UD a–10e–38. Dvigubo tikslumo duomenims
analogiškos charakteristikos: 15– UHLNãPLQLÐ VNDLWPHQÐ a–10e308 ir ~+/–10e–
308.
$WLWLQNDPÐWLSÐOLWHUDODLXåUDãRPLWDLS
boolean JDOLPRVUHLNãP¡Vtrue arba false

byte, short, int SDY\]GåLXL 123
0123 –GXRPXRDãWXQWDLQ¡MHVLVWHPRMH
0x123 arba 0X123 – duomuo
ãHãLROLNWDLQ¡MHVLVWHPRMH
long SDY\]GåLXL 123456789l arba 123456789L
14
float SDY\]GåLXL 1.2f arba 1.2F, arba eksponentine
forma 1.2e0f, 12e-1f ir pan.
double SDY\]GåLXL 1.2 arba 1.2d ar 1.2D, arba eksponentine
forma 1.2e0 ir pan.
char VLPEROLÐ UHLNãP¡V DSLPDPRV µ µ Specialieji simboliai
XåUDãRPL WDLS QDXMD HLOXW¡ – \n , ‘ – \’ , \ – \\ ,
tabuliatorius – \t ir t. t.
'DåQDL SULH SULPLW\YLÐMÐ GXRPHQÐ SULVNLULDPD LU Java YLGLQ¡ NODV¡ String -
HLOXWLQLRWLSRGXRPXR-RVOLWHUDODVXåUDãRPDVWDUSDQJOLãNÐNDEXþLÐVLPEROLÐ³³
7DLJLYLHQVLPERO³NRGHJDOLPDVDXJRWLLUNDLSSULPLW\YÐM³GXRPHQ³char, ir
NDLSNODV¡VCharacterREMHNW
char c = ‘a’;
Character cClass = new Character( ‘a’);
Java turi klases BigInteger ir BigDecimal su metodais, skirtais operuoti bet

NRNLRWLNVOXPRVYHLNDLVLDLVLUUHDOLDLVLDLVVNDLþLDLV
,GHQWLILNDWRULÐPDWRPXPRVULW\V
$QJOLãNDL WDL YDGLQDPD YLHQX åRGåLX scope. 6ULWLV DSLEU¡åLD WLHN YDUGR
PDWRPXP WLHN LU MR J\YDYLPR ODLN )DNWLãNDL þLD DSWDULDPD PDWRPXPR VULWLV
metoduose aSLEU¡åWLHPV YDUGDPV NODVLÐ NÌQXRVH DSLEU¡åWÐ YDUGÐ VULW\V SDNOÌVWD
VSHFLDOLHPVPRGLILNDWRULDPVSDY\]GåLXLpublic ar privateNXULHEXVDSWDUWLY¡OLDX
0DWRPXPRVULW³DSLEU¡åLDVNOLDXVWDL{ }.
3DY\]GåLXL
{ int x = 1;
þLD[\UDPDWRPDVLUSULeinamas
{ int y = 2;
þLDPDWRPL[LU\
}
þLDPDWRPDV[R\QHPDWRPDV
}
þLDQHPDWRPLQHL[QHL\
Java QHOHLGåLD ³G¡WLQ¡MH YLGLQ¡MH PDWRPXPR VULW\MH QDXGRWL WR SDWLHV YDUGR
3DY\]GåLXLWDL\UDNODLGLQJDVIUDJPHQWDV
{ int x = 1;
{ int x = 2; } }
Matomumo sritis objektams:
{ String s = new String( “abc” ); }
15
PDWRPXPRVULWLHVSDEDLJDýLDQHEHOLNVURG\NO¡VVWDþLDXREMHNWDV³NXU³
DQNVþLDX URG¡ URG\NO¡ LãOLHND -DP VNLUWD DWPLQWLV EXV JUåLQWD RSHUDFLQHL Vistemai
WLN SR WR NDL VDYR GDUE DWOLNV ÄãLXNãOLÐ ULQNWXYDV³ SHULRGLãNDL SHUåLÌULQWLV NRGXL
VNLUWDWPLQW³LUVXUHQNDQWLVDWPLQW³REMHNWÐ³NXULXRVQHURGRMRNLDQXRURGD
.ODV¡V
.ODV¡GHNODUXRMDPD
[modifikatorius ]class AclassName { NODV¡VNÌQDV }
.ODV¡VREMHNWDVSDY\]GåLXLYDUGXÄc“, sukuriamas metodu-konstruktoriumi:
AClassName c = new AClassName( );
.ODV¡VNÌQHJDOLEÌWLNODV¡VNLQWDPLHML–ODXNDLLUPHWRGDL6XNÌUXVREMHNWMR
laukais operuojama taip:
class DataOnly {
int i;
float f;
}
...
DataOnly d = new DataOnly( );
d.i = 1;
d.f = 1.2f;
...
-HL NODV¡V ODXNDV \UD NLWRV NODV¡V REMHNWDV WDL ãLR ODXNDV LãVNLULDPDV WROLDX
W
VLDQWÄWDãNLQ
³DGUHVDFLM
d.i.a = . . .
ir t. t.
-HL NODV¡V ODXNDPV – primityvams rHLNãP¡V Q¡UD SULVNLUWRV SDJDO QXW\O¡MLP
MLHPV VXWHLNLDPRV QXOLQ¡V UHLNãP¡V boolean primityvui – UHLNãP¡ false 7DþLDX
lokaliems metoduose deklaruotiems laukams –SULPLW\YDPVUHLNãP¡VWRNLXEÌGXQ¡UD
skiriamos.
Metodas deklaruojamas:
>PRGLILNDWRULÐ VUDãDV@ JUåLQDPRV UHLNãP¡V WLSDV_void YDUGDV >DUJXPHQWÐ

VUDãDV@^ PHWRGRNÌQDV `
0HWRGRNÌQXåEDLJLDRSHUDWRULXVreturn>JUåLQDPDUHLNãP¡@.DLPHWRGDV
QHJUåLQD MRNLRV UHLNãP¡V W \ GHNODUXRWDV VX UDNWDåRGåLX void), return QHEÌWLQDV.
Metodas „m“ objektui „o³NYLHþLDPDVDUEDWDLS
16
o.m( ); // –NDLPHWRGDVQHJUåLQDMRNLRVUHLNãP¡V
DUEDWXULEÌWLNLWRRSHUDWRULDXVGDOLPLMHLUHLNãP
SDY\]GåLXL, floatWLSRJUåLQD
float f = o.m( );
6WDWLQLDLNODVLÐODXNDLLUPHWRGDL
-HL NXULRV QRUV NODV¡V YLVÐ REMHNWÐ NXULV QRUV ODXNDV \UD EHQGUDV YLVLHPV
REMHNWDPV LU WXUL VDXJRWL WRNL SDþL UHLNãP
MLV GHNODUXRMDPDV VX PRGLILNDWRULXPL
static. Tokie laukai kitaip nei dinaminiai laukai saugomi atmintyje ir kitaip jiems
priskiriamoV SUDGLQ¡V UHLNãP¡V LãVDPLDX WDL DLãNLQDPD NDOEDQW DSLH PHWRGÐ –
NRQVWUXNWRULÐDWOLNLPRWYDUN3DY\]GåLXL
class StaticField {
static int i = 1;
}
...
StaticField sf1 = new StaticField( ),
sf2 = new StaticField( );
Dabar sf1.i ir sf2.iWXULWRNLSDWUHLNãP

LU\UDWRMHSDWDWPLQWLHVVULW\MH²WRN³
ODXNJDOLPDNUHLSWLVWLHNREMHNWRWLHNNODV¡VYDUGXsf1.i arba StaticField.i .
3DQDãLDL \UD VX VWDWLQLDLV PHWRGDLV MXRV JDOLPD NYLHVWL WLHN NRQNUHþLDP
objektui, tiek klasei:
class StaticMethod {
static void incr( ) {
StaticField.i++ ;
}
}
...
StaticMethod sm = new StaticMethod( );
sm.incr( );
StaticMethod.incr( ); // alternatyvi kvietimo forma
9HLNVPÐRSHUDWRULDL
<UDDULWPHWLQLÐYHLNVPÐRSHUDWRULDL+, – ,* , /, % (dalybos likutis).

Prieskyros operatoriai: =, +=SULHHVDPRVUHLNãP¡VSULG¡WLNLWRVSULHVN\URV
skirtos panašiems dalykams), –=, *=, /=, %= HVDP UHLNãP
SDNHLVWL OLNXþLX
3DY\]GåLXL
...
int i, j = 2;
i = (j+=2)*(j+3);
System.out.println( “j=”+j+”i=”+i ); // bus spausdinama j=4 i=28
17
...
3ULHDXJLRLUPDåLQLPRYHLNVPÐRSHUDWRULDL++, – –. Abiem operatoriams yra

pre- ir post- IRUPRV *DOL EÌWL WDLNRPL EHW NXULDP WLN QH boolean tipo) primityvui:
VYHLNLHVLHPV GXRPHQLPV YHLNVPR åLQgsnis yra 1, realiesiems – 1.f ir 1.d,
simboliniams –YLHQDVVLPEROLVSDJDOVLPEROLÐHLO¡VWYDUN3DY\]GåLXL
...
int i, j, k;
i = 1;
j = i++; // j=1: pirma atliekama prieskyra, paskui – prieaugio operacija
// (post- forma)
k = ++i; // k=3 – prieaugio pre- forma
...
6DQW\NLRYHLNVPÐRSHUDWRULDL= =, !=, >, <, >=, <=.

Loginiai operatoriai: && (login¡ GDXJ\ED || ORJLQ¡ VXG¡WLV 9HLNVPDL
DWOLHNDPL QDXGRMDQW ÄWUXPSM DWOLNLPR VFKHP³ MHL SLUPRMR YHLNVPR RSHUDQGR
UHLNãP¡QXOHPLDYLVRYHLNVPRUHLNãP
DQWURMRRSHUDQGRUHLNãP¡QHEHVNDLþLXRMDPD
%LWLQLRVXO\JLQLPRLUELWLQLRSHUVOLQNLPRYHLNVPDL/LN
JavaQXRWÐODLNÐNDL
NDOEDEXYRRULHQWXRMDPDHOHNWURQLNRV³UHQJLQLDPVYDOG\WLWRG¡OþLDMÐQHQDJULQ¡VLPH
Visi veiksmai atliHNDPL SDJDO YHLNVPÐ Y\UHVQXPR WYDUN 7DþLDX SDWRJLDX

YHLNVPÐDWOLNLPRWYDUNUHJXOLXRWL³UDãDQW³UHLãNLQLXVVNOLDXVWXV
3URJUDPXRMDQWDULWPHWLQLXVUHLãNLQLXVEÌWLQDWXU¡WLJDOYRMHLUYLHQQHPDORQL
Java \SDW\E
MHL ³Y\NVWD SHUSLOG\PDV ãL LãLPWLQ¡ VLWXDFLMD Q¡UD GHNODUXRMDPD WLN
SDNHLþLDPDVGXRPHQVåHQNODVLULPDPDNLWRNLDJDQDVXG¡WLQJDLDSLEU¡åLDPDGXRPHQV
UHLNãP¡
,ãYHVWLV³SXOW
Tam naudojamas metodas println( ):
System.out.println( String s );
3DY\]GåLDL
System.out.println( “Row Number” ); // arba

...
String s1 = “Row”,
s2 = “ Number”;
System.out.println( s1+s2 ); // konkatenacija –WHNVWLQLÐGXRPHQÐVXMXQJLPDV
...
int x = 3,
y = 4;
6\VWHPRXWSULQWOQ [ [ DXWRPDWLãNDL EXV SHUYHVWDV ³ 6WULQJ WLS W y.
automatiškai taikomas metodas toString( ).
Spausdins: 3 */
18
6\VWHPRXWSULQWOQ[\ LãSUDGåLÐEXVVXVNDLþLXRWDVDULWPHWLQLVUHLãNLQ\V
WDLS \UD WRG¡O NDG RSHUDWRULXV MXQJLD
aritmetinius duomenis ir yra interpretuojamas
NDLSVXG¡WLHVRSHUDWRULXVWDGDJDXWDUHLNãP¡EXV
SHUYHVWD³6WULQJWLS6SDXVGLQV
System.out.println( “Sum of x and y is: “+x+y ); /* Spausdins:
Sum of x and y is: 34
7DLS\UDWRG¡ONDGSLUPDVLVRSHUDWRULXVMXQJLD
6WULQJ WLSR EHL DULWPHWLQ³ GXRPHQLV LU \UD
interpretuojamas kaip sujungimo operatorius, o jo
GDUER UH]XOWDWDV EXV 6WULQJ WLSR UHLNãP¡ 7ROLDX
DQDORJLãND VLWXDFLMD SDVLNDUWRV GDU NDUW LU
galutinis rezultatas bus gautas toks, koks
SDURG\WDV DXNãþLDX 1RULQW JDXWL DWVSDXVGLQW
WLNU DULWPHWLQLR UHLãNLQLR UH]XOWDW DULWPHWLQ³
UHLãNLQ³UHLNLDDSVNOLDXVWL«[\«
Yra ir analogiškas metodas print( ),QHODXåLDQWLVHLOXþLÐ
System.out.print( “Ja” );
System.out.print( “va” ); // spausdins: Java
6SHFLDOLHML VLPEROLDL LãYHVW\MH SDY\]GåLXL QDXMRV HLOXW¡V simbolio \n

veikimas:
System.out.println( “First row \n Second row” ); /* spausdins:

First row
Second row */
Analogiškai veikia ir kiti specialieji simboliai, esantys String tipo literaluose

ar reiškiniuose.
3DSUDVþLDXVLÐDXWRQRmiškos programos ir
NOLHQWLQ¡VSURJUDPRVSDY\]GåLDL
class FirstApplication{
public static void main( String [ ] args ) {
System.out.println( “The first application” );
}
}
âLSURJUDPD³SXOWRHNUDQLãYHGDWHNVW³The first application”.
Programos paleidimo etapai:

1. $WVSDXVGLQXV SURJUDPRV WHNVW SDY\]GåLXL SDSUDVWX UHGDNWRULXPL
Notepad SDWDOSLQWL SURJUDPRV WHNVW ³ DSODQN LãRULQ¡MH DWPLQW\MH
SDWRJLDXVLD ³ DWVNLU SURJUDPDL VNLUW DSODQN YDUGX
19
FirstApplication.java. KrHLSWL G¡PHV³ ³ GLGåLVLDV LU PDåVLDV UDLGHV –
Java kompiliatorius jas skiria. 9¡OLDX PDW\VLPH NDG QHSDVNHOEXV
VWDUWLQ¡VNODV¡VW\NODV¡VNXULRMH\UD metodas main) vieša – public,
ULQNPHQRVYDUGJDOLPDSDULQNWLLUVNLUWLQJQXRVWDUWLQ¡VNODV¡Vvardo.
2. run ir commandNRPDQGRPLVSDOHLVWLSXOWcdNRPDQGDSHUHLWL³DSODQN
NXULDPH \UD SURJUDPRV SUDGLQ¡ ULQNPHQD LU SDOHLVWL Java NRPSLOLDWRULÐ
javac:
javac FirstApplication.java
6XNRPSLOLXRWD ULQNPHQD DLãNX MHL WLN WHNVWH QHEXYR VLQWDNV¡V NODLGÐ

³UDãRPD³WSDW³DSODQNWXRSDþLXYDUGXVXSO¡WLQLXclass.
3URJUDPD SDOHLGåLDPD NUHLSLDQWLV ³ -90 LQWHUSUHWDWRULÐ java VX VWDUWLQ¡V
NODV¡VYDUGX
java FirstApplication
Pastabos. Java NRGDV VXVLGHGD Lã NODVLÐ ýLD YLHQLQWHO¡MH NRGR NODV¡MH Q¡UD
SDVNHOEWDMRNLÐODXNÐ
²¡MLPR WDãNDV ³ SURJUDP – metodas main SHU DUJXPHQWÐ VUDã JDXQDQWLV
HLOXW¡V WLSR YLHQPDW³ PDV\Y args – SURJUDPRV SDOHLGLPR Lã SXOWR NRPDQGLQ¡MH
HLOXW¡MH SR NRPDQGRV java FirstApplication QXURG\WXV HLOXWLQLXV GXRPHQLV ýLa
WRNLÐGXRPHQÐQ¡UDPDV\YDVOLHNDWXãþLDV0HWRGDVWXULEÌWLpublic – viešas, statinis
– staticLUQHJUåLQDMRNLRVUHLNãP¡V– void.
0HWRGH NUHLSLDPDVL ³ LãYHVWLHV PHWRG println .UHLSLDQWLV ³ Java vidinius
PHWRGXV UHLNLD åLQRWL MÐ YLHW Java YDUGÐ HUGY¡MH 3LOQDV println vardas yra
java.lang.System.out.println. Paketo, kuriame saugomi sisteminiai Java dalykai, –
java.lang YDUGR QXURG\WL QHEÌWLQD âLV SDNHWDV DXWRPDWLãNDL LPSRUWXRMDPDV ³ YLVDV
SURJUDPDVâLDPHSDNHWH\UDNODV¡System, turinti PrintStream NODV¡VWLSRODXNout, o
NODV¡ PrintStream WXUL VWDWLQ³ PHWRG println WRG¡O GDåQLDXVLDL MLV NDLS þLD
NYLHþLDPDVNODV¡VYDUGX
/\JLDLWSDW³DWOLHNDQþLRVNOLHQWLQ¡VSURJUDPRVDQJOapplet) pavyzdys:
import javax.swing.*;
public class FirstApplet extends JApplet{
public void init(){
System.out.println( “The first applet” );
}
}
7DL ÄGLUEWLQ¡³ NOLHQWLQ¡ SURJUDPD QHV WRNLRV SURJUDPRV \UD VNLUWRV QH
VSDXVGLQWL ³ SXOWR HNUDQ R QDUã\NO¡V URGRPDP +70/ SXVODSLXL SUDWXUWLQWL
SpausdiQLPDV ³ SXOW þLD EÌWÐ SDWHLVLQDPDV QHEHQW GHULQLPR VWDGLMRMH ãLDLS MDX
UHLN¡WÐSDVLWHONWLLãNOLHQWLQ¡VSURJUDPRVVXSHUNODV¡VSDYHOGLPXVPHWRGXVJUDILQLDPV
elementams išvesti.
.OLHQWLQ¡VSURJUDPRVSDOHLGLPRHWDSDL
1. ²UDã\WLSURJUDPRVWHNVWYDUGXFirst Applet.java³DWVNLUDSODQN
20
2. 6XNRPSLOLXRWLWHNVWNRPDQGDjavac FirstApplet.java.
3. ² W SDW³ DSODQN ³UDã\WL +70/ ULQNPHQ NXULRMH NUHLSLDPDVL ³ NOLHQWLQ

SURJUDP
<HTML>
<HEAD>
<TITLE> APPLET FirstApplet</TITLE>
</HEAD>
<BODY>
<APPLET CODE = FirstApplet WIDTH = 100 HEIGHT =100 >
</APPLET>
</BODY>
</HTML>
+70/ NDOED QHVNLULD GLGåLÐMÐ LU PDåÐMÐ UDLGåLÐ QHNUHLSLD G¡PHVLR ³

LQWHUYDOXV .DOED VXVLGHGD Lã VDNLQLÐ tags SDåRGåLXL – HWLNHW¡V NXULH
pradedami sakinio pavadinimu skliaustuose <…> ir baigiami tokiu pat
pavadinimu skliaustuose </…>. Kai kurie sakiniai, kaip APPLET, yra
NRQWHLQHULDL WRG¡O ³ MXRV JDOLPD ³UDã\WL SDUDPHWUXV APPLET – SDUDPHWU
CODE – QXURGDQW³ NOLHQWLQ¡V SURJUDPRV YDUG MHL UHLNLD – su pilnu keliu;
WIDTH – programos lango plot³ YDL]GR WDãNDLV R HEIGHT – DXNãW³
3DUDPHWUÐUHLNãP¡VNDUWDLVDSLPDPRVNDEXW¡PLV³´6DNLQLDLHEAD ir TITLE
VXGDURWLWXOLQ
SXVODSLRGDO³RBODY DSUDãRSDW³SXVODS³
²UDã\WLVXNXUW+70/GRNXPHQWSDWRJLDXVLD–³WSDW³DSODQN
4. Atiduoti HTML doNXPHQWQDUã\NOHL
<UD VSHFLDOXV ³UDQNLV NOLHQWLQ¡PV SURJUDPRPV WHVWXRWL appletviewer,

OHLGåLDQWLV ³Y\NG\WL SURJUDPDV EH QDUã\NO¡V SDJDOERV ²UDQNLV UHDJXRMD WLN ³ +70/
VDNLQ³ APPLET WRG¡O WRN³ VDNLQ³ JDOLPD NRPHQWDUR SDYLGDOX ³UDã\WL WLHVLRJ
programos WHNVWH LU QHUHLN¡V UDã\WL DWVNLUR +70/ GRNXPHQWR 1DXGRMDQW ³UDQN³
SURJUDPRVWHNVWUHLN¡VSDNHLVWL³
//<APPLET CODE = FirstApplet WIDTH=100 HEIGHT=100>

//</APPLET>
public class FirstApplet extends JApplet{
public void init(){
System.out.println( ‘The first applet” );
}
}
o 4-DMDPHHWDSHYLHWRMHQDUã\NO¡VSDOHLVWL
appletviewer FirstApplet.java
7RNLXEÌGXSDSUDVWXPRG¡OHLSDOHLVLPHNOLHQWLQHVSURJUDPDVYLVRNXUVRPHWX
3DVWDERV .OLHQWLQ¡V SURJUDPRV J\YDYLPXL SDODLN\WL EÌWLQRV Java NODV¡V

HVDQþLRV SDNHWXRVH java.awt ODLNRPD NDG GDOLV ãLÐ NODVLÐ MDX \UD SDVHQ
LU
21
nenaudotinos) arba javax.swing (rekomenduojama naudoti klases iš šio paketo). Visi
SDNHWDL NXULÐ YDUGDL SUDVLGHGD javax (nuo Java extension), turi Java galimybes
SUDSOHþLDQþLDVNODVHV3DNHWDVLPSRUWXRMDPDVRSHUDWRULXPimport, o „*“ reiškia, kad
GLQDPLãNDLLPSRUWXRMDPRVWLNUHLNLDPRV³NHOWLNODV¡V
.OLHQWLQ¡VSURJUDPRVVWDUWLQ¡NODV¡WXULQWLPHWRGinitSULYDOREÌWLSDVNHOEWD
public LU WXUL SDYHOG¡ti (extends NOLHQWLQ¡V SURJUDPRV VXSHUNODV¡V JApplet MHL EÌWÐ
QXWDUWD ULQNWLV DQDORJLãN NODV
Lã java.awt paketo – WHNWÐ LPWL Applet) savybes ir
metodus.
²¡MLPR³SURJUDPWDãNDV– metodas initQHJUåLQDQWLVMRNLRVUHLNãP¡V
22
2. J A V A S I N T A K S ,â6$0,$8
2.1. SO\JRVRSHUDWRULDL
JavaVO\JRVRSHUDWRULDL– lygiai tokie pat, kaip kitose kalbose:
if( reiškinys )
^RSHUDWRULÐJUXS¡`
else
^RSHUDWRULÐJUXS¡`
5HLãNLQLRUHLNãP¡SULYDOREÌWLORJLQ¡-HLJUXS¡VH\UDWLNSRYLHQRSHUDWRULÐ
ILJÌULQLDL VNOLDXVWDL QHEÌWLQL else LU DQWURML RSHUDWRULÐ JUXS¡ WDLS SDW QHEÌWLQL -HL
reikia, prie else JDOLPD SULUDã\WL SDSLOGRP VO\J HOVH LI UHLãNLQ\V ^ RSHUDWRULÐ
JUXS¡`
3DY\]G\VVNDLþLDXV³YHGLPDVLãNODYLDWÌURVLUQXVWDW\PDVDUVNDLþLXVO\JLQLV
ar nelyginis.
...
int number = System.in.read( )³YHGDPDVYLHQDVVLPEROLVLãNODYLDWÌURV
if( number %2 = = 0 ) MHL³YHVWLNHOLVLPEROLDL– imamas paskutinis
System.out.println( “Even number entered” );
else
System.out.println( “Odd number entered” );
...
2.2. Selektorius
switch( reiškinys ) {
case value1:
^RSHUDWRULÐJUXS¡`
break;
case value2:
^RSHUDWRULÐJUXS¡`
break;
...
default:
{ operDWRULÐJUXS¡G`
break;
}
2SHUDWRULDXVUHLãNLQLRUHLNãP¡WXULEÌWLWLNbyte, char, short arba intWLSR2SHUDWRULÐ

breakJDOLQHEÌWLWDGDEXVY\NGRPDNLWDLãHLO¡VRSHUDWRULÐJUXS¡
3DY\]G\V SURJUDPD QXVWDWR DU Lã NODYLDWÌURV ³YHVWDV VLPEROLV \UD EDOV¡ DU
SULHEDOVLVSDJDODQJOÐNDOERVWDLV\NOHV
23
public class VowelsAndConsonants{
public static void main( String args[ ] ){
char c = ( char ) System.in.read( );
switch( c ) {
case ‘a’:
case ‘e’:
case ‘i’:
case ‘o’:
case ‘u’:
System.out.println( “Vowel” );
break;
case ‘y’:
case ‘w’:
System.out.println( “Sometimes vowel” );
break;
default:
System.out.println( “Consonant” );
}
}
}
2.3. Ciklai
1.
ZKLOHUHLãNLQ\V^RSHUDWRULÐJUXS¡`
2SHUDWRULDXV UHLãNLQLR UHLNãP¡ WXUL EÌWL ORJLQ¡ *DOLPDV DWYHMLV NDL FLNODV Lã
viso nebus vykdomas –NDLUHLãNLQLRUHLNãP¡false; galimas begalinio ciklo atvejis –
NDLUHLãNLQLRUHLNãP¡SDVWRYL– true.
Pavyzdys: tarkim metodas processCharNDåNRNLXEÌGXDSGRURMDLãNODYLDWÌURV
³YHVWVLPERO³GDUEDVQXWUDXNLDPDV³YHGXVVLPERO³q.
...
char c = (char) System.in.read( );
while( c != ‘q’ ) {
processChar( c );
c = (char) System.in.read( );
}
...
2.
GR^RSHUDWRULÐJUXS¡`
while( reiškinys );
Šio operatoriaus skirtumas nuo pirmojo – MLV EHQW YLHQ NDUW YLVDGD EXV
vykdomas. Dabar ankstesnis pavyzdys su šiuo operatoriumi:
24
...
do {
char c = (char) System.in.read( );
processChar( c );
}
while ( c != ‘q’ );
...
3.
forUHLãNLQ\VUHLãNLQ\VUHLãNLQ\V^RSHUDWRULÐJUXS¡`
reiškinys1 VXWHLNLD SUDGLQ

FLNOR VNDLWLNOLR UHLNãP
reiškinys2 nurodo, kaip
FLNOR VNDLWLNOLR UHLNãP
PRGLILNXRWL R ORJLQLV reiškinys3 – LNL NDGD FLNO Y\NG\WL
Aišku, reiškiniai JDOLEÌWLVXSDSUDVW¡M
LNLNLQWDPRMRDUNRQVWDQWRV
9¡OSHUUDã\VLPHWSDW³SDY\]G³
...
for( char c = (char) System.in.read( ); c != ‘q’; c = (char) System.in.read( ) )
processChar( c );
...
for cikluose galima naudoti opHUDWRULÐ-NDEOHO³3DY\]GåLXL
...
for( int i = 1, j = i+10; i < 5; i++, j = i*2 ) {
System.out.println( “i= “+i+” j= “+j );
}
...
Spausdinimo rezultatai:
i=1 j = 11
i=2 j=4
i=3 j=6
i=4 j=8
&LNOÐå\P¡MLPDV&LNOÐQXWUDXNLPDV
Nors Java ir yra JULHåWDL REMHNWLãNDL RULHQWXRWD NDOED YLV WLN LU MRMH IDNWLãNDL
\UD SURJUDPDYLPR SXULVWÐ VPHUNLDPDV RSHUDWRULXV go to. Java jo funkcijas atlieka
FLNOÐå\P¡MLPDVLUFLNORQXWUDXNLPRRSHUDWRULXVbreakEHLYDOG\PRSHUGDYLPR³å\P

operatorius continue. Šios NRQVWUXNFLMRVWXULSUDVP
NDUWRWLQLXRVHFLNOXRVH
Tarkime, apdorojamas kvadratinis masyvas array, turintis arraySizeHLOXþLÐLU
VWXOSHOLÐ 0DV\YR HLOLQLV HOHPHQWDV DSGRURMDPDV PHWRGX processArrayElement. Jei
randamas bent vienas neigiamas elementas, – tolesnis masyvo apdorojimas
nutraukiamas: nutraukiami abu ciklai.
25
...
HUUå\P¡åHPLDXHVDQþLDPRSHUDWRULXL– for
for( i = 0; i < arraySize; i++ ) {
for( j = 0; j < arraySize; j++ ) {
if( arry[ i ] [ j ] < 0 ) {
System.out.println( “Error: negative number encountered”
);
EUHDNHUUQXWUDXNLDPDVå\P¡WDVLV- išorinis ciklas
}
processArrayElement( array[ i ] [ j ] );
}
}
...
2.4. Metodas-konstruktorius. Konstruktoriaus ir metodo

perkrovimas
Metodas-konstruktRULXV JDUDQWXRMD NLHNYLHQR SURJUDPRV REMHNWR SUDGLQ¡V

UHLNãP¡V-LÐ SULHVN\U -LV DXWRPDWLãNDL NYLHþLDPDV VXNXULDQW REMHNW RSHUDWRULXPL
new .RQVWUXNWRULÐ EHW NXULDL SURJUDPXRWRMR SDUDã\WDL NODVHL DXWRPDWLãNDL VXNXULD
Java (VDQW UHLNDOXL SDY\]GåLXL NODV¡V ODXNDPV SULVNLUWL QH QXOLQHV SUDGLQHV
UHLNãPHV WRN³ PHWRG JDOL SDUDã\WL LU SDWV SURJUDPXRWRMDV .RQVWUXNWRULDXV YDUGDV
VNLUWLQJDL QXR ³SUDVWÐ PHWRGÐ SUDGHGDPDV GLGåLMD UDLGH .RQVWUXNWRULXV JDOL WXU¡WL
DUJXPHQWÐ.RQVWUXNWRULXVQHJUåLQDMRNLRVUHLNãP¡V
3DY\]GåLXLÄWXãþLRV³NODV¡VNRQVWUXNWRULXVJDOLEÌWLSDUDã\WDVWDLS
class AClass{
float x;
AClass( ) {
System.out.println( “Creation of AClass object” );
x = 1.23f;
}
}
Dabar new AClass( );NYLHþLDNRQVWUXNWRULÐLãVNLULDDWPLQW³REMektui –NODV¡V

ODXNDPVLUVXNXULDYLHQNODV¡VREMHNW
Konstruktorius su argumentais:
class AClass2{
AClass2( int i ){
System.out.println( “AClass object No “+ i );
}
}
public class ObjectCreation{
public static void main( String args [ ] ){
for( int i = 0; i < 10; i++ ) {
new AClass2( i );
}
}
}
26
VXNXULDREMHNWÐVXQXPHULDLV«$LãNXãLHREMHNWDLQHWXULMRNLÐ³VDYH
QXNUHLSWÐURG\NOLÐWRG¡OMXRVVXQDLNLQVãLXNãOLÐULQNWXYDV
7RV SDþLRV NODV¡V REMHNWXV JDOLPD VXNXUWL VNLUWLQJDLV EÌGDLV 7DP WHNWÐ
PHWRG-NRQVWUXNWRULÐ SDQDãLDL NDLS SDSUDVW PHWRG ÄSHUNUDXWL³ overload).
3HUNUDXQDQW PHWRGXV JDXQDPD YLVD EHQGUDYDUGåLÐ PHWRGÐ JUXS¡ 0HWRGDV QXR
PHWRGR ãLRMH JUXS¡MH WXUL VNLUWLV DUJXPHQWÐ VUDãX JDOL VNLUWLV QHW LU DUJXPHQWÐ
LãG¡VW\PRWYDUND.RPSLOLDWRULXVLãPHWRGÐJUXS¡VUHLNLDPPHWRGDWVLUHQNDSDJDO
NYLHWLPRPHWXQXURG\WDUJXPHQWÐVUDã
3DY\]G\VVXPHWRGÐ-NRQVWUXNWRULÐLUPHWRGÐSHUNURYLPX
class AClass3{
int number;
AClass3( ){
System.out.println( “Simple creation” );
number = 0;
}
AClass3( int i ){
System.out.println( “Numbered creation. No ”+i );
number = i;
}
void info( ){
System.out.println( “Object “+ number );
}
void info( String s ){
System.out.println( s + “ object “ + number );
}
}
public class Overloading{
AClass3 ac = new AClass3( );
ac.info( );
ac.info( “Overloaded” );
for( int i = 0; i < 10; i++ ) {
ac = new AClass3( i );
}
}
}
Skiriasi PHWRGÐ VX DUJXPHQWDLV – SULPLW\YDLV SHUNURYLPDV 7DLS \UD G¡O WR
NDG SULPLW\YDL DXWRPDWLãNDL JDOL EÌWL SHUYHVWL ³ EHQGUHVQ³M³ WLS ,ãLPWLV þLD \UD WLN
char SULPLW\YDVMLVSHUYHGDPDVLãNDUW³intWLSDSHLQDQWPDåLDXXåint bendrus byte
ir short tipus. Visi galimi atvejai parodyti šiame pavyzdyje:
public class PrimitiveOverloading{

static void prt(String s){
System.out.println(s);
}
void m1(char x){ prt("m1(char)"); }

void m1(byte x){ prt("m1(byte)"); }
27
void m1(short x){ prt("m1(short)"); }
void m1(int x){ prt("m1(int)"); }
void m1(long x){ prt("m1(long)");}
void m1(float x){ prt("m1(float)"); }
void m1(double x){ prt("m1(double)"); }
void m2(byte x){ prt("m2(byte)"); }





void testChar( ){
char x ='x';
prt("char argument");
m1(x); m2(x); m3(x); m4(x); m5(x); m6(x); m7(x);
}
void testByte( ){
byte x =1;
prt("byte argument");
m1(x); m2(x); m3(x); m4(x); m5(x); m6(x); m7(x);
}
void testShort(){
short x =1;
prt("short argument");
m1(x); m2(x); m3(x); m4(x); m5(x); m6(x); m7(x);
}
28
void testInt(){
int x =1;
prt("int argument");
m1(x); m2(x); m3(x); m4(x); m5(x); m6(x); m7(x);
}
void testLong(){
long x =1L;
prt("long argument");
m1(x); m2(x); m3(x); m4(x); m5(x); m6(x); m7(x);
}
void testFloat(){
float x =1F;
prt("float argument");
m1(x); m2(x); m3(x); m4(x); m5(x); m6(x); m7(x);
}
void testDouble(){
double x =1;
prt("double argument");
m1(x); m2(x); m3(x); m4(x); m5(x); m6(x); m7(x);
}
public static void main(String args[]){

PrimitiveOverloading pl = new PrimitiveOverloading();
pl.testChar();
pl.testByte();
pl.testShort();
pl.testInt();
pl.testLong();
pl.testFloat();
pl.testDouble();
}
}
âLRV SURJUDPRV VSDXVGLQLPDL DNLYDL]GåLDL URGR NXULV PHWRGDV SDVLUHQNDPDV

Lã YLVÐ SHUNUDXWÐ PHWRGÐ JUXS¡V NDL WUÌNVWD PHWRGR VX QXURG\WX NYLHWLPR PHWX
DUJXPHQWR WLSX SDVLWHONLDPDV PLQ¡WDVLV DXWRPDWLQLV SHUYHGLPDV ³ EHQGUHVQ³M³ WLS
Rezultatus pateiksimeOHQWHO¡VIRUPD
char argument byte argument short argument int argument

m1(char) m1(byte) m1(short) m1(int)
m2(int) m2(byte) m2(short) m2(int)
m3(int) m3(short) m3(short) m3(int)
m4(int) m4(int) m4(int) m4(int)
m5(long) m5(long) m5(long) m5(long)
m6(float) m6(float) m6(float) m6(float)
m7(double) m7(double) m7(double) m7(double)
29
OHQWHO¡VW
VLQ\V
long argument float argument double argument
m1(long) m1(float) m1(double)
m6(float) m6(float) m6(double)
m7(double) m7(double) m7(double)
,U SDVNXWLQ¡ SDVWDED DSLH PHWRGÐ-NRQVWUXNWRUÐ SHUNURYLP 0HWRGDV-

NRQVWUXNWRULXV NXU³ VXNXULD Java pagal nutyO¡MLP – EH DUJXPHQWÐ -HL
SURJUDPXRWRMDV VXNXULD VDYR NRQVWUXNWRULDXV YDULDQW VX DUJXPHQWDLV WDL GDEDU
NUHLSLQ\V ³ PHWRG-NRQVWUXNWRULÐ EH DUJXPHQWÐ WDPSD QHJDOLPDV NRPSLOLDWRULXV
DXWRPDWLãNDL NRQVWUXNWRULDXV QHEHNXULD *HQHUXRMDPDV SUDQHãLPDV ÄQ¡UD WRkio
konstruktoriaus“.
5DNWDåRGLVthis
Kompiliatorius, atlikdamas kurio nors metodo instrukcijas, dabartiniu

PRPHQWXDSGRURMDPDPREMHNWXLVXNXULDURG\NO
thisâLURG\NO
JDOLPDQDXGRWLNDLS
LUEHWNXULNLW'DåQLDXVLDLãLVUDNWDåRGLVQDXGRMDPDV konstruktoriuose.
Aptarsime situacijas su this naudojimu.
1.
...
class AClass4{
void m1( ) { . . .}
void m2( ) { this.m1( ); }
}
...
âLXRDWYHMXNDLYLHQDVPHWRGDVNYLHþLDNLWWRVSDþLRVNODV¡VYLGXMHthisQ¡UDEÌWLQDV
ýLD MLV SDSUDVþLDXVLDL SDEU¡åLD NDG PHWRGDV m1 NYLHþLDPDV GDEDU DSGRURMDPDP
objektui.
5DNWDåRGLVEÌWLQDVNDLSDSUDVWDVPHWRGDVJUåLQDNODV¡VREMHNW
public class AClass5{

int i = 0;
AClass5 incr( ) {
i++;
return this;
}
public static void main( String args [ ] ) {
AClass5 ac = new ACLass5( );
ac.incr( ); // NDGDQJLLQFUJUåLQDURG\NO
³GDUELQ³REMHNW
} MDPWROLDXJDOLPDW
VWLLQNUHPHQWRRSHUDFLMDV
} // ac.incr ( ).incr( ).incr( ) . . .;
30
5DNWDåRGLVEÌWLQDV NRQVWUXNWRULXMH NYLHþLDQWNLWPDåLDX EHQGU PHWRGR-
NRQVWUXNWRULDXV YDULDQW ýLD SDW LU SDY\]G\V SLUPDVLV AClass6 konstruktoriaus
variantas), kai be this NLOWÐ YDUGÐ NRQIOLNWDV %H DEHMR NRQIOLNWR OHQJYD LãYHQJWL
SDUHQNDQW DUJXPHQWXL NLWRN³ YDUG W GHPRQVWUXRja antrasis konstruktoriaus
YDULDQWDV 7DþLDX GDXJHOLV DXWRULÐ SURSDJXRMD SURJUDPDYLPR VWLOLÐ NDLS SLUPDMDPH
konstruktoriaus variante – su this naudojimu.
public class AClass6{

int i = 0;
String s = “null”;
AClass6( int i ) {
this.i = i;
System.out.println( “Constructor1: only int” );
}
AClass6( String ss ) {
s = ss;
System.out.println( “Constructor 2: only String” );
}
AClass6( int ii, String ss ) {
this( ii );
WKLVVVNODLGDOHLGåLDPDVWLNYLHQDVWRNVNYLHWLPas
s = ss;
System.out.println( “Constructor3: int and String” );
}
AClass6( ) {
this( 1, “string” );
System.out.println( “Constructor4: no arguments” );
}
AClass6 ac = new AClass6( ); // NYLHþLDPDV-asis
ac.System.out.println( “Object: “ + i + s ); // konstruktorius
}
}
2EMHNWÐQDLNLQLPDV
3URJUDPXRWRMXL QHUHLNLD SDþLDP UÌSLQWLV Java programose objektams skirtos

DWPLQWLHV LãODLVYLQLPX W GDUE DWOLHND ÄãLXNãOLÐ ULQNWXYDV³ %HQGUDVLV REMHNWÐ
QDLNLQLPRPHFKDQL]PDV\UDODEDLSDSUDVWDVNDLQHE¡UDQ¡YLHQRV³REMHNWQXWDLN\WRV
URG\NO¡VMDPVNLUWDDWPLQWLVVXUHQNDPD
âLXNãOLÐ VXULQNLPDV LãODLVYLQD WLN REMHNWDPV VNLUW DWPLQW³ LU QHOLHþLD NLWÐ
REMHNWDPVVNLUWÐUHVXUVÐ-HLREMHNWDVSDY\]GåLXLNDåNQXSLHã¡NRPSLXWHULRHNUDQH
WDLVXQDLNLQDQWREMHNWSLHãLQLRSDQDLNLQLPXWHQNDUÌSLQWLVSDþLDPSURJUDPXRWRMXL
âLXNãO¡V VXUHQNDPRV QH YLVDGD -HL SURJUDPD QDXGRMD QHGDXJ DWPLQWLHV LU
QHSDVLHNLD WDP WLNURV NULWLQ¡V DWPLQWLHs panaudojimo ribos, atminties surinkimo
PHFKDQL]PDV QHSDOHLGåLDPDV âLXR DWYHMX DWPLQWLV RSHUDFLQHL VLVWHPDL JUåLQDPD
SURJUDPDLEDLJXVGDUE
.ODV¡MH System \UD VSHFLDOXV PHWRGDV SULYHUVWLQDL LãNYLHþLDQWLV GDUEXL
DWPLQWLHVULQNWXY
31
System.gc( );
MHWRGRSDYDGLQLPDVNLO
VQXRåRGåLÐgarbage collectionSLUPÐMÐUDLGåLÐNDV
ãLDLSMDXQHEÌGLQJD JavaYDUGÐVLVWHPDL
âLXNãOLÐ ULQNWXYR GDUER DOJRULWPDL \UD SDNDQNDPDL VXG¡WLQJL QDXGRMDPD
schema „sustoti – ir – SHUNRSLMXRWL³ SURJUDPDL VNLUW DWPLQW³ heap) ³ NLW DWPLQWLHV
VULW³ SHUNRSLMXRMDPL WLN REMHNWDL WXULQW\V ³ VDYH QXNUHLSWDV URG\NOHV URG\NOLÐ
SUDGHGDPDLHãNRWLQXRSDþLDPHNODVLÐKLHUDUFKLMRVYLUãXMHHVDQþLRVNODV¡VObject). Be
WR³YDLULRV-90UHDOL]DFLMRVãLVFKHPGDUYLHQDLSDUNLWDLSSDWREXOina.
3UDGLQLÐUHLNãPLÐVN\ULPDV
3ULPHQDPH NODVLÐ NLQWDPLHVLHPV DXWRPDWLãNDL VNLULDPRV QXOLQ¡V UHLNãP¡V

(loginiams laukams –UHLNãP¡false). Matyt, geresnis programavimo stilius vis tik yra
ODXNÐ UHLNãPHV LãUHLNãWDL VNLUWL SULHVN\URV RSHUDWRULXRVH DUED WDL SHUNHOWL ³ PHWRGXV-
konstruktorius.
6NLULDQWSUDGLQHVUHLNãPHVLãUHLNãWDLNODV¡VYLGXMHRSHUDWRULÐY\NG\PRWYDUND
\UD JDQD QH³SUDVWD SLUPLDX QHSDLVDQW NXU MLH \UD DWOLHNDPL SUDGLQLÐ UHLNãPLÐ
prieskyros operatoriai, o tik paskui visi kiti PHWRGDL7LOLXVWUXRMDãLVSDY\]G\V
class Tag{
Tag( int i ){
System.out.println( "Tag( " + i + " )" );
}
}
class Card{
7DJW QHZ7DJSULHãNRQVWUXNWRULÐ
Card( ){
System.out.println( "Inside constructor Card" );
t3 = new Tag( 33 );
}
Tag t2 = new Tag( 2 );
void m( ){
System.out.println( "Finish" );
}
Tag t3 = new Tag( 3 ); // after constructor !
}
public class Initialization{

public static void main( String args[ ] ) {
Card c= new Card( );
c.m( );
}
}
32
Programos spausdinimai:
Tag( 1 )
Tag( 2 )
Tag( 3 )
Inside constructor Card
Tag( 33 )
Finish
Statiniams laukams SUDGLQ¡VUHLNãP¡VVNLULDPRVWLNWDGDNDLSURJUDPDVXNXULD

objektus su statiniais laukais.
7DLJLYLVDSUDGLQLÐUHLNãPLÐVN\ULPRWYDUND\UD
1. ,QWHUSUHWDWRULXV LHãNR NODV¡V VXNRPSLOLXRWRV ULQNPHQRV YDUGX
NODV¡V9DUGDVFODVV NDL EDQGRPD VXNXUWL ãLRV NODV¡V REMHNW DUED SULHLWL
SULHãLRVNODV¡VVWDWLQLÐODXNÐDUPHWRGÐ,QIRUPDFLMDNXULQWHUSUHWDWRULXV
turi ieškoti, nurodoma aplinkos kintamuoju CLASSPATH.
2. ²N¡OXV ULQNPHQ NODV¡V9DUGDVFODVV NODV¡V VWDWLQLDPV ODXNDPV
SDVNLULDPRVSUDGLQ¡VUHLNãP¡VLUWLNYLHQNDUW
3. .XULDQW QDXM NODV¡V NODV¡V9DUGDV REMHNW RSHUDWRULXPL new, išskiriama
DWPLQWLVNODV¡VQHVWDWLQLDPVODXNDPVLUMLHPVVNLULDPRVQXOLQ¡VUHLNãP¡V
4. -HL\UDDWOLHNDPDLãUHLNãWLQ¡ãLÐODXNÐUHLNãPLÐSULHVN\UD
5. Vykdomi metodai-konstruktoriai.
2.8. PradiQLÐUHLNãPLÐSULHVN\UDPDV\YDPV
Masyvas – YLHQRGR WLSR REMHNWÐ VHND YLHQX YDUGX *DOL EÌWL YLHQPDþLDL
GYLPDþLDLLUWW9LHQPDWLVPDV\YDVDSLEU¡åLDPDVSDY\]GåLXLWDLS
int [ ] m; arba int m[ ];
ýLD QHJDOLPD QXURG\WL HOHPHQWÐ NLHNLR PDV\YH QHV Nol kas sukurta tik
nuoroda, o atmintis masyvui dar nepaskirta. Atmintis masyvui paskiriama jam skiriant
SUDGLQHVUHLNãPHV7DLGDURPDNHOLDLVEÌGDLV
1. int [ ] m1 = { 1, 2, 3, 4, 5 }; // VXSDSUDVWLQWDVLQWDNV¡
// primityvams ir …
Integer [ ] m2 = { new Integer( 1 ), new Integer( 2 ), new Integer( 3 ),
new Integer( 4 ), new Integer( 5 ) }; // …objektams
2. int [ ] m3;
...
m3 QHZLQW>@LUSULPLW\YÐPDV\YDPVJDOLPDVÄQHZ³QDXGRMLPDV
// visiems 5 masyvo eOHPHQWDPVVNLULDPRVUHLNãP¡V
3UDGLQLÐ UHLNãPLÐ VN\ULPR GDXJLDPDþLDPV PDV\YDPV DELHP EÌGDLV

SDY\]GåLDL
33
int [ ] [ ] m4 ={ // dvimatis masyvas 2x3
{ 1, 2, 3 },
{ 4, 5, 6 },
};
int [ ] [ ] [ ] m5 = new int[ 2 ] [ 3 ] [4 ]; // trimatis nulinis masyvas 2x3x4
.LHNYLHQDV GYLPDþLR PDV\YR HOHPHQWDV m4[ i ] \UD YLHQPDWLV PDV\YDV ³ ã³

PDV\YJDOLPDVWRNVNUHLSLQ\VNDLSSDUDã\WD%HWRNLHNYLHQDPLQGHNVXLiYLHQPDþLDL
PDV\YDL JDOL EÌWL VNLUWLQJR LOJLR 3DY\]GåLXL WULPDþLDm masyvui m5 galima tokia
SDNRSLQ¡SUDGLQLÐUHLNãPLÐSULHVN\UD
m5 = new int[ 2 ] [ ] [ ];
...
int i = . . . ;
int j = . . . ;
m5[ i ] = new int[ j ] [ ];
...
int k = . . . ;
m5[ i ] [ j ] = new int[ k ];
...
.LHNYLHQDVPDV\YDVWXULLOJLRODXN lengthNLHNYLHQDLGLPHQVLMDL3DY\]GåLXL
WDPSDþLDPWULPDþLDPPDV\YXLMRDWVNLUDVGLPHQVLMDVJDOLPDEÌWÐQXVWDW\WL
m5.length; // pirmoji dimensija

m5[ i ].length; // i elemento –YLHQPDþLRPDV\YRNXULRHOHPHQWDLLUJL
YLHQPDþLDLPDV\YDLLOJLV
m5[ i ] [ j ].length; // ij elemento –YLHQPDþLRPDV\YR– ilgis
Java NDLS LU & NDOERVH PDV\YÐ HOHPHQWÐ LQGHNVDL NLHNYLHQRMH GLPHQVLMRMH
SUDGHGDPLVNDLþLXRWLQXRQXOLR
2.9. VardÐODXNÐPHWRGÐLUNODVLÐVO¡SLPDV
2.9.1. Paketai
3DNHWDL YLVÐ SLUPD VNLUWL VXWYDUN\WLJava ULQNPHQÐ VLVWHPDL SDQDXGRMDQW 26

ULQNPHQÐKLHUDUFKLM.DUWXWDLSDWRJLSULHPRQ¡YDUGÐPDWRPXPRVULWLPVYDOG\WL
3UDGLQLV SURJUDPRV WHNVWDV NXULDPH JDOL EÌWL NHOLRV NODV¡V YDGLQDPDV
NRPSLOLDFLMRVYLHQHWX7RNLDPHYLHQHWHJDOLEÌWLWLNYLHQDYLHãRMLNODV¡publicRM³
DSLPDQþLRV ULQNPHQRV YDUGDV WXUL VXWDSWL VX YLHãRVLRV NODV¡V YDUGX LU WXU¡WL SO¡WLQ³
*.java -HL NRPSLOLDFLMRV YLHQHWH Q¡ YLHQD NODV¡ Q¡UD SDVNHOEWD public, rinkmenos
YDUGDVJDOLEÌWLEHWNRNV6XNRPSLOLDYXVWRN³YLHQHWEXVVXNXUWRVULQNPHQRV class
NLHNYLHQDLNODVHL9\NGDQWSURJUDPãLDVULQNPHQDVVXUDQGD³NUDXQDLULQWHUSUHWXRMD
interpretatorius – Java virtuali mašina (JVM). Beje, *.class rinkmenas galima
VXVSDXVWL³JavaDUFK\YRULQNPHQ jar ³UDQNLX jar.
1RULQWVXJUXSXRWLNHOLVNRPSLOLDFLMRVYLHQHWXV³YLVXP–SDNHWSULHãpublic
NODV
EÌWLQDLSLUPRMRMHHLOXW¡MHQHVNDLWDQWNRPHQWDUÐUDãRPDVUDNWDåRGLV
34
package packageName;
Skirtingai neLNODVHLSDNHWRYDUG³SUDVWDSUDG¡WLPDåMDUDLGH'DEDUQRULQW
NUHLSWLV ³ public NODV
WDUNLPH MRV YDUGDV \UD AClass MDX WHNV QDXGRWL SLOQM³ MRV
YDUGpackageName.AClass arba importuoti paketo klases operatoriumi
import packageName;
Šiuo atvHMXNUHLSLQ\MHY¡OJDOLPDVWUXPSDVLVNODV¡VYDUGDV2SHUDWRULXV
import packageName.*;
importuoja tik reikiamas programai paketo klases – vadinamasis dinaminis

importavimas.
Kadangi Java programos pirmiausia skirtos internetui, tinkle neišvengiamai
galLNLOWLLUSDNHWÐYDUGÐNRQIOLNWDVâLDLSUREOHPDLLãVSU
VWLUDVWDWRNLDLãHLWLVSDNHWR
YDUGXL QDXGRMDPDV DWYLUNãþLDV GRPHQLQLV NRPSLXWHULR DGUHVDV LU NRPSLXWHULR
ULQNPHQÐKLHUDUFKLMDVNLULDQWGRPHQXVLUDSODQNÐYDUGXVWDãNDLV.DUWXWDLVXWYDUNRLU
rinkPHQÐÌN³YLVRVSDNHWRULQNPHQRV class yra viename aplanke. Kur kompiuteryje
LHãNRWLUHLNLDPÐNODVLÐNDLNXULRVH26QXURGRPDDSOLQNRVNLQWDPXRMXSDY\]GåLXL
CLASSPATH = .; C:\A\B\C; C:\D\e.jar
ýLD WDãNDV UHLãNLD GDUELQ³ DSODQN $UFK\YLQ¡PV ULQNPHQRPs, kaip matyti iš

SDY\]GåLRUHLNLDQXURG\WLLUULQNPHQRVYDUG
Kitas pavyzdys: tarkim, kompiuterio internetinis adresas yra
domeninisAdresas.com R NRPSLXWHU\MH MLV ÄURGR³ ³ C:\ABC\com.domeninisAdresas,
šiame aplanke yra aplankas def, kuriame ir bus paketas. Jei kompiuterio aplinkos
kintamasis nustatytas CLASSPATH = C:\ABCWDLSDNHWRYDUGUHLNLDVNHOEWL
package com.domeninisAdresas.def;
public class AClass{ . . . }
...
9¡OLDXLPSRUWDYXVSDNHW
import com.domeninisAdresas.def.*;
bus galimaQDXGRWLWUXPSM³NODV¡VYDUGAClass. Beje, importuojamos tik viešosios

NODV¡V
Jei JavaSURJUDPRMHQ¡UDGHNODUXRWDVSDNHWDVWDþLDXNHOLRVNODV¡V\UDYLHQDPH
NRPSLXWHULR ULQNPHQÐ DSODQNH WDL ãLRV NODV¡V YLV WLHN ODLNRPRV SDNHWR ÄSDJDO
QXW\O¡MLP³QDULDis.
35
/DXNÐLUPHWRGÐVO¡SLPDV
3DNHWDL LU NODV¡V SDODLNR ³YDLULDV YDUGÐ DUED PDWRPXPR VULWLV 3DNHWDL
IDNWLãNDL \UD NRQWHLQHULDL NODV¡PV LU NLWLHPV SDNHWDPV .ODV¡V \UD GXRPHQÐ LU NRGR
NRQWHLQHULDL 7DL OHLGåLD REMHNWR GXRPHQLV NXULXRV QHEÌWLQDL WXUL åLQRWL YLVL NLWL
SURJUDPRV REMHNWDL SDVO¡SWL incapsulate) objekte arba keliuose susijusiuose
objektuose.
,ãYLVR\UDSULHLWLHVO\JLDLNODV¡VHOHPHQWDPV
DSULHLWLVLãWRVSDWNODV¡V
ELãNODV¡VVXENODVLÐãLDPHSDNHWH
c) iš ne VXENODVLÐãLDPHSDNHWH
GLãVXENODVLÐVNLUWLQJXRVHSDNHWXRVH
HLãQHVXENODVLÐNLWXRVHSDNHWXRVH
Terminas VXENODV¡þLDUHLãNLDNDGMLpaveldiQDJULQ¡MDPRVNODV¡VVDY\EHVåU
VN\ULÐ
3ULHã NODV¡V HOHPHQWXV JDOLPD ³UDã\WL SULHLWLHV PRGLfikatorius public, private
arba protected 0RGLILNDWRULXV YHLNLD WLN W REMHNW SULHã NXU³ MLV ³UDã\WDV -HL MRNV
PRGLILNDWRULXV QH³UDã\WDV SULHLWLV SULH ODXNR \UD friendly WDþLDX WRNLR UDNWDåRGåLR
Q¡UD 0RGLILNDWRULÐ UHLNãP¡ LOLXVWUXRMDPD OHQWHO¡Me: prieitis galima arba
negalima.
2.1 OHQWHO¡0RGLILNDWRULÐUHLNãP¡V
Modifikatorius /
Prieities lygis private „friendly“ protected public
a taip taip taip taip

b ne taip taip taip
c ne taip taip taip
d ne ne taip taip
e ne ne ne taip
Taigi elementai, paskelbti public, yra prieinami iš visur. Elementai private

SULHLQDPL WLN Lã SDþLRV NODV¡V (OHPHQWDL EH PRGLILNDWRULDXV PDWRPL NODV¡MH MRV
VXENODV¡VHLUNLWRVHWRSDWLHVSDNHWRNODV¡VH(OHPHQWDLNXULHWXULEÌWLPDWRPLLUNLWÐ
SDNHWÐNODV¡VH–QDJULQ¡MDPRVNODV¡VVXENODV¡VHVNHOELDPLprotected.
Programos su klaidinga prieitimi pavyzdys:
package aPackage;
public class Class1{
int a = 0;
void m( ){
System.out.println( “AClass method” );
}
}
import aPackage.*;
36
Class1 c1 = new Class1( );
c1.a = 1; // Klaida!
c1.m( ); // Klaida!
}
}
Norint ãL SURJUDP VXNRPSLOLXRWL EH NODLGÐ WHNV DUED VNHOEWL SLUPRVLRV
NODV¡V ODXN LU PHWRG YLHãDLV DUED protected LU VXVLHWL DQWUM NODV
VX SLUPMD
SDYHOGLPXPXåUVN\ULÐ
.ODVLÐVO¡SLPDV
Klasei galimas tik modifikatorius public ir prieiWLV SDJDO QXW\O¡MLP friendly.

1RULQW YLHQDLS DU NLWDLS XåGDU\WL SULHLJ SULH NODV¡V UHLNLD SDVLWHONWL WDP WLNUDV
technologijas.
3DY\]G\V 7HFKQRORJLMD YLHQLQWHOLDP NODV¡V REMHNWXL VXNXUWL SHUUDã\WL
PHWRG-NRQVWUXNWRULÐLUSDVNHOEWLM³private –LãXåNODV¡VULEÐQHEXV³PDQRPDVXNXUWL
NODV¡V REMHNWÐ NODV¡V YLGXMH VXNXUWL YLHQLQWHO³ NODV¡V REMHNW VXNXUWL static PHWRG
NDGEÌWÐJDOLPDNUHLSWLVNODV¡VYDUGXJUåLQDQW³ã³VXNXUWM³NODV¡VREMHNW
class AClass{
private AClass( ){ . . . }
private static AClass ac = new AClass( );
public static AClass access( ){
return ac;
}
public void m( ){ . . . }
}
...
AClass.access( ).m( );
...
.RGRIUDJPHQWÐNDUWRMLPDV
kompozicija ir paveldimumas
6LQWDNV¡.RQVWUXNWRULÐY\kdymas
.DG EÌWÐ JUHLþLDX UDãRPDV SURJUDPRV NRGDV NLHNYLHQD SURJUDPDYLPR NDOED

VLÌOR WDP WLNUXV PHFKDQL]PXV OHLGåLDQþLXV SDNDUWRWL UHLNLDPXV NRGR IUDJPHQWXV
Java WRNLHPHFKDQL]PDL\UDNODVLÐNRPSR]LFLMDLUSDYHOGLPXPDV
Kompozicija taikytina, kai naujDL UDãRPRMH NODV¡MH UHLNLD SDQDXGRWL MDX
SDUDã\WÐ NODVLÐ JDOLP\EHV LU FKDUDNWHULVWLNDV 6XSDSUDVWLQWDL NRPSR]LFLM JDOLPD
DSLEÌGLQWL WHLJLQLX ÄWDL \UD WR GDOLV³ .ODVLNLQLV SDY\]G\V NXULXR NRPSR]LFLMD
LOLXVWUXRMDPDREMHNWLQLRSURJUDPDYLPRYDGRY¡OLXRVH– kODV¡ÄPDãLQD³VXVLGHGDQWLLã
NODV¡VÄYDULNOLR³REMHNWRNHOLÐNODV¡VÄUDWDL³REMHNWÐLUWW
37
3DYHOGLPXPDV QDXGRWLQDV WDGD NDL UHLNLD SDQDXGRWL PRWLQLQ¡V DUED
VXSHUNODV¡V VVDM VXENODV¡ JDOL ãL VVDM LãSO¡VWL 7HLJLQ\V NXU³ ³J\YHQGLQD
paveldimumas –ÄãLWDL\UDSDQDãX³WDL³
/DQNVWHVQLV SURJUDPDYLPR PHFKDQL]PDV \UD NRPSR]LFLMD R SDYHOGLPXP
UHLN¡WÐWDLN\WLWHQNXUUHLNDOLQJDVÄN\ODQW\VLVWLSÐSHUWYDUN\PDV³åUWROHVQ³VN\ULÐ
.RPSR]LFLMRVVLQWDNV¡\UDDLãNLUDãRPRMHNODV¡MHNXULDPLMDXHJ]LVWXRMDQþLÐ
NODVLÐREMHNWDLWRG¡OG¡PHV³VXWHONVLPH³SDYHOGLPXPRPHFKDQL]P
.DG VXENODV¡ SDYHOGL VXSHUNODV¡V GXRPHQLV LU PHWRGXV LãUHLãNLDPD
UDNWDåRGåLXextendsLUVXSHUNODV¡VYDUGX3DY\]G\V
// Inheritance
//
class Class1 {
private String s = "Class1: ";
public void append( String ss ) { s += ss; }
public void m1( ) { append( "m1() " );}
public void print( ) { System.out.println( s );}
Class1 c1 = new Class1();
c1.m1(); c1.m2(); c1.m3(); c1.print();
}
}
public class Class2 extends Class1 {
public void m3( ){ // overriding method m3
append( "Class2.m3( ) " );
super.m3( ); // calling m3 of superclass
}
public void m4( ) { append( " m4( )" ); } // extension of interface
c2.m1( ); c2.m2( ); c2.m3( ); c2.m4( ); c2.print( );
System.out.println( "Test for the superclass Class1:" );
Class1.main( args ); // args already defined
}
}
3URJUDPRVUH]XOWDWDLNDLNYLHþLDPDVDQWURVLRVNODV¡VPHWRGDVmain:
Class1: m1( ) m2( ) Class2.m3( )m3( ) m4( )

Test for the superclass Class1:
Class1: m1( ) m2( ) m3( )
Šiame pavyzdyje yra iškart keli nauji programavimo mechanizmai ir

technologijos:
1. äLQJVQLQLDP NODVLÐ WHVWDYLPR WHFKQRORJLMD ³ NLHNYLHQ NODV
³GHGDPDV
metodas main 'DEDU LQWHUSUHWDWRULXL JDOLPD QXURG\WL QXR NXULRV NODV¡V
38
SUDG¡WLSURJUDPRVY\NG\PNRPDQGDjava Class2 paleis visos programos
Y\NG\PRjava Class1OHLVWÐWHVWXRWLWLNSLUPMNODV

2. .DLNODV¡VVXVLHWRVSDYHOGLPXPXNXULDQWVXENODV¡VREMHNWDXWRPDWLãNDL
EXV VXNXUWDV VXSHUNODV¡V REMHNWDV 7RG¡O NUHLSLQ\V c2.m1( ); spausdins
Class1: m1( ) NDGDQJL NRQVWUXRMDQW VXSHUNODV¡V REMHNW HLOXWHL s
priskiriama reikšm¡Class1: .
3. 6XSHUNODV¡V PHWRG VXENODV¡MH JDOLPD SHUUDã\WL DUED NLWDLS PRGLILNXRWL
(overrideNUHLSLQ\V³PHWRGO\JLDLWRNVSDW– public void m3( ), o metodo
NÌQDV SHUUDãRPDV NLWDLS âLDPH SHUUDã\WDPH NÌQH JDOLPD NUHLSWLV LU³ EHW
NXU³ VXSHUNODV¡V PHWRG UDNWDåRGåLX super: super.m3( ); . Beje, jei šioje
HLOXW¡MHUDNWDåRGåLRsuperQHEÌWÐEÌWÐUHNXUV\YLDLNUHLSLDPDVL³VXENODV¡V
PHWRGm3 .
'DEDU WUXSXW³ SODþLDX DSLH SDYHOGLPXPX VXVLHWÐ NODVLÐ NRQVWUXNWRULÐ
Y\NG\P .DGDQJL VXENODV¡MH \UD Ä³G¡WDV³ LU SUDSO¡VWDV VXSHUNODV¡V REMHNWDV WDL
NRQVWUXRMDQW VXENODV¡V REMHNW DXWRPDWLãNDL SULHã WDL VXNRQVWUXRMDPDV VXSHUNODV¡V
REMHNWDV7PDW¡PHLãDQNVWHVQLRSDY\]GåLR-HLNRQVWUXNWRULDLWXULDUJXPHQWXVWDLLã
VXENODV¡VNRQVWUXNWRULDXVMXRVUHLNLDUDLãNLDLSHUGXRWLÄ³YLUãÐ³SDQDXGRMDQWUDNWDåRG³
super su argumentais, kaip parodyta šiame pavyzdyje:
// Inheritance: constructors
//
class Class3 {
Class3( int i ) {
System.out.println( "Constructor of Class3 "+i );
}
}
class Class4 extends Class3 {
Class4( int i ) {
super( i ); // calling constructor of superclass
// Class3
i++; // scope of "i" is limited within constructor’s
// area
System.out.println( "Constructor of Class4 " +i );
}
}
Class5( int i ) {
super( i ); // calling constructor of superclass
// Class4
i++;
System.out.println( "Constructor of Class5" +i );
}
public static void main ( String [] args ) {
Class5 c5 = new Class5( 123 );
}
}
Programos spausdiniai:
39
Constructor of Class3 123
Jei MRNLÐDUJXPHQWÐSHUGXRWLQHUHLN¡WÐVXSHUNODV¡VNRQVWUXNWRULDXVNYLHWLPXL
åRGåLRsuperQHUHLN¡WÐ–MLVEÌWÐNYLHþLDPDVDXWRPDWLãNDL
Kreipinys super( ) VXENODV¡V NRQVWUXNWRULXMH SULYDOR EÌWL SDWV SLUPDV
RSHUDWRULXVRWDLQHOHLGåLDSHULPWLMRNLÐLãLPþLÐåUVN\ULÐDSLHNODLGÐDSGRURMLP
N\ODQþLÐNRQVWUXNWRULXMH
2.10.2. .\ODQW\VLVWLSÐSHUWYDUN\PDV
Tai svarbiausias paveldimumo asSHNWDVNXU³JDOLPDLãUHLNãWLWHLJLQLXÄãLQDXMD

NODV¡\UDVXSHUNODV¡VWLSR³,OLXVWUDFLMDL– B. Eckelio pavyzdys:
class Instrument{
public void play( ){ . . . }
static void tune( Instrument i ){
i.play( );
...
}
}
class Wind extends Instrument{
Wind flute = new Wind( );
Instrument.tune( flute ); // upcasting here!
}
}
Kaip matyti, metodo tune argumentas yra Instrument WLSR WDþLDX NUHLSLQ\MH
jam atiduodamas WindWLSRDUJXPHQWDV7RNLDVLQWDNV¡Weisinga, nes WindNODV¡\UD
VXENODV¡ Instrument NODVHL R YLHWRMH ÄåHPHVQLRMR³ NODV¡V WLSR YLVDGD OHLGåLDPD
QDXGRWL ÄDXNãWHVQLRVLRV³ NODV¡V WLS WRG¡O LU WHUPLQDV WRNV – ÄN\ODQW\VLV WLSÐ
pertvarkymas“ (upcasting7RNVWLSÐSHUWYDUN\PDVYLVDGD\UD³PDQRPas ir saugus,
QHV VXENODV¡ WXUL YLVXV VXSHUNODV¡V PHWRGXV JDOL WXU¡WL LU GDXJLDX PHWRGÐ WRG¡O
VXSHUNODV¡VPHWRGYLVDGDEXV³PDQRPDDWOLNWL
7RNVWLSÐSHUWYDUN\PDVDWYHULDSROLPRUIL]PRJDOLP\E
NXULY¡OLDXLãVDPLDL
QDJULQ¡VLPH
2.10.3. RaktaåRGLVfinal ir paveldimumas
5DNWDåRGLV final YLVDGD UHLãNLD NDåN QHNLQWDQþLR 7DLNRPDV NODV¡PV

duomenims arba metodams.
-HL PRGLILNDWRULXV WDLNRPDV NODVHL MRV VXENODVLÐ VXNXUWL W \ SDYHOG¡WL MRV
VDY\ELÐQHOHLGåLDPD7RNLRVNODV¡VODXNÐUHLNãPHVNHLVWLJDOima, metodus – taip pat.
3ULWDLN\WDV GXRPHQLPV UDNWDåRGLV SULNODXVRPDL QXR NRQWHNVWR JDOL UHLNãWL
GXRPHQVQHNLQWDPXPDUEDREMHNWXLDUEDYLVLHPVNODV¡VREMHNWDPV
40
5DNWDåRGLV SULHã PHWRG UHLãNLD NDG ãLV PHWRGDV QHJDOL EÌWL MRNLRMH NODV¡V
VXENODV¡MH QHL SHUNUDXWDV QHL SHUUDã\WDV ,ã HVP¡V PHWRGDPV UDNWDåRGLV QDXMÐ
JDOLP\ELÐ QHVXWHLNLD QHV private metodas savaime yra nekintantis; jo modifikuoti
NLWRMHNODV¡MHQHJDOLPD–PHWRGDVSDSUDVþLDXVLDLWHQQHPDWRPDV
final³WDNDGXRPHQLPVSDURGRPDãLDPHSDY\]G\MH
class Value{
int i = 1;
}
class FinalData{
final int i1 = 1; // constant for object
static final int i2 = 2; // constant for class
public static final int I3 = 3; // same; standard declaration
final Value v1 = new Value( ); // constant pointer
FinalData fd = new FinalData( );
fd.i1++; // Error!
fd.v1 = new Value( ); // Error!
fd.v1.i++;
}
}
²SUDVWDSDVWRYÐGXRPHQ³YLVDLNODVHLVNHOEWLWDLSNDLSODXNXLI3. Tokio lauko

YDUG³SUDVWDUDã\WLGLGåLRVLRPLVUDLG¡PLV.DLSPDW\WLfinal Value v1 SDGDURSDVWRYL
SDþL URG\NO
WRG¡O QHEHJDOLPD MRV QXWDLN\WL ³ NLW DWPLQWLHV VULW³ WDþLDX OHLGåLDPD
kHLVWLSDW³DWPLQWLHVWXULQ³
2.11. Polimorfizmas
Polimorfizmas – vienas iš pagriQGLQLÐREMHNWLQLRSURJUDPDYLPRSULQFLSÐ'DU

YDGLQDPDV GLQDPLQLX DUED Y¡O\YXRMX VXVLHMLPX dynamic, late binding) – metodo
YDUGRY¡O\YXRMXVXVLHMLPXVXY\NGRPXNRGX
DarYLHQDVSDY\]G\VSDQDãXV³MDXQDJULQ¡WM³
class Instrument{
public void play( ){
System.out.println( “Instrument.play( )” );
}
}
class Wind extends Instrument{
public void play( ) {
System.out.println( “Wind.play( )” );
}
}
public class Music{
public static tune( Instrument i ) {
i.play( );
}
41
Wind flute = new Wind( );
tune( flute ); // upcasting here!
}
}
Programos rezultatas:
Wind.play( )
7DLJL NYLHþLDQW PHWRG tune, ignoruojamas tikslus argumento tipas. Atrodo,

SDSUDVþLDXPHWRGtune parašyti taip:
. . . tune( Wind i ) { . . . }
7DþLDX GDEDU SOHþLDQW SURJUDP QDXMDLV LQVWUXPHQWÐ WLSDLV Brass, Horn, …,

NLHNYLHQDPQDXMDPWLSXLNODV¡MHMusicWHNVPRGLILNXRWLPHWRGtune:
. . . tune( Brass i ){ . . . } , . . . tune( Horn i ){ . . . }, . . . .
,ã NXU NRPSLOLDWRULXV åLQR NDG DQNVWHVQLDPH SDY\]G\MH EÌWHQW Wind NODV¡V
PHWRG UHLNLD NYLHVWL" 7 åLQR QH NRPSLOLDWRULXV R -90 Y¡O\YRMR VXVLHMLPR
PHFKDQL]PDV7DP³VXNRPSLOLXRWXVJava objektus *.classDXWRPDWLãNDL³GHGDPDNDL
NXULSDVO¡SWDLQIRUPDFLMD
Kitas klasikinis polimorfizmui aiškinti naudojamas pavyzdys: programa
ILJÌURPV SDY\]GåLXL Circle, Square ir Triangle EUDLå\WL LU WULQWL PHWRGDL draw ir
erase). Sukuriama apibendrintaDEVWUDNWLNODV¡ÄILJÌUD³Shape), ir toliau visas kodas
NODV¡ Shapes UDãRPDV ãLDP DSLEHQGULQWDP GXRPHQÐ WLSXL QHNUHLSLDQW G¡PHVLR ³
NRQNUHþLXV WLSXV ²SUDVWD YLV NODVLÐ KLHUDUFKLM YDL]GXRWL 80/ Unified Modeling
Language VFKHPÐ SDYLGDOX SDY NXU QXURGRPL U\ãLDL WDUS NODVLÐ LU NODVLÐ
VVDMRV–DWYLUÐPHWRGÐVUDãDL
Shape
draw( )
erase( )
Circle Square Triangle
draw( ) draw( ) draw( )

erase( ) erase( ) erase( )
SDY80/VFKHPDNODVLÐKLHUDUFKLMDL
42
Programos tekstas:
// Polymorphous methods: 1th example

class Shape {
void draw( ){ }
void erase( ){ }
}
class Circle extends Shape {

void draw( ) {
System.out.println( "Circle.draw( )" );
}
void erase( ) {
System.out.println( "Circle.erase( )" );
}
}
class Square extends Shape {

void draw( ) {
System.out.println( "Square.draw( )" );
}
void erase( ) {
System.out.println( "Square.erase( )" );
}
}
class Triangle extends Shape {

void draw( ) {
System.out.println( "Triangle.draw( )" );
}
void erase( ) {
System.out.println( "Triangle.erase( )" );
}
}
public class Shapes {

public static void main ( String [ ] args ) {
Shape[ ] s = {
new Circle( ),
new Square( ),
new Triangle( )
}; // upcasting toward Shape
for( int i=0; i<s.length; i++ ) {
s[i].draw( ); // polymorphous calling
s[i].erase( ); // same
}
}
}
Programos rezultatai:
43
Circle.draw( )
Circle.erase( )
Square.draw( )
Square.erase( )
Triangle.draw( )
Triangle.erase( )
Taigi kODV¡ Shapes QHNUHLSLD G¡PHVLR ³ NRQNUHWÐ ILJÌURV WLS LU RSHUXRMD
tiesiog baziniu Shape WLSX âLRMH NODV¡MH NDG EÌWÐ GDU ³WLNLQDPLDX JDOLPD PDV\Y
ShapesXåSLOG\WLILJÌURPLVLUDWVLWLNWLQLXEÌGXDWVLWLNWLQLÐVNDLþLÐJHQHUDWRULDXVNXULR
rezultatas yra normalizuotas double VNDLþLXV Lã LQWHUYDOR > @ Math.random( ):
(int)(Math.random( )*3),LUQDXGRMDQWRSHUDWRULÐswitch*DOLPDVXNXUWLGDXJQDXMÐ
ILJÌUÐ WLSÐ WDþLDX NODV¡V Shapes WHNVWR MHL PDV\YR XåSLOG\PDV ILJÌURPLV EÌWÐ
atsitiktinis) keisti nereik¡V 7DL LU \UD SDJULQGLQLV SROLPRUIL]PR SUDQDãXPDV JDOLPD
DWVNLUWL NLQWDQþL LU QHNLQWDQþL SURJUDPRV GDO³ UDãDQW NRG WLN ED]LQLDPV GXRPHQÐ
WLSDPV7DLSJDOLPDGDXJHNRQRPLãNLDXXåUDã\WLSURJUDPRVWHNVW
%HVLOHLGåLDQW\VLVWLSÐSHUWYDUN\PDV
6XWRNLXGXRPHQÐWLSÐSHUWYDUN\PXVXVLGXULDPDSDYHOGLPXPRVFKHPRVHNDL
VXENODV¡V LãSOHþLD VXSHUNODV¡V VVDM R SURJUDPRVH RSHUXRMDPD EHQGUXRMX
VXSHUNODV¡VWLSX3DY\]G\V
Class1
m1( )
m2( )
Class2
m1( )
m2( )
m3()
m4( )
SDY.ODVLÐVFKHPD
44
'DEDU VLXQþLDQW SUDQHãLPXV EHndrajam tipui Class1 YLV WLN UHLN¡V WLNVOLDL
åLQRWLWLNUM³NODV¡VHJ]HPSOLRULDXVWLSMHLWDL\UDClass1 egzempliorius – jis negali
SULLPWL SUDQHãLPÐ m3( ) ar m4( ), jei Class2 egzempliorius – gali priimti visus
pranešimus m1( ), m2( ),m3( ), m4( ). Tod¡O Java tokiose situacijose naudoja
YDGLQDPM³ Y\NG\PR ODLNR WLSÐ QXVWDW\PR Run-Time Type Identification, RTTI)
PHFKDQL]P -HL WLSDV SDVLURGR QHWLQNDPDV – generuojama tipo pervedimo išimtis
ClassCastExceptionåUVN\ULÐVNLUWNODLGÐDSGRURMLPRPHFKDQLzmui).
Klaidingos programos parodytai schemai pavyzdys:
class Class1{
public void m1( ){ }
}
class Class2 extends Class1{
public void m1( ){ } // overriding
public void m2( ){ } // overriding
}
Class1[ ] c = {
new Class1( ), new Class2( )
};
c[0].m1( );
c[1].m2( );
c[1].m3( ); // compilation error !
( ( Class2 ) c[1] ).m3( ); // downcasting here
( ( Class2 ) c[0] ).m3( ); // error: ClassCastException !
}
}
Pranešimas c[1].m3( ); NODLGLQJDVQHVPDV\YDVSDVNHOEWDVVXSHUNODV¡VWLSR

– Class1, o toks tipas gali priimti tik pranešimus m1( ) ir m2( ) 3UREOHP JDOLPD
LãVSU
VWL WLN LãUHLNãWLQLX EÌGX SHUYHGDQW VXSHUNODV¡V WLS ³ NRQNUHWÐ VXENODV¡V WLS
( ( Class2 ) c[1] ).m3( ); . Operatorius ( ( Class2 ) c[0] ).m3( ); klaidingas, nes šis
masyvo elementas yra Class1 tipo.
2.13. AbstrakþLRVLRVNODV¡VLUPHWRGDL
2.11 skyriaus paskutiniame pavyzd\MH NODV¡V Shape PHWRGDL EXYR ILNW\YÌV

9LHQLQWHO¡SUDVP¡MXRVSDWHLNWL–SUDQHãWLNDGYLVRVVXENODV¡VSULYDORWXU¡WLWRNLSDW
VVDM DLãNX M JDOLPD GDU SUDSO¡VWL 7DLJL Shape IDNWLãNDL \UD DEVWUDNþLRML NODV¡
kurios tipu naudojamasi, manipuliuojant ³YDLULRPLV MRV VXENODV¡PLV 9LVL VXENODVLÐ
PHWRGDL³HLQDQW\V³VXSHUNODV¡VVVDMNYLHþLDPLY¡O\YRMRVXVLHMLPRPHFKDQL]PX
$EVWUDNþLRVLRV NODV¡V REMHNWDL QHUHLNDOLQJL $EVWUDNþLRVLRV NODV¡V PHWRGDPV
UHLNLDWXU¡WLWLNVVDMEHWQHNÌQWRG¡OWRNLHPHWRGDLVNHOELDPLSDY\]GåLXLWDLS
abstract void m( );
45
.ODV¡NXULRMH\UDEHQWYLHQDVDEVWUDNWXVPHWRGDVLUJLSULYDOREÌWLSDVNHOEWD
su modifikatoriumi abstract $EVWUDNþLRVLRV VXSHUNODV¡V VXENODV¡V SULYDOR SDWHLNWL
NÌQXV YLVLHPV DEVWUDNWLHVLHPV PHWRGDPV $QNVWHVQLDP SDY\]GåLXL NODV
Shape
JDO¡WXPHSHUUDã\WLWDLSYLVDVSURJUDPRVShapesAbstract.java tekstas yra prieduose):
abstract class Shape{

abstract void draw( );
abstract void erase( );
}
$EVWUDNþLRMRMHNODV¡MHJDOLEÌWLLUUHDOÌVPHWRGDi.
6VDMÐNODV¡V
7DLGDUYLHQDVåLQJVQLVDEVWUDNWXPROLQNSDO\JLQWLVXDEVWUDNþLRPLVNODV¡PLV
MÐ NÌQH MDX QHJDOL EÌWL MRNLÐ UHDOLÐ PHWRGÐ NÌQH JDOL EÌWL WLN NRPSLOLDYLPR ODLNR
(static final, o jei tokie modifikatoriai nenurodyti – jie pritaikomi automatiškai)
NRQVWDQWRV .RQVWUXNFLMRV SDVNLUWLV GYHMRSD 6VDMÐ NODV¡V interfaces JDOL EÌWL
QDXGRMDPRV NDLS SURJUDPRV SURMHNWDYLPR EHL NÌULPR ³UDQNLV – QXURGDQW NODVLÐ
EHQGUDYLPR SURWRNROXV 0DW\W GDU VYDUEHVQ¡ SDVNLUWLV \UD VXNXUWL JDOLP\E
WDP
tiNUDP GDXJ\ELQLDP SDYHOG¡MLPXL Lã NHOLÐ ED]LQLÐ WLSÐ YLVLãNDL GDXJ\ELQLR
SDYHOG¡MLPR JDOLP\EHV UHDOL]XRMD WLN YLGLQ¡V NODV¡V DSLH WDL NDOE¡VLPH Y¡OLDX
6LQWDNV¡VSDY\]G\V
interface Interface1{
int i = 123; // static final supposed
float m1( ); // public supposed
void m2( ); // public supposed
}
interface Interface2{
void m3( );
}
class Class1 implements Interface1, Interface2{
public float m1( ){ . . . } // class implementing interface
public void m2( ){ . . . } // gives realization of all
public void m3( ){ . . . } // methods
System.out.println( “i = “ + i ); // “i” is accessible
}
...
Dabar programoje LãVN\ULDXVNODV

ShapeJDO¡WXPHSHUUDã\WLNDLSVVDMRV
NODV
7RNVSURJUDPRVSDY\]G\V\UDSULHGXRVH
Daugybinio paveldimumo pavyzdys. Java, skirtingai nei C++, toks
SDYHOG¡MLPDVEXVVDXJXVQHVVVDMÐNODV¡VSDSUDVþLDXVLDLQHWXULUHDOL]DFLMRVLUMRNLÐ
GXRPHQÐ NRQIOLNWÐ QHJDOL EÌWL )DNWLãNDL VFKHPD WRNLD SDYHOGLPD Lã DEVWUDNþLRV DU
UHDOLRV NODV¡V LU GDU UHDOL]XRMDPRV UHLNLDPRV VVDMÐ NODV¡V (VPLQLV VFKHPRV
SULYDOXPDV \UD WDL NDG GDEDU ³JDOLQDPDV N\ODQW\VLV WLSÐ SHUWYDUN\PDV ³ EHW NXU³ Lã
46
ED]LQLÐ WLSÐ DEVWUDNþLRVLRV DU UHDOLRVLRV VXSHUNODV¡V EHL YLVÐ UHDOL]XRWÐ VVDMÐ
NODVLÐ3DWHLNLDPHWRNLRVSURJUDPRV-VFKHPRVSDY\]G³
interface I1{ // 1th basic type

void im1( );
}
interface I2{ // 2nd basic type
void im2( );
}
interface I3{ // 3rd basic type
void im3( );
}
class C1{
public void im1( ){ } // 4th basic type
}
class C2 extends C1 implements I1, I2, I3{
// im1 inherited from class C1
public void im2( ){ }
public void im3( ){ }
}
public class C{
void cm1( I1 x ) { x.im1( ); }
void cm2( I2 x ) { x.im2( ); }
void cm3( I3 x ) { x.im3( ); }
void cm4( C1 x ){ x.im1( ); }
C2 cc2 = new C2( );
cm1( cc2 ); // upcasting of type C2 toward type I1
cm2( cc2 ); // . . . toward I2
cm3( cc2 ); // . . . toward I3
cm4( cc2 ); // . . . toward C1
}
}
.DLS PDW\WL NODV¡MH C NYLHþLDQW PHWRGXV NRQNUHWXV WLSDV C2 JDOL EÌWL
QDXGRMDPDVYLHWRMED]LQLÐWLSÐI1, I2, I3, C1 – automatiškai panaudojamas kylantysis
WLSÐSHUWYDUN\PDVWDLSO\JLUUHDOL]XRMDPDVSDYHOG¡MLPDVLããLÐWLSÐ
6VDMÐ NODV¡V JDOL SDYHOG¡WL NLWÐ VVDMÐ NODVLÐ FKDUDNWHULVWLNDV RSHUDWRULDXV
extends G¡ND
6VDMÐ NODV¡V JDOL EÌWL QDXGRMDPRV NRPSLOLDYLPR ODLNR NRQVWDQWRPV ODLN\WL
-RMH VXWHLNXV UHLNãPHV NRQVWDQWRPV QHW LU SDY\]GåLXL DWVLWLNWLQLÐ VNDLþLÐ
generatoriumi Math.random( ), YLVR SURJUDPRV Y\NG\PR PHWX NRQVWDQWÐ UHLNãP¡
QHNLV SUDGLQ¡ UHLNãP¡ VXWHLNLDPD WLN YLHQLQWHO³ NDUW ³NHOLDQW VVDMÐ NODV
7HUPLQ
Ä³NHOWL³ DQNVþLDX QDXGRMRPH WLN NDOE¡GDPL DSLH NODVHV WDþLDX VVDMÐ NODVHL M³ O\JLDL
WDLSSDWJDOLPHWDLN\WLQHVMXNVVDMÐNODV¡\UDWDPWLNUDDEVWUDNWLNODV¡VUÌãLV
Prieduose yra programa ShapesInterface.java, realizuojanti jau kelis kartus
QDJULQ¡W VN\ULDXV SDY\]G³ VX ILJÌURPLV ã³NDUW SHUUDã\WD VX VVDMÐ NODV¡PLV
3ULG¡WD LU YLHQD NRPSLOLDYLPR ODLNR NRQVWDQWD NDG EÌWÐ LOLXVWUXRWDV WRNLRV NODV¡V
kintamojo matomumas.
47
9LGLQ¡VNODV¡V
.ODV
JDOLPD³G¡WL³NLWRVNODV¡VDUPHWRGRYLGÐDUED³NXULQRUVPDWRPXPR
VULW³7RNLDNODV¡YDGLQDPDYLGLQHNODVH9LGLQ¡NODV¡JDOLQHWXU¡WLYDUGR
3DJULQGLQ¡ YLGLQ¡V NODV¡V SDVNLUWLV – SDVO¡SWL NODV¡V UHDOL]DFLM QXR M
³WDOSLQDQþLRVNODV¡VLãRU¡VDUEDUHDOL]XRWLWLNUGDXJ\ELQ³SDYHOG¡MLPQHQXRVVDMÐ
NODVLÐRSDYHOG¡MLPQXRNHOLÐYLGLQLÐNODVLÐWLSÐ
9LGLQ¡PV NODV¡PV JDOLPD WDLN\Wi prieities modifikatorius public, private ar
protected.
3DY\]G\VNODV¡NLWRVNODV¡VYLGXMH
public class ExternalClass{

class InnerClass1{
private int i = 123;
public int valueInt( ){ return i; }
}
class InnerClass2{
private String s = “abc”;
public String valueString( ){ return s; }
}
public void m( ){
InnerClass1 ic1 = new InnerClass1( );
InnerClass2 ic2 = new InnerClass2( );
int j = ic1.valueInt( );
String s = ic2.valueString( );
System.out.println( “j = “+ j + “ s = “ + s );
}
ExternalClass ec = new ExternalClass( );
ec.m( );
}
}
Programos rezultatai:
j = 123 s = abc
Esminis skirtumas nuo ³SUDVWLQLÐ NODVLÐ – Lã Xå ExternalClass ULEÐ YLGLQ¡V
NODV¡V YLVLãNDL QHSDVLHNLDPRV URG\NOHV ³ YLGLQHV NODVHV JDOLPD EÌWÐ VXNXUWL WLN
naudojant specialius metodus:
...
public InnerClass1 makeInnerClass1( ){
return new InnerClass1( );
}
...
Dabar kitoje nei ExternalClassNODV¡MHYLGLQLÐNODVLÐREMHNWDLEÌWÐVXNXULDPL

taip:
48
...
ExternalClass.InnerClass1 ic1 = ec.makeInnerClass1( );
...
8åUDãDV ec.makeInnerClass1( ) URGR NDG YLGLQLÐ NODVLÐ REMHNWDL JDli

HJ]LVWXRWLWLNNDLSLãRULQLÐNODVLÐREMHNWÐGDOLV
.LWDVSDY\]G\VURGRN\ODQW³M³WLSÐSHUWYDUN\PVXYLGLQ¡PLVNODV¡PLV
public interface InnerClass1{

int valueInt( );
}
public interface InnerClass2{
String valueString( );
}
class ExternalClass{
private class PInnerClass1 implements InnerClass1{
private int i =123;
}
protected class PInnerClass2 implements InnerClass2{
private String s = “abc”;
public String value String( ){ return s; }
}
public InnerClass1 makeInnerClass1( ){ // upcasting from
return new PInnerClass1( ); // PInnerClass1 to InnerClass1
}
public InnerClass2 makeInnerClass2(){ // upcasting from
return new PInnerClass2( ); // PInnerClass2 to InnerClass2
}
}
public class PExternalClass{
InnerClass1 ic1 = ec.makeInnerClass1( );
InnerClass2 ic2 = ec.makeInnerClass2( );
}
}
âLDPH SDY\]G\MH YLGLQ¡V NODV¡V UHDOL]XRMD VVDMÐ NODVHV WRG¡O Y¡OLDX

PHWRGXRVH JUåLQDQþLXRVH YLGLQLÐ NODVLÐ REMHNWXV ³PDQRPDV N\ODQW\VLV WLSÐ
SHUWYDUN\PDV ³ VVDMÐ WLSXV .ODV¡V ExternalClass REMHNWDL VXGHULQD GYLHMÐ VVDMÐ
NODVLÐ IXQNFLRQDOXP – UHDOL]XRWDV MÐ VDY\ELÐ GDXJ\ELQLV paveldimumas. Kitoje
NODV¡MH PExternalClass YLGLQ¡V ExternaClass NODV¡V \UD YLVLãNDL QHPDWRPRV WRG¡O
MRMHEDQG\PDVVXNRQVWUXRWLREMHNWWDLS
ExternalClass.PInnerClass1 ic1 = ec.new PInnerClass1( );
NRPSLOLDWRULDXVEÌWÐSULSDåLQWDVNODLGLQJX
49
9LGLQ¡V NODV¡V PHWRGÐ YLGXMH 5HPLDQWLV DQNVWHVQLX SDY\]GåLX MHL WXU¡WXPH
WLNYLHQYLGLQ
NODV

public interface InnerClass{

int valueInt( );
}
public InnerClass makeInnerClass( ){
class PInnerClass implements InnerClass{
private int i =123;
}
return new PInnerClass( ); // upcasting to InnerClass1
}
InnerClass ic1 = ec.makeInnerClass( );
}
}
ýLD YLGLQ¡ NODV¡ \UD SDVO¡SWD GDU JLOLDX LU SULHLQDPD WLN Lã PHWRGR
makeInnerClass vidaus.
/DEDLSDQDãLDLYLGLQHVNODVHVJDOLPD³G¡WL³EHWNXULPDWRPXPRVULW³WLNLãWHQ
MRVLUEÌWÐSULHLQDPRV
%HYDUG¡VYLGLQ¡VNODV¡V3DY\]G\V

public InnerClass makeInnerClass( ){
return new InnerClass( ){ // here the inner class begins
private int i =123;
}; // …and here ends
}
InnerClass1 ic1 = ec.makeInnerClass( );
}
}
Šiuo atveju metode makeInnerClass konstruojamas InnerClass objektas, ir iš

NDUWR SDURGRPD NDLS WDL WXUL EÌWL DWOLNWD SDVLQDXGRMDQW YDGLQDPMD EHYDUGH YLGLQH
NODVH 7DL ODEDL WUXPSD LU DLãNL VLQWDNV¡V IRUPD WRG¡O ãLR WLSR YLGLQHV NODVHV SODþLDL
QDXGRVLPH NXUGDPL JUDILQHV YDUWRWRMR VVDMDV UHDOL]XRGDPL Swing SDNHWR ³Y\NLÐ
NODXV\WRMXVåUVN\ULÐÄSwingWHFKQRORJLMD³7RNLRVVVDMRV\UDÄ³Y\NLDLVYDOGRPRV
VLVWHPRV³ 3DNHWDV UHDOL]XRMD MÐ NDUNDV application framework R IXQNFLRQDOXP
ãLDPNDUNDVXLVXWHLNVLPHSDVLQDXGRGDPLYLGLQ¡PLVNODV¡PLV
Dabar pateiksime principiQ
VFKHP URGDQþL NDLS QDXGRMDQWLV YLGLQ¡PLV
NODV¡PLV JDOLPD UHDOL]XRWL GDXJ\ELQ³ SDYHOG¡MLP Lã NHOLÐ QH VVDMÐ NODVLÐ WRNLD
VFKHPD GDXJ\ELQLDP SDYHOG¡MLPXL Lã NHOLÐ VVDMÐ SDURG\WD SLUPDMDPH ãLR VN\ULDXV
programos pavyzdyje):
50
class C{ . . . }
abstract class D{ . . . }
class E extends C{
D makeD( ){
return new D( ){ . . . };
}
}
public class CD{

static void takesC( C c ){ . . . }
static void takesD( D d ){ . . . }
E e = new E( );
takesC( e ); // upcasting to type C
takesD( e.makeD( ) ); // upcasting to type D
}
}
ýLD NODV¡ E QDXGRMD NODVLÐ C ir D IXQNFLRQDOXP .DL C ir D \UD NODV¡V –

SDQDãL VFKHPD VX YLGLQH EHYDUGH NODVH \UD YLHQLQWHO¡ JDOLP\E¡ GDXJ\ELQLDP
SDYHOG¡MLPXL
3DVNXWLQ¡V SDVWDERV DSLH YLGLQHV NODVHV 3LUPD MDX VDN¡PH YLGLQ¡V NODV¡V
objektas egzistuoMD WLN NDLS LãRULQ¡V NODV¡V VXEREMHNWDV 7RG¡O YLGLQ¡ NODV¡
DXWRPDWLãNDL WXUL SULHLW³ SULH YLVÐ LãRULQ¡V NODV¡V HOHPHQWÐ $QWUD NRPSLOLXRMDQW
NODVHV VX YLGLQ¡PLV NODV¡PLV EXV VXNXUWRV LU class ULQNPHQRV YLVRPV YLGLQ¡PV
NODV¡PV SDY\]GåLXL SULHãSDVNXWLQHi programai bus sukurtos rinkmenos
ExternalClass.class – išorinei klasei ir ExternalClass$InnerClass.class – vidinei
NODVHLQDXGRMDQWEÌWHQWWRNLDVWDLV\NOHVNODV¡VYDUGXL
.ODLGÐDSGRURMLPRPHFKDQL]PDV
Klaida, arba išimtis (Java jas vadina exception) – objektas, aprašantis

NODLGLQJ VLWXDFLM SURJUDPRMH âLV REMHNWDV VXNXULDPDV NLOXV VLWXDFLMDL LU
SHUGXRGDPDV VLWXDFLM VXN¡OXVLDP PHWRGXL 0HWRGDV UHDJXRGDPDV ³ ãL LãLPW³ JDOL
atlikti kokius nors veiksmus – DSGRURWL LãLPW³ DUED SHUGXRWL LãLPW³ apdoroti
DXNãWHVQLDP PHWRGXL ,ãLPW³ SURJUDPRMH JDOL VXNHOWL LU SDWV SURJUDPXRWRMDV
LQIRUPXRGDPDV DSLH NRNL QRUV QHOHLVWLQ VLWXDFLM SDY\]GåLXL MHL NRNV SURJUDPRV
NLQWDPDVLVLãHLQDXåDOJRULWPRMDPOHLGåLDPÐULEÐ
,ãLPWLPV DSGRURWL UHLNDOLQJL UDNWDåRGåLDL try, catch, throw, throws ir finally.
5DNWDåRGLV try ILJÌULQLDLV VNOLDXVWDLV DSLPD RSHUDWRULÐ EORN NXULV EXV
kontroliuojamas. Jei šiame bloke kyla išimtis – M UHLNLD ÄVXJDXWL³ DUED SHULPWL –
catch, ir apdoroti. Programos vykdymo laiko klaidas (run-time errors) sukelia
automatiškai Java. Programuotojas pats savo išimtis sukelia specialiu operatoriumi
throw. Metodas, kuriame gali kilti išimtis, bet kuris pats neapdoroja šios išimties, o
QRUL SHUGXRWL M DSGRURWL DXNãWHVQLDP PHWRGXL WXUL EÌWL SDå\P¡WDV RSHUDWRULXPL
throws. Operatorius finally atlieka panašias funkcijas kaip default operatoriuje switch:
51
QXURGRNRGRIUDJPHQWNXULVEÌWLQDLWXULEÌWLDWOLNWDVQHDWVLåYHOJLDQW³WDLNLORLãLPWLV
DUQH7DLJLSULQFLSLQ¡NODLGÐDSGRURMLPRVFKHPD\UDWRNLa:
try{ kontroliuojamas kodo blokas }

catch( ExceptionType1 et1 ) { et1 apdorojimas }
catch( ExceptionType2 et2 ) { et2 apdorojimas }
...
finally {EÌWLQDLDWOLHNDPDVNRGRIUDJPHQWDV}
9LVRVLãLPW\V\UDNODV¡VThrowableVXENODV¡VäHPLDX\UDGYLMRVVXENODV¡V–
Exception ir Error. Exception NODV¡ DSLPD NODLGLQJDV SURJUDPRV VLWXDFLMDV NXULDV
WXU¡WÐVXJDXWLLUDSGRURWLSURJUDPXRWRMDV-RNXULDPRVLãLPW\VWDLSSDWWXULEÌWLãLRV
NODV¡V VXENODV¡V 6YDUEL Exception VXENODV¡ \UD RuntimeException: ji apima tokias
NODLGDV NDLS GDO\ED Lã QXOLR PDV\YR LQGHNVR LãHLWLV Xå PDV\YR ULEÐ LU SDQ $LãNX
SURJUDPXRWRMDV QRU¡GDPDV JDOL VXNHOWL WRNLR WLSR LãLPWLV LU SDWV .ODV¡V Error ir jos
VXENODVLÐ DSLEU¡åLDPÐ LãLPþLÐ SURJUDPRMH SHULPWL QHUHLNLD WDL WRNLRV LãLPW\V NXULÐ
programa negali pati apdoroti –WDLVLVWHPLQ¡VLUNRPSLOLDYLPRNODLGRV
Jei RuntimeException LãLPWLHV SURJUDPXRWRMDV QHSHULPD M DXWRPDWLãNDL
perima Java NODLGÐ DSGRURMLPR PHFKDQL]PDV LãYHGDPDV SUDQHãLPDV DSLH NODLG
PHWRGÐNYLHWLPÐVHNDLUSURJUDPRVGDUEDVQXWUDXNLDPDV6HNDLãYDUGLMDYLVPHWRGÐ
LUMÐNODVLÐYDUGÐVHNQXRLãLPW³VXN¡OXVLRPHWRGRLNLDXNãþLDXVLRPHWRGRLUDWURGR
taip:
at.ODV¡V9DUGDV0HWRGR9DUGDV5LQNPHQRV9DUGDVjavaHLOXW¡VQXPHULV
at .ODV¡V9DUGDV$XNãWHVQLRMR0HWRGoVardas (RinkmenosVardas.java HLOXW¡V
numeris)
...
2.16.1. Operatoriai try ir catch
Operatoriai reikalingi, kai programuotojas pats bando perimti Java ar savo

SDWLHVVXNXUWLãLPW³3DY\]GåLXLGDO\ERVLãQXOLRSHU¡PLPDV
class MyException{
int numerator, denominator, result;
try{
numerator = 123;
denominator = 0;
result = numerator/denominator;
System.out.println( “This won’t be printed” );
} catch( ArithmeticException ae ){
System.out.println( “Processing of exception” );
}
System.out.println( “After catch of exception” );
}
}
52
Processing of exception
After catch of exception
7DLJL SURJUDPRMH SHU¡PXV LãLPW³ DWOLHNDPDV WR catch operatoriaus, kurio

DUJXPHQWRWLSDVVXWDPSDVXN\ODQþLRVLãLPWLHVWLSXVULW\MHHVDQWLVNRGRIUDJPHQWDVR
toliau –Y\NGRPLåHPLDXtry srities esantys operatoriai. Taip galima parašyti niekada
avariškaiQHVLEDLJLDQþLDVSURJUDPDV
.ODV¡ Throwable WXUL PRGLILNXRW PHWRG toString SDYHOGLP Lã Object
NODV¡V.LHNYLHQDJavaLãLPWLVWXULVXMDDVRFLMXRWSDDLãNLQDPM³WHNVWNXU³JDOLPD
LãYHVWLãLXRPHWRGXPHWRGRLãUHLNãWDLNYLHVWLQHUHLNLDSDY\]GåLXL
...
} catch( ArithmeticException ae ){
System.out.println( “Exception” + ae );
...
Kai programa po kontroliuojamo bloko bando perimti kelias skirtingas išimtis

– reikalingi keli skirtingi operatoriai catch -LH WXUL EÌWL LãG¡VWRPL WDP WLNUD WYDrka:
SLUPLDX UHLNLD SHULPWL LãLPW³-VXENODV
R Y¡OLDX – LãLPW³-VXSHUNODV
$QWUDLS GDOLV
SURJUDPRVNRGRQLHNDGDQHEÌWÐY\NGRPDRWDLMDXVLQWDNV¡VNODLGD3DY\]GåLXL
...
try{
...
} catch ( Exception e ){
System.out.println( “Exception” + e );
} catch ( ArithmeticException ae ){
System.out.println( “Exception” + ae );
}
...
ArithmeticException yra ExceptionVXENODV¡WRG¡OYLVDGDEXVSHULPWDSLUPRML

išimtis – Exception R DQWUDVLV EORNDV QLHNDGD QHEÌWÐ Y\NGRPDV 7RG¡O WRNV
programos fUDJPHQWDVQHJDO¡WÐEÌWLVXNRPSLOLXRWDV
0LQ¡WLHML RSHUDWRULDL JDOL EÌWL LU NDUWRWLQLDL YLHQR try EORNR YLGXMH JDOL EÌWL
kitas try blokas ir t. t.
2.16.2. Operatorius throw
6XNHOLDSURJUDPXRWRMRLãLPW³QDXGRMDQWWRNLVLQWDNV

. . . throw ThrowableInstance;
þLD ThrowableInstance \UD DUED YLGLQ¡ Java išimtis – viena kuri nors Throwable
NODV¡V VXENODV¡ DUED SDWLHV SURJUDPXRWRMR VXNXUWD LãLPWLV WDLS SDW WXUL SDYHOG¡WL
ThrowableVDY\EHVâLVREMHNWDVVXNXULDPDV³SUDVWDLRSHUDWRULXPLnew9LVÐYLGLQLÐ
Java LãLPþLÐ NRQVWUXNWRULDL \UD GYLHMÐ WLSÐ EH DUJXPHQWR DUED VX String tipo
53
DUJXPHQWX 3DVWDUXRMX JDOLPD REMHNWXL VXWHLNWL SDDLãNLQDPM³ WHNVW NXU³ Y¡OLDX
spausdintume metodu toString.
²Y\NGåLXV RSHUDWRULÐ SURJUDPRV Y\NG\PDV SHUWUDXNLDPDV LU YDOGymas
atiduodamas atitinkamam catch blokui. Jei toks nerandamas –SURJUDPVWDEGRJava
NODLGÐ DSGRURMLPR PHFKDQL]PDV 3DY\]G\V-VFKHPD VXNHOLDPD YLGLQ¡ Java klaida
NullPointerException – tam operatoriumi new sukuriamas jos objektas; ji sugaunama,
paskui sukeliama nauja tokio pat tipo klaida, o jos apdorojimas atiduodamas
aukštesniam metodui:
public class MyException2{

static void throwException( ){
try{
throw new NullPointerException( “Example” );
} catch( NullPointerException npe ){
System.out.println( “Caugth inside throwException” );
System.out.println( “Exception type: “ + npe );
throw npe;
}
}
try{
throwException( );
} catch( NullPointerException npe ){
System.out.println( “Caugth repeatedly inside main” );
}
}
}
Caugth inside throwException

Exception type: Example
Caugth repeatedly inside main
2.16.3. Operatorius throws
7DL UDNWDåRGLV PHWRGXL NXULV JDOL VXNHOWL LãLPW³ WDþLDX Sats jos neapdoros –
WDGD NODLG SULYDOR DSGRURWL DXNãWHVQLV NYLHþLDQW\VLV PHWRGDV DLãNX ãLV JDOL
SHUDGUHVXRWL DSGRURMLP GDU DXNãWHVQLDP PHWRGXL LU W W 3R RSHUDWRULDXV throws
galima išvardyti ir kelias išimtis – WDGD YLVRV MRV WXUL EÌWL SHULPWRV DXNãtesniame
metode. Nereikia apdoroti tik Error ir RuntimeExceptionLãLPþLÐEHLMÐVXELãLPþLÐ
Pavyzdys:

static void throwException( ) throws Exception{
System.out.println( “Inside throwException” );
throw new Exception( “Example” );
}
54
try{
throwException( );
} catch( Exception e ){
System.out.println( “Exception “ + e + “ caught” );
}
}
}
2.16.4. Operatorius finally
âLR RSHUDWRULDXV EORNDV UDãRPDV SR YLVÐ catch bloNÐ LU Y\NGRPDV EHW NRNLX
atveju – NLOR LãLPWLV DU QH 3DY\]GåLX JDO¡WÐ EÌWL GXRPHQÐ VNDLW\PDV Lã ULQNPHQRV
VNDLWDQW GXRPHQLV JDOL NLOWL YLGLQ¡ Java išimtis IOException – WRNLX DWYHMX M UHLNLD
perimti, o po jos apdorojimo –XåGDU\WLULQNPHQMHLGXRPHQ\V nuskaityti tvarkingai
EHNODLGÐ–YLVWLHNSRYLVNRULQNPHQUHLNLDXåGDU\WL%HMHMHL\UDRSHUDWRULXVfinally,
Java kompiliatorius nereikalauja po try bloko catchRSHUDWRULÐ
Tas pat pavyzdys su šiuo operatoriumi:

static void throwException( ) throws Exception{
System.out.println( “Inside throwException” );
throw new Exception( “Example” );
}
try{
throwException( );
} finally{
System.out.println( “An exception caught” );
}
}
}
2.16.5. Kai kurios vLGLQ¡VJava išimtys
Java YLGLQ¡V LãLPW\V GDU VNLUVWRPRV ³ NRQWUROLXRMDPDV LU QHNRQWUROLXRMDPDV

LãLPWLV 0LQ¡WD NDG RuntimeException LãLPW\V JDOL EÌWL SURJUDPRMH QHSHULPDPRV –
WRG¡O MRV YDGLQDPRV QHNRQWUROLXRMDPRPLV .DL NXULRV Lã MÐ NDGD MRV N\OD – gerai
QXVDNRYLHQMÐLãVDPÌVSDYDGLQLPDL\UD
ArithmeticException
ArrayIndexOutOfBoundsException
ClassCastException
NullPointerException
.RQWUROLXRMDPRVLãLPW\VWXULEÌWLSHULPDPRVDUED³WUDXNLDPRV³throwsVUDã
-ÐSDY\]GåLDL
ClassNotFoundException
55
IllegalAccessException
InstantiationException – kai bandoma sukurti abstractNODV¡VREMHNW
InterruptedException –NDLEDQGRPDSHUWUDXNWLY\NGRPVUDXWåUWROHVQLXV
skyrius)
NoSuchMethodException
NoSuchFieldException
.XULDQW VDYR LãLPW³ UHLNLD SO¡VWL NODV

Exception âL NODV¡ QHWXUL MRNLÐ VDYR
PHWRGÐ MXRV SDYHOGL Lã Throwable: String toString( ), String getMessage( ) ir t. t.
Šiuos metodus galima perrašyti.
6DYRV LãLPWLHV NÌULPR SDY\]G\V 7DUNLPH SURJUDPD WXUL NYLHVWL VNDLþLDYLPR
PHWRG compute su nurodyta int WLSR DUJXPHQWR UHLNãPH -HL WD UHLNãP¡ YLUãLMD
UHLNLD VXåDGLQWL LãLPW³ .DUWX SHUUDãRPDV LU PHWRGDV toString NDG EÌWÐ LãYHGDPDV
sugeneruotos išimties pavadinimas ir metodui computeDWLGXRWDDUJXPHQWRUHLNãP¡
class MyException5 extends Exception{

private int arg;
MyException5( int i ){
arg = i;
}
public String toString( ){
return “MyException5( “ + arg + “ )”;
}
}
public class ExceptionExample{

static void compute( int i ) throws MyException5{
System.out.println( “Method compute( “ + i + “ )”;
if( i > 10 ) throw new MyException5( i );
System.out.println( “Regular finish of method compute” );
}
try{
compute( 5 );
compute( 15 );
} catch( MyException5 e ){
System.out.println( “An exception caught” + e );
}
}
}
Programos spausdiniai:
Method compute( 5 )
Regular finish of method compute
Method compute( 15 )
An exception caught MyException5( 15 )
56
²YHVWLHVLULãYHVWLHVVLVWHPRVSDJULQGDL
Diduma sistemos realizuota pakete java.io.

Java ³YHVWLHV LU LãYHVWLHV VLVWHPD IXQNFLRQXRMD YDGLQDPÐMÐ VUDXWÐ SDJULQGX
7DLWDPWLNUDSURJUDPLQ¡DEVWUDNFLMDVXNXULDPDVVUDXWRREMHNWDVVXVLHMDPDVVXNRNLX
QRUVIL]LQLXNRPSLXWHULR³UHQJLQLXLUVSHFLDOLDLVJava metodaLVVUDXWDPVSDY\]GåLXL
MDX PXPV åLQRPX PHWRGX println GXRPHQ\V ³YHGDPL Lã VUDXWR DU QXNUHLSLDPL ³
VUDXW
Yra baitiniai ir simboliniai (UnicodeVLPEROLÐVUDXWDL3DVWDUDLVLDLVSDSLOG\WD
tik Java 2.
Šiame kurse susidursime su tokiais baitiniais srautais:
InputStream –DEVWUDNþLRVLRVVUDXWÐNODV¡V³YHVþLDLLU
OutputStream LãYHVþLDL
BufferedInputStream –VUDXWDLQDXGRMDQW\VDWPLQWLHVEXIHU³NXULR
BufferedOutputStream WDOSD JDOL EÌWL QXVWDW\WD SDJDO QXW\O¡MLP DUED
išreikštai paties programuotojo. Daug
efektyvesni nei nebuferizuoti.
DataInputStream –SULPLW\YLÐGXRPHQÐLUStringGXRPHQÐ
DataOutputStream srautai
FileInputStream –VUDXWDLLãULQNPHQRVLU³ULQNPHQ
FileOutputStream
PrintStream – srautas metodams print( ) ir println( ) laikyti
Atitinkami simboliniai srautai yra:
Reader –DEVWUDNþLRVLRVVUDXWÐNODV¡V
Writer
BufferedReader
BufferedWriter
StringReader – tik iš dalies atitinka DataInputStream bei

StringWriter DataOutputStream: skirtas tik String
duomenims
FileReader
FileWriter
PrintWriter
57
Kadangi Java 2UHNRPHQGXRMDPLVLPEROLQLDLVUDXWDL\UDLUVSHFLDOLRVNODV¡V
SHUYHGDQþLRV EDLWLQLXV VUDXWXV ³ VLPEROLQLXV InputStreamReader ir
OutputStreamWriter.
*UHWDãLÐVUDXWÐSDODLNRPDLUYDGLQDPRMLVWDQGDUWLQ¡³YHVWLVLULãYHVWLV7RNLD
VYRND UHLãNLD YLVL GXRPHQ\V SURJUDPDL ³YHGDPL Lã YLHQLQWHOLR VWDQGDUWLQ¡V ³YHVWLHV
VUDXWRLULãYHGDPL³YLHQLQWHO³VWDQGDUWLQ³LãYHVWLHVVUDXWRYLVRVNODLGRVXåUDãRPRV³
YLHQLQWHO³ VWDQGDUWLQ³ NODLGÐ VUDXW âLH VWDQGDUWLQLDL VUDXWDL UHDOL]XRWL QH SDNHWH
java.io, bet java.lang.SystemNODV¡MHâLRMHNODV¡MH\UDpublic static laukai:
in –VUDXWDVVWDQGDUWLQHL³YHVþLDL
out –VUDXWDVVWDQGDUWLQHLLãYHVþLDL
err –VUDXWDVVWDQGDUWLQLDPNODLGÐVUDXWXL
Laukai out ir err\UDNODV¡VPrintStream objektai; jie susieti su pultu. Laukas

in yra InputStream objektas ir taip pat susietas su pultu. Šiuos baitinius srautus galima
SHUWYDUN\WL ³ VLPEROLQLXV VUDXWÐ-ÄWLOWÐ³ InputStreamReader ir OutputStreamWriter
pagalba. âLXRVVUDXWXVJDOLPDQXNUHLSWLLUQH³SXOWNODV¡VSystem metodais
setIn( InputStream ), setOut( PrintStream ) bei setErr( PrintStream ).
²YHVWLHV LU LãYHVWLHV VLVWHPD \UD NODLGL WRG¡O DSVLULERVLPH LãQDJULQ¡GDPL NDL
kuriuos standartiškai reikalingus atvejus.
²YHVWLV Lã SXOWR 5HNRPHQGXRMDPD QH EDLWLQ¡ EHW VLPEROLQ¡ ³YHVWLV LU GDU
buferizuota, t. y. reikia operuoti ne vienu simboliu, bet keliais iškart – taip efektyviau.
0LQ¡WDNDGSXOWR³YHVWLV–³YHVWLVLãREMHNWRSystem.in; šis objektas yra baitinio srauto
InputStream WLSR â³ EDLWLQ³ VUDXW UHLNLD SHUWYDUN\WL ³ VLPEROLQ³ WLOWX
InputStreamReader9LVNVXG¡MXVNDUWXWXULPH
BufferedReader br = new BufferedReader(

new InputStreamReader(
System.in ) );
.ODV¡MHBufferedReader yra metodai:
int read( ) throws IOException –YLHQDPVLPEROLXL³YHVWLMLVJUåLQDPDVNDLS

atitinkama int UHLNãP¡ .DL UDQGDPD VUDXWR
SDEDLJDJUåLQDPDUHLNãP¡–1;
String readLine( ) throws IOException – YLHQDL HLOXWHL ³YHVWL 6XUDGXV VUDXWR
SDEDLJJUåLQDPDUHLNãP¡null.
3DY\]G\VVLPEROLÐ³YHGLPDVLãNODYLDWÌURVNROQHEXV³YHVWDVVLPEROLVq:
import java.io.*;
class CharReading{
public static void main( String args [ ] ) throws IOException{
// “throws” transfers possible exception of method
// “read”.Now the “try” block is not needed
char c;
System.in ) );
58
do{
c =( char )br.read( );
System.out.println( c );
} while( c != ‘q’ );
}
}
²YHGXVSDY\]GåLXLabcdq ir QXVSDXGXV³YHGLPRNODYLãSURJUDPDVSDXVGLQV
a
b
c
d
q
7DLS \UD WRG¡O NDG ³YHGLPDV EXIHUL]XRWDV – ³ EXIHU³ QXVNDLWRPL LãNDUW YLVL
VLPEROLDL R Lã EXIHULR VNDLWRPD MDX SR VLPERO³ 1HEXIHUL]XRWR ³YHGLPR WRNLX DWYHMX
EÌWÐ³YHVWDVWLNSDVNXWLQLVVLPEROLV
,ãYHVWLV³SXOW3DSUDVþLDXVLDQDXGRWLNODV¡VSystem metodus out.print arba

out.println. Rekomenduojama naudoti simbolinius srautus – NODV
PrintWriter. Jos
REMHNWDLVXNXULDPLNHOLDLVDOWHUQDW\YLDLVNRQVWUXNWRULDLV9LHQDVLãMÐ\UDPrintWriter(
OutputStream os, boolean b ), t. y. simbolinis srautas gaunamas iš baitinio srauto.
Taigi vietoje šio argumento galima teikti System.out ODXN NDGDQJL ãLV \UD
PrintStream tipo, o pastarasis paveldi iš OutputStreamNODV¡V-HLb yra true, srautas
išvedamas iãEXIHULRGLVNHDXWRPDWLãNDLNDLVXUDQGDPDHLOXW¡VSDEDLJDVLPEROLDL\n).
Antraip galimas atvejis, kai nieko nebus išvesta: kol buferis nebus pripildytas,
GXRPHQ\V Lã MR QHEXV LãYHGDPL 7DLS JDOL QXWLNWL PÌVÐ SURJUDPRVH LãYHGDQW
nedidelius kiekius duomeQÐ9LVNVXG¡MXVWXULPH
PrintWriter pw = new PrintWriter( System.out, true );
.ODV¡PrintWriter turi metodus print( ) ir println( ), kurie prireikus pasitelkia

PHWRGtoString( ).
3DY\]G\VSHUUDã\VLPHDQNVWHVQ
SURJUDP
import java.io.*;
class CharReading{
char c;
System.in ) );
PrintWriter pw = new PrintWriter( System.out, true );
do{
c =( char )br.read( );
pw.println( c );
} while( c != ‘q’ );
}
}
59
'XRPHQÐ PDLQDL VX ULQNPHQRPLV 9LVRV Java ULQNPHQRV \UD EDLWLQ¡V
6UDXWDPVLãULQNPHQÐVDYRPDãLQRMHDWLGDU\WLSDSUDVWDLQDXGRMDPLNRQVWUXNWRULDL
FileInputStream( String fileName ) throws FileNotFoundException;

FileOutputStream( String fileName ) throws FileNotFoundException;
$WLGDULXV³UDã\PR ULQNPHQ DQNVWHVQ¡ WXR SDW YDUGX EXYXVL ULQNPHQD VXJULDXQDPD

Jei rinkmenos nebuvo – VXNXULDPD QDXMD 7DLJL OLHND QHDLãNX NRG¡O NRQVWUXNWRULXV
JHQHUXRMD QXURG\W LãLPW³ 3R ULQNPHQRV ³UDã\PR DU QXVNDLW\PR M UHLNLD XåGDU\WL
0XPVEXVUHLNDOLQJLWRNLHãLÐVUDXWÐPHWRGDL
int read( ) throws IOException;

void write( int i ) throws IOException;
void close( ) throws IOException;
6NDLWDQW ULQNPHQ PLQ¡WRML LãLPWLV N\OD NDL UDQGDPD ULQNPHQRV SDEDLJD (2)
JUåLQDPD UHLNãP¡ –1). Rekomenduojami simboliniai buferizuoti srautai, kurie turi
metodus readLine( ), kelis perkrautus write( ) metodus, ir kuriuos gautume jau
³SUDVWXEÌGX

new FileInputStream( “file.in” )));
PrintWriter pw = new PrintWriter(

new BufferedWriter(
new FileWriter( “file.out” )));
3DY\]G\VULQNPHQRVNRSLMDYLPDV³NLWULQNPHQULQNPHQÐYDUGDLSURJUDPDL
WHLNLDPLNRPDQGLQ¡MHHLOXW¡MH
import java.io.*;
class CopyingFile{
// transfers exceptions of “write”, “read”, “close”
String line;
BufferedReader in;
PrintWriter out
try{
in = new BufferedReader(
new FileInputStream( args[0] )));
out = new PrintWriter(
new BufferedWriter(
new FileWriter( args[1] )));
} catch( FileNotFoundException e ) {
// exception may arise when searching for source file
System.out.println( “Source file does not exist” );
60
return;
} catch( ArrayIndexOutOfBoundsException e ){
// exception may arise when the program is
// wrongly launched from command line
System.out.println( “To be used:” );
System.out.println( “java CopyingFile source target” );
return;
}
do{
line = in.readLine( );
if( line != null ) {
out.write( line+”\n” ); // here the overridden
} // write( String ) is used.
} while(line != null ); // \n breaks the line.
in.close( );
out.close( );
}
}
3URJUDPDWXULEÌWLSDOHLVWDLãNRPDQGLQ¡VHLOXW¡VWDLSGDUELQLDPHDSODQNHMDX
WXULEÌWL³UDã\WDHLOXWLQLÐGXRPHQÐULQNPHQDsourceFile):
java CopyingFile sourceFile targetFile
Darbiniame aplanke programa sukXULDULQNPHQtargetFile.
6LVWHPLQ¡V ³YHVWLHV LU LãYHVWLHV SHUDGUHVDYLPDV PHWRGDLV setIn, setOut,

setErr.
6LVWHPLQ¡V LãYHVWLHV LU VLVWHPLQLR NODLGÐ VUDXWR QXNUHLSLPDV ³ ULQNPHQ WHJX
rinkmenos vardas yra file.out):
...
PrintStream out;
try{
out = new PrintStream(
new BufferedOutputStream(
new FileOutputStream( “file.out” )));
System.setOut( out );
System.setErr( out );
...
System.out.println( “This message goes to the file file.out” );
System.err.println( “This error-message goes to the file file.out, too” );
} catch( Exception e ) {
System.err.println( “Error “ + e );
}
...
out.close( );
...
61
Šiame pavyzdyje WHQND QDXGRWL VUDXW PrintStream QHV NODV¡V System laukas
out NXU³ LU QRULPH SHUDGUHVXRWL \UD OutputStream tipo; o PrintStream paveldi
OutputStreamIXQNFLRQDOXP7ROLDXGDUSULGHGDPDVEXIHULVVNDLW\PRLãULQNPHQRV
srautui FileOutputStream9LVNVXG¡Mus gaunamas reikiamas programos objektas out.
6LVWHPLQ¡V ³YHVWLHV SHUDGUHVDYLPDV Lã ULQNPHQRV WDUNLPH file.in EÌWÐ WRNV
G¡OIUDJPHQWRWUXPSXPRSUDOHLVLPHtryEORN
...
BufferedInputStream in = new BufferedInputStream(
new FileInputStream( “file.in” ));
System.setIn( in );
new InputStreamReader( System.in ));
...
String line = br.readLine( );
...
in.close( );
...
,ã SURJUDPRV PDW\WL NDG VLVWHPLQ¡V ³YHVWLHV SHUDGUHVDYLPDV Lã Uinkmenos

SURJUDPRVWHNVWRQHVXWUXPSLQDLUQ¡UDODEDLQDXGLQJDV
Visa tai – WLN ³YDGDV ³ VXG¡WLQJ Java ³YHVWLHV LU LãYHVWLHV VLVWHP *DOEÌW
QRULQWUHDOL]XRWLNDLNXULDVLG¡MDVWHNVVDYDUDQNLãNDLLãQDJULQ¡WLLUNLWXVVUDXWXV
ZipInputStream, ZipOutputStream – VUDXWDL VX GXRPHQÐ DXWRPDWLQLX
VXVSDXGLPX³zipIRUPDW
PipedInputStream, PipedOutputStream ir analogiški simboliniai srautai
PipedReader, PipedWriter –VUDXWDLEHQGUDXWLWDUSNHOLÐSURJUDPRVY\NG\PRJLMÐåU
tolesnius skyrius);
RandomAccessFile –YLVLãNDLVDYDUDQNLãNDNODV¡ãLRWLSRULQNPHQRPVLUWW
6DYLDQDOL]¡VVLVWHPD
'DXJHOLV DQNVþLDX QDJULQ¡WÐ NODVLÐ \UD SDNDQNDPDL VXG¡WLQJRV .DG MRPLV

EÌWÐ JDOLPD V¡NPLQJDL QDXGRWLV UHLNLD åLQRWL MÐ VXSHUNODV
VVDMÐ NODVHV
konstruktorius,PHWRGXVSDþLRMHNODV¡MHVNHOELDPXVPHWRGXVLUPHWRGXVSDYHOGLPXV
LãYLVÐVXSHUNODVLÐLNLSDWObjectNODV¡VODXNXV9LVXVãLXRVGDO\NXVJDOLPDVXåLQRWL
naudojantis JavaVDYLDQDOL]¡VVLVWHPDNXUL³J\YHQGLQDSDNHWDVjava.lang.reflect ir jo
NODV¡Class.
.ODV¡ Class VDXJR LQIRUPDFLM DSLH YLV REMHNWR EÌNO
SURJUDPRV Y\NG\PR
(ne kompiliavimo!) metu. Class REMHNWDL DXWRPDWLãNDL VXNXULDPL ³NHOLDQW NODVHV MÐ
QHJDOLPD VXNXUWL ³SUDVWLQLX EÌGX RSHUDWRULXPL new 5RG\NO
³ Class REMHNW JDOLPD
gauti statiniu Class metodu:
static Class forName( String name ) throws ClassNotFoundException
3DY\]GåLXL
62
Class c = Class.forName( “java.lang.String” );
.LHNYLHQDPHJ]LVWXRMDQþLDPEHWNXULRVNODV¡VREMHNWXLURG\NO
³MR&ODVVREMHNWWDLS
pat galima gauti metodu getClass( ):
...
ClassX cx = new ClassX( );
Class c = cx.getClass( );
...
7XULQW UHLNLDP URG\NO

PHWRGDLV getConstructors( ), getMethods( ), ...
gaunami visi klasei prieinami konstruktoriai, metodai ir kita informacija.
âLVVDYLDQDOL]¡VPHFKDQizmas reikalingas JavaBeansWHFKQRORJLMRMHåUVN\ULÐ
apie SwingWHFKQRORJLMýLDM³SDQDXGRVLPHNXUGDPL³UDQN³NXULVVXåLQRVLU³SXOW
EHL ULQNPHQ List.out tame pat aplanke, kaip ir programos kodo rinkmena, išves
NODV¡V NRQVWUXNWRULÐ LU PHWRGÐ VUDãXV %H WRNLÐ VUDãÐ QDXM NODV
LU MRV JDOLP\EHV
LãQDJULQ¡WL ODEDL NHEOX .DGDQJL SLOQXRVH PHWRGÐ LU NRQVWUXNWRULÐ YDUGXRVH GDåQDL
SDVLNDUWRMD SUDGLQ¡ YDUGR GDOLV java.lang M Lã YLVÐ YDUGÐ SDãDOLQVLPH NODV¡V String
PHWRGDLV 'XRPHQ\V DSLH QRULP LãW\ULQ¡WL NODV
³UDQNLXL SHUGXRGDPL NRPDQGLQ¡V
HLOXW¡V SLUPXRMX DUJXPHQWX UHLNLD SLOQRMR NODV¡V YDUGR R DQWUXRMX DUJXPHQWX MHL
SDJHLGDXMDPD SHUGXRVLPH ³UDQNLXL LQIRUPDFLM DSLH EÌWLQDL YDUGH WXULQþL EÌWL
VXEHLOXW
SDY\]GåLXL MHL QRULPH VXåLQRWL WLN VUDã PHWRGÐ LãYHVþLDL JDOLPH ³WDUWL
NDG YDUGH WXU¡V EÌWL åRGLV write – WRN³ String GXRPHQ³ LU WHLNVLPH DQWUXRMX
NRPDQGLQ¡VHLOXW¡VDUJXPHQWX
//
// Utility: list of methods for the indicated class
// [ possessing indicated substring ]
// to the screen and
// to the file "List.out" in the same directory
//
import java.lang.reflect.*; //for class Class

import java.io.*;
public class ML{
static final String usage =

"Use: java ML packageName.ClassName or\n"+
" java ML packageName.ClassName subnameOfMethod";
static String [] ls; //array for the list
static int count = 0; //counts the methods found
static String removeName( String s ) { //removes "java.lang." from

int sl = s.length(); //the name of method
int first = s.indexOf( "java.lang." ); //see class String
if( first == -1 ) return s;
int last = first + 10;
return removeName(
s.substring( 0,first ) + s.substring( last,sl ) ); //see class String
63
}
public static void main( String args[]){

if( args.length < 1 ) {
System.out.println( usage );
System.exit( 1 ); //erroneous exit; see class System
}
try {
Class c = Class.forName( args[0] );
Method [] m = c.getMethods(); //see class Class
Constructor [] cr = c.getConstructors(); //same
ls = new String[ m.length+cr.length ];
if( args.length == 1 ) { //ie, full list of methods and constructors

for ( int i = 0; i < m.length; i++ ) //for class given in args[0]
ls[count++] = "method "+ removeName( m[i].toString() );
for ( int i = 0; i < cr.length; i++ )
ls[count++]= "constructor "+ removeName( cr[i].toString() );
}else { //ie, length==2; list of methods containing substring given
count = 0; //in args[1]
for ( int i = 0; i < m.length; i++ ) {
String ms = m[i].toString();
if( ms.indexOf( args[1] )!=-1 )
ls[count++]= "method "+ removeName( ms );
}
for ( int i = 0; i < cr.length; i++ ) {
String ms = cr[i].toString();
if( ms.indexOf( args[1] )!=-1 )
ls[count++]= "constructor "+ removeName( ms );
}
}
} catch( ClassNotFoundException e ) {
System.err.println( "Class "+e+" does not exist" ); //errors to the screen
}
try{ //output to the screen and file
PrintWriter out = new PrintWriter(
new BufferedWriter(
new FileWriter( "List.out" ))),
con = new PrintWriter( System.out, true ); //true: empty
for( int i=0; i<count; i++) { //the buffer
out.println( (i+1) +" "+ls[i] );
con.println( (i+1) +" "+ls[i] );
}
out.close();
System.err.println( e.toString() ); //errors to the screen
}
}
}
64
Pastabos:
1. Metodas removeName( ) iš pilnojo konstruktoriaus ar metodo vardo išmeta
VXEHLOXW
java.lang. Tam pasitelkiami klaV¡V String metodai s.length( ) – jie nustato
String duomens s LOJ³ s.indexOf ( String sub ) – QXVWDWR VXEHLOXW¡V sub pirmojo
³¡MLPR ³GXRPHQ³sSR]LFLMRMHL³¡MLPRQ¡UD–JUåLQD–1; s.substring( int i1, int i2 ) –
JUåLQD s VXEHLOXW
SUDGHGDQW QXR simbolio pozicijoje i1 ir baigiant simboliu
pozicijoje i2 .DGDQJL ³ YLHQ PHWRGR DU NRQVWUXNWRULDXV DSUDã java.lang. JDOL ³HLWL
kelis kartus, metodas removeNameNYLHþLDPDVUHNXUV\YLDL
-HL ³UDQNLV ML NYLHþLDPDV QHWHLVLQJDL ³ SXOW LãYHGDPDV SUDQHãLPDs apie
WDL NDLS QDXGRWL ³UDQN³ String usage LU SURJUDPD VWDEGRPD NODV¡V System metodu
exit, kuriam teikiama int UHLNãP¡ ²SUDVWD NDG SURJUDPDL QRUPDOLDL EDLJLDQW GDUE
exitUHLNãP¡WXU¡WÐEÌWL0, kitais atvejais –NLWDSDY\]GåLXLNDLSþLD– 1.
3. Metodai getMethods ar getConstructors JUåLQD NODVLÐ Method ir
ConstructorREMHNWXVMXRVWHQNDLãUHLNãWDLSHUYHVWL³StringWLSPHWRGXtoString, kad
EÌWÐJDOLPDDQDOL]XRWLYDUGXV
2.19. Vykdymo srautai
Java OHLGåLD YLHQX PHWX Y\NG\WL NHOLDV SURJUDPRV dalis. Tai efektyvu,
SDY\]GåLXLDWOLHNDQW³YHGLPRLULãYHGLPRRSHUDFLMDVMDVDWOLHNDQW\V³UHQJLQLDLO¡WLLU
NLWDV SURJUDPRV RSHUDFLMDV YLHQX PHWX DUED JUDILQ¡MH YDUWRWRMR VVDMRMH
EHVLNDUWRMDQþLXV XåGDYLQLXV VOHQNDQWLV YDL]GDV EHVLVXNDQWLV SDYHLNVO¡Ois ir pan.)
SDOHLGåLDQWDWVNLUXQXRSDJULQGLQLRVVDMRVVUDXWRVUDXWX9LVDLVãLDLVDWYHMDLVSLOQLDX
išnaudojamas kompiuterio CPU.
Keli Java srautai (arba gijos, threadsSDOHLGåLDPLY\NG\WLYLHQRMHSURJUDPRMH
(kitaip – YLHQDPH SURFHVH LU QDXGRMD W SDþL DGUHVÐ HUGY
LU WXRV SDþLXV DWPLQWLHV
išteklius. Tuo Java VUDXWDL VNLULDVL SDY\]GåLXL QXR & VUDXWÐ NXULDPÐ IXQNFLMD
fork. Pastarieji yra pilnos pradinio srauto kopijos – atskiri procesai. Perjungimas iš
YLHQRVUDXWR³NLWUHLNDODXMDWDPWLNUÐLãWHNOLÐãLPWÐRSHUDFLMÐHLO¡VWDþLDXWDLGDXJ
HIHNW\YLDX QHL SHUMXQJLPDL WDUS SURFHVÐ SDY\]GåLXL GDXJLDSURJUDP¡MH 26
UHLNDODXMDQW\VWÌNVWDQþLÐRSHUDFLMÐHLO¡V
Programoje gyvuojant keliems srautams, galimos situacijos, kai keli srautai
NRQNXUXRMD G¡O WR SDWLHV NRPSLXWHULR LãWHNOLR SDY\]GåLXL NHOL VUDXWDL EDQGR YLHQX
PHWXUDã\WLGXRPHQLV³ULQNPHQ7RG¡OQRULQWVXWYDUN\WLNHOLÐVUDXWÐGDUEJDOLWHNWL
VXGHULQWLMÐGDUE– sinchronizuoti srautus.
6UDXWDL JDOL EÌWL JUXSXRMDPL ³ JUXSHV *DOLPD LãNDUW YDOG\WL YLHQRV JUXS¡V
visus srautus.
Visos Java ELEOLRWHNRV VXNXUWRV ³YHUWLQDQW JDOLP GDXJLDVUDXWLãNXP 0DW\W
GDXJLDVUDXWLãNXPR PRGHOLV YLV WLN Q¡UD WREXODV QHV GDXJHOLV DXWRULÐ SURJUDPDYLP
QDXGRMDQWNHOLVVUDXWXVYDGLQDPHQX9LVÐSLUPD\UDULERVNDLGLGHVQLVVUDXWÐNLHNLV
VXPDåLQD SURJUDPRV HIHNW\YXP WD ULED VLHNLD ãLPWXV LU WÌNVWDQþLXV VUDXWÐ LU
SULNODXVR QXR NRPSLXWHULR SDM¡JXPR $QWUD SDX]¡V VUDXWR Y\NG\PR PHWX
(gaunamos metodu sleep( )DUEDVDYDQRULãNDVYDOG\PRDWVLVDN\PDVVUDXWHNYLHþLant
PHWRG yield( ) JDOL WDLS SDW SDGLGLQWL SURJUDPRV HIHNW\YXP 7DLJL DXWRPDWLQLV
SHUMXQJLPRWDUSVUDXWÐPHFKDQL]PDVQ¡UDWREXODV
6UDXWREÌNO¡JDOLEÌWLWRNLD
3DVLUXRã
VGDUEXLVXNXUWDVEHWQHSDOHLVWDV
9\NGRPDV WLNVOLDX JDOL EÌWL Y\NGRPas, jei Java JVM srautui skirs CPU
LãWHNOLÐ
65
3DVLEDLJ
VEDLJ¡GDUEVUDXWRPHWRGDVrun( ) ).
%ORNXRWDV SDY\]GåLXL ODXNLD LãWHNOLR DUED SDWV VUDXWDV LãNYLHW¡ PHWRG
sleep( ) –WDGDMRHLO¡VUDXWÐHLO¡MHSUDOHLGåLDPDLUY\NGRPDVNLWDVVUDXWDV.
Vienas programos srautas yra pagrindinis: jame kuriami kiti srautai, jis turi
EDLJWLV SDWV SDVNXWLQLV -HL SDJULQGLQLV VUDXWDV JUHLþLDX EDLJLDVL QHL NXULV GXNWHULQLV
srautas – dokumentacijoje nurodoma, kad JVM gali „pakibti“. To išvengti padeda
metodas join( ),VXVLHMDQWLVSDJULQGLQ³VUDXWVXGXNWHULQLXLUOHLGåLDQWLVSDJULQGLQLDP
VUDXWXL SDODXNWL NRO EDLJV GDUE GXNWHULQLV 6UDXWDL PHWRGX setDaemon( true ) gali
EÌWLSDVNHOEWLVUDXWDLV-GHPRQDLVLUGLUEWLIRQLQLXUHåLPX'DEDUSURJUDPDEDLJLDVLNDL
baigiasi pagrindinis srautas.
'DEDU SDWHLNLDPD VUDXWR VXNÌULPR VLQWDNV¡ R Y¡OLDX – VUDXWÐ SDQDXGRMLPR
VDYDUDQNLãNRVH SURJUDPRVH LU NOLHQWLQ¡VH SURJUDPRVH SDY\]GåLDL 7RG¡O GDOLV ãLÐ
SDY\]GåLÐGDEDULNLJDORGDUQHEXVVXSUDQWDPLSULHMÐWHNVJU³åWLLãQDJULQ¡MXVSwing
SDNHW
2.19.1. Srauto sintaks¡
6UDXWDV VDXJRPDV NODV¡V Thread REMHNWH âL NODV¡ UHDOL]XRMD VVDMÐ NODV

Runnable7RG¡OVUDXWJDOLPDVXIRUPXRWLGYLHPEÌGDLV–SOHþLDQWNODV
Thread arba
UHDOL]XRMDQWVVDMÐNODV
Runnable. Pagrindiniai Thread metodai yra šie:
start( ) –SDOHLGåLDVUDXW
run( ) – QXURGR N UHLNLD DWOLNWL VUDXWH -DP SDVLEDLJXV EDLJLDVL VUDXWR
gyvavimas;
sleep( t ) –EORNXRMDVUDXWODLNXLtPDWXRMDPDPPLOLVHNXQG¡PLV
yield( ) –DWLGXRGDYDOG\Pã³VUDXWVXNÌUXVLDPVUDXWXL – supersrautui;
join ( ) –VXVLHMDã³VUDXWVXSDJULQGLQLX
isAlive( ) – nustato, ar šis srautas dar gyvuoja;
getPriority( ) –QXVWDWRVUDXWRSULRULWHW
getName( ) –QXVWDWRVUDXWRYDUG
Net jei programa nesukuria jokio išreikšto srauto, vienas – pagrindinis srautas
MDL VXNXULDPDV DXWRPDWLãNDL 9DUG LU SULRULWHW MDP VXWHLNLD -90 9LVDGD JDOLPD
JDXWLURG\NO
³ã³VUDXWVWDWLQLXPHWRGXcurrentThread( ):
class OneThread{
Thread t = Thread.currentThread( );
t.setName( “Thread1” );
System.out.println( “Current thread: “ + t );
try{
for( int i=5; i>0; i-- ){
System.out.println( i );
t.sleep( 1000 );
}
} catch( InterruptedException ie ) { }
}
}
Programa spausdins:
66
Current thread: Thread[ Thread1, 5, main]
TRNLVSDXVGLQLPRIRUPQXVWDWRDXWRPDWLãNDLREMHNWXLtNYLHþLDPDVPHWRGDV
toString( ) R SDVNXL NDV VHNXQG
VSDXVGLQDPL FLNOH QXURG\WL VNDLþLDL QHV
NLHNYLHQDV FLNOR åLQJVQLV WRNLDP ODLNXL SHUWUDXNLDPDV .DLS PDW\WL VUDXWR
SULRULWHWDV SDJDO QXW\O¡MLP \UD 5 SULRULWHWÐ ULERV \UD –10), o srautas
DXWRPDWLãNDL³MXQJLDPDV³VUDXWÐJUXS
main6XVWDEGåLXVVUDXWJDOLNLOWLLãLPWLV
InterruptedException, MHL ã³ VUDXW SDX]¡V PHWX SHUWUDXNWÐ NLWDV VUDXWDV PHWRGX
interrupt( ).7HLJLDPDNDGWRNLDJDOLP\E¡EXVQDXdinga ir bus naudojama ateities
JavaYHUVLMRVH'DEDUWHQNDWLNSHULPWLLãLPW³
3LUPDVLVEÌGDVVXNXUWLGXNWHULQ³VUDXW– Thread NODV¡VSO¡WLPDV
class NewThread extends Thread{

NewThread( ){
super( “Child-thread” );
System.out.println( “Child- thread: “ + this );
start( );
}
public void run( ){
try{
for( int i=5; i>0; i-- ){
System.out.println( ”Child-thread: ” + i );
this.sleep( 500 ); // or Thread.sleep( 500 );
}
System.out.println( “End of child-thread” );
}
}
class TwoThreads1{
new NewThread( );
try{
for( int i=5; i>0; i-- ){
System.out.println( ”Main thread: + i );
Thread.sleep( 1000 );
}
System.out.println( “End of main thread” );
}
}
ýLD IRUPXRMDQW GXNWHULQ³ VUDXW SLUPLDXVLD LãNYLHþLDPDV Thread

NRQVWUXNWRULXVYLHQDLãSHUNUDXWÐMRYHUVLMÐSULLPDYLHQDUJXPHQW– StringGXRPHQ³
–VUDXWRYDUG5HNRPHQGXRMDPDNRQVWUXNWRULXMHVUDXWLUSDOHLVWL3URJUDPRVGDUER
UH]XOWDWDLSULNODXVRQXRNRPSLXWHULRSDM¡JXPRLUDELHMÐVUDXWÐSDX]LÐWUXNP¡V
$QWUDVLVEÌGDVVUDXWXLVXNXUWL–VVDMÐNODV¡VRunnable, kurioje yra tik vienas
metodas run( ), realizavimas. Šioje programoje panaudota kita konstruktoriaus versija
su dviem argumentais – Runnable ir StringWLSÐ
67
class NewThread implements Runnable{
Thread t;
NewThread( ){
t = new Thread( this, “Child-thread” );
System.out.println( “Child-thread: “ + t );
t.start( );
}
public void run( ){
try{
for( int i=5; i>0; i-- ){
System.out.println( “Child-thread: “ + i );
}
} catch( InterruptedException ie ){ }
System.out.println( “End of child-thread” );
}
}
class TwoThreads2{
new NewThread( );
try{
for( int i=5; i>0; i-- ){
System.out.println( “Main thread: “+ i
);
}
System.out.println( “End of main thread” );
}
}
Ši programa parodo, kaip reikia sujungti kelis srautus metodu join( ), kad JVM
niekada „neSDNLEWÐ³SDJULQGLQLDPVUDXWXLEDLJXVGDUESLUPLDXQHLGXNWHULQLDP
class NewThread implements Runnable{

Thread t;
NewThread( ){
t = new Thread( this,"Child-thread" );
System.out.println( "Child-thread: "+ t );
t.start( );
}
public void run( ){
try{
for( int i=5; i>0; i-- ){
System.out.println( "Child-thread: "+ i );
}
68
System.out.println( "End of child-thread" );
}
}
class TwoThreads21{
public static void main( String args[] ) {
NewThread nt = new NewThread( );
try{
for( int i=5; i>0; i-- ){
System.out.println( "Main thread: "+ i );
}
try{
nt.t.join( ); //now main thread waits for finish
} catch( InterruptedException ie ){ } // of thread "nt.t"
System.out.println( "End of main thread" );
}
}
3DY\]G\V LOLXVWUXRMDQWLV SULRULWHWÐ ³WDN VUDXWÐ Y\NG\PXL 5HNRPHQGXRMDPD

sraute daryti pauzes arba iš srauto kai kuriais momentais savanoriškai atiduoti
YDOG\PVXSHUVUDXWXL–WDGDLUNLWLVUDXWDLWXU¡VãDQVJDXWLYDOG\P.DUWDLVDLãNX
SDX]¡V N\OD QDWÌUDOLDL SDY\]GåLXL NDL VUDXWDV EORNXRMDPDV ODXNLDQW ³YHVWLHV DU
išvesties operacijos. Kai kada aukštesnio prioriteto srautas priverstinai blokuoja
åHPHVQLRSULRULWHWRVUDXW
<UD DSLEU¡åWRV static final konstantos MIN_PRIORITY, NORM_PRIORITY ir
MAX_PRIORITYQXVWDWDQþLRVåHPLDXVLQRUPDOÐLUDXNãþLDXVLSULRULWHWXV
3URJUDPD SDOHLGåLD GX VUDXWXV NXULH NLHNYLHQDV DXJLQD VDYR VNDLWLNO³ – int
GXRPHQ³ .DUWX þLD SDDLãNLQDPD WHFKQRORJLMD NDLS VUDXWXV SDOHLVWL Lã JUDILQ¡V
YDUWRWRMRVVDMRVVXVLHMDQWVUDXWRJ\YDYLPDSLEU¡åLDQW³booleanGXRPHQ³running su
VVDMRV P\JWXNDLV âLV GXRPXR WXUL GDU QHPDW\W PRGLILNDWRULÐ volatile, kuris
QHOHLGåLDNRPSLOLDWRULXLRSWLPL]XRWLWRNLRGXRPHQVVDXJRMLPR.LWDLVåRGåLDLVWDULDQW
volatile informuoja, kad kintamojo reikšm¡ EHWNDGDJDOLEÌWLSURJUDPRVSDNHLVWD LU
VO\Jwhile( running ) reikia tikrinti kiekvienoje iteracijoje.
3URJUDPRV UH]XOWDWDL URGR NDG SDOHLGXV SURJUDP SDNDQNDPDL LOJDP
SDVLUHLãNLDSULRULWHWÐ³WDND–DXNãWHVQLRSULRULWHWRVNDLWLNOLRUHLNãP¡EXVDNLYDL]GåLDL
GLGHVQ¡ 7UXPSDP SDOHLGXV SURJUDP GDXJLDX SULDXJWL JDOL LU åHPHVQLR SULRULWHWR
srauto skaitiklis.
1XVSDXGXV NHOLV NDUWXV VVDMRV P\JWXNXV ÄStart threads“ ir „Stop threads“,
VNDLWLNOLÐ UHLNãP¡V QHEXV Lã QDXMR VNDLþLXRMDPRV QXR QXOLR 7RNL VNDLWLNOius
SHUVNDLþLXRMDQþL SURJUDPRV YHUVLM JDOLWH SDEDQG\WL SDUDã\WL SDW\V DEL SURJUDPRV
versijos pateikiamos prieduose).
//Creating threads with different priorities

//in applet context
//The only evaluation of counters enabled.
//
//<applet code = Threads3 width =600 height=550>
//</applet>
69
import java.awt.*;
import java.awt.event.*;
class Counter implements Runnable{
int count = 0;
Thread t;
volatile boolean running = true;
public Counter( int priority ){
t = new Thread( this );
t.setPriority( priority );
}
public void run( ){

while( running ) count++;
}
public void start( ){

t.start( );
}
public void stop( ){

running = false;
}
public class Threads3 extends JApplet{
Counter c1 = new Counter( Thread.NORM_PRIORITY+2 ), //priorities for

c2 = new Counter( Thread.NORM_PRIORITY-2 ); // child-threads
JButton b1 = new JButton( "Start threads" ),

b2 = new JButton( "Stop threads " );
JTextArea ta = new JTextArea( 3,50 );
public void init( ) {

Thread.currentThread().setPriority( Thread.MAX_PRIORITY );
//for current thread!
b1.addActionListener( new ActionListener( ){
public void actionPerformed( ActionEvent ae ){
c1.start( );
c2.start( );
ta.append(" Threads started \n" );
}
} );
70
c1.stop( );
c2.stop( );
ta.append( "Low-priority counter: "+c2.count+ "\n" );
ta.append( "High-priority counter: "+c1.count+ "\n" );
}
} );
try{
Container c = getContentPane( );
c.setLayout( new FlowLayout( ) );
c.add( b1 );
c.add( b2 );
c.add( ta );
}
}
'DEDU SULQFLSLQ¡ VFKHPD URGDQWL NDLS NOLHQWLQ¡MH SURJUDPRMH DWVNLUX VUDXWX

paleLVWL MXGDQW³ GDXJLDO\S¡V WHUS¡V HOHPHQW 7RN³ VUDXW JDOLPD SDVNHOEWL GHPRQX
3DSUDVWXPR G¡OHL DSVLULERVLPH SDþLX SDSUDVþLDXVLX DWYHMX – MXGDQþLMD IUD]H
.OLHQWLQ¡MH SURJUDPRMH \UD JDOLP\E¡ VXVWDEG\WL LU Y¡O SDOHLVWL MXG¡WL IUD]
)UD]¡V
MXG¡MLPDV RUJDQL]XRMDPDV SDSUDVWDL LPDPDV SLUPDVLV MRV VLPEROLV LU SHUNHOLDPDV ³
IUD]¡VJDO)UD]¡VVOLQNLPRJUHLWLVQXVWDWRPDVUHJXOLXRMDQWSDX]¡VG\G³
-XGDQþLM IUD]
UHDOL]XRMDQWL NODV¡ MovingBanner \UD YLGLQ¡ – NDG EÌWÐ
SDWRJXSULHLWLSULHJUDILQLÐVVDMRVHOHPHQWÐ
//Applet with moving banner

//
//<applet code = Banner width =500 height=100>
//</applet>
import java.awt.*;
public class Banner extends JApplet{
JTextField tf = new JTextField( 20 );

JButton b1 = new JButton( "Start moving"),
b2 = new JButton( "Stop moving");
MovingBanner mb;
class MovingBanner implements Runnable{
String message = " A simple moving banner ";

Thread t;
volatile boolean moving;
71
moving = true;
t.start();
}

moving = false;
}
public void run( ){

char c;
while( moving ){
try{
repaint( );
c = message.charAt( 0 );
message = message.substring( 1,
message.length( ) );
message += c;
tf.setText( message );
}
}
}
public void init( ){

mb = new MovingBanner( );
mb.start( );
}
} );
mb.stop( );
}
} );
c.add( tf );
c.add( b1 );
c.add( b2 );
}
72
6UDXWÐVLQFKURQL]DYLPDV7DUSVUDXWLQLDLU\ãLDL
6LQFKURQL]DYLPDVOHLGåLDLãYHQJWLVUDXWÐVXVLGÌULPRNRQNXUXRMDQWG¡OWRSDWLHV
LãWHNOLR *DOLPD VLQFKURQL]XRWL YLV PHWRG DU DWVNLU MR GDO³ – YDGLQDPM NULWLQ

VHNFLM 6LQFKURQL]DYLPDV YLVDGD SDGLGLQD Y\NG\PR ODLN 3DY\]GåLXL % (FNHOLV
VLQFKURQL]XRWDV PHWRGR NYLHWLPDV Y\NGRPDV PDåGDXJ NHWXULV NDUWXV LOJLDX Xå
³SUDVWM³ NYLHWLP þLD WXULPDV RPHQ\MH SDWV PHWRGR NYLHWLPDV QH³YHUWLQDQW SDWLHV
metodo vykdymo).
Metodo sinchronizavimo pavyzdys:
synchronized void m1( ){ . . . }

synchronized void m2( ){ . . . }
-HL REMHNWXL LãNYLHþLDPDV PHWRGDV m1, kitas sinchronizuotas (atkreipiame

G¡PHV³ NDG ãLV WHLJLQ\V JDOLRMD WLN VLQFKURQL]XRWDP PHWRGXL PHWRGDV m2 tam
SDþLDP REMHNWXL JDO¡V EÌWL LãNYLHVWDV WLN SDEDLJXV GDUE SLUPDMDP PHWRGXL WDLJL
„objektas blokuojamas“.
.DUWDLV YLVR PHWRGR EORNDYLPDV QHUHLNDOLQJDV DUED Lã YLVR QH³PDQRPDV
Tarkime, programoje Threads3 metodas
public synchronized void run( ){

}
EÌWÐEHJDOLQLVNDGDQJLM³XåEORNDYXVQH³PDQRPDSDNHLVWLrunningUHLNãP¡V5HLN¡WÐ
EORNXRWLWLNVNDLWLNOLRUHLNãP¡VNHLWLP
public void run( ){

while( running ){
synchronized( count ){
count++;
}
}
}
âLV SDY\]G\V Q¡UD SUDVPLQJDV LU VNLUWDV WLN NULWLQ¡V VHNFLMRV EORNDYLPXL
SDDLãNLQWLVNOLDXVWXRVHQXURGRPDVEORNXRMDPDVREMHNWDVRILJÌULQLXRVHVNOLDXVWXRVH
– YLVD EORNXRMDPRML VHNFLMD 7RNV SDY\]G\V EÌWÐ SUDVPLQJDV WLN WDGD MHL UHLNãPHL
NHLVWLUHLN¡WÐNHOLÐRSHUDFLMÐýLDEORNHW¡UDYLHQLQWHO¡RSHUDFLMDWRG¡OWRNLDLSDSUDVWDL
VHNFLMDLWDVSDWDUEORNXRWLMDUQH
Sinchronizuotuose srautuose galimi metodai wait( ), notify( ), notifyAll( ),
SDGHGDQW\VVXGHULQWLVUDXWÐGDUE9LVLãLHPHWRGDLDSLEU¡åWLNODV¡MHObjectWRG¡OLã
principo prieinami kiekvienai klasei.
final void wait( ) throws InterruptedException – EORNXRMD VDYR GDUE LU

praneša apie tai savo supersrautui.
final void notify( ) –VXåDGLQDVUDXWNXULVWDPSDþLDPREMHNWXLEXYRLãNYLHW
V
wait( ).
final void notifyAll( ) – sXåDGLQDYLVXVVUDXWXVNXULHWDPSDþLDPREMHNWXLEXYR
LãNYLHW
wait( ).3LUPDVLVEXVY\NGRPDVDXNãþLDXVLRMRSULRULWHWRVUDXWDV
73
ýLD SDURG\VLPH WLN VUDXWÐ GDUER VXGHULQLPR VLQWDNV
3DWV VUDXWÐ GHULQLPDV
LãHLQD Xå NXUVR ULEÐ LU \UD GDXJLDX O\JLDJUHþLÐMÐ VNDLþLDYLPÐ DOJRULWPÐ UHLNDODV
Klasikinis tarpsrautinio darbo organizavimo pavyzdys – GXRPHQÐ VWUXNWÌURV-HLO¡V
UHDOL]DYLPDV31DXJKWRQDV3URJUDPRMH\UDGYLNODV¡VSDODLNDQþLRVHLO¡VNODV
Q:
Producer ÄJDPLQD³ REMHNW – ³ HLO
³GHGD HLOLQ³ VNDLþLÐ PHWRGu void put( int n ), o
Consumer W VNDLþLÐ VXYDUWRMD – atspausdina metodu int get( ). -HL ³ SURJUDP
QH³WUDXNWXPH wait ir notify PHWRGÐ NYLHWLPÐ VUDXWÐ GDUEDV EÌWÐ QHVXGHULQWDV LU
SDY\]GåLXL JDPLQWRMDV JDO¡WÐ SDJDPLQWL Lã HLO¡V NHOLV VNDLþLXV MÐ QHVXYDrtojus
YDUWRWRMXLDUEDYDUWRWRMDVJDO¡WÐVXYDUWRWLWSDW³VNDLþLÐNHOLVNDUWXV
.DG SURJUDPRV HVP¡V QHXåGHQJWÐ VVDMRV RUJDQL]DYLPR LU NLWL GDO\NDL
SURJUDPDSDUDã\WDSDSUDVþLDXVLXEÌGXLU\UDEHJDOLQ¡-RVGDUEJDOLPDQXWUDXNWLWLN
klavišais Ctrl – C.
// Model of queue Q: Producer produces number n, Consumer takes it

// Synchronization. Inter-threads collaboration
//
class Q{
int n;
boolean go = false;
synchronized int get( ){

if( !go )
try{
wait( );
System.out.println( "Got: "+ n );
go = false;
notify( );
return n;
}
synchronized void put( int n ){
if( go )
try{
wait( );
} catch( InterruptedException ie ){}
this.n = n;
System.out.println( "Put: "+ n );
go = true;
notify( );
}
}
class Producer implements Runnable{
Q q;
Producer( Q q ){
this.q = q;
74
new Thread( this,"Producer" ).start( );
}
public void run(){

int i = 0;
while( true ){
q.put( i++ );
try{
}
}
}
class Consumer implements Runnable{
Q q;
Consumer( Q q ){
this.q = q;
new Thread( this,"Consumer" ).start( );
}
public void run( ){

while( true ) q.get( );
}
}
class InfiniteQueue{
public static void main( String [] args ){
System.out.println( "Press Ctrl-C for finish" );
Q q = new Q( );
new Producer( q );
new Consumer( q );
}
}
2.20. Kolekcijos
Kolekcijos – SURJUDPLQ¡V WDOS\NORV REMHNWÐ JUXS¡PV VDXJRWL & NDOERVH

vadinamos konteineriais). Java NROHNFLMRV DSUÌSLQD programuotojus rinkiniu
SURJUDPLQLÐ JDOLP\ELÐ GDXJ\EHL GDåQDL SDVLWDLNDQþLÐ SURJUDPDYLPR XåGDYLQLÐ
Kolekcijos naudotinos visada, kai UHLNLD LãVDXJRWL LQIRUPDFLM NRPSLXWHULQ¡MH
VDXJ\NORMH LU Y¡O M SDLPWL .ROHNFLMRV QHWLQNDPRV WLN GLGHO¡V DSLPWLHV XåGDYLQLDPV
VSU
VWLWDP\UDGXRPHQÐED]LÐVLVWHPRV
9LVRVNROHNFLMÐNODV¡VLUVVDMÐNODV¡VWDLSSDWNODV¡V³YDLULHPVLQIRUPDFLMRV
³G¡MLPR LU Lã¡PLPR YHLNVPDPV UÌãLDYLPR DOJRULWPDPV VXWHONWL SDNHWH java.util.
Dauguma Java NROHNFLMÐ SDVLURG¡ WLN Java 2 kalboje. Šiame pakete yra ir kitos
75
SDJDOELQ¡V Java NODV¡V EHL VVDMÐ NODV¡V PDQLSXOLXRWL GDWD LU ODLNX DWVLWLNWLQLDPV
VNDLþLDPVJHQHUXRWLHLOXWLQLÐGXRPHQÐDQDOL]HLLUWW
<UD NROHNFLMRV YLVRPV SURJUDPDYLPH SODþLDX QDXGRMDPRPV GXRPHQÐ
VWUXNWÌURPV GLQDPLQLDPV PDV\YDPV ULQNLQLDPV VUDãDPV VXVLHWLHVLHPV VUDãDPV
PHGåLDPV hash-OHQWHO¡PV 9LVL ³YDLULRPV NROHNFLMRPV UHLNDOLQJL DOJRULWPai sutelkti
NODV¡MH Collections LU ³IRUPLQWL NDLS VWDWLQLDL PHWRGDL -LH \UD SULHLQDPL YLVRPV
NROHNFLMRPV 0HWRGDL UHLNDOLQJL GXRPHQLPV Lã NROHNFLMRV LãULQNWL SR YLHQ Lã HLO¡V
NDLS MLH VXG¡WL ³ NROHNFLM DSLEU¡åWL VVDMÐ NODV¡MH Iterator (Java 1 yra panašias
IXQNFLMDV DWOLHNDQWL VVDMÐ NODV¡ Enumeration, tik, aišku, Java 2 kolekcijose ji
QHUHDOL]XRWD .LHNYLHQD NROHNFLMÐ NODV¡ UHDOL]XRMD VVDMÐ NODV
Iterator. Metodai,
UHLNDOLQJL NDL NXULRPV NROHNFLMRPV ³YDLULDL UÌãLXRWL DSLEU¡åWL VVDMÐ NODV¡MH
Comparator.
2EMHNWDPVVDXJRWLVNLUWLLUPDV\YDLNXULXRVQDJULQ¡MRPHDQNVþLDXLUNXULXRV
naudojant programose paketas java.util nereikalingas. Masyvas – pats efektyviausias
GXRPHQÐ NRQWHLQHULV WDþLDX MR PDWPXR Y\NGDQW SURJUDP \UD SDVWRYXV W \
programoje WXUL EÌWL QXURG\WD NLHN REMHNWÐ JDO¡V WLOSWL ³ PDV\Y R Y¡OLDX PDV\YDV
SULUHLNXV QHJDO¡V DXWRPDWLãNDL SO¡VWLV 3DNHWH java.util \UD NODV¡ ArrayList,
UHDOL]XRMDQWL DXWRPDWLãNDL EHVLSOHþLDQþLXV PDV\YXV EHW MRV HIHNW\YXPDV JHURNDL
menkesnis. Pakete taip paW\UDNODV¡Arrays, turinti statinius metodus equals – dviem
masyvams sulyginti, fill – PDV\YXL XåSLOG\WL QRULPDLV GXRPHQLPLV sort – masyvui
UÌãLXRWLWDPWLNUDWYDUNDbinarySearch –QRULPDPHOHPHQWXLUDVWLUÌãLXRWDPHPDV\YH
ir asList – masyvui pertvarkytL³VUDãList7DLJLNODV¡ArraysPDV\YDPV\UDNODV¡V
Collections kolekcijoms atitikmuo. Masyvams kopijuoti skirtas metodas yra
VWDQGDUWLQ¡MH Java bibliotekoje – NODV¡V System statinis metodas arraycopy kur kas
HIHNW\YHVQLV QHL PDV\YÐ NRSLMDYLPDV SDVLWHONLDQW FLNOÐ RSHUDWRULXV 0DV\YDL VNLUWL
tam tikro tipo duomenims, taip pat ir primityvams, saugoti (skyrius 2.8).
Visose kolekcijose yra tik Object tipo duomenys. Kadangi Object –
DXNãþLDXVLD Java NODVLÐ KLHUDUFKLMRV NODV¡ EHW NXUL WLHN Java, tiek programuotojo
VXNXUWD NODV¡ JDO¡V EÌWL ³G¡WD ³ EHW NXUL NROHNFLM SULPLW\YÌV GXRPHQ\V – QHJDO¡V
WDP SULPLW\YLXV GXRPHQLV UHLNLD SHUWYDUN\WL ³ DWLWLQNDPDV NODVHV-kevalus (1.3
VN\ULXV 7DþLDX WDGD SUDUDQGDPDV WLNVOXV NROHNFLMRMH HVDQþLÐ GXRPHQÐ WLSDV WRG¡O
v¡OLDXLãNROHNFLMRVSD¡PXVGXRPHQ³SULHãGLUEDQWMXRWHNVSDVLWHONWLEHVLOHLGåLDQW³M³
GXRPHQÐWLSÐSHUWYDUN\PVN\ULXV
.ROHNFLMÐKLHUDUFKLMD
-HL QHQDJULQ¡WXPH SDVHQXVLÐ Java 1 NROHNFLMÐ YLV KLHUDUFKLM JDO¡WXPH

VXVNLUVW\WL ³ SDJULQGLQLXV NROHNFLMÐ WLSXV Map, List ir Set. List ir Set WXUL EHQGU
VXSHUNODV
Collection6UDãHListHOHPHQWDLVDXJRPLSDJDOWDPWLNUDSLEU¡åWWYDUN
MDPH JDOL EÌWL SDVLNDUWRMDQW\V HOHPHQWDL $LE¡MH DUED ULQNLQ\MH Set SDVLNDUWRMDQþLÐ
HOHPHQWÐQ¡UD/HQWHO¡MHMap duomenys saugomi poromis „raktas –UHLNãP¡³UDNWDL
OHQWHO¡MH QHVLNDUWRMD ,ã OHQWHO¡V Map JDOLPD JDXWL SRUÐ ULQNLQ³ UDNWÐ ULQNLQ³ LU
UHLNãPLÐ NROHNFLM Collection /HQWHO¡V SDQDãLDL NDLS PDV\YDL JDOL EÌWL NHOLDPDW¡V
WDLOHQWHO¡VNXULÐUHLNãP¡V\UDNLWRVOHQWHO¡V
ýLD SDWHLNLDPD VXSDSUDVWLQWD VVDMÐ NODVLÐ LU NODVLÐ KLHUDUFKLMD % (FNHOLV
6VDMÐ NODV¡V DSYHVWRV SXQNW\ULQLDLV U¡PHOLDLV NODV¡V – U¡PHOLDLV LãWLVLQH OLQLMD
/LQLMRVVXURG\NO¡PLVURGRSDYHOGLPXPRVFKHPDV
76
Iterator Collection Map
ListIterator HashMap TreeMap
WeekHashMap
List Set
ArrayList LinkedList HashSet TreeSet
Collections Arrays
Comparable Comparator
SDY.ROHNFLMÐKLHUDUFKLMD
.DLS PDW\WL VVDMÐ NODV¡VL Set ir Map turi hash-subklases HashSet ir

HashMapâLÐNODVLÐG¡NDJDOLPDJUHLWDQRULPRNROHNFLMRVHOHPHQWRSDLHãNDSDLHãND
atitinkamose ne hash-NODV¡VH \UD SDNDQNDPDL O¡WD SDQDXGRMDQW YDGLQDPM³ hash-
NRG.RGDVWXULVYHLNXRVLXVVNDLþLXV–LQGHNVXVDWLWLQNDQþLXVNROHNFLMRVHOHPHQWXV
Hash-kodas gaunamas metodu hashCodeSDYHOGLPXLãNODV¡VObject.
2.20.2. Collection kolekcijos
Pagrindiniai metodai visoms List ir SetVXSHUWLSÐNROHNFLMRPV\UD
boolean add( Object o ) – ³GHGD ³ NROHNFLM REMHNW o LU JUåLQD true.

*UåLQDPDUHLNãP¡falseJDOLPDWLNWDGDNDL³NROHNFLMQHSDODLNDQþLNHOLÐYLHQRGÐ
HOHPHQWÐEDQGRPD³G¡WLMDXWRMHNROHNFLMRMHHVDQW³REMHNW
boolean addAll( Collection c ) –³GHGD³PHWRGNYLHþLDQþLMNROHNFLMYLV

NROHNFLMc*UåLQDPDbooleanUHLNãP¡– analogiškai metodui add.
77
boolean remove( Object o ) – SDãDOLQD Lã NROHNFLMRV HJ]HPSOLRULÐ o (jei
NROHNFLMD SDODLNR EHVLNDUWRMDQþLXV HOementus – SDãDOLQD WLN YLHQ HOHPHQW O\JÐ o).
Jei oSDãDOLQWDVJUåLQDPDUHLNãP¡true, jei o kolekcijoje nebuvo – niekas nepašalinta
– false.
boolean removeAll( Collection c ) – SDãDOLQD Lã PHWRG NYLHþLDQþLRVLRV

NROHNFLMRVNROHNFLMc*UåLQDboolean reikšmes analogiškai metodui remove.
void clear( ) – pašalina iš kolekcijos visus elementus.
boolean contains( Object o ) –JUåLQDtrueMHLNROHNFLMDWXULHJ]HPSOLRULÐo;

DQWUDLSJUåLQDPDfalse.
boolean equals( Object o ) – JUåLQD true, jei kvLHþLDQþLRVLRV NROHNFLMRV

objektas ir objektas o\UDO\JÌVDQWUDLS– false.
int size( ) –JUåLQDNROHNFLMRVHOHPHQWÐNLHN³
Object[ ] toArray( ) – JUåLQD PDV\Y NXULR HOHPHQWDL \UD NROHNFLMRV

HOHPHQWÐNRSLMRV
Iterator iterator( ) –JUåLQDLWHUDWRULÐNYLHþLDQþLDMDLNROHNFLMDL
6VDMÐ NODV¡ List NDLS PDW\WL Lã VFKHPRV LãSOHþLD VVDMÐ NODV
Collection
SDSLOGRPDLVPHWRGDLV9LVLãLHSDSLOGRPLPHWRGDLIDNWLãNDLOHLGåLDRSHUXRWLNROHNFLMRV
elementu (ar elementais) tam tikroje kolekcijos vietoje, apLEU¡åLDPRMH LQGHNVX
'DåQLDXLããLÐPHWRGÐQDXGRMDPL
void add( int i, Object o ) –³GHGDREMHNWo³VUDãRSR]LFLMi$QNVþLDXãLRMH

SR]LFLMRMH EXY
V VUDãR HOHPHQWDV LU YLVL WROLDX EXY
HOHPHQWDL SHUVWXPLDPL WRO\Q ³
VUDãRJDORSXV
SHUYLHQSR]LFLM
boolean addAll( int i, Collection c ) – ³GHGD YLV NROHNFLM c ³ VUDã QXR

pozicijos i panašiai kaip metode add *UåLQDPD UHLNãP¡ true MHL NYLHþLDQW\VLV
VUDãDVSDNHLþLDPDV
Object set( int i, Object o ) –SHUNHOLDREMHNWo³NYLHþLDQþLRMRVUDãRSR]LFLM

i*UåLQDPDDQNVWHVQ¡HOHPHQWRUHLNãP¡
Object get( int i ) –JUåLQDREMHNWHVDQW³SR]LFLMRMHL
int indexOf( Object o ) – JUåLQD VUDãH HVDQþLR SLUPRMR REMHNWR o

HJ]HPSOLRULDXVLQGHNV-HLVUDãHWRNLRREMHNWRQ¡UDJUåLQDUHLNãP
–1.
int lastIndexOf( Object o ) – veikia panašiai kaip metodas indexOf,

JUåLQGDPDVSDVNXWLQLRMRREMHNWRoHJ]HPSOLRULDXVLQGHNV
Object remove( int i ) – pašalina pozicijoje iHVDQW³VUDãRHOHPHQWLUJUåLQD

ãLR HOHPHQWR UHLNãP
3HUWYDUN\WDV VUDãDs „sutraukiamas“ – WXãþLD SR]LFLMD
XåSLOGRPDHOHPHQWXLãGHãLQ¡VLUWW
78
List subList( int i1, int i2 ) –JUåLQDPHWRGNYLHþLDQþLRMRVUDãRGDO³–VUDã
pradedant nuo i1-ojo elemento ir baigiant i2-1-uoju elementu.
ListIterator listIterator( ) – gUåLQDVUDãXLLWHUDWRULÐSDVLUXRãXV³SHUULQNWLQXR

VUDãRSUDGåLRVVUDãRHOHPHQWXV
ListIterator listIterator( int i ) –JUåLQDVUDãXLLWHUDWRULÐSDVLUXRãXV³SHUULQNWL

VUDãRHOHPHQWXVQXRVUDãRi-ojo elemento.
6VDMÐ NODV¡ Set, kaip matyti iš sFKHPRV LãSOHþLD VVDMÐ NODV

Collection,
WDþLDX QH³YHGD MRNLÐ SDSLOGRPÐ PHWRGÐ .DGDQJL ULQNLQ\V QHVDXJR EHVLNDUWRMDQþLÐ
HOHPHQWÐ PHWRGDV add MDP JUåLQWÐ false EDQGDQW ³G¡WL ³ ULQNLQ³ MDX HJ]LVWXRMDQW³
REMHNW
'DEDU WUXPSDL SHUåYHOJVLPH NODVHV UHDOL]XRMDQþLDV VVDMÐ NODV
List:
ArrayList ir LinkedList.
.ODV¡ArrayListIDNWLãNDLUHDOL]XRMDGLQDPLQ³PDV\YJDOLQW³SO¡VWLVY\NGDQW
SURJUDP 0DV\YH VDXJRPRV URG\NO¡V ³ REMHNWXV 0DV\YDV VXNXULDPDV WDP WLNUR
SUDGLQLRG\GåLR.DLSURJUDPRVY\NG\PRPHWXšis masyvo pradinis dydis viršijamas,
PDV\YDV DXWRPDWLãNDL SOHþLDPDV -HL Lã DQNVWR DLãNX NDG PDV\YDV SDVLHNV WDP WLNU
G\G³ JDOLPD Lã DQNVWR NODV¡V PHWRGX void ensureCapacity(int capacity) nustatyti
UHLNLDPPDV\YRG\G³WDLSEXVLãYHQJWDNHOLÐDXWRPDWLQLÐPDV\YRSO¡WLPÐSHUUDãDQW
YLVXVPDV\YRHOHPHQWXVLUVXWDXS\WDVSURJUDPRVY\NG\PRODLNDV.ODV¡MHSHUNUDXWRV
3 konstruktoriaus versijos:
ArrayList( )
ArrayList( Collection c )
ArrayList( int capacity )
3LUPDVLV NRQVWUXNWRULXV VXNXULD WXãþL WDP WLNUR G\GåLR QXRURGÐ PDV\Y

WUHþLDVLV – WXãþL capacity G\GåLR PDV\Y R DQWUDVLV – NROHNFLMRV G\GåLR PDV\Y
WXULQW³NROHNFLMRVHOHPHQWÐUHLNãPHV
3DY\]G\V NDL NXULHPV NODV¡V PHWRGDPV LOLXVWUXRWL VUDãR VXIRUPDYLPDV
SUDGLQLÐStringWLSRUHLNãPLÐVXWHLNLPDVHOHPHQWR³G¡MLPDV³VUDãLUSDãDOLQLPDVLã
VUDãRãLRSHUWYDUN\PDV³PDV\YMRHOHPHQWDLEXVObjectWLSRLUPDV\YRHOHPHQWÐ
sumavimas:
import java.util.*;
class MyArrayList{
ArrayList al = new ArrayList( );
System.out.println( "Initial size of array " + al.size( ) );
al.add( "A" );
al.add( "B" );
al.add( "C" );
al.add( "D" );
al.add( 1,"A1" );
System.out.println( "Size of array after resizing " + al.size( ) );
System.out.println( "Array: " + al ); // invokes method toString
al.remove( "C" );
79
al.remove( 1 );
System.out.println( "Size of array after removing " +
al.size( ) );
System.out.println( "Array: " + al );
Object array[ ] = al.toArray( ); // transforming list to
// an array
String sum = "";
for( int i=0; i<array.length; i++ )
sum = sum + ( String )array[ i ]; // downcasting
System.out.println( "Sum of array elements: " + sum );
}
}
Programa, spausdindama kolekcijos elementus, neišreikštai kvLHþLD PHWRG

toStringWDLSDå\P¡WDNRPHQWDUHDWLWLQNDPRMHHLOXW¡MH3URJUDPDVSDXVGLQD
Initial size of array 0

Size of array after resizing 5
Array: [A, A1, B, C, D]
Size of array after removing 3
Array: [A, B, D]
Sum of array elements: ABD
SusLHWRMR VUDãR NODV¡V LinkedList objektai kuriami konstruktoriais

LinkedList() arba LinkedList( Collection c ). .ODV¡ WXUL NHOLDV QDXMDV JDOLP\EHV
palyginti su ArrayList –PHWRGXVNXULÐSDVNLUWLVDLãNLLãMÐSDYDGLQLPÐ
void addFirst( Object o ) –³GHGD o³VUDãRSLUPMSR]LFLM

void addLast( Object o ) –DQDORJLãNDL³SDVNXWLQ
SR]LFLM
Object getFirst( )
Object getLast( )
Object removeFirst( )
Object removeLast( )
5LQNLQLRNODV¡HashSet turi 4 perkrautus konstruktorius:
HashSet( )
HashSet( Collection c )
HashSet( int capacity )
HashSet( int capacity, float fillRatio )
-Ð SUDVP¡ DLãNL Lã DQDORJLMRV VX ArrayList konstruktoriais, išskyrus 4-M
IRUPULQNLQLRXåSLOG\PRNRHILFLHQWDVfillRatioQXVWDWRULENXULSDVLHNXVULQNLQ\V
SOHþLDPDV.RHILFLHQWRUHLNãP¡VWXULEÌWLWDUSLURVWDQGDUWLQ¡NRHILFLHQWRUHLNãP¡
– âLRV NODV¡V REMHNWR HOHPHQWDL Q¡UD NDLS QRUV SDSLOGRPDL LãULNLXRMDPL WXR
tarpu TreeSet elementai – LãG¡VWRPL QDWÌUDOLD GLG¡MDQþLD WYDUND SDY\]GåLXL
simboliniai duomenys –SDJDOORW\QÐDE¡F¡O
DUEDNRPSDUDWRULXPLQXVWDW\WDWYDUND
âLRVNODV¡VREMHNWDLJDOLEÌWLNXULDPLYLHQXLãNRQVWUXNWRULÐ
80
TreeSet( )
TreeSet( Collection c )
TreeSet( Comparator comp )
TreeSet( SortedSet ss )
ýLD SortedSet yra dar viena anNVþLDX QHPLQ¡WD VVDMÐ NODV¡ UÌãLXRWDP
ULQNLQLXL³VLWHUSLDQWLWDUSTreeSetNODV¡VLUSetVVDMÐNODV¡V
Pavyzdys:
import java.util.*;
class MyTreeSet{
TreeSet ts = new TreeSet( );
ts.add( "F" );
ts.add( "b" );
ts.add( "B" );
ts.add( "K" );
ts.add( "A" );
ts.add( "a" );
System.out.println( "Set: " + ts );
}
}
Programa spausdina:
Set: [A, B, F, K, a, b]
&LNOLãNDL SR YLHQ SHUULQNWL EHW NXULRV NROHNFLMRV HOHPHQWXV OHLGåLD

vadinamaVLVLWHUDWRULDXVREMHNWDVVXNXULDPDVNROHNFLMDLNYLHþLDPXPLQ¡WXRMXPHWRGX
Iterator iterator( ) 6UDã JDOLPD SHUULQNWL JDOLQJHVQLX DQDORJLãNDL JDXQDPX
ListIteratorLWHUDWRULXPL.ODV¡VIterator metodai yra:
boolean hasNext( ) –JUåLQDtrue, jei kolekcijoje yra kitas elementas.
Object next( ) – JUåLQD NLW HOHPHQW -HL NLWR HOHPHQWR Q¡UD VXNHOLDPD
išimtis NoSuchElementException.
void remove( ) – SDãDOLQDGDEDUWLQ³ HOHPHQW 9LVDGD WXUL EÌWLNYLHþLDPDVSR
next( ); jei to nepaisysime – kils išimtis IllegalStateException.
.ODV¡ListIteratorSDSLOGRPDLVLÌORPHWRGXV
void add( Object o ) – ³ VUDã SULHã HOHPHQW NXULV EÌWÐ JUåLQWDV PHWRGX
next( ),³WHUSLDPDVo.
boolean hasPrevious( ) – JUåLQD true, jei kolekcijoje yra ankstesnis

elementas.
Object previous( ) – JUåLQD DQNVWHVQ³M³ HOHPHQW -HL MR Q¡UD – kyla išimtis
NoSuchElementException.
81
int nextIndex( ) –JUåLQDNLWRHOHPHQWRLQGHNV
int previousIndex( ) –JUåLQDDQNVWHVQLRMRHOHPHQWRLQGHNV
void set( Object o ) – dabartiniam HOHPHQWXL W \ HOHPHQWXL JUåLQWDP

metodais next( ) ar previous( ) ) suteikiama oUHLNãP¡
TreeSet REMHNWÐ HOHPHQWDL NDLS PLQ¡WD UÌãLXRMDPL DUED QDWÌUDOLDL DUED

NRPSDUDWRULXPLWHLNLDPDWYDUND6VDMÐNODV¡MHComparator yra du metodai:
int compare( Object o1, Object o2 ) –JUåLQDMHLREMHNWDLO\JÌVWHLJLDP

UHLNãP
MHLo1>o2QHLJLDPUHLNãP
MHLo1<o2-HLREMHNWÐWLSDLQHVXGHULQDPLN\OD
išimtis ClassCastException.
boolean equals( Object o ) –O\JLQDGXNRPSDUDWRULXVNYLHþLDQW³M³PHWRGLUo.
3DY\]G\V LOLXVWUXRMDQWLV LWHUDWRULDXV LU NRPSDUDWRULDXV SDQDXGRMLP

UÌãLXRWDPH ULQNLQ\MH .RPSDUDWRULXV QXVWDWR DWYLUNãþL HOHPHQWÐ LãG¡VW\PR WYDUN
Metode compare NYLHþLDPDV PHWRGDV compareTo priklauso String klasei, o jo
JUåLQDPRVint tipo rHLNãP¡VDQDORJLãNRVJUåLQDPRPVLãPHWRGRcompare.
import java.util.*;
class MyComparator implements Comparator{

public int compare( Object o1, Object o2 ){
String s1 = (String) o1,
s2 = (String) o2;
return s2.compareTo( s1 ); // reversing the natural order
}
}
class MyIteratorComparator{
TreeSet ts = new TreeSet( new MyComparator( ) );
ts.add( "F" );
ts.add( "b" );
ts.add( "B" );
ts.add( "K" );
ts.add( "A" );
ts.add( "a" );
Iterator i = ts.iterator( ); // getting iterator
while( i.hasNext( ) ){
Object tse = i.next( );
System.out.print( tse + " " );
}
}
}
82
Programa spausdina TreeSet objekto ts HOHPHQWXV LãULNLXRWXV DWYLUNãþLD
tvarka:
baKFBA
2.20.3. MapOHQWHO¡V
6VDMÐNODV¡MHMapDSLEU¡åWLSDJULQGLQLDLPHWRGDL
Object put( Object key, Object Value ) – ³GHGD ³ OHQWHO

YDGLQDPM³ OHQWHO¡V
³¡MLP – UDNW key LU SDJDO M³ DWUHQNDP UHLNãP
value *UåLQDPD UHLNãP¡ null, jei
WHLNLDPRUDNWROHQWHO¡MHQHEXYRDQWUDLS–DQNVWHVQ¡VXUDNWXVXVLHWDUHLNãP¡
void putAll( Map m ) –³GHGD³OHQWHO

YLVOHQWHO
m.
Object get( Object key ) –JUåLQDVXUDNWXkeyVXVLHWUHLNãP

int size( ) –JUåLQDOHQWHO¡V³¡MLPÐNLHN³
Set entrySet( ) –JUåLQDOHQWHO¡V³¡MLPÐ–VVDMÐNODV¡VMap.EntryWLSRREMHNWÐ

ULQNLQ³
Set keySet( ) –JUåLQDOHQWHO¡VUDNWÐULQNLQ³
Collection values( ) –JUåLQDOHQWHO¡VUHLNãPLÐNROHNFLM
Object remove( Object key ) –SDãDOLQDLãOHQWHO¡V³¡MLPNXULRUDNWDV\UDkey,

LUJUåLQDã³REMHNW
boolean containsKey( Object key ) –JUåLQDtrueMHLPHWRGNYLHþLDQWLOHQWHO¡

WXULUDNWkey; antraip – false.
boolean containsValue( Object value ) – analogiškas ankstesniam metodas, tik

åLÌULPDOHQWHO¡MHHVDQþLÐUHLNãPLÐ
6VDMÐ NODV
Map LãSOHþLD VVDMÐ NODV¡V SortedMap – UÌãLXRWDL OHQWHOHL EHL
Map.Entry OHLGåLDQWL PDQLSXOLXRWL OHQWHO¡V ³¡MLPDLV âLRV VVDMÐ NODV¡V SDSLOGR
PLQ¡WXRVLXVPHWRGXVGDUNHOLDLVQDXGLQJDLVPHWRGDLV'DOLVMÐ\UD
Comparator comparator( ) –JUåLQDOHQWHO¡VNRPSDUDWRULDXVREMHNW
Object firstKey( ) –JUåLQDUÌãLXRWRVOHQWHO¡VSLUPM³UDNW
Object lastKey( ) –DQDORJLãNDLSDVNXWLQ³M³
SortedMap subMap( Object start, Object end ) – JUåLQD LãUÌãLXRW OHQWHO

WXULQþL WLN ³¡MLPXV NXULÐ UDNWÐ UHLNãP¡V GLGHVQ¡V DUED O\JLRV start LU PDåHVQ¡V Xå
end.
83
Object getKey( ) –JUåLQDGDEDUWLQLROHQWHO¡V³¡MLPRUDNW
Object getValue( ) –JUåLQDGDEDUWLQLROHQWHO¡V³¡MLPRUHLNãP

âLDV VVDMÐ NODVHV UHDOL]XRMD NODV¡V HashMap, WeakHashMap ir TreeMap.

Hash-OHQWHO¡HashMapJDUDQWXRMDYLHQRGDLJUHLWSULHLW³SULHYLVÐOHQWHO¡V³¡MLPÐ-RV
NRQVWUXNWRULDL \UD NRQVWUXNWRULDL DQDORJLãNL DQNVþLDX QDJULQ¡WLHPV NODV¡V HashSet
NRQVWUXNWRULDPVWRG¡OMÐSUDVP¡VQHUHLNLDSDSLOGRPDLDLãNLQWL
HashMap( )
HashMap( Map m )
HashMap( int capacity )
HashMap( int capacity, float fillRatio )
TreeMap OHQWHO¡ VXGDU\WD QDXGRMDQW GXRPHQÐ VWUXNWÌU – PHG³ /HQWHO¡

LãUÌãLXRWD SDJDO UDNWXV QDWÌUDOLD DUED NRPSDUatoriumi teikiama tvarka, arba, jei
lentelei suteikiamos SortedMap ³¡MLPÐ UHLNãP¡V – SortedMap tvarka. Yra
konstruktoriai:
TreeMap( )
TreeMap( Comparator comp )
TreeMap( Map m )
TreeMap( SortedMap sm )
3DY\]G\V VX OHQWHO¡PLV SDWHLNWDV NLWDPH VN\ULXMe, kalbant apie klientines

programas.
2.20.4. CollectionsNODV¡VDOJRULWPDL
.ROHNFLMRPVLUOHQWHO¡PVJDOLPDWDLN\WLDOJRULWPXV³IRUPLQWXVNDLSNODV¡V
CollectionsVWDWLQLDLPHWRGDLýLDSDPLQ¡WLWLNNHOLLãMÐ
static void fill( List l, Object o ) –XåSLOGRVUDãl objekto o kopijomis.
static Object max( Collection c ) – JUåLQD GLGåLDXVL SDJDO QDWÌUDOL WYDUN

kolekcijos cHOHPHQW
static Object min( Collection c ) – analogiškas ankstesniam metodas.
static Object max( Collection c, Comparator comp ) – JUåLQD GLGåLDXVL

kolekcijos cHOHPHQWSDJDONRPSDUDWRULÐcomp.
static Object min( Collection c, Comparator comp ) – analogiškas ankstesniam

metodas.
static void reverse( List l ) –VUDãRHOHPHQWXVLãG¡VWRDWYLUNãþLDWYDUND
static void sort( List l, Com,parator comp ) –UÌãLXRMDVUDãRl elementus pagal

NRPSDUDWRULÐcomp.
84
%DLJLDPRVLRV SDVWDERV .ROHNFLMÐ LU OHQWHOLÐ SDVLULQNLPDV JDQD GLGHOLV
3DWDUVLPHNDGDLUNRNLSDVLULQNWLNROHNFLM
1. -HL Y\NGDQW SURJUDP WHNV GDXJ NDUWÐ Lãrinkti bet kuriuos sekos elementus,
efektyviausia naudoti ArrayListNODV¡VREMHNW
2. -HL WHNV GDXJ NDUWÐ ³ VHN ³WHUSWL DU LãPHVWL HOHPHQWXV QDXGRWLQDV LinkedList
objektas.
3. Rinkiniai Set saugo tik unikalius sekoje elementus. HashSetJDUDQWXRMDSDþL
JUHLþLDXVLHOHPHQWÐSDLHãN
4. -HLULQNLQ\VWXULEÌWLLãUÌãLXRWDVQDXGRWLQDVTreeSet objektas.
5. 3ULPLW\YLRPVGXRPHQÐED]¡PVNXUWLXåWHQNDOHQWHOLÐMapJDOLP\ELÐ
85
3. J A V A T E C H N O L O G I J O S
3.1. .OLHQWLQ¡VSURJUDPRVSwing technologija
3.1.1. %HQGURVLRVåLQLRVDSLHNOLHQWLQHVSURJUDPDV
3DJULQGLQ¡ NOLHQWLQ¡V SURJUDPRV applet) paskirtis – SUDWXUWLQWL ³SUDVWXV

LQWHUQHWR QDUã\NO¡V URGRPXV ZZZ SXVODSLXV .DGDQJL NOLHQWLQ¡V SURJUDPRV
³NUDXQDPRV³NOLHQWRNRPSLXWHU³LãQXWROXVLRNRPSLXWHULRVDXJXPRVXPHWLPDLVMRPV
DSULERWDSULHLWLVSULHNOLHQWRNRPSLXWHULRNLHWRMRGLVNRWLHNUDã\WLWLHNVNDLW\WL7DþLDX
patikimoms (trusted NOLHQWLQ¡PV SURJUDPRPV SDVLUDã\WRPV VNDitmeniniu parašu,
WRNLD SULHLJD JDOLPD .OLHQWLQ¡V SURJUDPRV YHLNLD QDUã\NO¡V YLGXMH – MRV DGUHVLQ¡MH
HUGY¡MH 1DUã\NO¡ NOLHQWLQ¡V SURJUDPRV DWåYLOJLX DWOLHND PDåGDXJ WDV SDW IXQNFLMDV
NDLS26VDYDUDQNLãNRVDSOLNDFLMRVDWåYLOJLX
.OLHQWLQLÐ SURJUDPÐ ³NURYDL UHLNLD ODLNR 7RG¡O UHNRPHQGXRMDPD MDV ³G¡WL ³
DUFK\YLQHV -$5 ULQNPHQDV VXVSDXVWDPH IRUPDWH³ YLHQ ULQNPHQ VXGHGDPRV YLVRV
UHLNLDPRV NOLHQWLQLÐ SURJUDPÐ GDUEXL NODV¡V LU YLVRV UHLNLDPRV GDXJLDO\S¡V WHUS¡V
rinkmenos.
.OLHQWLQLÐ SURJUDPÐ DSOLNDFLMRV NDrkasas – NODV¡ Applet MHL NOLHQWLQ¡PV
SURJUDPRPV NXUWL QDXGRMDPDV SDVHQ
V SDNHWDV java.awt DUED NODV¡ JApplet (jei
naudojamas dabar rekomenduojamas paketas javax.swing %HMH YLVL NDOE
papildantys Java 2 paketai pradedami vardu javax – QXR åRGåLR eXtension –
LãSO¡WLPDV). Mes visas klientines programas kursime remdamiesi JApplet klase.
3URJUDPXRWRMRUDãRPDNOLHQWLQ¡VSURJUDPRVVWDUWLQ¡NODV¡WXULSDYHOG¡WLLããLRVNODV¡V
metodus ir savybes. Nors AWT (Abstract Windowing Toolkit) paketas skelbiamas
pasenusiX WHEHVLQDXGRMDPD MR NRQWHLQHULÐ LU ³Y\NLÐ NODV¡PLV EHL PHWRGDLV WRG¡O
NOLHQWLQ¡MH SURJUDPRMH WHNV ³VLNHOWL NODVHV Lã SDNHWÐ javax.swing, java.awt ir
java.awt.event.
$:7 Q¡UD GDXJ JUDILQLÐ HOHPHQWÐ R QDXMR JUDILQLR HOHPHQWR NÌULPDV \UD
NHEOXV EÌWLQD SDYHOG¡WL SDVLULQNWRMR HOHPHQWR VDY\EHV LU SHUUDã\WL PHWRGXV WXR
VXWHLNLDQW QDXMDMDL NODVHL UHLNLDP IXQNFLRQDOXP 9LVL SDNHWR HOHPHQWDL \UD
vadinamieji „sunkiasvoriai“ (heavyweight .DG SDNHWDV EÌWÐ QHSULNODXVRPDV QXR
platformos, Sun SDVLULQNR WRN³ HOHPHQWÐ NÌULP IDNWLãNDL QDXGRMDPL JLPWLHML
RSHUDFLQ¡VVLVWHPRVJUDILQLDL³UDQNLÐNRPSOHNWDL7RG¡ONXULDQWSDY\]GåLXLP\JWXN
Windows OS, sukuriamas Windows mygtukas, o jei mygtukas kuriamas iš Linux –
JVM sukuria LinuxP\JWXN7RNLDWHFKQLNDGDUYDGLQDPDO\JLDYHUþLÐãDEORQÐpeer
patternWHFKQLND-LPHQNDLWLQNDVXG¡WLQJRPVJUDILQ¡PVVVDMRPVNXUWLNDGDQJLNXUL
QRUV26JDOLQHWXU¡WLNXULRQRUVVXG¡WLQJHVQLRJUDILQLRHOHPHQWR
Swing SDNHWH DWVLVDN\WD QDXGRWL JLPWXRVLXV 26 JUDILQLÐ ³UDQNLÐ DWLWLNPHQLV
visi elementai 100 % sukurti Java – jie yra „lengvasvoriai“ (lightweight7RG¡OWRNLH
HOHPHQWDL YLVRVH 26 YDL]GXRMDPL O\JLDL WDLS SDW 7DþLDX G¡O WRV SDþLRV SULHåDVWLHV
WRNLÐNRPSRQHQWÐNODV¡V\UDGLGHO¡VDSLPWLHVGDåQLDXVLDL– apie 2 MB). Paketas yra
daXJ WXUWLQJHVQLV R SDNHWR HOHPHQWXV JDOLPD å\PLX PDVWX WLQNLQWL YDUWRWRMR
UHLNP¡PV
.OLHQWLQLÐSURJUDPÐSDOHLGLPRWRNLXEÌGDL
1DUã\NOHSHUåLÌU¡WLZZZSXVODS³NXULR+70/NRGH\UDVDNLQLDL<applet>
arba <embed> QXURGDQW\V Lã NXU UHLNLD SDUVLVLÐVGLQWL NOLHQWLQ¡V SURJUDPRV NRG
86
$WVLÐVWD NOLHQWLQ¡ SURJUDPD DXWRPDWLãNDL SDOHLGåLDPD 'DEDU HVDQW GDXJHOLXL
QDUã\NOLÐ YHUVLMÐ LU NHOHWXL Java -'. DU 6'. YHUVLMÐ \UD GLGHO¡ WLNLP\E¡ NDG
NOLHQWLQ¡ SURJUDPD QDUã\NO¡MH QHYHLNV *DOL SULUHLNWL SO¡WLQLÐ plug-ins) Netscape
Navigator naršyklei arba Active-X PRGXOLÐ Internet Explorer naršyklei. Kompanija
JavasoftJDUDQWXRMDWRNLXVSO¡WLQLXVLUQHPRNDPDLMXRVSODWLQD²+70/NRGJDOLPD
³G¡WL VDNLQLXV <object> ir <embed> VX LQIRUPDFLMD DSLH WXRV SO¡WLQLXV 5HLNLDPÐ
SO¡WLQLÐ YDUGDL ³YDLULRPV -90 YHUVLMRPV SDWHLNWL
java.sun.com/products/plugin/version.html.
Sakiniuose <applet> arba <embed>WXULEÌWLWU\VSULYDORPLSDUDPHWUDL
code = rinkmenos *.class vardas

width NOLHQWLQ¡VSURJUDPRVODQJRSORWLVYDL]GRWaškais
height NOLHQWLQ¡VSURJUDPRVODQJRDXNãWLVYDL]GRWDãNDLV
LUJDOLEÌWLQHSULYDORPLSDUDPHWUDL
codebase NOLHQWLQ¡V SURJUDPRV NRGR 85/ DGUHVDV MHL SDUDPHWUDV

nenurodytas –NOLHQWLQ¡VSURJUDPRV³NURYDLQDXGRMDPDV+70/
dokumento URL adresas
align = QXURGR NOLHQWLQ¡V SURJUDPRV ODQJR O\JLDYLP QDUã\NO¡V ODQJH
*DOLPRV SDUDPHWUR UHLNãP¡V left, rigth, top, bottom, middle,
baseline, ... .
Visas HTML dokumento pavyzdys yra 1.9 skyriuje. Beje, nesvarbu, ar HTML
VDNLQLDLUDãRPLGLGåLRVLRPLVDUPDåRVLRPLVUDLG¡PLV-ÐSDUDPHWUÐLãG¡VW\PRWYDUND
sakinyje-NRQWHLQHU\MH \UD QHVYDUEL 6DNLQLÐ SDUDPHWUDL VNLULDPL YLHQDV QXR NLWR
WXãþLDLV WDUSDLV 3DUDPHWUÐ UHLNãP¡V WHLNLDPRV DUED WDUS NDEXþLÐ ³ ³ DUED EH MÐ R
NOLHQWLQ¡V SURJUDPRV VXNRPSLOLXRWDL ULQNPHQDL SULHVDJ class galima praleisti.
'DXJHOLV GDEDUWLQLÐ QDUã\NOLÐ +70/ GRNXPHQW DWSDå³VWD LU EH VWDUWLQLÐ VDNLQLÐ
<HTML>, <HEAD> ir <BODY>,WDLJLJDOLPDMÐLUQHUDã\WL3ODWHVQLXVSDDLãNLQLPXV
apie kai kuriuos HTML sakinius rasite šioje dalyje, serverLQLÐ SURJUDPÐ VN\ULXMH
YLHQDPHLãVHUYHULQLÐSURJUDPÐSDY\]GåLÐ
²UDQNLX appletviewer âL JDOLP\E¡ UHNRPHQGXRMDPD WHVWXRMDQW NOLHQWLQHV

SURJUDPDV .OLHQWLQHL SURJUDPDL SDOHLVWL ³UDQNLX Lã SXOWR UHLNLD VXNRPSLOLXRWRV
NOLHQWLQ¡V SURJUDPRV ULQNPHQRV LU HTML dokumento su sakiniu <applet>, kuriame
QXURG\WDV VXNRPSLOLXRWRV ULQNPHQRV YDUGDV ULQNPHQRV DEL ULQNPHQRV WXUL EÌWL
viename aplanke:
appletviewer HTML_rinkmenos_vardas
Testuoti klientines programas vis tik daug patogiau naudojantis appletviewer

VDY\EH NUHLSWL G¡PHV³ WLN ³ VDNLQ³ <applet> *DOLPD WLHVLDL ³ NOLHQWLQ¡V SURJUDPRV
NRPSLOLDFLMRVYLHQHWRWHNVW³G¡WLXåNRPHQWXRWVDNLQ³
// <applet code = ... width = … height = …

// </applet>
LU³UDQNLXSDOHLVWLNOLHQWLQ
SURJUDPWDip:
87
appletviewerNOLHQWLQ¡VSURJUDPRVBSUDGLQ¡BULQNPHQD.java
'DEDU NHLþLDQW SDY\]GåLXL NOLHQWLQ¡V SURJUDPRV ODQJR SUDGLQLXV PDWPHQLV

NOLHQWLQ¡V SURJUDPRV QHUHLN¡V LU SHUNRPSLOLXRWL WHNV WLN SDNHLVWL VDNLQLR WHNVW
komentare.
3. Galima pritaikyWL NOLHQWLQ

SURJUDP SDOHLVWL LU Lã QDUã\NO¡V LU Lã
NRPDQGLQ¡V HLOXW¡V SXOWH 7DP NOLHQWLQ¡V SURJUDPRV WHNVW GDU UHLN¡WÐ SDSLOG\WL
metodu main VX LãUHLNãWX YLVÐ NOLHQWLQ¡V SURJUDPRV NDUNDVR PHWRGÐ NYLHWLPX åU
%(FNHOLRNQ\J
3.1.2. .OLHQWLQ¡VSURJUDPRVDUFKLWHNWÌUD
.OLHQWLQ¡SURJUDPD–SURJUDPDGLUEDQWLVXODQJXLUMDPHLãG¡VWRPDLVYDOG\PR
HOHPHQWDLV WRG¡O MRV DUFKLWHNWÌUD VNLULDVL QXR NLWÐ SURJUDPÐ – WDL Ä³Y\NLÐ YDOGRPD
sistema“ (event-driven system ,ã HVP¡V WDL SDQDãX ³ LãLPþLÐ DSGRURMLPR
mechani]P NOLHQWLQ¡ SURJUDPD ODXNLD NRNLR QRUV ³Y\NLR M³ ÄVXJDXQD³ ³Y\NLR
DSGRURNOLV WDGD NOLHQWLQ¡ SURJUDPD DWOLHND UHLNLDPXV YHLNVPXV R SDVNXL NOLHQWLQ¡
SURJUDPDODXNLDNLWÐ³Y\NLÐâLHYHLNVPDLWXULEÌWLDWOLNWLJUHLWDLUHDOLDPHODLNHWRG¡O
kartais juosWHQNDY\NG\WLDWVNLUXY\NG\PRVUDXWX.LWDVNOLHQWLQ¡VSURJUDPRVHVPLQLV
VNLUWXPDV QXR ³SUDVWRV SURJUDPRV – GDUE VX NOLHQWLQH SURJUDPD LQLFLDOL]XRMD
YDUWRWRMDVNDLMDPWRUHLNLDSDVSDXVGDPDVSHO¡VNODYLãDQWUHLNLDPRJUDILQLRODQJR
elemento ar pan.). 7RNVYDUWRWRMRYHLNVPDVJHQHUXRMD³Y\N³³NXU³UHDJXRMDNOLHQWLQ¡
programa.
.OLHQWLQ¡ SURJUDPD SDYHOGL JApplet NODV¡V VDY\EHV LU PRGLILNXRMD UHLNLDPXV
PHWRGXV 0HWRGDL YDOGDQW\V NOLHQWLQ¡V SURJUDPRV J\YDYLP ZZZ SXVODS\MH \UD
(visi – public void) šie:
init( ) – DXWRPDWLãNDL NYLHþLDPDV ³NUDXQDQW NOLHQWLQ

SURJUDP ³ QDUã\NO

3HUUDãDQWPHWRGMDPHUHLN¡WÐLQLFLDOL]XRWLGXRPHQLVQXVWDW\WLJUDILQLÐNRPSRQHQWÐ
LãG¡VW\PODQJHâLVPHWRGDVYLVDGDSHUUDãRPDV
start( ) – NYLHþLDPDV SR PHWRGR init ir visada DXWRPDWLãNDL NYLHþLDPDV NDL

NOLHQWLQ¡V SURJUDPRV ODQJDV SDWHQND ³ PDWRP ZZZ SXVODSLR ]RQ SDY\]GåLXL
DWNXULDQW NOLHQWLQ¡V SURJUDPRV ODQJ DQNVþLDX VXWUDXNW ³ SLNWRJUDP DWLWLQNDPX
mygtuku).
stop( ) – DXWRPDWLãNDL NYLHþLDPDV NLHNYLHQNDUW NOLHQWLQ¡VSURJUDPRV ODQJXL

SDOLHNDQWPDWRPSXVODSLR]RQSDY\]GåLXLVXWUDXNLDQWNOLHQWLQ¡VSURJUDPRVODQJ³
SLNWRJUDP P\JWXNX 3HUUDãDQW PHWRG MDPH UHNRPHQGXRMDPD VXVWDEG\WL GDXJ
LãWHNOLÐUHLNDODXMDQþLXVYHLNVPXV
destroy( ) – DXWRPDWLãNDL NYLHþLDPDV NDL NOLHQWLQ¡ SURJUDPD LãNUDXQDPD Lã

QDUã\NO¡V 0HWRGDV LãODLVYLQD YLVXV NOLHQWLQ¡V SURJUDPRV QDXGRWXV NRPSLXWHULR
išteklius.
7DLJLLããLÐNOLHQWLQ¡VSURJUDPRVJ\YDYLPSDODLNDQþLÐPHWRGÐGDåQDLXåWHNV
tik perrašyti initPHWRGRNLWXVSDOLNWLWRNLXVNRNLHMLHDSLEU¡åWLJAppletNODV¡MH'DU
NHOLPHWRGDLNXULXRV WHNV GDåQDL SHUUDã\WL VDYR NOLHQWLQ¡VH SURJUDPRVH– iš metodo
88
void repaint( )NYLHþLDPDVPHWRGDVvoid paint( Graphics g). Šiaip paint automatiškai
NYLHþLDPDV NDL UHLNLD SHUSLHãWL NOLHQWLQ¡V SURJUDPRV JHQHUXRMDP ODQJ 7DLJL MHL
NOLHQWLQ¡V SURJUDPRV GDUER PHWX SDY\]GåLXL UHDJXRMDQW ³ NXULR QRUV P\JWXNR
SDVSDXGLP UHLNLD NDLS QRUV SDNHLVWL NOLHQWLQ¡V SURJUDPRV ODQJR YDL]G – teks
LãUHLNãWDLNYLHVWLPHWRGrepaint, šis automatiškai kvies paint, o perrašytame metode
paintWHNVQXURG\WLNLUNDLSQXSLHãWL0HWRGDVpaintWXULYLHQJavaNODV¡VGraphics
WLSRDUJXPHQWSHUNXU³JDXQDYLVJUDILQ³NOLHQWLQ¡VSURJUDPRVNRQWHNVW
.OLHQWLQ¡V SURJUDPRV NXUL WLN ODQJH VXNXULD GX P\JWXNXV EHW QLHNDLS
nHUHDJXRMD³MÐSDVSDXGLPXVSDY\]G\V9LVLPHWRGDLLUNODV¡VEXVSDDLãNLQWLY¡OLDX
// Applet shows two buttons

// <applet code = Buttons width = 200 height = 100
// </applet>
import java.awt.*;
public class Buttons extends JApplet{

JButton b1 = new JButton( “Button 1” ),
b2 = new JButton( “Button 2” );
c.add( b1 );
c.add( b2 );
}
}
.OLHQWLQ
SURJUDP SDOHLVWL JDOLPD VXNRPSLOLDYXV ãL SURJUDP LU
NRPDQGLQ¡MHHLOXW¡MHVXULQNXV
appletviewer Buttons.java
3.1.3. ²Y\NLÐDSGRURMLPRVLVWHPD
²Y\NLÐ NODV¡V \UD SDNHWH java.awt.event R MÐ NODXV\WRMÐ NODV¡V – pakete

javax.swing.
.OLHQWLQ¡VHSURJUDPRVHQDXGRMDPDVYDGLQDPDVLV³Y\NLÐGHOHJDYLPRPRGHOLV
Ä³Y\NLR ãDOWLQLV³ JHQHUXRMD ³Y\N³ LU VLXQþLD SUDQHãLP DSLH WDL YLHQDP DU NHOLHPV
Ä³Y\NLÐ NODXV\WRMDPV³ ²Y\NLR ãDOWLQLV – NXULV QRUV NOLHQWLQ¡V SURJUDPRV YDUWRWRMR
YHLNVPDV JUDILQ¡MH VVDMRMH SDY\]GåLXL SHO¡V NODYLãR QXVSDXGLPDV SHO¡V å\PHNOLXL
esant ant mygtuko. Klausytojo funkcijos – ODXNWL SUDQHãLPR DSLH ³Y\N³ *DY
V WRN³
SUDQHãLP NODXV\WRMDV UHLNLDPX EÌGX W XåSURJUDPXRMD SURJUDPXRWRMDV DSGRURMD
³Y\N³LUJUåLQDYDOG\PNOLHQWLQHLSURJUDPDLâLVODXNLDNLWÐYDUWRWRMRYHLNVPÐ
7DLJLãLDPHPRGHO\MH³Y\NLXVJHQHUXRMDQWLYDUWRWRMRVVDMD\UDJULHåWDLDWVNLUWD
QXR³Y\NLÐDSGRURMLPRPHFKDQL]PR6YDUELPRGHOLRVDY\E¡³YHVWDWLN Java 2, yra tai,
NDG ³Y\NLÐ NODXV\WRMDL QRU¡GDPL JDXWL SUDQHãLPXV DSLH ³Y\N³ SULYDOR
ÄXåVLUHJLVWUXRWL³³Y\NLÐãDOWLQ\MH$QNVWHVQ¡MHJavaYHUVLMRMHSUDQHãLPDLDSLH³Y\NLXV
EXYRVLXQþLDPLYLVLHPVNODXV\WRMDPV
89
'DEDUVPXONLDXDSLH³Y\NLÐGHOHJDYLPRPRGHOLRHOHPHQWXV
²Y\NLDL – REMHNWDL DSUDãDQW\V ãDOWLQLR EÌNO¡V SRN\þLXV .DLS PLQ¡WD WDL JDOi
EÌWL YDUWRWRMR YHLNVPÐ VXNHOWL ³Y\NLDL JUDILQ¡MH VVDMRMH DUED ODLNPDþLR QXURG\PX
JHQHUXRMDPDV ³Y\NLV DUED WDP WLNURV VNDLWLNOLR UHLNãP¡V SDVLHNLPDV YHLNLDQW
NOLHQWLQHL SURJUDPDL LU SDQ 3URJUDPXRWRMDV SDWV QXVWDWR ³Y\NLXV NXULXRV DSGRURV
NOLHQWLQ¡ SURJUDPD ²Y\NLÐ NODVLÐ YDUGDL SDNOÌVWD JULHåWDL ³YDUGLMLPR VFKHPDL
TypeEvent, kur vietoje pirmosios vardo dalies Type \UD åRGåLDL Mouse – SHO¡V
³Y\NLDPVKey –NODYLDWÌURV³Y\NLDPVAdjustment –VODQNLNOLR³Y\NLDPVLUWW9LVRV
ãLRV ³Y\NLÐ NODV¡V \UD SDkete java.awt.event. 9LVÐ MÐ VXSHUNODV¡ – EventObject,
NXULRMHDSLEU¡åWLWLNGXPHWRGDL
Object getSource( ) –JUåLQD³Y\NLRãDOWLQ³

String toString( ) –JUåLQD³Y\NLRDSUDã
²Y\NLÐ ãDOWLQLDL – REMHNWDL JHQHUXRMDQW\V ³Y\NLXV 9LHQDV ãDOWLQLR REMHNWas

JDOLJHQHUXRWLLUNHOLV³Y\NLXVSDY\]GåLXLSHO¡JHQHUXRMDSDYLHQLXV³Y\NLXVNODYLãXL
QXVSDXVWL NODYLãXL DWOHLVWL NODYLãXL GXNDUW QXVSDXVWL SHO¡V å\PHNOLXL WUDXNWL
QXVSDXGXV NODYLã QHQXVSDXGXV NODYLãR âDOWLQLV UHJLVWUXRMD ³Y\NLÐ NODXV\WRMXV
kuriHPV VLÐV SUDQHãLPXV .LHNYLHQDV ³Y\NLR WLSDV WXUL DWVNLU UHJLVWUDFLMRV PHWRG
NXULRDSUDãDVSDNOÌVWDJULHåWDLVFKHPDL
public void addTypeListener( TypeListener tl ),
þLDType –³Y\NLRREMHNWRYDUGDV
.DLNXULHãDOWLQLDLOHLGåLDUHJLVWUXRWLWLNYLHQLQWHO³NODXV\WRMMLHVXNHOLDLãLPW³
java.util.TooManyListenerException.
âDOWLQLDL NDLS LU UHJLVWUDFLMDL WXUL DQDORJLãNXV NODXV\WRMXV SDãDOLQDQþLXV
metodus
public void removeTypeListener( )
9LVLUHJLVWUDFLMRVLUSDãDOLQLPRPHWRGDL\UDDWLWLQNDPRVH³Y\NLÐNODV¡VH
²Y\NLÐNODXV\WRMDL –REMHNWDLJDXQDQW\VSUDQHãLPXVDSLH³Y\NLXV%HPLQ¡WRV
³Y\NLÐUHJLVWUDFLMRVNODXV\WRMDVSULYDORUHDOL]XRWLSUDQHãLPÐSUL¡PLPRLUDSGRURMLPR
PHWRGXV QXURGRPXV NODXV\WRMXV DWLWLQNDQþLRVH VVDMÐ NODV¡VH HVDQþLRVH SDNHWe
java.awt.eventâLÐVVDMÐNODVLÐYDUGDLVXIRUPXRWLWDLSSDWJULHåWDLTypeListener.
OHQWHO¡MH SDWHLNLDPDV VUDãDV JUDILQ¡VH VVDMRVH GDåQLDXVLDL QDXGRMDPÐ

³Y\NLÐNODVLÐNODXV\WRMÐVVDMÐNODVLÐNODXV\WRMÐUHJLVWUDFLMRVLUSDãDOLQLPRPHWRGÐLU
³Y\NLÐãDOWLQLÐ
90
3.1 lHQWHO¡ ²Y\NLÐVLVWHPD
²Y\NLRNODV¡
.ODXV\WRMRVVDMRVNODV¡ ²Y\NLRDSLEÌGLQLPDV ²Y\NLÐãDOWLQLÐNODV¡V
Klausytojo registracijos
ir pašalinimo metodai
ActionEvent Generuojamas, kai JButton, JList, JTxtField,

ActionListener QXVSDXGåLDPDVSHO¡VNODYLãDV JMenuItem, JCheckBoxMenuItem,
addActionListener arba klavišas dukart JMenu, JPopupMenu
removeActionListener QXVSDXGåLDPDVVVDMRV
elemente
AdjustmentEvent Generuojamas, kai slankikliu JScrollBar LUYLVRVNODV¡V

AdjustmentListener SDNHLþLDPDUHLNãP¡ UHDOL]XRMDQþLRVVVDMÐNODV
addAdjustmentListener Adjustable
removeAdjustmentListener
ComponentEvent Generuojamas, kai Component LUYLVRVMRVVXENODV¡V

ComponentListener komponentas paslepiamas,
addComponentListener pasidaro matomas,
removeComponentListener SHUVWXPLDPDVSDNHLþLDPLMR
matmenys.
ContainerEvent Generuojamas, kai Container ir visosMRVVXENODV¡V

ContainerListener NRPSRQHQWDV³GHGDPDVDU
addContainerListener SDãDOLQDPDV³LãNRQWHLQHULR
removeContainerListener
FocusEvent Generuojamas, kai Component LUYLVRVMRVVXENODV¡V

FocusListener NRPSRQHQWDVSDWHQND³IRNXV
addFocusListener ar jo netenka
removeFocusListener
KeyEvent Generuojamas, kai klavišas Component LUYLVRVMRVVXENODV¡V

KeyListener QXVSDXGåLDPDVDWOHLGåLDPDV
addKeyListener kai spausdinamas simbolis
removeKeyListener
MouseEvent Generuojamas, kai objektas Component LUYLVRVMRVVXENODV¡V

MouseListener ir WUDXNLDPDVSHOHNDLSHO¡
MouseMotionListener MXGLQDPDNDLSHO¡VNODYLãDV
addMouseListener ir paspaustas ir atleistas; kai
addMouseMotionListener klavišas paspaustas; kai
removeMouseListener ir NODYLãDVDWOHLVWDVNDLå\PHNOLV
removeMouseMotion-Listener ³HLQD³NRPSRQHQWNDL
å\PHNOLVSDOLHNDNRPSRQHQW
91
WindowEvent Generuojamas, kai langas Window LUYLVRVMRVVXENODV¡V
WindowListener aktyvuojamas,
addWindowListener deaktyvuojamas, atidaromas,
removeWindowListener XåGDURPDVVXWUDXNLDPDV³
SLNWRJUDPLãSOHþLDPDVLã
piktogramos
ItemEvent *HQHUXRMDPDVNDLSDå\PLPDV JCheckBox, JCheckBoxMenuItem,

ItemListener VUDãRDUPHQLXHOHPHQWDV JComboBox, JList LUYLVRVVVDMÐ
addItemListener DUEDY¡OLDY¡O¡ NODV
ItemSelectable
removeItemListener UHDOL]XRMDQþLRVNODV¡V
TextEvent Generuojamas, kai JTextComponent ir visos jos

TextListener komponente pakinta tekstas VXENODV¡V
addTextListener
removeTextListener
äLQDQW OHQWHO¡MH LãYDUG\WXV ³Y\NLÐ NODXV\WRMÐ YDUGXV QHVXQNX LQWHUQHWH

NDOERV GRNXPHQWDFLMRMH VXVLUDVWL YLVXV VVDMÐ NODV¡VH GHNODUXRWXV PHWRGXV
Pavy]GåLXLActionListenerVVDMÐNODV¡WXULWLNYLHQPHWRG
actionPerformed( ActionEvent ae )
6VDMÐ NODV¡V SHO¡V ³Y\NLXL MouseEvent – MouseListener ir

MouseMotionListener – turi atitinkamai metodus
mouseClicked(MouseEvent me )
mouseEntered( MouseEvent me )
mouseExited(MouseEvent me )
mousePressed( MouseEvent me )
mouseReleased(MouseEvent me )
ir metodus
mouseDragged( MouseEvent me )
mouseMoved( MouseEvent me )
.DGDQJLNODXV\WRMÐVVDMÐNODV¡VGDåQLDXVLDLWXULSRNHOLVSDVNHOEWXVPHWRGXV
R NXULDQW JUDILQ
VVDM GDåQDL WHUHLNLD WLN YLHQR NXULR PHWRGR – UHDOL]XRWL VVDMÐ
NODVHV QH YLVDGD SDWRJX 7RNLHPV DWYHMDPV VNLUWRV NODV¡V-DGDSWHULDL WXULQþLRV YLVXV
DWLWLQNDPRVH VVDMÐ NODV¡VH SDVNHOEWXV WDþLDX ÄWXãþLXV³ PHWRGXV 7DGD JHULDX QH
realizXRWLVVDMÐNODV
RSO¡VWLNODV
-DGDSWHU³SHUUDãDQWWLNGRPLQDQW³PHWRGDUNHOLV
PHWRGXV âLÐ NODVLÐ YDUGDL NRQVWUXRMDPL SDJDO W SDþL YDUGÐ VFKHP SDY\]GåLXL
VVDMÐNODV
MouseListenerDWLWLQNDNODV¡MouseAdapter ir t. t.
3DWHLNVLPH³Y\NLÐNODV¡VSDY\]G³–NDGEÌWÐDLãNXNJDOLPDJDXWLLã³Y\NLR
NODV¡V REMHNWR NDLS LãSO¡VWL NODV
UDãDQW VDY DQDORJLãN NODV
7DLJL NODV¡
ActionEvent turi konstruktorius:
92
ActionEvent( Object source, int type, String cmd )
ActionEvent( Object source, int type, String cmd, int modifiers )
ýLDsource –URG\NO¡³REMHNWVXN¡OXV³³Y\N³type – konstanta –³Y\NLRWLSDV

cmd – ³Y\NLR NRPDQGLQ¡ HLOXW¡ modifiers – NRQVWDQWD NXULRV UHLNãP
DWLWLQND
klavišas-PRGLILNDWRULXVEXY
VQXVSDXVWDVJHQHUXRMDQW³Y\N³$OW&WUl ir/arba Shift).
.ODV¡WXULPHWRGXV
String getActionCommand( )
String setActionCommand( )
int getModifiers( )
3LUPRMR PHWRGR SUDVP¡ SDY\]GåLXL NDL JUDILQ¡MH VVDMRMH QXVSDXVWDV

mygtukas, metodo rezultatas yra mygtuko tekstas – JLabel objektas. KLWÐ GYLHMÐ
PHWRGÐSDVNLUWLVDLãNLLãMÐSDYDGLQLPÐ
.OLHQWLQLÐSURJUDPÐSDY\]GåLDL
1 pavyzdys. .OLHQWLQ¡V SURJUDPRV ODQJH QDXGRMDQW NRPSRQHQWÐ LãG¡VW\PR

WYDUN\NO
FlowLayout åU NLW VN\ULÐ LãG¡VWRPL GX P\JWXNDL JButton NODV¡V
objektai) ir vienas tekstinis laukas (JTextField 0\JWXNDL WXUL XåUDãXV Button 1 ir
Button 2NXULHQXVSDXGXVDWLWLQNDPP\JWXNSDVLURG\VWHNVWLQLDPHODXNH
// 1st example of applet: buttons and event

//
//<applet code = Button2 width = 300 height = 200>
//</applet>
//
import java.awt.*;
public class Button2 extends JApplet{

JButton b1 = new JButton("Button 1"),
b2 = new JButton("Button 2");
class ALC implements ActionListener{
public void actionPerformed( ActionEvent e){
String buttonName = ( (JButton)e.getSource() ).getText();
tf.setText( buttonName );
}
}
ALC al = new ALC( );
b1.addActionListener( al );
93
c.add( b1 );
c.add( b2 );
c.add( tf );
}
}
7DLJL NOLHQWLQ¡MH SURJUDPRMH UHLNLD UHDOL]XRWL NODXV\WRMR VVDMRV NODV

ActionListener QHV EÌWHQW MRMH \UD PHWRGDV actionPerformed UHDJXRMDQWLV ³ SHO¡V
NODYLãRQXVSDXGLPR³Y\N³HVDQWå\PHNOLXLDQWNXULRQRUVNRPSRQHQWRActionEvent.
6VDMÐNODV¡VWLSRREMHNWDVNRQVWUXRMDPDVYLGLQHYDUGLQHNODVHSHUUDãDQWMRMHPHWRG
actionPerformed. Metode, norint identifikuoti, kuris mygtukas nuspaustas,
SDVLWHONLDPDV DQNVþLDX PLQ¡WDV YLVÐ ³Y\NLÐ VXSHUNODV¡V ObjectEvent metodas
getSource .DGDQJL ãLV JUåLQD Object WLSR URG\NO
– EÌWLQDV EHVLOHLGåLDQWLV WLSÐ
SHUWYDUN\PDV³JButtonWLS7ROLDXNYLHþLDPDVJButton metodas getTextJUåLQDQWLV
P\JWXNR WHNVW – String WLSR GXRPHQ³ 9¡OLDX NODV¡V JTextField metodu setText šis
GXRPXRNRSLMXRMDPDV³WHNVWLQ³ODXNtf.
.OLHQWLQ¡MH SURJUDPRMH SHUUDãRPDV YLHQLQWHOLV NOLHQWLQ¡V SURJUDPRV NDUNDVR
metodas init.-DPHDELHPVP\JWXNDPVXåUHJLVWUXRMDPDVWDVSDWV³Y\NLÐNODXV\WRMDVal.
.OLHQWLQ¡MH SURJUDPRMH YLVL JUDILQLDL NRPSRQHQWDL LãG¡VWRPL NRQWHLQHU\MH NXULV
gaunamas metodu getContentPane ,ãG¡VW\P YDOGR LãG¡VW\PR WYDUN\NO¡V
nustatomos konteineriui metodu setLayout 9¡OLDX ³ NRQWHLQHU³ QRULPD WYDUND
sudedami visi reikiami grafiniai komponentai.
-HL SDOHLVLPH ãL NOLHQWLQ
SURJUDP EXV SDURG\WDV NOLHQWLQ¡V SURJUDPRV
ODQJDV VX GYLHP P\JWXNDLV LU WXãþLX WHNVWLQLX ODXNX .OLHQWLQ¡V SURJUDPRV JUDILQ¡
VVDMD UHDJXRV WLN ³ SHO¡V NODYLãR QXVSDXGLP DQW P\JWXNR – ³Y\N³ ActionEvent.
1XVSDXGXV NXU³ QRUV P\JWXN ã³ ³Y\N³ ÄVXJDXV³ ³Y\NLR NODXV\WRMDV LU DWLWLQNDPDL
reaguos: tekstiniam laukui bus nustatytas tekstas Button 1 arba Button 2.
2 pavyzdys.äHPLDXSDWHLNLDPDNOLHQWLQ¡SURJUDPDUHDOL]XRMDWSDþLJUDILQ

VVDM GHPRQVWUXRGDPD VNLUWLQJDV JDOLPDV VLQWDNVHV NODXV\WRMXL NRQVWUXRWL EHYDUG

YLGLQ
NODV
LU NODXV\WRMR REMHNWR NRQVWUDYLP WRMH NRGR YLHWRMH NXU MLV
registruojamDVâLIRUPDEÌWÐSDWRJLWDGDNDLNXULDPQRUVNRPSRQHQWXLNOLHQWLQ¡MH
programoje registruojamas vienintelis toks klausytojas. Demonstruojamos ir
VNLUWLQJRVNRPSRQHQWÐLãG¡VW\PRWYDUN\NO¡V
// 2nd example: buttons and event, inner classes, other layouts

//
//</applet>
//
import java.awt.*;

JButton b1 = new JButton("Button 1"),
b2 = new JButton("Button 2");
94
ActionListener al = new ActionListener( ){ // 2nd syntax' alternative;
public void actionPerformed( ActionEvent e ){ // to be preferred
String buttonName = ( (JButton)e.getSource( ) ).getText( );
}
}; // ;! “:” inherited from constructor
b2.addActionListener( new ActionListener( ){ // 3rd syntax' alternative; to be
public void actionPerformed( ActionEvent e ){ // preferred for a single addition
}
} );
c.add( BorderLayout.EAST, b1 );
c.add( BorderLayout.WEST, b2 );
c.add( BorderLayout.CENTER, tf );
}
}
3 pavyzdys. 5HDOL]XRMDPD WD SDWL JUDILQ¡ VVDMD âLV NOLHQWLQ¡ SURJUDPD

GHPRQVWUXRMD Lã SULQFLSR NLWRNL NOLHQWLQ¡V SURJUDPRV VFKHP NODXV\WRMX SDGDURPD
SDWL NOLHQWLQ¡ SURJUDPD WRG¡O MRV NODV¡ WXUL UHDOL]XRWL DWLWLQNDP NODXV\WRMR VVDMRV
NODV
W\MRMHWXULEÌWLSHUUDã\WLVVDMÐNODV¡VPHWRGDL
// 3rd example: buttons and event, alternative listening to the events

//
//</applet>
//
import java.awt.*;
public class Button31 extends JApplet implements ActionListener{

JButton b1 = new JButton( "Button 1" ),
b2 = new Jbutton( "Button 2" );
b1.addActionListener( this ); // ie, adding applet as a listener
b2.addActionListener( this );
c.add( BorderLayout.NORTH, b1 );
c.add( BorderLayout.SOUTH, b2 );
}
public void actionPerformed(ActionEvent e){
95
}
}
4 pavyzdys. .HOLÐ ³Y\NLÐ DSGRURMLPR SDY\]G\V JUDILQ¡ VVDMD UHDJXRMD ³

YLVXV SHO¡V ³Y\NLXV 1DXGRMDPD -LDPH SDY\]G\MH SDURG\WD NOLHQWLQ¡V SURJUDPRV
VFKHPD SDþLRMH MRV NODV¡MH UHDOL]XRMDPRV DEL SHO¡V ³Y\NLÐ NODXV\WRMÐ VVDMÐ NODV¡V
.OLHQWLQ¡SURJUDPDVSDXVGLQDSUDQHãLPDSLH³Y\N³messageRSHO¡Vå\PHNOLR³¡MLPR
³ODQJLULã¡MLPRLãODQJR³Y\NLDPV–LU³¡MLPREHLLã¡MLPRWDãNRNRRUGLQDWHVYDL]GR
WDãNDLV 3HO
WUDXNLDQW VX QXVSDXVWX NODYLãX ODQJH VSDXVGLQDPDV LU å\PHNOLR
S¡GVDNDV5HDJXRMDPD³EHWNXU³SHO¡VNODYLã
// 4th example: mouse and multiple events

//
//<applet code = Mouse1 width = 800 height = 500>
//</applet>
//
import java.awt.*;
public class Mouse1 extends JApplet

implements MouseListener, MouseMotionListener{ // applet listens to all
// mouse events
String message = "";
int x=0, y=0; // where the message is printed
int xa=0, ya=0; // where the mouse enters and leaves window
int i=0; // counts events "entered" and "exited"

addMouseListener( this ); // ie, adding applet as a listener
addMouseMotionListener( this );
}
public void mouseClicked( MouseEvent me ){

x = me.getX( )+100; // to separate messages "clicked" and "pressed"
y = me.getY( );
message = "Mouse clicked";
repaint( );
}
public void mouseEntered( MouseEvent me ){

i++;
x = 10;
y = i*10;
xa = me.getX( );
ya = me.getY( );
message = "Mouse entered" + xa + ya;
repaint( );
}
96
public void mouseExited( MouseEvent me ){
i++;
x = 10;
y = i*10;
xa = me.getX( );
ya = me.getY( );
message = "Mouse exited" + xa + " " + ya;
repaint( );
}
public void mousePressed( MouseEvent me ){

x = me.getX( );
y = me.getY( );
message = "Mouse pressed";
repaint( );
}
public void mouseReleased( MouseEvent me ){

x = me.getX( ) + 100;
y = me.getY( );
message = "Mouse released";
repaint( );
}
public void mouseDragged( MouseEvent me ){

x = me.getX( );
y = me.getY( );
message = "*";
showStatus( "Dragging at " + x + ", " + y ); // message at the bottom of window
repaint( );
}
public void mouseMoved( MouseEvent me ){

x = me.getX( );
y = me.getY( );
message = " ";
showStatus( "Moving at " + x + ", " + y );
repaint( );
}
public void paint( Graphics g) {

g.drawString( message, x, y );
}
}
Šioje klLHQWLQ¡MH SURJUDPRMH EÌWLQD LãUHLNãWDL NYLHVWL NOLHQWLQ¡V SURJUDPRV

SHUSLHãLPR PHWRG repaint 0LQ¡WD NDG ãLV DXWRPDWLãNDL NYLHþLDPDV NOLHQWLQHL
programai startuojant po startPHWRGRLUNLHNYLHQNDUWNDLMRVODQJDVWDPSDPDWRPDV
SDY\]GåLXLVXWUDXNXVODQJ–LãSO¡WXVODQJ.LWDLVDWYHMDLVNQRUVSDNHLWXVODQJH
97
LU QRULQW LãNDUW PDW\WL SRN\þLXV EÌWLQDV UDLãNXV NYLHWLPDV 9LVD SLHãLPR PHWRGÐ
NYLHWLPRJUDQGLQ¡\UDrepaintNYLHþLDupdate, o šis – paint.
7DLJL VSUHQGLPDV NOLHQWLQ¡V SURJUDPRV ODQJXL SHUSiešti akimirksniu yra toks:
VXIRUPXRWLLULãVDXJRWLLGHQWLILNDWRULXMHREMHNWNXU³UHLN¡VSHUSLHãWLNDLUHLNDOLQJDV
objekto perpiešimas – kviesti repaint SHUUDã\WL PHWRG paint QXPDWDQW UHLNLDPÐ
REMHNWÐLãYHGLP0HWRGDVpaintWXULYLHQNODV¡VGraphicsWLSRDUJXPHQWNXULDPH
VDXJRPDVYLVDVJUDILQLVNOLHQWLQ¡VSURJUDPRVNRQWHNVWDV
Metodo repaint yra keturi variantai:
void repaint( ) –SHUSLHãLDYLVODQJ

void repaint( int left, int top, int width, int height ) – SHUSLHãLD QXURG\W
(vaizdo taškaiV ODQJR GDO³ âLHPV YDULDQWDPV JDOLPL NHEOXPDL NDL PHWRGDV
NYLHþLDPDV SHU GDåQDL 3HU GDåQL NYLHWLPDL EXV DWPHVWL ³Y\NLÐ DSGRURMLPR
mechanizmo, ir updateEXVNYLHþLDPDVWLNODLNRWDUSDLVSDJDOQXW\O¡MLP7DLQHWLQND
MXGDQWLHPVYDL]GDPVSHUWHLNWLWRG¡Otam yra šie repaint variantai:
void repaint( long maxDelay ) – þLD maxDelay yra maksimalus laiko tarpas
tarp updateNYLHWLPÐPLOLVHNXQG¡PLV
void repaint( int left, int top, int width, int height, long maxDelay )
7DþLDX MHL G¡O VLVWHPLQLÐ SULHåDVþLÐ PHtodas update QHJDOL EÌWL NYLHþLDPDV
QXURG\WDLV LQWHUYDODLV PHWRGDV LãYLV QHNYLHþLDPDV LU QHJHQHUXRMDPD MRNLD LãLPWLV –
NOLHQWLQ¡VSURJUDPRVYHLNLPDVãLXRDWYHMXWDPSDYLVLãNDLQHVXSUDQWDPDV
3.1.5. Baziniai grafiniai komponentai
Rašant klientines programas, be Swing SDNHWRNRPSRQHQWÐNODVLÐUHLNDOLQJLLU

$:7 SDNHWH HVDQW\V NRPSRQHQWDL 3DJULQGLQLÐ NODVLÐ Swing paketas yra labai
GLGHOLVþLDDSVLULERMDPDWLNNHOLRPLVMRNODV¡PLVKLHUDUFKLMDSDURG\WDSDY
98
java.awt
Object
Component
Container
Panel
Window
java.applet
Applet Frame
java.swing
JApplet JFrame JComponent ImageIcon
JScrollBar JPanel JTextComponent AbstractButton
JButton
JScrollPane JLabel
JFileChooser
JTextField JTextArea
SDY3DNHWÐNODVLÐKLHUDUFKLMD
Taigi Swing hierarchijos viršuje yra JComponentNODV¡-LSDVNHOEWDabstract,

EHWWXULGDXJHO³PHWRGÐ9LVRVMRVVXENODV¡V\UDWULMÐWLSÐ
99
1. Grafiniai komponentai (graphical widgets);
2. Tekstiniai komponentai;
3. Konteineriai.
*UDILQLÐ NRPSRQHQWÐ SDY\]GåLDL – mygtukas JButton, slankiklis JScrollBar,

ULQNPHQÐ PHGLV JFileChooser -LHPV SDQDXGRWL IDNWLãNDL SDNDQND åLQRWL PHWRGXV-
NRQVWUXNWRULXV9LHQD LãLPWLV þLD– SLNWRJUDPRV XåUDãDVImageIconSOHþLDQWLVWLHVLDL
ObjectNODV

Tekstiniai komponentai – tekstinis laukelis JTextField; jame galima pateikti
WHNVWLU³YHVWLGXRPHQLVWHNVWLQ¡VULWLVLãNHOLÐHLOXþLÐJTextArea.
Konteineriai – MXRVH SULYDOR EÌWL LãG¡VW\WL NRPSRQHQWDL <UD GYLHMÐ WLSÐ
konteineriai:
1. Aukštesniojo lygio (JFrame, Window);

2. äHPHVQLRMRO\JLRJPanel, JScrollPane).
$XNãWHVQLRMR O\JLR NRQWHLQHULDL QHJDOL EÌWL ³GHGDPL ³ NLWXV NRQWHLQHULXV

äHPHVQLRMRO\JLRNRQWHLQHULDL–JDOLYLHQJPanelNRQWHLQHU³JDOLPDG¡WL³NLWRã³
GDU ³ NLW LU W W 7DLS JDOLPD VXIRUPXRWL EHW NRNLR JUDILQLR YDL]GR YDUWRWRMR VVDMDV
.RPSRQHQWÐ³G¡MLPDV³NRQWHLQHULXV–VXG¡WLQJDVSURFHVDV'DåQLDXVLDLWDLNRPDVWRNV
EÌGDVYLVLåHPRO\JLRNRQWHLQHULDLLUJUDILQLDLEHLWHNVWLQLDLNRPSRQHQWDLPHWRGXadd
VXGHGDPL ³ Container egzempliorLÐ NXULV JDXQDPDV NDLS SDURG\WD DQNVWHVQLXRVH
NOLHQWLQLÐSURJUDPÐSDY\]GåLXRVH
Container c = getContentPane( )
Konteineriai Window, Frame, JFrame pirmiausia skirti savarankiškoms kalbos

DSOLNDFLMRPV OHLGåLDPRPV VDYR NRPSLXWHU\MH NLWL – NOLHQWLQ¡PV Srogramoms,
OHLGåLDPRPV NLWXRVH NRPSLXWHULXRVH 6NLULDVL ãLÐ NRQWHLQHULÐ VDXJXPR JDOLP\E¡V
WRG¡ODQNVWHVQ¡VHJava YHUVLMRVHNOLHQWLQ¡MHSURJUDPRMHVXNÌUXVSDY\]GåLXLJFrame
ODQJQHWEXYRLãYHGDPDV³VS¡MLPDV³Warning: This is an applet window”.
3.1..RPSRQHQWÐLãG¡VW\PRNRQWHLQHU\MHWYDUN\NO¡V
3DWL WYDUN\NO¡ VSUHQGåLD NDLS LãG¡VW\WL NRQWHLQHU\MH JUDILQLXV NRPSRQHQWXV

.RPSRQHQWÐ G\GLV IRUPD LãG¡VW\PR EÌGDV VNLUVLV QDXGRMDQW VNLUWLQJDV WYDUN\NOHV
3DNHLWXV NOLHQWLQ¡V SURJUDPRV ODQJR PDWPHQLV Sakis konteinerio matmenys –
WYDUN\NO¡SDNHLVLUNRPSRQHQWÐLãG¡VW\P<UDWRNLRVLãG¡VW\PRWYDUN\NO¡V
BorderLayout
BoxLayout
CardLayout
FlowLayout
GridBagLayout
GridLayout
OverlayLayout
ScrollPaneLayout
ViewportLayout
100
.ODV¡ Container WXUL PHWRG setLayout QXVWDWDQW³ NRQWHLQHULXL QRULP
WYDUN\NO
5RG\NO¡ ³ Container REMHNW JDXQDPD PHWRGX getContentPane. Grafiniai
NRPSRQHQWDL OHLGåLD KLHUDUFKLQ
MÐ VDQGDU SDY\]GåLXL JPanel – objekte galima
VXG¡WL NLWXV åHPHVQLRMR O\JLR JPanel objektus ir t. t â³ LãG¡VW\P WDLS SDW YDOGR
WYDUN\NO¡V
3DJDO QXW\O¡MLP NOLHQWLQ¡V SURJUDPRV QDXGRMD WYDUN\NO
BorderLayout. Ji
NRPSRQHQW GHGD ³ NRQWHLQHULR FHQWU LU ÄLãWHPSLD³ LNL NRQWHLQHULR PDWPHQÐ
.RPSRQHQWDV ³GHGDPDV ³ NRQWHLQHU³ PHWRGX add(Component c) arba
add(BorderLayout.CONSTNAME, Component c þLD static final int konstanta
CONSTNAME QXVWDWR YLHW NXU SDGHGDPDV NRPSRQHQWDV <UD WRNLRV NRQVWDQWRV
UHLNãP¡V IL]LQ¡ MÐ SUDVP¡ DLãNL Lã SDYDGLQLPÐ NORTH, SOUTH, EAST, WEST,
CENTER.
7YDUN\NO¡ FlowLayout G¡VWR NRPSRQHQWXV HLOXWH Lã NDLU¡V ³ GHãLQ
SDVNXL ³
NLW HLOXW
LU W W 1DXGRMDPDV YLHQRGDV DUED UHLNLDPDV – MHL W QXVWDWR SDY\]GåLXL
XåUDãDVDQWP\JWXNRNRPSRQHQWÐG\GLV
7YDUN\NO¡GridLayoutLãG¡OLRMDNRPSRQHQWXVOHQWHO¡VIRUPD/HQWHO¡VHLOXþLÐ
iUVWXOSHOLÐNLHNLVQXVWDWRPDVNRQVWUXNWRULXMHGridLayout( int rows, int columns ).
BoxLayout DWVNLUDL VNLUVWR NRPSRQHQWXV YHUWLNDOLMD LU KRUL]RQWDOLMD
NU\SWLPLV*DOLPDVSHFLDOLDLVPHWRGDLVQXURG\WLUHLNLDPXVWDUSHOLXVWDUSNRPSRQHQWÐ
(vadinamieji strut ir glue).
3DWL VXG¡WLQJLDXVLD WYDUN\NO¡ – GridBagLayout. Jos aprašas pateikiamas tik
specializuotose Swing paketui skirtose knygose.
3.1.7. Kai kurie Swing komponentai
Tekstinis laukas JTextField WHNVWLQ¡ VULWLV JTextArea. $EL NODV¡V SOHþLD

JTextComponentNODV
7HNVWLQLRODXNRNODV¡OHLGåLDSHUWHLNWLLUUHGDJXRWLYLHQWHNVWR
HLOXW
*DOLPL NRQVWUXNWRULDL VXWHLNLDQW\V ODXNXL UHLNãP
LU MRV QHVXWHLNLDQW\V
QXURGDQW\VODXNRLOJ³LUMRQHQXURGDQW\V
JTextField( )
JTextField( int columns )
JTextField( String s, int columns )
JTextField( String s ).
JTextArea OHLGåLD UHGDJXRWL NHOLDV WHNVWR HLOXWHV 7HNVWLQ¡V VULWLHV NODV¡V

konstruktoriai – SDQDãÌV 7HNVWLQ
VULW³ JDOLPD Ä³YLONWL³ ³ YHUWLNDOLXRVLXV LU
horizontaliuosius slankiklius. Tai atliekama NRQVWUXRMDQW VODQNLNOLR REMHNW
konstruktoriais
JScrollBar( Component c )
JScrollBar( Component c, int VERTSB, int HORSB ).
6VDMÐ NODV¡MH ScrollPaneConstants QXVWDW\WRV WRNLRV ãLÐ static final int

NRQVWDQWÐYDOGDQþLÐYHUWLNDOÐM³LUKRUL]RQWDOÐM³VODQNLNOLXVUHLNãP¡VIL]LQ¡MÐSUDVP¡
DLãNLLãSDYDGLQLPÐ
VERTICAL_SCROLLBAR_ALLWAYS
VERTICAL_SCROLLBAR_AS_NEEDED
101
VERTICAL_SCROLLBAR_NEVER
HORIZONTAL_SCROLLBAR_ALLWAYS
HORIZONTAL_SCROLLBAR_AS_NEEDED
HORIZONTAL_SCROLLBAR_NEVER
² NRQVWDQWDV JDOLPD NUHLSWLV LU VVDMÐ NODV

UHDOL]XRMDQþLRV NODV¡V YDUGX
SDY\]GåLXLJScrollPane.VERTICAL_SCROLLBAR_ALWAYS – vertikalusis slankiklis
bus visada rodomas.
1 pavyzdys./DQJHLãG¡VWRPLGXP\JWXNDLLUWHNVWRVULWLV9LHQDVP\JWXNDV³
WHNVWLQ
VULW³ ³NHOLD WHNVW HVDQW³ hash-OHQWHO¡MH åU NROHNFLMÐ VN\ULÐ NLWDV – WHNVW
WULQD 7HNVWLQ¡ VULWLV ³YLONWD ³ VODQNLNO³ WDþLDX VODQNLNOLV EXV SDURG\WDV WLN WDGD NDL
UHLN¡V–MHLYLVRWHNVWRWHNVWLQ¡MHVULW\MHMRSDURG\WLQHJDOLPD
// Example: JTextArea, collection HashMap

//
//<applet code = TextArea width = 500 height = 500>
//</applet>
//
import java.awt.*;
import java.util.*; //all collections are saved here
public class TextArea extends JApplet {

JButton b1 = new JButton( "Add data" ),
b2 = new JButton( "Delete data" );
HashMap hm = new HashMap( );
hm.put( "a",new Double( 1. ) );
hm.put( "b",new Double( 2. ) );
hm.put( "c",new Double( 3. ) );
hm.put( "d",new Double( 4. ) );
hm.put( "e",new Double( 5. ) );
hm.put( "f",new Double( 6. ) );
Set s = hm.entrySet( ); //all entries (pairs key/value) of hashtable
// rendered to a set; iterator is available for a set
Iterator i = s.iterator( ); //method returns iterator’s object i
while( i.hasNext( ) ){ //hasNext - method of class Iterator
Map.Entry me = ( Map.Entry ) i.next( ); //method next returns object of
//type Object; downcasting
//Entry - inner class of Map
ta.append( me.getKey( ) + " : "
+me.getValue( ) + "\n" ); //method append (JTextArea) appends
//current text to the existing text
}
}
102
} );
ta.setText( "" ); //ie, deletes text
}
} );
c.add( new JScrollPane( ta ) ); //text area wrapped into a scrollbar
c.add( b1 );
c.add( b2 );
}
}
(WLNHW¡V JLabel JUDILQLV REMHNWDV VX WHNVWX *DOLPD VXNXUWL HWLNHW

VX
åHQNOHOLXIcon.
9¡OLDY¡O¡V JCheckBox NHWXUNDPSLV LU HWLNHW¡ ãDOLD 9¡OLDY¡O¡ JDOL EÌWL
ÄSDULQNWD³MRMHEXVSDYDL]GXRWDVåHQNODVÄ;³
Perjungikliai JRadioButton MLH JUXSXRMDPL ³ JUXSHV MRMH ³MXQJWDV JDOL EÌWL
WLN YLHQDV MXQJLNOLV 3DUHQNDQW YLHQ Lã MXQJLNOLÐ EXY
V ³MXQJWDV DXWRPDWLãNDL
išjungiamas.
Ä.UHQWDQWLHML³VUDãDLJComboBoxOHLGåLDSDULQNWLYLHQVUDãRHOHPHQWR
VUDãDL -/LVW – NHOHW NODYLãÐ Shift ar Ctrl SDJDOED âLÐ VUDãÐ HOHPHQWDL \UD YLV
ODLNPDWRPL
Skirtingi meniu tipai: paprastasis meniu JMenu ÄLãVLVNOHLGåLDQWLV³ PHQLX
JPopupMenu, „lentelinis“ meniu JTabbedPane.
6XG¡WLQJLDXVL JUDILQLDL REMHNWDL \UD PHGåLDL JTree UHDOL]XRMDQW\V WRNL
JUDILQ
VWUXNWÌUNDLS26DSODQNÐPHGLVLUOHQWHO¡JTable.
%HW NXULDP NRPSRQHQWXL JDOLPD SULVNLUWL SDDLãNLQDPM³ WHNVW SDVLURGDQW³
XåODLNLXVSHO¡Vå\PHNO³YLUãNRPSRQHQWRPHWRGDVsetToolTipText( String s )%HWNXU³
NRPSRQHQWJDOLPD³U¡PLQWLPHWRGXsetBorder( ) su daugybe nuVWDW\WÐstatic final int
NRQVWDQWÐ
2 pavyzdys NOLHQWLQ¡ SURJUDPD UHDOL]XRMDQWL JTable NODV

ýLD PLQLPRV WLN
NHOLRV OHQWHO¡V VDY\E¡V /HQWHOHL WDLNRPÐ PHWRGÐ VUDãDV VLHNLD SHU .OLHQWLQ¡
SURJUDPD Lã ULQNPHQRV HVDQþLRV WDPH NRPSLXWHU\MH Lã NXULR SDWL ³NUDXQDPD
NRPSLXWHULÐU\ãLRJDOLP\EHVåUVN\ULXMHDSLHED]LQ³WLQNOLQ³SURJUDPDYLPQXVNDLWR
GYLPDW³ PDV\Y NXULV EXV GHGDPDV ³ OHQWHO
9LHQPDWLV PDV\YDV QXVWDWR OHQWHO¡V
VWXOSHOLÐ SDYDGLQLPXV /HQWHO¡V OVWHO¡PV SULVNLULDPDV DLãNLQDPDVLV WHNVWDV,
SDVLURGDQWLV YLUã OVWHO¡V XåODLNLXV SHO¡V å\PHNO³ /HQWHO¡V HLOXWHL LãVNLUWL Lã OHQWHO¡V
pasinaudota metodu getPoint JUåLQDQþLX Point NODV¡V REMHNW p – fizines taško
koordinates vaizdo taškais, o paskui metodu rowAtPoint( p ) JDXQDPDV HLOXW¡V
indeksas.
103
/*Applet with some new components:
JTable, JPanel, tool-tip-text.
Input file on the same directory as code:
collection of lines, each of 3 String-type
elements divided by space. Later on first two elements
of each line are put to the array1 while the third one to array2.
array1 makes the model for the table; array2 plays role of
explanatory text.
Name of file may be supplied in the text field.
All errors from error stream are put to the text area. */
//<applet code = Table width =500 height=550>

//</applet>
import java.awt.*;
import java.net.*;
import java.io.*;
public class Table extends JApplet{

String array1[ ][ ] = new String[ 20 ][ 2 ],
array2[ ] = new String[ 20 ],
colHeads[ ] = { "Number", "Name" };
JTextField tf = new JTextField( "Input.txt", 20 );
JTextArea ta = new JTextArea( 3, 40 );
JTable table = new JTable( array1, colHeads ){
public String getToolTipText( MouseEvent me ){ //overriding method
String tip = ""; //that sets "tip-text"
Point p = me.getPoint( ); //to the table
int row = table.rowAtPoint( p );
tip = array2[ row ];
return tip;
}
};
class ReadingFile implements ActionListener{

try{
URL url = new URL( getCodeBase( ), tf.getText( ) );
InputStream is = url.openStream( );
BufferedReader in = new BufferedReader( new InputStreamReader( is ));
String line = "";
int count = 0;
while( (line = in.readLine( )) != null ){
array2[count] = line.substring( line.lastIndexOf( " " )+1, line.length( ) );
array1[count][0] = line.substring( 0, line.indexOf( " " ) );
104
array1[count][1] = line.substring( line.indexOf( " " )+1,
line.lastIndexOf( " " ) );
count++;
}
ta.append( "Dimensions of table only until 20 rows allowed" );
ta.append( "Error reading data: "+ e );
}
table = new JTable( array1, colHeads );
showStatus( "Data added" );
repaint( );
}
}
class DeletingData implements ActionListener{

for( int i=0; i<20; i++ ){
array1[i][0] = "";
array1[i][1] = "";
array2[i] = "";
}
table = new JTable( array1, colHeads ); //modifying table
showStatus( "Data deleted" );
repaint( );
}
}

b1.addActionListener( new ReadingFile( ) );
b2.addActionListener( new DeletingData( ) );
JScrollPane spt = new JScrollPane( table );
JPanel p1 = new JPanel( );
p1.setLayout( new FlowLayout( ) );
p1.add( tf );
p1.add( b1 );
p1.add( b2 );
JScrollPane spta = new JScrollPane( ta );
p2.add( spta );
c.add( spt,BorderLayout.NORTH );
c.add( p1,BorderLayout.CENTER );
c.add( p2,BorderLayout.SOUTH );
}
}
105
Langai JFrame, JDialog -HL NOLHQWLQ¡MH SURJUDPRMH UHLNLD SDSLOGRPR ãDOLD
NOLHQWLQ¡VSURJUDPRVODQJRSDVLURGDQþLRODQJRSDSUDVþLDXVLDVXNXUWLJFrame REMHNW
QRUV NDLS PLQ¡WD ãLRV NODV¡V REMHNWDL SLUPLDXVLD VNLUWL VDYDUDQNLãNRPV Java
aplikacijoms). JFrame langas jau neprikODXVRQXRQDUã\NO¡V7RNLHPVODQJDPVJDOLPD
SULVNLUWL VDYXV DWVNLUXV ³Y\NLXV 7RNLXV ODQJXV XåGDUDQW NOLHQWLQ¡ SURJUDPD GDUER
QHEDLJLDWLNDWODLVYLQDPLãLDPODQJXLEXY
SDVNLUWLLãWHNOLDLPHWRGDVwindowClosing,
R MDPH NYLHþLDPDV PHWRGDV dispose). Galima tokius langus padaryti matomus arba
nematomus metodu setVisible su argumentais atitinkamai true arba false.
Panašiai darbas organizuojamas ir su dialogo langais – NODV¡V JDialog
objektais.
3 pavyzdysNOLHQWLQ¡SURJUDPDVXJFrameODQJX.OLHQWLQ¡SURJUama sukuria
SDSLOGRP ODQJ NODV¡ Boxes SDGDO\W ³ DWVNLUXV ODXNHOLXV LU NLHNYLHQ ODXNHO³
nuspalvina atsitiktine spalva (metodas gettingColor, o šiame jau naudojamas vienas iš
Java VSDOYRV NÌULPR NRQVWUXNWRULÐ /DXNHOLV VSDOYLQDPDV Graphics NODV¡V PHtodu
fillRect QXURG\WD VSDOYD XåSLOGDQþLX QXURG\WR G\GåLR VWDþLDNDPS³ 1XURG\WX
LQWHUYDOX YLVL ODXNHOLDL NHLþLD VDYR VSDOY .LHNYLHQDV WRNV ODXNHOLV SDOHLGåLDPDV
J\YXRWLDWVNLUXVUDXWXWRG¡OãLDNOLHQWLQHSURJUDPDJDOLPDQXVWDW\WLNLHNNRPSLXWHULV
realLDL JDOL SDODLN\WL DWVNLUÐ VUDXWÐ 'XRPHQÐ ODXNHOLÐ NLHNLV QXURGRPDV GYLHP
G\GåLDLV HLOXþLÐ LU VWXOSHOLÐ VNDLþLDLV PLUNV¡MLPR GDåQLV QXURGRPDV SDX]H
PLOLVHNXQG¡PLV ³YHGLPR RSHUDFLMRV DWOLHNDPRV DWLGDO\WRMH QXR OLNXVLRV SURJUDPRV
GDOLHVJUDILQ¡MHVVDMRMHMDXåLQRPRPLVWHFKQRORJLMRPLV
//Blinking random-colored boxes. <grid*grid> boxes in all.

//Blinking rate: <pause>, in milisec.
//Applet launches individual thread for each box.
//Applet illustrates the efficiency of multitasking.
//
//<applet code = MThreads width = 500 height = 500>
//</applet>
//
import java.awt.*;
class Box extends JPanel implements Runnable{ //separate colored box.

private Thread t; //Rendered in separate thread.
private int pause;
boolean running = true;
private Color clr = gettingColor( );
private Color gettingColor(){ //random color for the box

int red = ( int ) ( Math.random( ) * 255 ),
green = ( int ) ( Math.random( ) * 255 ),
blue = ( int ) ( Math.random( ) * 255 );
return new Color( red,green,blue );
}
106
public void paintComponent( Graphics g ){ //painting the colored box
super.paintComponent( g );
g.setColor( clr );
Dimension d = getSize( );
g.fillRect( 0, 0, d.width-1, d.height-1 );
}
public Box( int pause ){

this.pause = pause;
t.start();
}
public void run( ){

while( running ){ //will be stopped by closing frame-window for all boxes
clr = gettingColor( ); //re-coloring the box
repaint( );
try{
t.sleep( pause ); //stops thread for <pause> milisec
}
}
}
class Boxes extends JFrame{ //panel for <grid*grid> boxes

int grid, pause;
public Boxes( int grid, int pause ){
this.grid = grid;
this.pause = pause;
setSize( 300,300 );
Container cf = getContentPane( );
cf.setLayout( new GridLayout( grid, grid ) );
for( int i=0; i<grid*grid; i++ )
cf.add( new Box( pause ) );
addWindowListener( new WindowAdapter( ){
public void windowClosing( WindowEvent we ) {
dispose( ); //responce to the frame-window buttons: close the window
}
} );
}
}
public class MThreads extends JApplet{ //monitor program

private int grid = 5;
private int pause = 100;
JLabel l1 = new JLabel( "Enter number of rows and columns" ),
l2 = new JLabel( "Enter delay time (milisec)" ),
l3 = new JLabel( "Messages" );
JTextField t1 = new JTextField( 10 ),
t2 = new JTextField( 10 );
107
JButton b1 = new JButton( "Start" ),
b2 = new JButton( "Reenter" );
JFrame boxes;

JPanel p11 = new JPanel( ),
p12 = new JPanel( );
p11.setLayout( new GridLayout( 3,3 ) );
t1.addActionListener( new ActionListener( ){
ta.setText( "" );
String s = t1.getText( );
try{
grid = Integer.parseInt( s );
} catch( NumberFormatException nfe ){
ta.append( "Erroneous input for number of rows." +
" Reenter or use default: 5 \n" );
grid = 5;
}
if( grid<1 ) {
ta.append( "Erroneous input for number of rows \n" +
"Using default: 5 \n" );
grid = 5;
}
ta.append( "Entered: number of rows " + grid + "\n" );
}
});
ta.setText( "" );
try{
pause = Integer.parseInt( s );
ta.append( "Erroneous input for pause." +
" Reenter or use default: 100 milisec \n" );
pause = 100;
}
if( pause<1 ) {
ta.append( "Erroneous input for pause \n" +
"Using default: 100 milisec \n" );
pause = 100;
}
ta.append( "Entered: pause (milisec) "+ pause + "\n" );
}
});
p11.add( l1 ); p11.add( t1 ); p11.add( l2 ); p11.add( t2 );
108
p11.add( l3 ); p11.add( ta );

boxes = new Boxes( grid, pause );
boxes.setVisible( true );
}
});
t1.setText( "" );
t2.setText( "" );
ta.setText( "" );
boxes.dispose( );
repaint( );
}
});
p12.add( b1 );
p12.add( b2 );
c.add( p11,BorderLayout.NORTH );
}
}
.OLHQWLQLÐSURJUDPÐDUFK\YDYLPDV
.DLSPDW\WLLãDQNVWHVQLÐSDY\]GåLÐNOLHQWLQ¡VSURJUDPRVJDOLEÌWLQHPDåRV
DSLPWLHV DSLPWL GDXJLDO\S¡V WHUS¡V HOHPHQWXV 7RNLDV NOLHQWLQHV SURJUDPDV UHLN¡WÐ
DUFK\YXRWL³Java archyvus – jar rinkmenas. Juose yra viVRVUHLNLDPRVNODV¡VNDUWXVX
GDXJLDO\S¡VWHUS¡VULQNPHQRPLV
$UFK\YDYLPRNRPDQGRVSDSUDVþLDXVLDIRUPD
jar cf archiveName.jar *.class
þLD jar –SDJDOELQ¡VSURJUDPRV-archyvatoriaus vardas, yra pakete java.util.

c –NRPDQGDVXNXUWLQDXMDUFK\Y
f – komanda, nurodanti, kad pirmasis vardas toliau bus archyvo vardas.
*.class – reiškia, kad pakuojamos rinkmenos yra darbiniame aplanke.
5XRãLDQW +70/ GRNXPHQW VXDUFK\YXRWDL NOLHQWLQHL SURJUDPDL VDNLQ\MH

<applet>GDEDUWHNWÐQXURG\WLWRNLSDSLOGRPLQIRUPDFLM
<applet code = publicClassName.class archive = archiveName.jar

width = … height = …
</applet>
109
3.2. Java Beans technologija
7HFKQRORJLMD OHLGåLD IRUPXRWL VXG¡WLQJDV SURJUDPLQHV VLVWHPDV Lã DWVNLUÐ

SURJUDPLQLÐ NRPSRQHQWÐ YDGLQDPÐMÐ beans. Java Beans – DUFKLWHNWÌUD QXVDNDQWL
kaip šie komponentai turi kartu dirbti. Technologija pirmiausia naudojama
ÄYL]XDOLQLDPSURJUDPDYLPXL³ODEDLSDJUHLWLQDQþLDPNRGRNÌULP7LSLQLVYL]XDOLQLR
SURJUDPDYLPR ³UDQNLV WXUL SDOHW
VX NRPSRQHQWÐ VUDãX SDOHW
NXULRMH EXV GHGDPL
NRPSRQHQWDL LU SDOHW
NXULRMH NRPSRQHQWDV EXV NRQILJÌUXRMDPDV – pritaikomi
³Y\NLDL FKDUDNWHULVWLNRV .RPSRQHQWR NRQILJÌUDFLMD JDOL EÌWL LãVDXJRWD DWPLQW\MH LU
Y¡OLDXDWNXUWD3URJUDPXRMDQWYL]XDOLQLX³UDQNLXSDY\]GåLXLJUDILQ
VVDMWHUHLNLD³
GDUELQ
SDOHW
SHOH ÄSHUWHPSWL³ UHLNLDPXV NRPSRQHQWXV MXRV UHLNLDPDL LãG¡OLRWL LU
VXNRQILJÌUXRWL3URJUDPRVNRGDVJHQHUXRMDPDVDXWRPDWLãNDL9LHQDVWRNLÐ³UDQNLÐ–
Bean Development Kit (BDK), www.javasoft.com.
Komponentas bean \UD SDSUDVWD NODV¡ XåSURJUDPXRWD ODLNDQWLV WDP WLNUÐ
WDLV\NOLÐ3LUPLDXVLDYLVLNODV¡VODXNDLWXULEÌWLSDVNHOEWLSULYDþLDLV/DXNÐUHLNãPHV
galima gauti ir nustatyti tik metodais
public type getField( ) ir

public void setField( ),
þLDField – lauko identifikatorius, o type –ODXNRWLSDV,QGHNVXRWLODXNDLSULYDORWXU¡WL

po du metodus:
public type getField( int index )

public type[ ] getField( )
ir analogiškai metodus set.

Kitiems metodams ši varGÐ WDLV\NO¡ QHJDOLRMD private ir protected metodai
JUDILQLDPV SURJUDPDYLPR ³UDQNLDPV QHSULHLQDPL – Java VDYLDQDOL]¡V VLVWHPD MÐ
QHUDQGD ²Y\NLÐ VLVWHPD O\JLDL WRNLD NRNLD QDXGRMDPD Swing pakete. Kur tik
³PDQRPD public PHWRGDL WXUL EÌWL VNHOELDPL synchronized NDG NRPSRQHQW EÌWÐ
JDOLPDVDXJLDLQDXGRWLGDXJLDVUDXW¡MHDSOLQNRMH
.DG NRPSRQHQWR EÌNO¡ EÌWÐ LãVDXJRWD MLV WXUL UHDOL]XRWL VVDMÐ NODV

Serializable âRMH VVDMÐ NODV¡MH Q¡UD Q¡ YLHQR PHWRGR MLV WLN QXURGR JDOLP\E

XåUDã\WLREMHNWEDLWLQLRVUDXWRSDYLGDOXSDY\]GåLXLULQNPHQRMH2EMHNWRXåUDã\PR
EDLWLQLXVUDXWXSURFHVDVYDGLQDPDVVHULDOL]DYLPX9¡OLDXDWNXULDQWREMHNWM³JDOLPD
JUåLQWL ³ SUDGLQ³ SDYLGDO 6HULDOL]DFLMRV PHWX XåUDãRPDV LU SDWV REMHNWDV LU YLVL
VXEREMHNWDL³NXULXRVREMHNWHEXYRURG\NO¡V7DLGDUYDGLQDPDÄJLOLXRMXNRSLMDYLPX³
Serializuojant neišsaugomos static ir transientODXNÐUHLNãP¡V
Komponento pavyzdys (P. Naughtonas): piešiamas keturkampis arba ovalas ir
QXVSDOYLQDPDVDWVLWLNWLQHVSDOYD,ãSUDGåLÐQXSLHãLDPDVRYDODV0\JWXNXNXULVEÌWÐ
susietas su metodu changeNHLþLDPDVSDOYD6SDOYWDLSSDWJDOLPDNHLVWLQXVSDXGXV
SHO¡VNODYLãSDQHOLRULERVH7ROLDXDUYDL]GXRWLVWDþLDNDPS³DURYDO–EÌWÐJDOLPD
QXURG\WL NRQILJÌUXRMDQW NRPSRQHQW Figure grafinio programaYLPR ³UDQNLR
JDOLP\E¡PLV .RQILJÌUDYLPR SDOHW¡MH EÌWÐ DXWRPDWLãNDL VXIRUPXRWL P\JWXNDL ODXNR
rectangular reikšmei keisti, taip pat foninei spalvai ir panelio spalvai nustatyti.
110
// Java Bean: figure of random color
//
package figureBean; //CLASSPATH must point to the directory of figureBean!
import java.awt.*;
public class Figure extends JPanel implements Serializable{

transient private Color color; //this will not be kept during serialization
private boolean rectangular;
public Figure( ){
addMouseListener( new MouseAdapter( ){
change( );
}
} );
rectangular = false; //the oval will be drawn for the first
setSize( 200, 100 );
change( ); //for the first coloring
}
public synchronized boolean getRectangular( ){

return rectangular;
}
public synchronized void setRectangular( boolean flag ){

rectangular = flag;
repaint( ); //to see changes immediately
}
public synchronized void change( ){

int red =( int ) ( 255 * Math.random( ) ),
green = ( int ) ( 255 * Math.random( ) ),
blue = ( int ) ( 255 * Math.random( ) );
color = new Color( red, green, blue );
repaint( );
}
public void paint( Graphics g ){ //not synchronized! Metod paint is set

Dimension d = getSize( ); //as non-synchronized in the language
int h = d.height;
int w = d.width;
g.setColor( color );
if( rectangular )
g.fillRect( 0, 0, w-1, h-1 );
else
g.fillOval( 0, 0, w-1, h-1 );
}
}
111
Taigi komponentas – nesavarankiška programa, MDPHQ¡UDQHLPHWRGRinit, nei
metodo main.RPSRQHQWRSDOHLGLPXSDVLUÌSLQDJUDILQLRSURJUDPDYLPR³UDQNLV
7ROHVQ¡GDUERVXNRPSRQHQWXHLJD
1. Kompiliavimas.
2. Vadinamosios manifesto rinkmenos sudarymas komponentui:
Manifest – Version: 1.0

Name: figureBean/figure.class
Java – Bean: True
Ši rinkmena vardu Figure.mf³UDãRPD³DSODQNODLSWHOLXDXNãWHVQ³QHLfigureBean.
9LVÐNRPSRQHQWRULQNPHQÐDUFK\YDYLPDV
jar cfm Figure.jar Figure.mf figureBean
þLD c –NRPDQGDVXNXUWLQDXMDUFK\Y
f – komanda, nurodanti, kad pirmasis vardas bus archyvo vardas;
m – kad antrasis vardas yra manifesto rinkmenos vardas.
figureBean –DSODQNRNXULDPHUHLNLDLHãNRWLYLVÐNLWÐUHLNLDPÐNODVLÐYDUGDV
$UFK\YDWRULXVVXSDNXRV³DUFK\YYLVDVULnkmenas, kurias ten ras.
4. jar ULQNPHQD ³UDãRPD ³ YL]XDOLQLR SURJUDPDYLPR ³UDQNLR UHLNDODXMDP

ULQNPHQ7ROHVQLVGDUEDVSULNODXVRQXR³UDQNLRNRPDQGÐ
*UDILQLDL³UDQNLDLNRPSRQHQWÐVDY\E¡PVQXVWDW\WLQDXGRMDVDYLDQDOL]¡VVLVWHP–
tiria komponento class REMHNWXV 3DQDãLHPV GDO\NDPV DQNVþLDX SDUDã¡PH VDYR
SURJUDP 3DNHWH java.beans tam yra ir Java ³UDQNLV – NODV¡ Introspector, o ši turi
PHWRG static BeanInfo getInfo( Class c ), NXU NODV¡V BeanInfo REMHNWDV WXUL LãVDPL
LQIRUPDFLMDSLHNRPSRQHQWRclass oEMHNWc.
3.3. Bazinis tinklinis programavimas
5\ã\VWDUSGYLHMÐNRPSLXWHULÐWLQNOH
9LVRV ED]LQLR WLQNOLQLR SURJUDPDYLPR JDOLP\EHV UHDOL]XRMDQþLRV NODV¡V \UD

pakete java.net.
Java UHDOL]XRMDPDV U\ã\V WDUS GYLHMÐ NRPSLXWHULÐ WLQNOH \UD ODEDL SDQDãXV ³
³SUDVWGDUEVX³YHGLPREHLLãYHGLPRVUDXWDLVWLNWLHVUDXWDLJDXQDPLDUQXNUHLSLDPL
LãDUED³MXQJW³WDUSNRPSLXWHULÐ–YDGLQDPÐMÐOL]GÐsockets).
.DG YLHQDV VHUYHULV JDO¡WÐ DSWDUQDXWL NHOLV NOLHQWXV WHQND QDXGRWL Java
daugiasrautiškumo galimybes.
Kompiuteris-serveris laukia, kol prie jos pasijungs kompiuteris-klientas,
„klausydamas“ tinklo tam tikrame prievade. Laukimo ir tinklo klausymo funkcijas
112
atlieka speciali Java NODV¡ ServerSocket, kurios darbo rezultatas (faktiškai – jos
objekto metodo accept GDUER UH]XOWDWDV JDOL EÌWL MXQJWLV WDUS PDãLQÐ – Socket. Iš
NOLHQWR SXV¡V MXQJW³ VWHQJLDVL VXNXUWL NODV¡V Socket objektas. Socket konstruktoriui
UHLNLDQXURG\WLVHUYHULR,3DGUHVLUSULHYDGRQXPHU³.DLMXQJWLVV¡NPLQJDLVXGDU\WD
skirtumo tarp VHUYHULRLUNOLHQWRQHEHOLHNDDWOLHNDPLSDSUDVWLGXRPHQÐPDLQDL7DP
naudojami metodai getInputStream ir getOutputStream, sukuriantys baitinius srautus
InputStream ir OutputStreamQRULQWJDOLPDMXRV³YLONWL³VLPEROLQLXVVUDXWXV
.DLSPLQ¡WDNOLHQWDVNDGSULVLMXQJWÐSULHVHUYHULRWXULåLQRWLVHUYHULR,3DGUHV
Tai – VNDLþLDL QXR LNL DWVNLUWL WDãNDLV â³ DGUHV MHL åLQRPDV NRPSLXWHULR-
VHUYHULRYDUGDVDUEDMR'16DGUHVDVJDOLPDJDXWLVWDWLQLXNODV¡VInetAddress metodu
getByName( String computerName ) arba getByName( String DNSAddress ).
6DYR NRPSLXWHULR ,3 DGUHV LU YDUG JDOLPD VXåLQRWL QDXGRMDQWLV 26
SULHPRQ¡PLV 7LQNOLQ¡PV SURJUDPRPV WHVWXRWL QXPDW\WD JDOLP\E¡ VLPXOLXRWL WLQNO
vien tik savo kompiuteriu. Tam naudojamas specialus IP adresas, atitinkantis
YDGLQDPM localhost PDãLQ âLV DGUHVDV JDOL EÌWL JDXWDV WRNLDLV EÌGDLV
InetAddress.getByName( “localhost” ) arba InetAddress.getByName( null ).
ServerSocket VHUYHULR SXV¡MH LU Socket NOLHQWR SXV¡MH REMHNWDPV NXUWL GDU
UHLNLDåLQRWLMXQJWLHVSULHYDGRQXPHU³3ULHYDGDV–SURJUDPLQ¡DEVWUDNFLMDQDXGRMDPD
DWOLHNDQWåHPHVQ³DQWURMRO\JLRDGUHVDYLPMXNNLHNYLHQDVNRPSLXWHULVJDOLSDODLN\WL
GDXJHO³VHUYHULÐWRG¡OYLHQWLNMRV,3DGUHVRMXQJþLDLVXNXUWLQHSDNDQND.LHNYLHQDV
serveris tam tikrame prievade gali teikti tam tikras paslaugas klientui. Prievadai nuo 1
LNLUH]HUYXRWL26UHLNP¡PVSDY\]GåLXL-as prievadas skirtas FTP protokolui,
25-as – elektroniniam paštui, 80-as – HTTP protokolui.
.DLS SDY\]G³ SDWHLNVLPH SDSUDVþLDXVLR VHUYHULR LU SDSUDVþLDXVLR NOLHQWR

SURJUDPDV $EX VXNXULDPL WDPH SDW NRPSLXWHU\MH QDXGRMDQW NRPSLXWHU³ localhost
DWLWLQNDQW³,3DGUHV
//The simplest server: getting messages from

//client and printing them
//
import java.io.*;
import java.net.*;
public class SimpleServer{

public static final int PORT = 2000; //number is our arbitrary choice
public static void main( String args[ ] ) throws IOException{
ServerSocket ss = new ServerSocket( PORT );
System.out.println( "Launched: " + ss );
try{
Socket s = ss.accept( ); //waiting for connection
try{
System.out.println( "Connection got: " + s );
BufferedReader in = new BufferedReader(
s.getInputStream( ) ) );
113
new BufferedWriter(
new OutputStreamWriter(
s.getOutputStream( ) ) ),true );
while( true ){ //server will be closed after
String str = in.readLine(); //client's message "END"
if( str.equals( "END" )) break;
System.out.println( "Got from client: " + str );
out.println( str );
}
} finally{ //socket must be closed!
System.out.println( "Disconnecting client" );
s.close( );
}
System.out.println( "Closing server" );
ss.close( );
}
}
}
Serveris laukia kliento prisijungimo. Prisijungus klientui, skaito kliento

VLXQþLDPDV HLOXWHV LU SHUVLXQþLD MDV DWJDO NOLHQWXL 7RNV VLXQWLQ¡MLPDV Y\NVWD NRO
NOLHQWRVLXQþLDPDPHGXRPHQÐVUDXWHDSWLQNDPDHLOXW¡END. Serverio darbo rezultatus
SDURG\VLPH WLN SR DQDORJLãNRV NOLHQWR SURJUDPRV DQDOL]¡V QHV NDUWX IXQNFLRQuoti
privalo abi šios programos.
Kaip matyti, ServerSocket objektas kuriamas nurodant konstruktoriuje tik
SULHYDGRQXPHU³M³SDVLUHQNDPHGLGHVQ³QHLR,3DGUHVDVQHUHLNDOLQJDV– juk
VHUYHULV NXULDPDV PÌVÐ NRPSLXWHU\MH Socket objektas gaunamas ServerSocket
metodu accept. Kol accept QHJUåLQD Socket objekto – programos veikimas
blokuojamas, ji laukia, kol pasijungs klientas.
Kai tik ServerSocket ir Socket objektai sukuriami, spausdinama informacija
DSLHãLXRVREMHNWXV³SXOWQDXGRMDQWQHLãUHLNãWmetodo toStringNYLHWLP
Iš Socket REMHNWR JDXQDPDV EDLWLQLV³YHGLPR VUDXWDVin NXULV SHUWYDUNRPDV ³
VLPEROLQ³ EXIHUL]XRW VUDXW ² Socket REMHNW WDLS SDW QXNUHLSLDPDV VLPEROLQLV
buferizuotas srautas outþLDUHLNDOLQJDVGDUYLHQDVSDSLOGRPDVDQWVWDWDs PrintWriter,
QHVWLNãLRMHNODV¡MH\UDPXPVUHLNDOLQJDVPHWRGDVprintln. PrintWriter objektui kurti
EÌWLQDV LU DQWUDVLV boolean WLSR DUJXPHQWDV NXULR UHLNãP¡ WXUL EÌWL true. Tik tokiu
DWYHMX Lã EXIHULR ³ VUDXW EXV SHUNHOWL GXRPHQ\V NLHNYLHQNDUW VXYHLNus metodui
println W \ VXUDGXV HLOXW¡V ODXåLPR VLPERO³ \n -HL DQWURMR DUJXPHQWR UHLNãP¡ EÌWÐ
false DUED EÌWÐ QDXGRWDV NRQVWUXNWRULXV EH DQWURMR DUJXPHQWR – SULHã ³NHOLDQW
GXRPHQLV ³ VUDXW W \ IRUPXRMDQW GXRPHQÐ SDNHW VLXQWLPXL – EÌWÐ ODXNLDPD NRO
EXIHULV SULVLSLOG\V 7RNLDL SURJUDPDL NDLS DSUDã\WRML WDL QHWLQND GXRPHQÐ QHGDXJ
EXIHULVQHSULVLSLOG\VGXRPHQ\VQHEXVLãVLÐVWL-HLEÌWÐVLXQþLDPLNLWRNLHGXRPHQ\V
SDY\]GåLXL GLGHOL EDLWLQLDL VUDXWDL – HIHNW\YLDX QDXGRWL DXWRPDWLQ³ GXRPHQÐ
SHUN¡OLP ³ EXIHU³ 7DLS EÌWÐ VXIRUPXRWL GLGHVQL VLXQWLPR SDNHWDL SURFHVDV Y\NWÐ
JUHLþLDX
'¡OtryEORNÐServerSocket NÌULPRQHEÌWLQD³G¡WL³WRN³EORN-HLQHSDY\NWÐ
sukurti ServerSocket objekto konstruktoriumi, metodas mainWLHVLRJJHQHUXRWÐLãLPW³
IOExceptionLUSURJUDPRVGDUEDVEÌWÐEDLJWDVSocketREMHNWRNÌULPDV³YLONWDV³try-
114
finallyNRQVWUXNFLMRVEORNQHVVHUYHULXLEDLJXVGDUEVXNOLHQWXEÌWLQDM³DWMXQJWL–
XåYHUWLMXQJW³7DGDLãMXQJLDPDVLUVHUYHULV–XåYHULDPDVServerSocket objektas.
Klientas:
//The simplest client: sending messages to

//server and getting messages from server
//
import java.io.*;
import java.net.*;
public class SimpleClient{

InetAddress ia = InetAddress.getByName( null ); //ie, server is on the
//same machine
System.out.println( "Address of server: " + ia );
Socket s = new Socket( ia, SimpleServer.PORT ); //code "SimpleServer” must
//be in the same package
System.out.println( "Launched socket: " + s );
try{
new BufferedWriter(
for( int i=0; i<10; i++ ){
String msg = "Client's message " + i;
out.println( msg );
System.out.println( "Sent to server: " + msg );
String str = in.readLine( );
System.out.println( "Got from server: " + str );
}
out.println( "END" ); //"END" appointed for the finish
} finally{
System.out.println( "Closing client" );
s.close( );
}
}
}
.OLHQWDVEDQGRSULVLMXQJWLSULHVHUYHULRHVDQþLRWRPHSDþLDPHNRPSLXWHU\MH
kaip ir serveris – localhostWRG¡OMRDGUHVDVQXVWDWRPDVPHWRGXLgetByName teikiant
DUJXPHQWnull. SocketREMHNWXLIRUPXRWLEÌWLQDVNLWDVDUJXPHQWDV– prievado numeris
nurodomas static final int lauku PORTDSLEU¡åWXVHUYHULRSURJUDPRMH.DGãLUHLNãP¡
EÌWÐSULHLQDPDNOLHQWRSURJUDPDLDELSURJUDPRVWXULEÌWLWDPHSDþLDPHSDNHWH1RUV
MRNV SDNHWDV QHGHNODUXRWDV WDLS LU EXV MHL DEL SURJUDPDV ³G¡VLPH ³ W SDW³ DSODQN
115
.DLS åLQLD YLVRV DSODQNH HVDQþLRV ULQNPHQRV SULNODXVR EHYDUGåLDP SDNHWXL SDJDO
QXW\O¡MLP
3ULVLMXQJ
V SULH VHUYHULR NOLHQWDV QXVLXQþLD VHUYHULXL SUDQHãLPÐ LU HLOXW

END6HUYHULVNOLHQWXLDWJDOSHUVLXQþLDWRNLXVSDWSUDQHãLPXV
9LVRVNOLHQWRIXQNFLMRV³YLONWRV³try-finallyEORNNDGEHWNRNLXDWYHMXEDLJXV
GDUENOLHQWRREMHNWDVEÌWÐXåGDU\WDV
$ELãLDVSURJUDPDVUHLNLDSDOHLVWLLãDWVNLUÐSXOWÐ3LUPDSDOHLGåLDPDVVHUYHULV
Y¡OLDX – NOLHQWDV 3LUPLDX SDOHLGXV NOLHQW EXV VXJHQHUXRWD LãLPWLV
java.net.ConnectException.
3R VHUYHULR LU NOLHQWR SDOHLGLPR VHUYHULR SXOWH PÌVÐ NRPSLXWHU\MH PDW¡PH
pranešimus:
Launched: ServerSocket[ addr = 0.0.0.0./0.0.0.0., port = 0, localport =

2000 ]
Connection got: Socket[ addr=/127.0.0.1, port = 4496, localport = 2000 ]
Got from client: Client’s message 0
.
.
.
Disconnecting client
Closing server
Kliento pulte:
Address of server: localhost /127.0.0.1

Launched socket: Socket[ addr = localhost /127.0.0.1, port = 2000, localport
= 4496 ]
Sent to server: Client’s message 0
Got from server: Client’s message 0
.
.
.
Closing client
AbiejÐ SURJUDPÐ SUDQHãLPDL SXOWXRVH SDVLURG\V VXGHULQWL NOLHQWXL QXVLXQWXV

SUDQHãLPVHUYHULXL–JDYXVLãMRDWVDN\P
KeOLRV SDVWDERV 7DLJL MXQJWLV WDUS NRPSLXWHULÐ DSLEÌGLQDPD GDO\NDLV
kliento IP adresu ir prievado numeriu, serverio IP adresu ir prievado numeriu. Kai
SDOHLGåLDPDVVHUYHULVMLVXåLPDQXURG\WSULHYDG2000.DL JUåLQDPDMXQJWLVVX
klientu (objektas s MDPH \UD LQIRUPDFLMD DSLH VHUYHULR ,3 DGUHV MR SULHYDG
116
(localport = 2000LUSULHYDGRNXU³XåLPDNOLHQWDV4496QXPHU³âLVDGUHVDVQXRODW
GLGLQDPDVSUDGHGDQWQXRLNLNROEXVSHUNUDXWD267RNLSDþLLQIRUPDFLMDSLH
VXNXUW MXQJW³ VSDXVGLQD LU NOLHQWR SURJUDPD WLN NLWRNLD WYDUND MXN QDJULQ¡MDPDL
programai port yra taikinys, o localport – šaltinis. Tai, kas klientui yra port, serveriui
bus localportLUDWYLUNãþLDL
6HUYHULV SULYDOR DSWDUQDXWL QH YLHQ EHW GHãLPWLV NOLHQWÐ WRG¡O DQNVWHVQ¡
SURJUDPDDLãNXQHWLQNDPD-LWLNGHPRQVWUDYRNDLSVLÐVWLLUJDXWLSUDQHãLPXV³NLW
PDãLQ LU Lã NLWRV PDãLQRV 5HDOHVQLV VHUYHULV VXNXULDPDV YLHQDV ServerSocket
REMHNWDV LU NYLHþLDPDV PHWRGDV accept .DL WLN MLV JUåLQD Socket REMHNW –
sukuriamas srautas šio kliento aptarnavimui, o ServerSocket toliau laukia kito kliento,
LUWW9HLNVPDLWDUSVHUYHULRLUNOLHQWÐDWOLHNDPLO\JLDLWRNLHSDWNDLSLUDQNVWHVQLDPH
pavyzdyje.
Serverio programa:
//The simplest multi-client server: getting messages from

//clients and printing them
//One server-thread for one client
//
import java.io.*;
import java.net.*;
class ServeOneClient extends Thread{

private Socket s;
private BufferedReader in;
private PrintWriter out;
private static int counter = 0;
private int id = counter++;
public ServeOneClient( Socket s ) throws IOException{
this.s = s;
new BufferedWriter(
start( );
}
public void run( ){
try{
while( true ){
if( str.equals( "END" ) ) break;
System.out.println( "Got from client: " + str );
out.println( str );
}
} catch( IOException ioe ){
System.err.println( "I/O error" );
117
} finally{
try{
System.out.println( "Disconnecting client " + id );
s.close( );
System.err.println( "Error while closing socket" );
}
}
}
}
public class SimpleMultiServer{

public static final int PORT = 2000;
System.out.println( "\n Press Ctrl/C for termination \n" );
System.out.println( "Launched: " + ss );
try{
while( true ){ //endless loop!
try{
new ServeOneClient( s );
s.close( );
}
}
} finally{
ss.close( );
}
}
}
Ir šioje programoje MXQJþLÐREMHNWDLSULYDOREÌWLXåGDU\WLEHWNRNLXDWYHMX-HL

NRQNUHþLDP NOLHQWXL QHSDY\NVWD VXNXUWL VUDXWR – nesuveikia ServeOneClient
konstruktorius –MXQJWLVLãNDUWXåGDURPDPHWRGRmain viduje. Jei sukuriamas, –MXQJW³
XåGDURVUDXWRPHWRGDVrun.
Kliento programa:
//Code generates simplest clients: sending messages to

//server and getting messages from server.
//Until MAX_CLIENTS clients may exist simultaneously.
//One thread is created for one client.
//
//Results of code depend exclusively on the period
//of pause. Experiment on it!
//
import java.io.*;
import java.net.*;
118
class OneClient extends Thread{
private Socket s;
private int id = counter++; //id-number of client
private static int threadCount = 0; //number of "living" clients
public static int threadCounting(){
return threadCount;
}
public OneClient( InetAddress ia,int PORT ){
System.out.println( "Creating client No " + id );
threadCount++; //count in this client
try{
s = new Socket( ia, PORT );
System.err.println( "Error while creating socket No " + id );
}
try{
new BufferedWriter(
start();
} catch( IOException ioe1 ){
try{
s.close( );
System.err.println( "Unable to close socket No " + id );
}
}
}
public void run( ){
try{
for( int i=0; i<10; i++ ){
String msg = "Client's No " + id + " message " + i;
out.println( msg );
System.out.println( "Sent to server: " + msg );
System.out.println( "Got from server: " + str );
}
out.println( "END" );
System.out.println( "I/O error" );
} finally{
try{
s.close( );
119
System.out.println( "Disconnecting socket No " + id );
System.out.println( "Unable to close socket No " + id );
}
threadCount--; //client is closed; decrease the number of clients
}
}
}
public class SimpleMultiClient{

static final int MAX_CLIENTS = 3;
public static void main( String args[ ] ) throws IOException, InterruptedException{
InetAddress ia = InetAddress.getByName( null );
System.out.println( "Address of server: " + ia );
for( int i=0; i<20; i++ ){
if( OneClient.threadCounting( ) < MAX_CLIENTS )
new OneClient( ia, SimpleMultiServer.PORT );
Thread.currentThread( ).sleep( 10 );
}
}
}
9LHQXPHWXãLSURJUDPDOHLGåLDJ\YXRWLLNLMAX_CLIENTSNOLHQWÐ3URJUDPD
bando kurti naujus klientus 20 NDUWÐ 3DJULQGLQLV SURJUDPRV Y\NG\PR VUDXWDV
pristabdomas kuriam laikui metodu sleepNDGSHUã³ODLNGDOLVNOLHQWÐVXVS¡WÐDWOLNWL
VDYRGDUELUEÌWÐXåGDU\WLRWDGDYLHWRMHMÐEXVNXULDPLQDXMLNOLHQWDL
9¡O SLUPLDXVLD UHLNLD SDOHLVWL VHUYHULR SURJUDP SDVNXL – NOLHQWR .DG EÌWÐ
SDSUDVþLDXVHUYHULRSURJUDPD\UDEHJDOLQ¡LUMVXVWDEG\WLJDOLPDWLNNODYLãDLV
Ctrl-C 3URJUDPÐ OHLGLPR UH]XOWDWDL SULNODXV\V QXR YLHQX PHWX ÄJ\YÐ³ NOLHQWÐ
VNDLþLDXV SDX]¡V ODLNR LU NRPSLXWHULR SDM¡JXPR 3DHNVSHULPHQWDYXV su šiais
GXRPHQLPLVSURJUDPÐYHLNLPDVWDSVYLVLãNDLDLãNXV
3.3.2. Ryšys tarp HTTP serverio ir kliento
âLDPH VN\ULXMH WUXPSDL DSåYHOJLDPRV Java WHLNLDPRV JDOLP\E¡V DWVNLUDP

serverio tipui – HTTP serveriui.
Kliento programos gali jungtis tik su kompiutHULX Lã NXULR ³NUDXWDV NOLHQWR
programos kodas. Aplikacijos gali jungtis su bet kuria tinklo mašina. Bet kuriuo
DWYHMXUHLNDOLQJDV85/DGUHVDV85/DGUHVVXGDURNRPSRQHQWDL
1. Protokolas (http, ftp, gopher, file). Po jo seka 3 simboliai :// .

2. Kompiuterio IP adresas (arba jo DNS forma). Po jo seka 1 simbolis / arba : .
3. Prievado numeris.
.HOLDV³QRULPULQNPHQ
'DåQLDXVLDLSURWRNRORSDYDGLQLPLUSULHYDGRQXPHU³JDOLPDSUDOHLVWLLUOLHND
SDY\]GåLXLwww.nba.com/index.html .
120
<UD NHOL 85/ DGUHVÐ NÌULPR NRQVWUXNWRULDL 9LVL MLH JDOL VXNHOWL LãLPW³
MalformedURLException. 6HUYHU\MH HVDQþLR QRULPR DSODQNR LU QRULPRV ULQNPHQRV
DGUHVXLNXUWLUHLN¡WÐQDXGRWLãLDVNRQVWUXNWRULDXVIRUPDV
URL url = new URL( getDocumentBase( ) ), String fileName )

URL url = new URL( getCodeBase( ) ), String fileName )
3LUPRMLIRUPDQXVWDWR85/DGUHVRGDO³VHUYHULRDSODQNXLNXULDPH\UD+70/
GRNXPHQWDV VX QXRURGD ³ NOLHQWR SURJUDP R DQWURML – aplankui, kuriame yra pats
kliento programos kodas.
7ROLDXJDOLEÌWLDWLGDU\WDVEDLWLQLV³YHGLPRLãVHUYHULRVUDXWDVRMLV–³YLONWDV³
EXIHUL]XRW VLPEROLQ³ VUDXW NDLS PDW¡PH YLHQDPH Lã DQNVWHVQLÐ NOLHQWR SURJUDPÐ
SDY\]GåLÐ
...
new InputStreamReader( is ) );
...
Java DSOLNDFLMRPV NXULRV JDOL MXQJWLV VX EHW NXULD WLQNOR PDãLQD GHU¡WÐ
QDXGRWLNLWNRQVWUXNWRULDXVIRUP
URL url = new URL( String urlSpecifier )
ýLDurlSpecifier – pilnas DNS adresas.
3ULHã SDUVLVLXQþLDQW Lã QXWROXVLR NRPSLXWHULR ULQNPHQ JDOLPD Lã DQNVWR

QXVWDW\WL YLVDV MR VDY\EHV NODV¡V URLConnection metodais Date getDate( ), Date
getLastModified( ), String getContentType( ), int getContentLength( ), NXULÐ SDVNLUW³
DLãNLDLQXVDNRMÐSDYDGLQLPDLâLRMHNODV¡MHWDLSSDW\UDPHWRGDVgetInputStream( ) –
tai alternatyva URLNODV¡VPHWRGXLopenStream( ). .ODV¡VREMHNWDVNRQVWUXRMDPDVLU
³YHGLPRVUDXWDVJDOLEÌWLJDXQDPDVWDLSPHWRGDVopenConnection gali VXNHOWLLãLPW³
IOException):
...
URL url = . . .
URLConnection urlcon = url.openConnection( );
System.out,println( “Date” + new Date( urlcon.getDate( ) ) );
System.out,println( “Type of content” + urlcon.getContentType( ) );
System.out,println( “Period of storage” + urlcon.getExpiration( ) );
System.out,println( “Last modified” + new Date( urlcon.getLastModified() ) );
System.out,println( “Length, bytes” + urlcon.getContentLength( ) );
InputStream is =urlcon.getInputStream( );
...
.LWDV GDåQai reikalingas dalykas – SDURG\WL Lã NOLHQWR SURJUDPRV NLW +70/
GRNXPHQW–SHUDGUHVXRWLQDUã\NO
³NLWSXVODS³7DPUHLNLDDWOLNWLYHLNVPXV
6XIRUPXRWLQRULPRGRNXPHQWR85/DGUHVurl MDXåLQRPDLVPHWRGDLV
121
.YLHVWLPHWRGshowDocument:
getAppletContext( ).showDocument( url )
3LUPDVLV PHWRGDV JUåLQD JUDILQ³ NOLHQWR SURJUDPRV DSOLQNRV NRQWHNVW –

NODV¡V AppletContext REMHNW R ãLRMH NODV¡MH \UD SHUNUDXWL void showDocument
metodai:
void showDocument( URL url )

void showDocument( URL url, String where )
$EX PHWRGDL SDURGR +70/ ULQNPHQ HVDQþL QXURG\WX DGUHVX R DQWURML

IRUPD GDU SDSLOGRPDL QXVDNR NXULRMH QDUã\NO¡V ODQJR YLHWRMH SDURG\WL GRNXPHQW
String GXRPHQV UHLNãP¡ _self QXURGR GRNXPHQW URG\WL GDEDUWLQLDPH NOLHQWR
programos lange, _blank –QDXMDPHQDUã\NO¡VODQJHLUWW
6HUYHULQ¡VSURJUDPRV
%HQGURVLRVåLQLRVDSLHVHUYHULQHVSURJUDPDV
6HUYHULQ¡VSURJUDPRVservlets)–PDåRVSURJUDPRVY\NGRPRVZZZMXQJWLHV
VHUYHULR SXV¡MH 3DQDãLDL NDLS NOLHQWLQ¡V SURJUDPRV GLQDPLãNDL LãSOHþLD QDUã\NOLÐ
IXQNFLQHV JDOLP\EHV VHUYHULQ¡V SURJUDPRV GLQDPLãNDL LãSOHþLD ZZZ VHUYHULR
IXQNFLQHVJDOLP\EHVâLRVSURJUDPRV³GLHJLDPRV³WLQNORVHUYHU³SDODLNDQW³Java.
,QVWUXPHQWDL VHUYHULQ¡PV SURJUDPRPV NXUWL \UD SDNHWH -6'. Java Servlet
Development Kit 7DUS LQVWUXPHQWÐ \UD LU ³UDQNLV VHUYHULQHL SURJUDPDL WHVWXRWL
servletrunner 9LVDV LQVWUXNFLMDV -6'. LQVWDOLXRWL NRPSLXWHU\MH åU
www.javasoft.com âLXR PHWX ãLV QHVXG¡WLQJDV QDXGRWL SDNHWDV MDX ³WUDXNWDV ³
DUFK\YÐ WDUS YLHWRM MR UHNRPHQGXRMDPD SDUVLVLÐVWL WLHVLRJ Java WLQNOR DSOLNDFLMÐ
VHUYHU³ Application Server HVDQW³ SDNHWH -(( Java 2 Enterprise Edition). Serveris
nemokamas. Windows SODWIRUPDL MR DSLPWLV WUXSXW³ YLUãLMD 0% ,QVWDOLDYLPR
insWUXNFLMRV DWHLQD NDUWX VX SDNHWX 6HUYHULQLÐ SURJUDPÐ WHVWDYLPDV VHUYHULX
naudojant localhost,3DGUHV\UDVXG¡WLQJHVQLVQHLservletrunner³UDQNLX
Abiejuose siuntos paketuose yra vadinamasis Servlet API (Applied
Programming Interface NXULDPH VXG¡WL GX SDNHWDL VX YLVRPLV NODV¡PLV
SDODLNDQþLRPLV YLVDV VHUYHULQLÐ SURJUDPÐ JDOLP\EHV javax.servlet ir
javax.servlet.http.
.DVO¡P¡VHUYHULQLÐSURJUDPÐWHFKQRORJLMRVVXNÌULP"7UDGLFLQ¡ZZZWLQNOR
veikimo schema informacijai gauti yra tokia.
1. www-serverLV JDXQD LQIRUPDFLM Lã NOLHQWR-QDUã\NO¡V 5HLNLDPR VHUYHULR
85/ DGUHV QXURGR QDUã\NO¡V YDUWRWRMDV R QDUã\NO¡ VXJHQHUXRMD VHUYHULXL XåNODXV
+70/ NDOED 5HLNLDPD LQIRUPDFLMD XåNODXVRMH \UD VDNLQLXRVH <form>. 8åNODXVD
VLXQþLDPDSURWRNROX+773WRG¡OGDåQDLGDUYDGLQDPD+773XåNODXVD
6HUYHULVDQDOL]XRMDXåNODXVLUDSGRURMDJDXWLQIRUPDFLMâLXRVYHLNVPXV
atlieka serverio dalis CGI (Common Gateway InterfaceJDOLQWLVYHLNDXWLVXNLWRPLV
SURJUDPRPLV VHUYHULR NRPSLXWHU\MH GXRPHQÐ ED]¡PLV HOHNWURQLQ¡PLV
VNDLþLXRNO¡PLVLUSDQ&*,JDOLEÌWLUHDOL]XRWDEHWNXULDSURJUDPDYLPRNDOEDWDþLDX
122
GDåQLDXVLDL WDP QDXGRMDPD SLUPLDXVLD WHNVWXL DSGRURWL VNLUWD NDOED Perl. Programa
PerlNDOED\UDLQWHUSUHWXRMDPDWRG¡OGDåQDL&*,VVDMRVGDUYDGLQDPL&*,VFHQDULMais
arba tiesiog CGI scripts. Jei CGI programa negali reikiamai apdoroti gautos
XåNODXVRVMLVDYRUXRåWXJHQHUXRMDXåNODXVNRPSHWHQWLQJDLSURJUDPDLSDWHLVLQGDPD
VDYRSDYDGLQLPgateway – šliuzas.
3. Sukuriamas (ar tiesiog kopijuojamas – jei reikalingas statinis dokumentas)
NOLHQWR SUDã\WDV +70/ GRNXPHQWDV LU SHUVLXQþLDPDV NOLHQWXL-naršyklei. Šio HTTP
DWVDN\PRSUDGåLRMHQXURGRPDVDWVDN\PRWXULQLRWLSDV0,0(Multipurpose Internet
Mail Extension IRUPDWX 3DY\]GåLXL text/plain UHLãNLD $6&,, VLPEROLÐ WHNVW
text/html –+70/WHNVWLUWW
&*, SURJUDPRV SULNODXVR QXR NRPSLXWHULR DUFKLWHNWÌURV %H WR MRV Q¡UD
pakankamai efektyvios, kadangi, aptarnaujant kelis klientus, kiekvienam sukuriamas
atskiras procesas (ne srautas!). Pakeitus CGI programas serverLQ¡PLVSURJUDPRPLVMÐ
SUDQDãXPDLEÌWÐ
6HUYHULQ¡V SURJUDPRV Y\NGRPRVL VHUYHULR DGUHVÐ HUGY¡MH .LHNYLHQDL
DWVNLUDLNOLHQWRXåNODXVDLDSGRURWLJDOLPDVXNXUWLDWVNLUY\NG\PRVUDXW
6HUYHULQ¡VSURJUDPRVQHSULNODXVRPRVQXRNRPSLXWHULRWLSRSun, Netscape,
06 WLQNOR DSOLNDFLMÐ VHUYHULDL SDODLNR Servlet $3, WRG¡O SURJUDPRV VXNXUWRV Java,
JDOLEÌWLODLVYDLSHUNHOLDPRVLãYLHQRVHUYHULR³NLW
6HUYHULQ¡VSURJUDPRVJDOLQDXGRWLWXUWLQJDVJavaNODVLÐELEOLRWHNDV
4. Java saugumo mechanizmas palaiko WDP WLNUXV VHUYHULQLÐ SURJUDPÐ
DSULERMLPXVNDGEÌWÐDSVDXJRWLVHUYHULRPDãLQRVLãWHNOLDL
7DLJLVHUYHULQ¡VSURJUDPRV\UDWDUSLQLQNDLWDUSNOLHQWRLUVHUYHULRSHULPGDPL
GDXJHO³ IXQNFLMÐ WLHN Lã NOLHQWR WLHN Lã VHUYHULR 3DY\]GåLXL EHQGUDXGDPRV VX
kliHQWLQ¡PLV SURJUDPRPLV VHUYHULQ¡V SURJUDPRV JDOL DWOLNWL MÐ proxy-serverio
YDLGPHQ³ MHL NOLHQWLQ¡ SURJUDPD WXUL NUHLSWLV ³ GXRPHQÐ ED]
NLWRMH PDãLQRMH NDV
NOLHQWLQ¡PVSURJUDPRPVXåGUDXVWDãLXRVYHLNVPXVXåNOLHQWLQ
SURJUDPJDOLDWOLNWL
VHUYHULQ¡SURJUDPD7DLSSDWVHUYHULQ¡VSURJUDPRVJDOLSUDWXUWLQWLVHUYHULRJDOLP\EHV
SDODLN\GDPRV NRN³ VHUYHULXL QHSDå³VWDP XåNODXVÐ LU DWVDN\PÐ SDJULQGX YHLNLDQW³
SURWRNRO SDY\]GåLXL 6073 323 )73 'DåQLDXVLDL YLV WLN VHUYHULQ¡V SURJUDPRV
naudojamos kartu su HTTP protokolu dinaminiams HTML puslapiams generuoti,
WRG¡OWDPVXNXUWDVLUVSHFLDOXVSDNHWDV+773SURWRNROXLSDODLN\WLjavax.servlet.http.
.DLSVHUYHULQ¡VSURJUDPRVSDVLHNLDPRVNOLHQWXL".HOLDLVEÌGDLV
.DLYDUWRWRMDVQDUã\NOHLWHLNLD85/DGUHVNXULV\UDVHUYHULQ¡VSURJUDPRV
adresas.
2. Iš HTML dokumento sakinio <form>.
3. Iš HTML dokumento sakinio <servlet>. 7RNLXV VDNLQLXV SDå³VWD QH YLVL
serveriai.
,ã+70/GRNXPHQWÐVSHFLDOLÐNRPDQGÐ– SSI (Server-Side Includes).
6HUYHULQLÐ SURJUDPÐ LQVWDOLDYLPDV \UD JDQD VXG¡WLQJDV SURFHVDV WRG¡O YLVÐ

LQVWUXNFLMÐ SDWHLNLDPÐ -(( Application Server GRNXPHQWDFLMRMH þLD
QHNDUWRVLPH 7UXPSDL WDULDQW UHLNLD SDOHLVWL VHUYHU³ VHUYHULR GRPHQ SDVNXL ³GLHJWL
J2EE aplikacijas iš jar ULQNPHQÐ WDP WLNUXRVH DSODQNXRVH 6HUYHULQ¡V SURJUDPRV LU
JSP, Java Server PagesDSLHNXULXRVNDOE¡VLPHY¡OLDXWXULEÌWLVXDUFK\YXRWRV³jar
ULQNPHQÐWLSwar (Web Application Archive7RNLÐDUFK\YÐULQNPHQRVWXULSO¡WLQLXV
*.war $UFK\YDYLPR JDOLP\E¡V \UD VHUYHULR SURJUDPRMH 6HUYHULQ¡V SURJUDPRV JDOL
123
EÌWLODLNLQRVDUEDSDVWRYLRVW\YHLNVNROYHLNVSDWVVHUYHULV–WDLSULNODXV\VQXRMÐ
³GLHJWLHVVHUYHU\MH
6HUYHULQ¡VSURJUDPRVJ\YDYLPRFLNODV
6HUYHULQ¡ SURJUDPD WXUL WULV PHWRGXV init, service ir destroy. Metodus

LãNYLHþLD VHUYHULV 7LSLãNR VHUYHULQ¡V SURJUDPRV J\YDYLPR FLNOR SDY\]G\V 7LQNOR
VHUYHULVJDY
VLãNOLHQWR-QDUã\NO¡V+773XåNODXV85/DGUHVXLNXULXR\UDVHUYHULQ¡
SURJUDPD³NHOLD³VDYRDGUHVLQ
HUGY
QXURG\WMVHUYHULQ
SURJUDP
1. Kai serveriQ¡ SURJUDPD ³NHOWD ³ DWPLQW³ NYLHþLDPDV SUDGLQLV PHWRGDV init.

3UDGLQLÐUHLNãPLÐSDUDPHWUXVJDOLPDSHUGXRWLVHUYHULQHSURJUDPDL
.YLHþLDPDV PHWRGDV service DSGRURMDQWLV +773 XåNODXV QXVNDLWR
SHUGXRWXVGXRPHQLVIRUPXRMD+773DWVDN\P
6HUYHULQ¡SURJUDPDOLHNDVHUYHU\MHLUJDOLDSGRURWLNLWDVNOLHQWÐXåNODXVDV
.LHNYLHQDLXåNODXVDLNDVNDUWLãNYLHþLDPDVPHWRGDVservice.
7DP WLNUDLV VSHFLILQLDLV NLHNYLHQDP VHUYHULXL DOJRULWPDLV QXVWDþLXV NDG
VHUYHULQ¡ SURJUDPD QHEHUHLNDOLQJD VHUYHULQ¡ SURJUDPD iškeliama iš
serverio atminties – NYLHþLDPDV PHWRGDV destroy. Java ãLXNãOLÐ ULQNWXYDV
JUåLQDVHUYHULXLVHUYHULQ¡VSURJUDPRVXåLPWDWPLQW³
3DSUDVþLDXVLRV VHUYHULQ¡V SURJUDPRV SDY\]G\V 6HUYHULQ¡ SURJUDPD WLN

QXVLXQþLDQDUã\NOHLSUDQHãLPSDU\ãNLQWXãULftu Simplest servlet.
//The simplest servlet

//
import java.io.*;
import javax.servlet.*;
public class SimplestServlet extends GenericServlet{

public void service( ServletRequest request, ServletResponce responce )
WKURZV 6HUYHULQ¡MH SURJUDPRMH[ception,
IOException{
responce.setContentType( “text/html” );
PrintWriter pw = responce.getWriter( );
pw.println( “<B> Simplest servlet” );
pw.close( );
}
}
Šioje programoje javax.servlet – paketas, kartu su specializuotu paketu HTTP

protokolui VXGDUDQWLVYLVServlet API, o GenericServlet –MRNODV¡ServletRequest yra
VVDMÐNODV¡NOLHQWR+773XåNODXVRVGXRPHQLPVVNDLW\WLRServletResponce –VVDMÐ
NODV¡+773DWVDN\PXLNXUWL0HWRGDVsetContentType nurodo HTTP atsakymo turinio
WLS 0,0( IRUPDWX 6VDMÐ NODV¡V ServletResponce metodas getWriter JUåLQD
PrintWriter REMHNW 0HWRGDV JDOL VXNHOWL LãLPW³ IOException. PrintWriter NODV¡V
metodas println LãYHGD ³ +773 DWVDN\P – VDNLQ³ SDU\ãNLQWX ãULIWX +70/
GRNXPHQWRWLWXOLQ¡GDOLVVDNLQLDL<HEAD> ir <TITLE>)QHEÌWLQDWRG¡OþLDSUDOHLVWD
124
-HLVHUYHULQ¡SURJUDPDEXVWHVWXRMDPD³UDQNLXservletrunner, teks atlikti šiuos
veiksmus:
6HUYHULQ
SURJUDP VXNRPSLOLXRWL LU ³G¡WL ³ DSODQN &\JSDK2.0\examples
(tik tada servletrunnerJDO¡VDSWLNWLVHUYHULQ
SURJUDP
2. Paleisti servletrunner.
3DOHLVWLQDUã\NO
LUQXURG\WLMDL85/DGUHV
http://localhost:8080/servlet/SimplestServletýLDlocalhost –
PÌVÐNRPSLXWHULRDGUHVDVR8080 – prievadas, kurio „klauso“
servletrunner.
1DUã\NO¡WXULSDURG\WLSUDQHãLPSimplest Servlet.
3.4.3. Servlet$3,VVDMÐNODV¡VNODV¡VLUPHWRGDL
.DLS PLQ¡WD $3, VXGDUR GX SDNHWDL javax.servlet ir javax.servlet.http. API

palaiko Sun, MS, NetscapeILUPÐVHUYeriai.
Pakete javax.servlet\UDVVDMÐNODV¡V
Servlet – VNHOELD PLQ¡WXRVLXV VHUYHULQ¡V SURJUDPRV J\YDYLPR FLNOR

metodus.
ServletConfig – OHLGåLD VHUYHULQ¡PV SURJUDPRPV JDXWL SUDGLQLÐ UHLNãPLÐ

parametrus.
ServletContext – OHLGåLD VHUYHULQ¡PV SURJUDPRPV JDXWL LQIRUPDFLM DSLH MÐ

Y\NG\PRDSOLQNEHLXåWLNULQD³Y\NLÐVLVWHP
ServletRequest –VNHOELDPHWRGXVNOLHQWRXåNODXVRVGXRPHQLPVVNDLW\WL
ServletResponce –VNHOELDPHWRGXVDWVDN\PRNOLHQWXLGXRPHQLPVXåUDã\WL
SingleThreadModel – XåGUDXGåLD GDXJLDVUDXWLãNXPR JDOLP\EHV VHUYHULQHL

programai.
.DLNXULRVSDNHWRNODV¡V
GenericServlet –UHDOL]XRMDVVDMÐNODVHVServlet ir ServletConfig.
ServletException, UnavailableException – LãLPþLÐ NODV¡V DQWURVLRV REMHNWDV

sukuriamas, kai serverin¡ SURJUDPD \UD QHSULHLQDPD +773 XåNODXVDL – QH³NHOWD ³
VHUYHU³
'DEDUDSLHVVDMÐNODVLÐLUNODVLÐSDJULQGLQLXVPHWRGXV6VDMÐNODV¡MHServlet
\UDWU\VVHUYHULQ¡VSURJUDPRVJ\YDYLPRFLNORLUNHOLNLWLPHWRGDL
void init(ServletConfig sc) throws ServletException – sc \UD VHUYHULQ¡V

programos inicializavimo parametrai. Kaip pateikiami šie parametrai, priklauso nuo
125
VHUYHULR ²UDQNLXL servletrunner MLH WXUL EÌWL ULQNPHQRMH servlet.properties, o ši –
aplanke C:\JSDK2.0\examples. Rinkmenos turiniui keliami tam tikri reikalavimai,
NXULÐþLDQHQDJULQ¡VLP
void service(ServletRequest req, ServletResponce res) throws

ServletException, IOException –DSGRURMDXåNODXVreqLUIRUPXRMDDWVDN\Pres.
void destroy( ) –LãNHOLDVHUYHULQ

SURJUDPLãVHUYHULRDWPLQWLHs ir išlaisvina
serverinei programai skirtus išteklius.
ServletConfig getServletConfig( ) –JUåLQDSUDGLQLÐUHLNãPLÐSDUDPHWUXV
String getServletInfo( ) – JUåLQD HLOXW

DSUDãDQþL VHUYHULQ
SURJUDP
*DOLPDSHUUDã\WLPHWRGNDGMLVJUåLQWÐUHLNLDPLQIRUPDFLM
6VDMÐNODV¡VServletConfig metodai yra:
ServletContext getServletContext( ) –JUåLQDVHUYHULQ¡VSURJUDPRVNRQWHNVW

–VDYRUXRåWXVVDMÐNODV¡VServletContextWLSRãLRMH\UDPHWRGDLJUåLQDQW\VYLV
LQIRUPDFLMDSLHVHUYHULQ¡VSURJUDPRVDSOLQN
String getInitParameter( String param ) – JUåLQD SDUDPHWUR param SUDGLQ

UHLNãP

Enumeration getInitParameterNames( ) – JUåLQD YLVXV SUDGLQLÐ SDUDPHWUÐ

vardus.
6VDMÐNODV
ServletRequest UHDOL]XRMDVHUYHULV6VDMÐNODV¡VPHWRGDLOHLGåLD
JDXWLLQIRUPDFLMDSLHNOLHQWRXåNODXV.DLNXULHLãWÐPHWRGÐ\UD
int getContentLength( ) – JUåLQD XåNODXVRV LOJ³ MHL QHJDOLPD QXVWDW\WL LOJLR

JUåLQDPDUHLNãP¡–1.
String getContentType( ) – JUåLQD XåNODXVRV WLS 0,0( IRUPDWX MHL WLSR

nustatyti negalima –JUåLQDPDUHLNãP¡null.
Enumeration getParameterNames( ) – JUåLQD YLVXV XåNODXVRV SDUDPHWUÐ

vardus.
String getParameterValues( ) –JUåLQDYLVDVXåNODXVRVSDUDPHWUÐUHLNãPHV
BufferedReader getReader( ) throws IOException – JUåLQD EXIHUL]XRW

VLPEROLQ³VUDXWUHDOL]XRMDQW³REMHNWXåNODXVDLVNDLW\WL
String getRemoteAddr( ) –JUåLQDNOLHWR,3DGUHV
String getServerName( ) –JUåLQDVHUYHULRYDUG
int getServerPort( ) –JUåLQDSULHYDGRQXPHU³
126
$QDORJLãND VVDMÐ NODV¡ +773 DWVDN\mams generuoti yra ServletResponce.
Kai kurie jo metodai:
PrintWriter getWriter( ) throws IOException – JUåLQD EXIHUL]XRW VLPEROLQ³

VUDXWUHDOL]XRMDQW³REMHNWDWVDN\PXLUDã\WL2EMHNWDVWXULPHWRGXVprintln() ir print().
void setContentLength( int size ) –QXVWDWRDWVDN\PRWXULQLRLOJ³
void setContentType( String type ) –QXVWDWRDWVDN\PRWLS0,0(IRUPDWX
1HVXG¡WLQJRV VHUYHULQ¡V SURJUDPRV SDY\]G\V Programa tik nuskaito

+70/ SXVODS\MH NXU \UD ãLRV VHUYHULQ¡V SURJUDPRV 85/ DGUHVDV WHLNLDPXV
paraPHWUXVLUSHUVLXQþLDMXRVDWJDOQDUã\NOHL31DXJKWRQDV7HJXWLHSDUDPHWUDL\UD
GDUEXRWRMR SDYDUG¡ +70/ SXVODS\MH EXV OHQWHO¡ R ãLRMH – ODXNHOLV VX XåUDãX
EmployeeLUMRWHOHIRQRQXPHULVODXNHOLVVXXåUDãXPhone).
3LUPLDXVLDDSWDUVLPH+70/GRNXPHQWNXULVNUHLSVLV³VHUYHULQ
SURJUDP
7HJXMDPHEXVOHQWHO¡VXGYLHPPLQ¡WDLVLDLVODXNDLVEHLP\JWXNDVGXRPHQÐ³YHGLPXL
patvirtinti. Dokumentas tegu bus saugomas vardu PostParameters.htm:
<HTML>
<BODY>
<CENTER>
<FORM NAME = “FORM”
METHOD = POST
ACTION =
“http://localhost:8080/servlet/PostParametersServlet”>
<TABLE>
<TR>
<TD><B> Employee</B></TD>
<TD><INPUT TYPE = TEXTBOX NAME =”e”
SIZE = “25” VALUE = “ “></TD>
</TR>
<TR>
<TD><B> Phone </TD>
<TD><INPUT TYPE =TEXTBOX NAME = “p”
SIZE = “25” VALUE = “ “></TD>
</TR>
</TABLE>
<INPUT TYPE = SUBMIT VALUE = “Submit”>
</FORM>
</BODY>
</HTML>
'RNXPHQWH VDNLQLXV UDã¡PH GLGåLRVLRPLV UDLG¡PLV QRUV WDL QHWXUL MRNLRV

³WDNRV.DLNXULRVSDUDPHWUÐUHLNãP¡VVDNLQLXRVH-NRQWHLQHULXRVHUDãRPRVNDEXW¡VH–
MRV QHEÌWLQRV .DEXþLÐ QHUDã¡PH WDLV DWYHMDLV NDL SDUDPHWUDPV SULVN\U¡PH
standartines reikšmes, pavy]GåLXLTEXTBOX ar SUBMIT.
9LVL GRNXPHQWR GXRPHQ\V VNLUWL SHUVLÐVWL ³ VHUYHU³ GHGDPL ³ VDNLQ³
<FORM>. 9LHQLQWHOLV EÌWLQDV VDNLQLR SDUDPHWUDV \UD ACTION – URL adresas
SURJUDPRV NXULDL EXV DWLGXRGDPL GRNXPHQWR GXRPHQ\V 7DL JDOL EÌWL VHUYHULQ¡
127
programa (kaip šiuo atveju) arba kokia nors CGI programa. Parametras METHOD
QXVWDWRGXRPHQÐSHUVLXQWLPRPHWRG0HWRGÐ\UDWU\VGET, POST ir HEAD. GET,
kaip sako vien jo vardas, pirmiausia skirtas informacijai iš serverio pareikalauti
SDY\]GåLXL NRNLRV QRUV ULQNPHQRV VHUYHULQ¡V SURJUDPRV DU NLWRV SURJUDPRV
LãYHVWLHV VUDXWR VHUYHULR NRNLR QRUV ³UHQJLQLR LãYHVWLHV VUDXWR GET duomenys
VLXQþLDPL NDUWX VX XåNODXVD PDåGDXJ WRNLX IRUPDWX SRURPLV parametro vardas =
UHLNãP¡0HWRGDVWXULJULHåWXVDSULERMLPXVGDXJXPDVHUYHULÐQHOHLGåLDSHUVLÐVWLMXR
GDXJLDX NDLS NHOLV ãLPWXV EDLWÐ ² GET panašus ir HEAD metodas: juo serveris
SHUVLXQþLD WLN WLWXOLQ
LQIRUPDFLM POST metodas pirmiausia skirtas kliento
GXRPHQLPV VLÐVWL ³ VHUYHU³ 'XRPHQ\V VLXQþLDPL NDLS ³YHVWLHV VUDXWDV WRG¡O Q¡UD
GXRPHQÐLOJLRDSULERMLPÐ
<TABLE> –OHQWHO¡VVDNLQ\V<TR> –MRVDWVNLURVHLOXW¡VVDNLQ\VR<TD> –
HLOXW¡V DWVNLURV OVWHO¡V VDNLQ\V 3LUPRMRMH GRNXPHQWR OVWHO¡MH SDU\ãNLQWX ãULIWX W
nustato <B>EXVVSDXVGLQDPDVXåUDãDVEmployee.
Sakinys-konteineris <INPUT> WXUL GX EÌWLQXV SDUDPHWUXV TYPE nurodo
ODXNRWLSTEXTBOX), o NAME –WRODXNRYDUGQDUã\NO¡YDUGRQHURGR3DUDPHWUDV
SIZEQXVWDWRODXNRLOJ³RVALUEVXWHLNLDODXNXLUHLNãP
.DGDQJLãLVVDNLQ\V³G¡WDV
³VDNLQ³<TD> – jis nustato OHQWHO¡VHLOXW¡VOVWHO¡VSDYLGDOäHPLDXWRNLDPHVDNLQ\MH
parametrui INPUT WHLNLDPD UHLNãP¡ SUBMIT – WDL VXNXULD GXRPHQÐ SHUGDYLPR
P\JWXN NXU³ QXVSDXGXV GXRPHQ\V SHUVLXQþLDPL VHUYHULXL VALUE šiuo atveju
QXVWDWR XåUDã DQW P\JWXNR 3DQDãLDL TYPE = RESET VXNXULD GXRPHQÐ DWPHWLPR
P\JWXN
6HUYHULQ¡ SURJUDPD GXRPHQLPV Lã SDUDã\WR +70/ GRNXPHQWR ³YHVWL LU MXRV
SHUVLÐVWLDWJDOQDUã\NOHL
//Servlet for reading /sending parameters

//from/to client, ie, HTML page
//A HTML file PostParameters must be provided
//from client side
import java io.*;

import java.util.*;
public class PostParametersServlet extends GenericServlet{

public void service( ServletRequest request, ServletResponce responce )
throws ServletException, IOException{
Enumeration e = request.getParameterNames( );
pw.println( “<H2> Your data </H2>” );
while( e.hasMoreElements( ) ) {
String name = ( String )e.nextElement( );
String value = request.getParameter( name );
pw.println( name + “= “ + value );
}
pw.close( );
}
}
128
Darbas su šia serverine programa:
1. Paleisti servletrunner.
3DURG\WL QDUã\NO¡MH GRNXPHQW PostParameters.htm ³YHVWL IRUPRMH
prašomus duomenLVLUSDVSDXVWLP\JWXNSubmit.
1DUã\NO¡ WXUL SDURG\WL VHUYHULQ¡V SURJUDPRV PostParametersServlet
DWVDN XåUDã Your data pavadinimo sakinio <H2> IRUPDWX SDYDGLQLPÐ
VDNLQLÐ \UD QXR H1 iki H6 GLGåLDXVLDV MÐ – H1 LU WROLDX ³YHVWÐ GXRPHQÐ
vardus bei reikšmes.
'LUEDQW VX +773 XåNODXVRPLV GDåQLDX QDXGRMDPD VSHFLDOL]XRWD NODV¡

HttpServlet³HLQDQWL³SDNHWjavax.servlet.http, o ne GenericServlet. Šiame pakete yra
VVDMÐ NODV¡V HttpServletRequest, HttpServletResponce, HttpSession ir kt. Pirmosios
dvi VVDMÐ NODV¡V DWLWLQND QDJULQ¡WR SDNHWR javax.servlet DQDORJLãNDV VVDMÐ NODVHV R
WUHþLRML VNHOELD PHWRGXV OHLGåLDQþLXV VHNWL YLV NOLHQWR – VHUYHULQ¡V SURJUDPRV
EHQGURMRGDUERVHVLMDUNLWDLS–VHDQV3DJULQGLQ¡VSDNHWRNODV¡V\UDHttpServlet,
realL]XRMDQWLPHWRGXVGDUEXLVX+773XåNODXVRPLVLUDWVDN\PDLV bei Cookie, turinti
PHWRGXV OHLGåLDQþLXV LãVDXJRWL NOLHQWR PDãLQRMH VHDQVR EÌNO¡V LQIRUPDFLM Cookie
VDXJRYLVXV+70/GRNXPHQWÐWLWXOLQLRVN\ULDXVGXRPHQLV
6VDMÐNODV¡HttpServletRequest skelELDPHWRGÐWDUSMÐ
Cookie [ ] getCookies( ) –JUåLQDCookieGXRPHQÐPDV\Y
Enumeration getHeaderNames( ) –JUåLQDYLVXVGRNXPHQWRWLWXOLQLRVN\ULDXV

vardus.
String getRemoteUser( ) –JUåLQDQXWROXVLRNOLHQWRYDUG
HttpSession getSession( boolean new ) – jei new yra true –VXNXULDLUJUåLQD

ãLRVXåNODXVRVVHVLMRVREMHNWMHLfalse –JUåLQDMDXHJ]LVWXRMDQþLRVVHVLMRVREMHNW
6VDMÐNODV¡HttpServletResponce WXULPHWRGÐWDUSMÐ
void addCookie( Cookie c ) – prie HTTP atsakymo prijungiaREMHNWc.
void sendError( int i, String s ) throws IOException –³Y\NXVNODLGDLNOLHQWXL

VLXQþLDNODLGRVNRGiLUSUDQHãLPs.
void sendRedirect( String url ) throws IOException –SHUMXQJLDNOLHQWDGUHVX

url.
6VDMÐ NODV¡MH HttpSession yra 10 metodÐ OHLGåLDQþLÐ JDXWL LQIRUPDFLM DSLH

+773 VHDQV DUED ³UDã\WL LQIRUPDFLM DSLH VX VHDQVX VXVLMXVL NOLHQWR EÌNO
6HDQVR
VYRND UHLNDOLQJD SDY\]GåLXL HOHNWURQLQ¡MH SDUGXRWXY¡MH +773 SURWRNRODV VHDQVÐ
QHSDODLNRWRG¡OEÌWLQRVWRNLRVSURJUDPDYLPRSULHPRQ¡VNXULRVOHLVWÐLãVDXJRWLYLV
LQIRUPDFLMDSLHNOLHQWRYLVDVXåNODXVDVSDUGXRWXYHLLUYLVXVSDUGXRWXY¡VDWVDN\PXV
klientui. Objektai Session HJ]LVWXRMD WDP WLNU ODLN SULNODXVRPDL QXR VHUYHULQ¡V
SURJUDPRV VHUYHULR DSLH PLQXþLÐ 9LVL VVDMÐ NODV¡V PHWRGDL JDOL VXNHOWL LãLPW³
129
IllegalStateException – MHL PHWRGR NYLHWLPR PHWX VHDQVDV MDX SDVLEDLJ
V 6VDMÐ
NODV¡MH\UDPHWRGDL
String getID( ) –JUåLQDVHDQVRLGHQWLILNDWRULÐ
long getCreationTime( ) – JUåLQD Session REMHNWR VXNÌULPR ODLN SUDGHGDQW

nuo 1970-01-01 GMT (Greenwich Mean TimePLOLVHNXQG¡PLV
long getLastAccessedTime( ) –JUåLQDSDVNXWLQ¡VNOLHQWRXåNODXVRVODLNWXR

pat formatu, kaip metodas getCreationTime.
void putValue( String name, Object obj ) –VHDQVRREMHNWobj susieja su vardu

name.
Object getValue( String name ) –JUåLQDVHDQVRREMHNWRWXULQþLRYDUGname,

UHLNãP

void invalidate( ) –XåEDLJLDVHDQV
.ODV¡ Cookie. Vadinamieji Cookie duomenys ar kitaip – HOHPHQWDL OHLGåLD

LãVDXJRWLNRNLXVQRUVGXRPHQLVDSLHNOLHQWMRNRPSLXWHU\MH3DY\]GåLXLHOHNWURQLQ¡V
SDUGXRWXY¡V DWYHMX HOHPHQWDV JDOL VDXJRWL NOLHQWR YDUG DGUHV LU SDQ .OLHQWXL
QHUHLN¡V NHOLV NDUWXV ³YHGLQ¡WL ãLÐ GXRPHQÐ NHOHW NDUWÐ XåVDNDQW SUHNHV 7DLJL
VHUYHULQ¡ SURJUDPD JDOL ³ NOLHQWR NRPSLXWHU³ PHWRGX addCookie ³UDã\WL Cookie
GXRPHQLV GXRPHQV YDUG LU UHLNãP
VDXJRMLPR ODLN Cookie HOHPHQWR GRPHQLQ³
DGUHV LU NHOL LNL MR $GUHVDV LU NHOLDV LNL HOHPHQWR UHLNDOLQJL WDP NDG EÌWÐ JDOLPD
QXVWDW\WLDU³WUDXNWLCookieHOHPHQW³+773XåNODXVLUVLÐVWLVHUveriui. Jei vartotojo
QDUã\NO¡V QXURG\WDV 85/ DGUHVDV VXWDPSD VX Cookie elemento adresu – elementas
SULHXåNODXVRVSULMXQJLDPDV-HLCookieGXRPHQÐVDXJRMLPRNOLHQWRPDãLQRMHODLNDV
QHQXURG\WDV WDL HOHPHQWDV SDãDOLQDPDV SDVLEDLJXV GDEDUWLQLDP QDUã\NO¡V Veansui.
.ODV¡ WXUL YLHQLQWHO³ NRQVWUXNWRULÐ Cookie(String name, String value), QXVWDWDQW³
HOHPHQWRYDUGLUUHLNãP

.ODV¡MHWDUSNLWÐ\UDPHWRGDL
String getName( ) –JUåLQDCookieHOHPHQWRYDUG
String getValue( ) –JUåLQDHOHPHQWRUHLNãP

String getDomain( ) –JUåLQDHOHPHQWRGRPHQLQ³DGUHV
String getPath( ) –JUåLQDNHOLLNLHOHPHQWR
int getMaxAge( ) –JUåLQDPDNVLPDOÐHOHPHQWRVDXJRMLPRODLNVHNXQG¡PLV
.ODV¡MHWDLSSDW\UDDQDORJLãNÐPHWRGÐUHLNãPLÐSULHVN\UDLset.
.ODV¡ HttpServlet SOHþLD NODV

GenericServlet .ODV¡ WXUL PHWRGXV
UHDOL]XRMDQþLXV ³YDLULDV +773 XåNODXVDV XåNODXVDL GET – PHWRG doGet, POST –
doPost, PUT – doPut LU SDQ %HQGULDXVLDV NODV¡V PHWRGDV \UD PHWRGXL service iš
NODV¡VGenericServlet atitinkantis
130
void service(HttpServletRequest request, HttpServletResponce responce)
throws IOException, ServletException
Darbo su Cookie klase pavyzdys. Iliustruojamas darbas su Cookie

elementais (P. Naughtonas). Yra HTML dokumentas, saugomas rinkmenoje vardu
AddCookie.htm, kuriR ³YHGLPR ODXNHO\MH YDUGX data ³YHGDPD HOHPHQWR UHLNãP¡
'RNXPHQWH WDLS SDW \UD P\JWXNDV VX XåUDãX Submit GXRPHQÐ SHUVLXQWLPXL ³ VHUYHU³
SDWYLUWLQWL'XRPHQ\VVLXQþLDPLPHWRGXPOSTDGUHVXNXULV\UDVHUYHULQ¡VSURJUDPRV
AddCookieServlet adresas – taigi busVXDNW\YLQWDãLVHUYHULQ¡SURJUDPDýLDNDLSLU
DQNVWHVQLXRVH SDY\]GåLXRVH QDXGRMDPDVL localhost DGUHVX OHLGåLDQþLX LPLWXRWL
VHUYHULRGDUEVDYXNRPSLXWHULX
<HTML>
<BODY>
<CENTER>
<FORM NAME = “FORM2”
METHOD = POST
ACTION =”http://localhost:8080/servlet/AddCookieServlet”>
<B> Enter a value for MyCookie: </B>
<INPUT TYPE = TEXTBOX NAME =”data”
SIZE = “25” VALUE = “ “>
<INPUT TYPE = SUBMIT VALUE = “Submit “>
</FORM>
</BODY>
</HTML>
6HUYHULQ¡ SURJUDPD AddCookieServlet metodu getParameter (metodas

SULNODXVRVVDMÐNODVHLServletRequestWDþLDX\UDSULHLQDPDVNODVHLHttpServlet, nes ji
SOHþLD NODV
GenericServlet R ãL UHDOL]XRMD PLQ¡WM VVDMÐ NODV
JDXQD SDUDPHWUR
data UHLNãP
VXNXULD Cookie HOHPHQW NXULDP VXWHLNiamas vardas MyCookie, o su
šiuo vardu susiejama parametro data UHLNãP¡ (OHPHQWR J\YDYLPR ODLNDV
QHQXURGRPDV WDLJL HOHPHQWDV EXV VDXJRPDV WRO NRO Y\NV QDUã\NO¡V GDUER VHDQVDV
9¡OLDX SULH VHUYHULQ¡V SURJUDPRV +773 DWVDN\PR PHWRGX addCookie prijungiamas
šis sukurtasis Cookie HOHPHQWDVLUVLXQþLDPDVDWJDONOLHQWXLVXSDDLãNLQDPXRMXWHNVWX
MyCookie has been set to:
import java io.*;

import javax.servlet.http.*;
public class AddCookieServlet extends HttpServlet{

public void doPost( HttpServletRequest request,
HttpServletResponce responce )
WKURZV 6HUYHULQ¡MH SURJUDPRMH[FHSWLRQ
IOException{
String data = request.getParameter( “data” );
Cookie cookie = new Cookie( “MyCookie”, data );
response.addCookie( cookie );
131
pw.println( “<B> MyCookie has been set to:” );
pw.println( data );
pw.close( );
}
}
$QWURML VHUYHULQ¡ SURJUDPD SDURG\V NDG NOLHQWR NRPSLXWHULV VDXJR Cookie

HOHPHQW VX N WLN VXWHLNWRPLV SUDGLQ¡PLV UHLNãP¡PLV Cookie HOHPHQWÐ PDV\YDV
cookies gaunamas taip, kaip to reikalauja metodas getCookies, kiekvienam masyvo
elementui išskiriamos Cookie elemento dalys: vardas metodu getName EHL UHLNãP¡
metodu getValueLUVLXQþLDPas klientui.
import java io.*;

import javax.servlet.http.*;
public class GetCookiesServlet extends HttpServlet{

public void doGet( HttpServletRequest request,
HttpServletResponce responce )
WKURZV 6HUYHULQ¡MH SURJUDPRMH[FHStion,
IOException{
Cookie [ ] cookies = request.getCookies( );
for( i = 0; i < cookies.length; i++ ) {
String name = cookies[ i ].getName( );
String valuee = cookies[ i ].getValue( );
pw.println( “name = “ + name + “ value = “ + value );
}
pw.close( );
}
}
Šias serverines programas paleisti taip:
3DOHLVWL³UDQN³servletrunner.
1DUã\NO¡MH SDURG\WL GRNXPHQW AddCookie.htm ²YHVWL IRUPRMH SUDãRP
GXRPHQ³LUSDVSDXVWLP\JWXNSubmit.
'DEDU VHUYHULQ¡ SURJUDPD NXUL VXDNW\YLQV GRNXPHQWDV AddCookie.htm,
DWJDOSDUVLÐV³YHVWGXRPHQVUHLNãP
VXSaaiškinamuoju tekstu.
1DUã\NO¡MH³YHVWLNLW85/DGUHV
http://localhost:8080/servlet/GetCookiesServlet.
'DEDU EXV VXDNW\YLQWDV DQWURML VHUYHULQ¡ SURJUDPD NXUL QDUã\NOHL SHUGXRV

Cookie HOHPHQWRYDUGLUUHLNãP

.DG ³VLWLNLQWXP¡WH NLHN ODLNR GXRPHQÐ HOHPHQWDL VDXJRPL NRPSLXWHU\MH
SDHNVSHULPHQWXRNLWH VX ãLRPLV SURJUDPRPLV SLUPRMRMH VHUYHULQ¡MH SURJUDPRMH
galima metodu setMaxAgeQXVWDW\WLHOHPHQWRVDXJRMLPRODLNLUSDåLÌU¡WLNLHNODLko
tie duomenys bus prieinami antrajai serverinei programai.
132
3.4.4. JSP technologija
JSP (Java Server Pages) tikslas – VXSDSUDVWLQWL GLQDPLQLÐ ZZZ SXVODSLÐ

NÌULP 7HFKQRORJLMD SDUHPWD VHUYHULQLÐ SURJUDPÐ NODV¡PLV LU \UD -(( 6'.
VWDQGDUWLQ¡GDOLV-63WHFKQRORJLMSDODLNRGDXJXPDWLQNORVHUYHULÐSDODLNDQþLÐSDþL
Java-63SXVODSLDLNRPSLOLXRMDPL³VHUYHULQLÐSURJUDPÐNODVHV
.XULDQW ZZZ SXVODS³ WHFKQRORJLMD OHLGåLD NDUWX NRPELQXRWL +70/ NRG LU
Java NRGRIUDJPHQWXVâLHIUDJPHQWDL³MXQJLDPL³VSHFLDOius sakinius. JSP konteineriai
DWSDå³VWDãLXRVVDNLQLXVLUQDXGRMDMXRVH³G¡WNRGVHUYHULQHLSURJUDPDLDUMRGDOLDL
generuoti, arba šis kodas gali kviesti JavaBeans komponentus. Taigi JSP yra
SDSUDVWHVQLV SXVODSLÐ NÌULPR ³UDQNLV QHL VHUYHULQ¡V SURJUDPRV pakanka vieno
YLHQLQWHOLRGRNXPHQWRGLQDPLQLDPSXVODSLXLDSLEU¡åWL
-63 SXVODSLR ULQNPHQRV WXUL SO¡WLQLXV jsp arba .jspx 3O¡WLQLDL QXURGR WLQNOR
serveriui, kad rinkmenos tam tikras dalis turi kompiliuoti JSP kompiliatorius.
Kompiliatorius interpretuoja -63 VDNLQLXV LU JHQHUXRMD DWLWLQNDP NRG – VHUYHULQ¡V
SURJUDPRV NRG 7RNLRV SXVODSLÐ ULQNPHQRV \UD VXNRPSLOLXRMDPRV SLUPNDUW
VXDNW\YLQXV SXVODS³ Y¡OLDX VXNRPSLOLXRWDV WHNVWDV VDXJRPDV VHUYHULR DGUHVLQ¡MH
HUGY¡MH 7RG¡O NLWRV WR SDWLHV SXVODSLR XåNODXVos atliekamos greitai, o pats puslapis
faktiškai yra statinis HTML puslapis. Pakeitus JSP rinkmenos sakinius, rinkmena
DXWRPDWLãNDLSHUNRPSLOLXRMDPDLUSHUNUDXQDPD³VHUYHULRDWPLQW³
3DSUDVþLDXVLRV-63ULQNPHQRVSDY\]G\VZZZSXVODSLRURGDQþLRHVDPODLN
VHNXQG¡PLVNÌULPDV5LQNPHQRVWHNVWDV
<HTML>
<BODY>
<H1> The time is:
<% = System.currentTimeMillis( ) / 1000 %>
</H1>
</BODY>
</HTML>
.DLSPDW\WL-63VDNLQ\VSUDGHGDPDVLUEDLJLDPDVSURFHQWRåHQNOXRO\J\E¡VåHQNODV
QXVWDWR DWVNLU VDNLQLR WLS – LãUDLãNRV VDNLQ³ .OLHQWXL SLUPNDUW SDUHLNDODYXV 85/
adreso – ãLRV ULQNPHQRV DGUHVR WLQNOR VHUYHULV SHUVLÐVWÐ XåNODXV -63 NRQWHLQHULXL
ãLVVXNRPSLOLXRWÐ-63SXVODS³³VHUYHULQ
SURJUDPâLRMHVHUYHULQ¡MHSURJUDPRMHEÌWÐ
kodas, naudojantis klases HttpServletResponse, PrintWriter ir String (rezultatui –
ODLNXLVDXJRWLLUJHQHUXRMDQWLV+773DWVDN\PNOLHQWXLVXHVDPXODLNXVHNXQG¡PLV
DWVDN\PDVEÌWÐSDURG\WDVIRUPDWXH1.
7UXPSDL DSLH -63 VLQWDNV
<UD -63 VDNLQLDL-direktyvos, skirti tik JSP
kRQWHLQHULXL LU QLHNR QHUDãDQW\V ³ LãYHVWLHV VUDXW PrintWriter, bei sakiniai-VFHQDULMÐ
elementai. Direktyvos pavyzdys:
<% page language = “java” import = “java.util.*” %>
Direktyva JSP konteineriui praneša, kad toliau naudojama Java kalba, ir prašo
GLQDPLãNDL³NHOWLQXURG\WRSDNHWRNODVHV.LWRVGLUHNW\YRVextends, buffer, autoFlush,
info, isThreadSafe ir t.t.
6DNLQLÐ-VFHQDULMÐ HOHPHQWÐ \UD WU\V WLSDL VNHOELPDL YDGLQDPLHML scriplets ir
LãUDLãNRV 6NHOELPDL DSUDãR VFHQDULMÐ HOHPHQWXV DQWULHML \Ua kodo fragmentai, o
LãUDLãNRVSDY\]G³MDXPDW¡PHDQNVWHVQLDPHSDY\]G\MH-ÐVDNLQLDLDWLWLQNDPDL\UD
133
<%! %>, <% %>, <%= %>. Sakinys <%-- --%> yra JSP
komentaras.
JSP kuriamo www puslapio pavyzdys: puslapyje bus parodyta puslapio
³N¡OLPR GDWD ãLRV GLHQRV GDWD NLHN ODLNR SXVODSLV URGRPDV LU NLHN NDUWÐ SXVODSLV
DSODQN\WDV3DVNXL³SXVODS³LãYHGDPDVWHNVWDVGood bye. JSP rinkmenos tekstas:
<%@ page language = “java” import = “java.util.*” %>

<%!
long loadTime = System.currentTimeMillis( );
Date loadDate = new Date( );
int hitCount = 0;
%>
<HTML>
<BODY>
<H1> This page is loaded on <%= loadDate%> </H1>
<H1> Today’s date is <%= new Date( ) %> </H1>
<H1> This page is working <%= (System.currentTimeMillis( ) – loadTime )/1000
%>
seconds </H1>
<H1> This page was visited <%= ++hitCount %> times since
<%= loadDate %> </H1>
<%-- This scriplet prints message “Good bye” to the www page.
The PrintWriter object is always named “out” by default.
--%>
<%
out.println( “Good bye” );
%>
</BODY>
</HTML>
3.5. RMI technologijos pagrindai
RMI (Remote Method Invocation –QXWROXVLÐPHWRGÐNYLHWLPDVWHFKQRORJLMD

OHLGåLD REMHNWXL J\YXRMDQþLDP YLHQDPH NRPSLXWHU\MH NYLHVWL PHWRGXV REMHNWR
HVDQþLR NLWDPH WLQNOR NRPSLXWHU\Me. Visus technologinius reikalavimus atitinkantis
QXWRO
V PHWRGDV WUDNWXRMDPDV O\JLDL WDLS SDW NDLS ORNDOXVLV ãLDPH NRPSLXWHU\MH
esantis metodas.
7HFKQRORJLMUHDOL]XRMDSDNHWDLjava.rmi, java.rmi.registry, java.rmi.server.
Technologijai realizuoti teks VXGDU\WLNHWXULDVULQNPHQDV3LUPLDXVLDWXULEÌWL
SDUDã\WD QXWROXVL VVDMÐ NODV¡ VNHOELDQWL UHLNLDPXV PHWRGXV âL VVDMÐ NODV

UHDOL]XRMD VHUYHULV âL VVDMÐ NODV¡ WXUL EÌWL SDVNHOEWD public WXUL SO¡VWL VVDMÐ NODV

java.rmi.Remote, o kiekvienas jos metRGDV JDOL VXNHOWL LãLPW³
java.rmi.RemoteException. Antra rinkmena – serverio programa, realizuojanti
QXWROXVL VVDM âL SURJUDPD GDU SULYDOR SO¡VWL NODV
UnicastRemoteObject – ši
VXSHUNODV¡ SDODLNR REMHNWÐ HVDQþLÐ QXWROXVLDPH NRPSLXWHU\MH IXQNFLRQDOXP.
3URJUDPRMH EÌWLQD SHUUDã\WL NODV¡V NRQVWUXNWRULÐ NDG ãLV JDO¡WÐ VXNHOWL LãLPW³
RemoteException .RQVWUXNWRULXV JDOL EÌWL ÄWXãþLDV³ VXSHUNODV¡V NRQVWUXNWRULXV
134
NYLHþLDPDVDXWRPDWLãNDL7UHþLRMLULQNPHQD–WDLSSDWVHUYHULRSURJUDPRVWXULQþLRV
VWDUWLQ³ main PHWRG âL SURJUDPD WDLS SDW SULYDOR XåUHJLVWUXRWL VXNXUWM³ QXWROXV³
REMHNW YDGLQDPDMDPH 50, UHMHVWUH VHUYHU\MH PHWRGX Naming.rebind. Ketvirtoji
rinkmena – SURJUDPD NOLHQWR NRPSLXWHU\MH -RMH UHLNLD JDXWL Lã VHUYHULR URG\NO
³
QXWROXVL VVDMÐNODV
WRV SDþLRVNODV¡V Naming metodu lookup, o toliau jau su šiuo
REMHNWX HOJLDPDVL ³SUDVWDL O\J VX HVDQþLX ORNDOLRMH PDãLQRMH %H ãLÐ SURJUDPÐ
NRPSLOLDYLPR LU SDOHLGLPR GDU WHNV SDVLWHONWL ³UDQN³ 50, UHMHVWUXL SDOHLVWL VHUYHU\MH
EHL³UDQN³SURJUDPRPV-NDPãþLams (stubsWXULQþLRPVO\JLDLWRNLDVSDþLDVNODVHVNDLS
QXWROXVLRV VVDMÐ NODV¡V LU HVDQþLRPV NOLHQWR NRPSLXWHU\MH WDLS SDW SURJUDPRPV-
karkasams (skeletons HVDQþLRPV VHUYHULR NRPSLXWHU\MH JHQHUXRWL 3URJUDPRV-
NDPãþLDL LU SURJUDPRV-NDUNDVDL UÌSLQDVL visais ryšiais tarp kliento ir serverio;
SURJUDPXRWRMXL WXR XåVLLPWL QHUHLNLD -HL UHLNLD SHUVLÐVWL REMHNWXV ãLH VLXQþLDPL
serializuoti, o paskirties vietoje automatiškai atkuriami.
9LVXV ãLXRV UHLNDODYLPXV LOLXVWUXRVLPH SDSUDVþLDXVLX XåGDYLQLX WDUNLPH,
QRULPH VXG¡WL GX double IRUPDWR VNDLþLXV 3DUDã\VLPH VXG¡WLHV PHWRG add, o šis
metodas bus vykdomas nutolusiame kompiuteryje. Duomenis – abu sudedamus
VNDLþLXV WDLS SDW VHUYHULR 85/ DGUHV ³YHVLPH NOLHQWLQ¡MH SURJUDPRMH SHU
NRPDQGLQ¡VHLOXW¡VDUJXPHQWus.
1. 1XWROXVLVVDMÐNODV¡DWLWLQNDQWLPLQ¡WXRVLXVUHLNDODYLPXV
import java.rmi.*;
public interface ServerInterface extends Remote{
double add( double d1, double d2) throws RemoteException;
}
2. 6HUYHULRSURJUDPDUHDOL]XRMDQWLQXWROXVLVVDMÐNODV

import java.rmi.*;
import java.rmi.server.*;
public class ServerImplementation extends UnicastRemoteObject

implements ServerInterface{
public ServerImplementation( ) throws RemoteException{ }
public double add( double d1, double d2 ) throws RemoteException{

return d1 + d2;
}
}
3. 6WDUWLQ¡ VHUYHULR SURJUDPD VXNXULDQWL EHQW YLHQ SDUDã\WM³ PHWRG add

WXULQþLRV NODV¡V REMHNW W \ ServerImplementation REMHNW LU UHJLVWUXRMDQWL ã³
QXWROXV³REMHNW50,UHMHVWUHSDNHWRjava.rmiNODV¡VNaming statiniu metodu rebind.
Metodo pirmasis argumentas – VWDUWLQ¡V SURJUDPRV YDUGDV WHLNLDPDV NDLS String
duomuo, o antrasis – sukurtasis ServerImplementationNODV¡VREMHNWDV
import java.net.*;
import java.rmi.*;
import java.rmi.registry.*;
135
public class ServerProgram{

try{
ServerImplementation si = new ServerImplementation( );
Naming.rebind( “ServerProgram”, si );
System.out.println( “Exception: “ + e );
}
}
}
4. .OLHQWLQ¡ SURJUDPD (VPLQLV GDO\NDV ãLRMH programoje – JDXWL URG\NO

³
QXWROXVLRVVVDMÐNODV¡VQHNODV¡V!WLSRREMHNWHVDQW³VHUYHU\MH7DLDWOLHNDNODV¡V
Naming statinis metodas lookup, kuriam teikiamas vienas argumentas – serverio
programos URL adresas su specialiu protokolu rmi. Šis adresas suformuojamas kaip
String WLSR GXRPXR Lã SLUPRMR NRPDQGLQ¡V HLOXW¡V DUJXPHQWR 7XULQW URG\NO
³
QXWROXV³REMHNWMDPMDXJDOLPDNYLHVWLPHWRGadd.
import java.rmi.*;
import java.rmi.registry.*;
public class ClientProgram{

try{
String serverURL = “rmi://”+args[0]+ “/ServerProgram”;
ServerInterface si = ( ServerInterface ) Naming.lookup(
serverURL );
System.out.println( “Numbers to be added “ + args[1] +
“ “ + args[2] );
double d1 = Double.valueOf( args[1] ).doubleValue( );
double d2 = Double.valueOf( args[2] ).doubleValue( );
System.out.println( “Result “ + si.add( d1,d2 ) );
System.out.println( “Exception “ + e );
}
}
}
9LVDVãLVSURJUDPÐSDNHWDVSDOHLGåLDPDVWDLS
9LVRVSURJUDPÐULQNPHQRVVXNRPSLOLXRMDPRV
2. Suformuojamos programos-NDPãþLDLLUSURJUDPRV-NDUNDVDL³UDQNLXrmic:
rmic ServerImplementation
²UDQNLR GDUER UH]XOWDWDL – rinkmenos ServerImplementation_Stub.class (programai-

NDPãþLXLLUServerImplementation_Skel.class (karkasui).
136
3. Aplanke kliento kompiuteryje sudedamos rinkmenos ClientProgram.class,
ServerInterface.class, ServerImplementation_Stub.class.
Aplanke serverio koPSLXWHU\MHWXULEÌWLULQNPHQRVServerProgram.class,
ServerInterface.class, ServerImplementation.class, ServerImplementation_Stub.class,
ServerImplementation_Skel.class.
7DLJLGDOLVULQNPHQÐWXULEÌWLLUVHUYHU\MHLUNOLHQWRNRPSLXWHU\MH
4. Serveryje palHLGåLDPDV50,UHMHVWUR³UDQNLVrmiregistry:
start rmiregistry
3DOHLGåLDPDVVHUYHULV
java ServerProgram
3DOHLGåLDPDV NOLHQWDV -HL QRULPH SDWLNULQWL YLVÐ SURJUDPÐ YHLNLP EH
VHUYHULRW\NDGWDVSDWVNRPSLXWHULVDWOLNWÐLUVHUYHULRLUNOLHQWR vaidmenis, vietoje
VHUYHULR85/DGUHVRNRPDQGLQ¡MHHLOXW¡MHQXURGRPHVSHFLDOÐ,3DGUHVåU
VN\ULÐ DSLH ED]LQ³ WLQNOLQ³ SURJUDPDYLP %H WR EÌWLQL GDU GX NRPDQGLQ¡V HLOXW¡V
DUJXPHQWDLDQWUDVLVEXVSLUPDVVXGHGDPDVVNDLþLXVRWUHþLDVLV– antras:
java ClientProgram 127.0.0.1 1 2
3URJUDPÐÌNLRVSDXVGLQLPDLEXVWRNLH
Numbers to be added 1 2
Result 3
%HQGURVLRVåLQLRVDSLH&25%$WHFKQRORJLM
-HL50,ELEOLRWHNDUHDOL]XRMDVYHLNWDUSQXWROXVLÐJavaREMHNWÐWDL&25%$
t SDW³ OHLGåLD SDGDU\WL WDUS EHW NRNLRPLV SURJUDPDYLPR NDOERPLV SDUDã\WÐ REMHNWÐ
CORBA –WDLLQWHJUDFLQ¡WHFKQRORJLMDNXULRVVSHFLILNDFLMSDUHQJ¡20*NRPLWHWDV
(Object Management Group, www.omg.org ).
Specifikacija VXVLGHGD Lã GYLHMÐ GDOLÐ SDJULQGLQLR REMHNWÐ PRGHOLR Core
Object Model LU REMHNWÐ YDOG\PR DUFKLWHNWÌURV Object Management Architekture,
20$20$QXVWDWREÌWLQDVREMHNWRFKDUDNWHULVWLNDVVVDMRVRSHUDFLMRVVDY\EHVLU
pan. –QXVWDWRPHFKDQL]PÐOHLGåLDQþLÐREMHNWDPVVYHLNDXWLLQIUDVWUXNWÌU-RMHWDLS
SDW DSLEU¡åWRV REMHNWDPV WHLNLDPRV SDVODXJRV Object Services) ir vadinamasis
XåNODXVÐREMHNWDPVWDUSLQLQNDVObject Request Broker, ORB).
Java&25%$JDOLP\E¡VUHDOL]XRWRVNODVLÐSDNHWXRVH&25%$IDNWLškai jame
\UDNODV¡25%org.omg. CORBA, org.omg. CosNaming,
org.omg.CosNaming.NamingContextPackage ir keliuose kituose CORBA paketuose
ir subpaketuose.
137
.OLHQWLQ¡MH ãLRV WHFKQRORJLMRV SURJUDPRMH PHWRGDL NYLHþLDPL ³SUDVWX EÌGX
WDþLDX SDWV NYLHWLPR PHFKDQL]PDV VXG¡WLQJDV UHLNLD SDVLWHONWL 25% NDG EÌWÐ
VXVLMXQJWD VX VHUYHULX SDVNXL PHWRGÐ DUJXPHQWDL VXSDNXRMDPL ³ GYHMHWDLQLXV
GXRPHQLVLUSHUVLXQþLDPLåHPRMRO\JLRSURWRNROXVHUYHU\MHGXRPHQ\VGHNRGXRMDPL³
UHLNLDP IRUPDW LU NYLHþLDPL UHLNLDPR SURFHVR Ueikiami metodai. Visos šios
SDVODXJRVDSLEU¡åWRV20*NRPLWHWRQXVWDW\WRVHVVDMRVH
.DGDQJL ³PDQRPD VNLUWLQJRPLV NDOERPLV SDUDã\WÐ REMHNWÐ VVDMD EÌWLQD GDU
YLHQDVWDQGDUWL]XRWDNDOEDPLQ¡WRVLRPVVVDMRPVSDWHLNWL7DLVVDMÐDSLEU¡åLPRNDOED
IDL (Interface Definition Language.DOEDQXVWDWRNDLSWXULEÌWLDSUDã\WLGXRPHQÐ
WLSDL RSHUDFLMRV DUJXPHQWDL VVDMÐ NODV¡V PHWRGDL .DOERV VLQWDNV¡ SDQDãL ³ Java
VLQWDNV
WLN YLHWRMH Java SDNHWR VYRNRV ,'/ NDOERMH QDXGRMDPD PRGXOLR module)
VYRND
IDL kalba parašyta programa kompiliuojama kompiliatoriumi IDL/Java³Java
NRG.RPSLOLDWRULXVWDLSSDWVXJHQHUXRMDSURJUDPDV-NDPãþLXVLUSURJUDPDV-karkasus
åU50,WHFKQRORJLM
.DG VXVLGDU\WÐ ³VSÌGLV DSLH WHFKQRORJLM QHVLJLOLQGDPL ³ GHWDOHV SDWHLNVLPH
viHQSDY\]G³%(FNHOLVNXULDPDVQXWRO
VVHUYHULVWHLNLDQWLVNOLHQWDPVWLNVOÐODLN
$ELSURJUDPRVGDO\VþLDSDUDã\WRV JavaQRUVJDOLPDEÌWÐQDXGRWLLUVNLUWLQJDVNDOEDV
3DY\]GåLXL UHDOL]XRWL SDVLWHONWL -(( LQVWDOLDFLQLDPH SDNHWH HVDQW\V LQVWUXPHQWDL
Java'/25%URG\NOLÐ-REMHNWÐLGHQWLILNDYLPRWDUQ\ED
3LUPLDXVLD,'/NDOEDUHLNLDSDUDã\WLEÌWLQDVVVDMDV
module remotetime{
interface ExactTime{
string getTime( );
};
};
Rinkmena išsaugoma su priesaga .idl ir kompiliuojama IDL/Java

kompiliatoriumi (pakete – idltojava.exe programa), gaunant programas-NDPãþLXV LU
programas-karkasus:
idltojava remotetime.idl
6XIRUPXRMDPRVPLQ¡WRVLRVSURJUDPRV_ExactTimeStub.java ir
_ExactTimeImplBase.javaEHLVVDMÐNODV¡ Java kalba ExactTime.java.
DabDU ³ YLHQ SURJUDP ³GHGDPDV VHUYHULV ExactTimeServer LU MR REMHNW
UHDOL]XRMDQWL NODV¡ RemoteTimeServer âL GDU WXUL W REMHNW SDQDãLDL NDLS 50,
WHFKQRORJLMRMH XåUHJLVWUXRWL WLN þLD – VX 25% 7DUSLQLQNR 25% PHWRGÐ þLD
neaiškinsime, tai galima rasti Javasoft ir OMG internetiniuose puslapiuose.
Programa:
import remotetime.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage*;
import org.omg.CORBA.*;
import java.util.*;
import java.text.*;
138
// Server
class ExactTimeServer extends _ExactTimeImplBase{
public String getTime( ){
return DateFormat. getTimeInstance( DateFormat.FULL ).
format( new Date( System.currentTimeMillis( )));
}
}
// Implementation and registry of server
public class RemoteTimeServer{
public static void main( String args[ ] ) throws Exception{
ORB orb = ORB.init( args, null );
ExactTimeServer ets = new ExactTimeServer( );
orb.connect( ets );
org.omg.CORBA.Object obj = orb.resolve_initial_references(
“NameService” );
NamingContext nct = NamingContextHelper.narrow( obj );
NameComponent nc = new NameComponent( “ExactTime”, “ “ );
nct.rebind( path, ets );
java.lang.Object sync = new java.lang.Object( );
synchronized( sync ){
sync.wait( );
}
}
}
-HL ãL SURJUDPD EÌWÐ SDOHLVWD EÌWÐ VXNXUWDV VHUYHULV LU MLV ODXNWÐ NOLHQWÐ
XåNODXVÐ
.OLHQWR SURJUDPD 6VDM ³ REMHNW VHUYHU\MH SURJUDPD JDXQD WDLS SDW SHU
WDUSLQLQN25%
import remotetime.*;
import org.omg.CosNaming.*;
import org.omg.CORBA.*;
public class RemoteTimeClient{

public static void main( String args[ ] ) throws Exception{
ORB orb = ORB.init( args, null );
Org.omg.CORBA.Object obj = orb.resolve_initial_references(
“NameService” );
NamingContext nct = new NamingContextHelper.narrow( obj );
NameComponent nc = new NameComponent( “ExactTime”, “ “ );
NameComponent [ ] path = { nc };
ExactTime et = ExactTimeHelper.narrow( nct.resolve( path ));
String exactTime = et.getTime( );
System.out.println( exactTime );
}
}
139
Kad YLVDVSURJUDPLQLVÌNLVYHLNWÐEÌWLQDSDQDãLDLNDLS50,WHFKQRORJLMRMH
VXDNW\YLQWLVHUYHU³NOLHQWVVDMÐNODV
SURJUDP-NDPãW³LUSURJUDP-NDUNDVEHLGDU
Java'/LGHQWLILNDYLPRWDUQ\ENXULSDJDOQXW\O¡MLPNODXVR-ojo prievado.
Šiame pavyzdyjeLUVHUYHULVLUNOLHQWDV\UDWDPHSDþLDPHNRPSLXWHU\MHWDþLDX
MLHUHDOL]XRMDPLGYLHMÐVNLUWLQJÐ-90
140
/,7(5$7Ë5$
1. Austin M., Chancogne D. Engineering programming C, MATLAB, Java. John

Wiley & Sons, 1999. ~700 p.
2. Eckel B. Thinking in Java. Prentice Hall, 2nd ed., 2001. ~900 p.

Yra rus.vertimas.
Yra nemokamas ankstesnis leidimas: www.BruceEckel.com
3. Naughton P., Schildt H. JavaTM 2: The Complete Reference. McGraw-Hill,

3rd ed., 2001. ~1100 p.
Yra rus. vertimas.
4. Horstmann C., Cornell G. Core Java 2. Volume I – Fundamentals.

Volume II – Advanced Features. Prentice Hall, 2002. ~ 2000 p.
Yra rus. vertimas.
5. Wayner P. Java and JavaScript Programming. AP Professional, 1997. ~250 p.

Yra rus. vertimas.
6. www.java.sun.com arba
java.sun.com arba
www.javasoft.com
7. www.omg.org
.
8. GhjlhgI.,KlZg_d B. Ijh]jZfbjh\Zgb_gZJava.l.KDIj_kk, 1998.
∼ 900 c.
8. Kfbjgh\G. Java 2.LjbE, 2000. ∼ 300 c.
141
PRIEDAI
3URJUDPÐSDY\]GåLDLLUVDYDUDQNLãNRGDUERXåGXRW\V
1–2 programos
Savarankiškos aplikacijos pavyzdys
class FirstApp {
public static void main ( String args[ ] ) {
System.out.println( "My first application." );
}
}
.OLHQWLQ¡VSURJUDPRVSDY\]G\V
import java.awt.*;
import java.applet.*;
public class FirstApplet extends Applet{

Image NewImage;
resize( 400, 400 );
NewImage = getImage( getCodeBase( ),"New.gif" );
}
public void paint( Graphics g ){
g.drawImage( NewImage, 100, 350, this );
play( getCodeBase( ), "New.au" );
}
}
142
3 programa
Aritmetiniai reiškiniai. Pasakykite, kokius rezultatus turi gauti programa.

3DVLWLNULQNLWHY\NG\GDPLSURJUDP.
public class ArithmTest extends Applet{

int x = 2;
int y = 3;
int z = 0;
int tripleAndAdd( int a ) {
x = x + a;
return 3 * a; }
x ++;
System.out.println( "x=" + x + " y=" + y + " z=" + z );
x += y;
z = x + tripleAndAdd( y );
z = tripleAndAdd( y ) + x;
x += tripleAndAdd( y );
}
}
HTML dokumentas programai:
<HTML>
<HEAD>
<TITLE>First Java Applet</TITLE>
</HEAD>
<BODY>
<APPLET CODE="ArithmTest" WIDTH=500 HEIGHT=100></APPLET>
</BODY>
</HTML>
143
4 programa
Matomumo sritys. Pasakykite, kokius rezultatus turi gauti programa.

3DVLWLNULQNLWHY\NG\GDPLSURJUDP
public class ArithmTest2 extends Applet{
int x = 2;
int y = 3;
int z = 0;
int tripleAndAdd( int a ) {
System.out.println( "Beginning of tripleAndAdd:" +
"x =" + x + " a = " + a );
x = x + a;
System.out.println( "End of tripleAndAdd:" +
"x =" + x + " a = " + a );
return x * a;
}
int x = 5;
x ++;
x += y;
z = x + tripleAndAdd( y );
x += tripleAndAdd( y );
}
}
144
5–6 programos
/RJLQLDL UHLãNLQLDL 5DNWDåRGLV this 3DVDN\NLWH N VSDXVGLQV SURJUDPRV

3DVLWLNULQNLWHY\NG\GDPLSURJUDP
class InventoryItem extends Object{

public int InStock = 0;
public boolean getItem(){
if( this.InStock > 0 ) {
this.InStock--;
return true; }
else { return false; }
}
}
public class Store extends Applet{

InventoryItem Chicken, Egg;
Chicken = new InventoryItem( );
Chicken.InStock = 2;
Egg = new InventoryItem( );
Egg.InStock = 2;
if(Chicken.getItem( ) || Egg.getItem( ) ){
System.out.println( "First order filled" ); }
else { System.out.println( "First order not filled" ); }
System.out.println( "Chickens left:" + Chicken.InStock );
System.out.println( "Eggs left:" + Egg.InStock );
if( Chicken.getItem( ) && Egg.getItem( ) ){
System.out.println( "Second order filled" ); }
else { System.out.println( "Second order not filled" ); }
System.out.println( "Chickens left:" + Chicken.InStock);
if( Chicken.getItem( ) && Egg.getItem( ) ){
System.out.println( "Third order filled" ); }
else { System.out.println( "Third order not filled" ); }
System.out.println( "Chickens left:" +
Chicken.InStock );
}
}
145
public class Kids extends Applet {

int boredomFactor=5; //how long until they quit
String message=""; //what they normaly say
String quitMessage=""; //what they say until they quit
public void MyTurn ( Kids WhozNext ){
if ( boredomFactor-- <=0 ){
System.out.println( quitMessage );}
else{
System.out.println( message );
WhozNext.MyTurn( this );
}
}
Kids Bobby,Kenny;
Bobby = new Kids( );
Bobby.message = "kenny, you did it";
Bobby.boredomFactor = 4;
Bobby.quitMessage = "fine";
Kenny = new Kids( );
Kenny.message = "BOBBY, YOU DID IT";
//Kenny.boredomFactor = 3;
Kenny.quitMessage = "FINE";
Kenny.MyTurn( Bobby );
}
}
146
7–8 programos
0HWRGÐ-NRQVWUXNWRULÐY\NG\PRWYDUND0HWRGÐSHUNURYLPDV.VSDXVGLQV
SURJUDPRV"3DVLWLNULQNLWHY\NG\GDPLSURJUDP
// Initialization: variables and methods

//
class Tag{
Tag( int i ){
System.out.println( "Tag("+i+")" );
}
}
class Card{
Tag t1 = new Tag( 1 ); // before constructor !
Card( ){
System.out.println( "Inside constructor Card" );
t3 = new Tag (33 );
}
Tag t2 = new Tag( 2 );
void m( ){
System.out.println( "Finish" );
}
Tag t3 = new Tag( 3 ); // after constructor !
}
public class Initialization{

public static void main(String args[ ]) {
Card c= new Card( );
c.m( );
}
}
147
// Overloading
//
public class PrimitiveOverloading{

static void prt( String s ){
System.out.println( s );
}
void m1(char x){ prt("m1(char)" ); }

void m1(byte x){ prt("m1(byte)" ); }
void m1(short x){ prt("m1(short)" ); }
void m1(int x){ prt("m1(int)" ); }
void m1(long x){ prt("m1(long)" );}
void m1(float x){ prt("m1(float)" ); }
void m1(double x){ prt("m1(double)" ); }
void m2(byte x){ prt("m2(byte)" ); }





void testChar( ){
char x ='x';
prt( "char argument" );
m1( x ); m2( x ); m3( x ); m4( x ); m5( x ); m6( x ); m7( x );
}
148
void testByte( ){
byte x =1;
prt( "byte argument" );
m1( x ); m2( x ); m3( x ); m4( x ); m5( x ); m6( x ); m7( x );
}
void testShort( ){
short x =1;
prt( "short argument" );
m1( x ); m2( x ); m3( x ); m4( x ); m5( x ); m6( x ); m7( x );
}
void testInt( ){
int x =1;
prt( "int argument" );
m1( x ); m2( x ); m3( x ); m4( x ); m5( x ); m6( x ); m7( x );
}
void testLong( ){
long x =1L;
prt( "long argument" );
m1( x ); m2( x ); m3( x ); m4( x ); m5( x ); m6( x ); m7( x );
}
void testFloat( ){
float x =1F;
prt( "float argument" );
m1( x ); m2( x ); m3( x ); m4( x ); m5( x ); m6( x ); m7( x );
}
void testDouble( ){
double x =1;
prt( "double argument" );
m1( x ); m2( x ); m3( x ); m4( x ); m5( x ); m6( x ); m7( x );
}

PrimitiveOverloading pl = new PrimitiveOverloading( );
pl.testChar( );
pl.testByte( );
pl.testShort( );
pl.testInt( );
pl.testLong( );
pl.testFloat( );
pl.testDouble( );
}
149
9 programa
PaveldimuPDV.VSDXVGLQVSURJUDPD"3DVLWLNULQNLWHY\NG\GDPLSURJUDP
// Inheritance
//
class Class1 {
private String s = "Class1: ";
public void append( String ss ) { s += ss; }
public void m1( ) { append( "m1( ) " );}
public void print( ) { System.out.println( s );}
c1.m1( ); c1.m2( ); c1.m3( ); c1.print( );
}
}

public void m3( ){ // overriding method m3
append( "Class2.m3() " );
super.m3( ); // calling m3 of superclass
}
public void m4( ) { append( " m4( )" ); } // extension of interface
c2.m1( ); c2.m2( ); c2.m3( ); c2.m4( ); c2.print( );
System.out.println( "Test for the superclass Class1:" );
Class1.main( args ); // args already defined
}
}
150
10 programa
3DYHOGLPXPDV3DYHOGLPXPXVXVLHWÐNODVLÐNRQVWUXNWRULÐY\NG\PRWYDUND
.VSDXVGLQVSURJUDPD"3DVLWLNULQNLWHY\NG\GDPLSURJUDP
// Inheritance: constructors
//
class Class3 {
Class3( int i ) {
System.out.println( "Constructor of Class3 "+i );
}
}
class Class4 extends Class3 {

Class4( int i ) {
super( i ); // calling constructor of superclass Class3
i++; // scope of "i" is limited with constructor area!
}
}

Class5( int i ) {
super( i ); // calling constructor of superclass Class4
i++;
}
Class5 c5 = new Class5( 123 );
}
}
151
11 programa
3ROLPRUIL]PDV*HUHVQHLSROLPRUIL]PRLOLXVWUDFLMDLSHUUDã\NLWHSURJUDPNDG
³PDV\YShapeHOHPHQWDLEÌWÐVXGHGDPLDWVLWLNWLQHWYDUNDQDXGRNLWHMath.random
PHWRG
// Polymorphous methods: 1th example

//
class Shape {
void draw( ){}
void erase( ){}
}
class Circle extends Shape {
void draw( ) {
}
void erase( ) {
}
}
class Square extends Shape {
void draw( ) {
}
void erase( ) {
}
}
class Triangle extends Shape {
void draw( ) {
}
void erase( ) {
}
}
public class Shapes {

Shape[ ] s = {
new Circle( ),
new Square( ),
new Triangle( ) }; // upcasting toward Shape
s[ i ].draw( ); // polymorphous calling
s[ i ].erase( );
}
}
}
152
12 programa
11SURJUDPDSHUUDã\WDQDXGRMDQWDEVWUDNþLDVNODVHV
// Polymorphous methods: 2nd example

//
abstract class ShapeAbstract {
abstract void draw( );
abstract void erase( );
void print( int i ) {
System.out.println( "Real method print( "+i+" )" );
}
}
class Circle extends ShapeAbstract {
void draw( ) {
}
void erase( ) {
}
}
class Square extends ShapeAbstract {
void draw( ) {
}
void erase( ) {
}
}
class Triangle extends ShapeAbstract {
void draw( ) {
}
void erase( ) {
}
}
public class ShapesAbstract {
ShapeAbstract[ ] s = {
new Circle( ),
new Square( ),
new Triangle( ) }; // upcasting
s[ i ].draw( ); // polymorphous calling!
s[ i ].erase( );
s[ i ].print( i );
}
}
}
153
13 programa
11 programa, perrašyta naudojant VVDMÐNODVHV
// Polymorphous methods: 3rd example

//
interface ShapeInterface {
int i = 123;
void draw( );
void erase( );
}
class Circle implements ShapeInterface {
public void draw( ) {
}
public void erase( ) {
System.out.println("Circle.erase( )" );
}
}
class Square implements ShapeInterface {
}
}
}
class Triangle implements ShapeInterface {
}
}
static void print( ) {
System.out.println( "Triangle.print( "+i+" )" );
}
}
class Polygon extends Triangle { }
public class ShapesInterface {

ShapeInterface[ ] s = {
new Circle( ),
new Square( ),
new Triangle( ),
new Polygon( ),
};
s[ i ].draw( ); // polymorphous calling!
154
s[ i ].erase( );
}
Polygon.print( );
}
}
155
14 programa
.OLHQWLQ¡SURJUDPD*UDILQLÐNRPSRQHQWÐLãG¡VW\PRNRQWHLQHU\MHWYDUN\NO¡
3DEDQG\NLWHNRPSRQHQWXVLãG¡VW\WLVDYRQXRåLÌUD,ãEDQG\NLWHNLWDVLãG¡VW\PR
tvarkykles (BorderLayout, GridLayout ir kt.).
// 1th example: buttons

//
//</applet>
//
import java.awt.*;

Jbutton b1 = new JButton( "Button 1" ),
b2 = new JButton( "Button 2" );
c.add( b1 );
c.add( b2 );
}
}
156
15–17 programos
.OLHQWLQ¡SURJUDPD6NLUWLQJRV³Y\NLÐUHDOL]DYLPRVLQWDNV¡V3DEDQG\NLWH
SHUUDã\WLSURJUDPDVQDXGRGDPLVNLUWLQJDV³Y\NLÐUHJLVWUDYLPRVLQWDNVHV
// 2nd example: buttons and event, inner class

//
//</applet>
//
import java.awt.*;

class ALC implements ActionListener{
public void actionPerformed( ActionEvent e ){
String buttonName = ( ( JButton )e.getSource( ) ).getText( );
}
}
ALC al = new ALC( );
c.add( b1 );
c.add( b2 );
c.add( tf );
}
}
157
// 3rd example: buttons and event, inner classes, other layouts
//
//</applet>
//
import java.awt.*;

ActionListener al = new ActionListener( ){ // 2nd syntax' alternative;
public void actionPerformed( ActionEvent e ){ // to be preferred
}
}; // ;!
// 3rd syntax' alternative; to be
// preferred for a single addition
}
} );
c.add( BorderLayout.EAST, b1 );
c.add( BorderLayout.WEST, b2 );
}
}
158
// 4th example: buttons and event, alternative listening to the events
//
//</applet>
//
import java.awt.*;
public class Button31 extends JApplet implements ActionListener{

b1.addActionListener( this ); // ie, adding applet as a listener
b2.addActionListener( this );
c.add( BorderLayout.NORTH, b1 );
c.add( BorderLayout.SOUTH, b2 );
}
}
}
159
18 programa
.OLHQWLQ¡ SURJUDPD 5HDJDYLPDV ³ NHOLV SHO¡V ³Y\kius – SUDQHãLPÐ DSLH

³Y\NXV³³Y\N³LU³Y\NLRNRRUGLQDWHVVSDXVGLQLPDVNOLHQWLQ¡VSURJUDPRVODQJH
3R NHOLÐ ³Y\NLÐ ODQJDV SULVLSLOGR SUDQHãLPÐ SHO¡V S¡GVDNDV VSDXVGLQDPDV
WHPSLDQW SHO
QXVSDXVWX NODYLãX WDLS SDW JDOL SULSLOG\WL ODQJ 3DNHLVNLWH SURJUDP
WDLS NDG EÌWÐ VSDXVGLQDPL WLN NHOLÐ SDVNXWLQLÐ ³Y\NLÐ SUDQHãLPDL VDN\NLPH -ies
³Y\NLÐLUEÌWÐVSDXVGLQDPDVULERWRLOJLRWDUNLPHLã-LHVVLPEROLÐSHO¡VS¡GVDNDV
*DOLPDV VSUHQGLPR NHOLDV VXWDOSLQWL SUDQHãLPXV LU S¡GVDN ³ PDV\YXV NDL PDV\vai
prisipildo –QDXMXVHOHPHQWXVXåUDã\WLY¡OQXRPDV\YRSUDGåLRV
$WNUHLSNLWHG¡PHV³³PHWRGRrepaint( )QDXGRMLP
// Applet example: mouse and multiple events

//
//<applet code = Mouse1 width = 800 height = 500>
//</applet>
//
import java.awt.*;
public class Mouse1 extends JApplet

implements MouseListener, MouseMotionListener{ // applet listens to all
// mouse events
String message = "";
int x=0, y=0; // where the message is printed
int xa=0, ya=0; // where the mouse enters and leaves window
int i=0; // counts events "entered" and "exited"

addMouseListener( this ); // ie, adding applet as a listener
addMouseMotionListener( this );
}
public void mouseClicked( MouseEvent me ){

x = me.getX( )+100; // to separate messages "clicked" and "pressed"
y = me.getY( );
message = "Mouse clicked";
repaint( );
}
public void mouseEntered( MouseEvent me ){

i++;
x = 10;
y = i*10;
xa = me.getX( );
ya = me.getY( );
message = "Mouse entered"+xa+ya;
repaint( );
160
}
public void mouseExited( MouseEvent me ){

i++;
x = 10;
y = i*10;
xa = me.getX( );
ya = me.getY( );
message = "Mouse exited"+xa+" "+ya;
repaint();
}

x = me.getX( );
y = me.getY( );
message = "Mouse pressed";
repaint( );
}
public void mouseReleased( MouseEvent me ){

x = me.getX( )+100;
y = me.getY( );
message = "Mouse released";
repaint( );
}
public void mouseDragged( MouseEvent me ){

x = me.getX( );
y = me.getY( );
message = "*";
showStatus( "Dragging at "+x+", "+y ); // message at the bottom of window
repaint( );
}
public void mouseMoved( MouseEvent me ){

x = me.getX( );
y = me.getY( );
message = " ";
showStatus( "Moving at "+x+", "+y );
repaint( );
}
public void paint( Graphics g ) {

g.drawString( message, x, y );
}
}
161
19 programa
.OLHQWLQ¡ SURJUDPD .ROHNFLMRV SDY\]G\V HashMap OHQWHO¡ ² WHNVWR ODXN

SHUGXRGDPLOHQWHO¡MHVDXJRPLGXRPHQ\V.LWXP\JWXNXWHNVWLQLVODXNDVLãYDORPDV
1. ² JUDILQ
VVDM ³G¡NLWH GX QDXMXV P\JWXNXV YLHQ QXVSDXGXV ³ WHNVWR ODXN
WXULEÌWLLãYHVWRVYLVRVOHQWHO¡VUDNWÐUHLNãP¡VQDWÌUDOLDGLG¡MLPRWYDUNDNLW–
YLVRVUHLNãP¡VQDWÌUDOLDGLG¡MLPRWYDUND
2. 3DEDQG\NLWH NOLHQWLQ¡V SURJUDPRV DWOLHNDPLHPV YHLNVPDPV SULWDLN\WL NLWDV
NROHNFLMÐ NODVHV ULQNLQLXV LU VUDãXV 3DUDã\NLWH EHQW GX QDXMXV SURJUDPRV
variantus.
// Example for JTextArea,collection HashMap

//
//<applet code = TextArea width = 500 height = 500>
//</applet>
//
import java.awt.*;
import java.util.*; //all collections are saved here
public class TextArea extends JApplet {

HashMap hm = new HashMap( );
hm.put( "a",new Double( 1. ) );
hm.put( "b",new Double( 2. ) );
hm.put( "c",new Double( 3. ) );
hm.put( "d",new Double( 4. ) );
hm.put( "e",new Double( 5. ) );
hm.put( "f",new Double( 6. ) );
Set s = hm.entrySet( ); //all entries (pairs key/value) of hashtable
// transmitted to a set; iterator is available for a set
Iterator i = s.iterator( ); //method returns iterator object i
while( i.hasNext( ) ){ //hasNext - method of class Iterator
Map.Entry me = ( Map.Entry )i.next( ); //method next returns object of
//type Object; downcasting.
//Entry - inner class of Map
ta.append( me.getKey( )+" : "
+me.getValue( )+"\n"); //method append (JTextArea) appends
//current text to the existing text
}
}
});
162
ta.setText( "" ); //ie, deletes text
}
} );
c.add( new JScrollPane( ta ) ); //text area wrapped into a scrollbar
c.add( b1 );
c.add( b2 );
}
}
163
20 programa
.OLHQWLQ¡SURJUDPD'XRPHQÐVNDLW\PDVLãULQNPHQRVDSODQNHHVDQþLDPHWHQ
SDW Lã NXU ³NUDXQDPDV SURJUDPRV NRGDV ,ãQDJULQ¡NLWH NRG LU SDUHQNLWH VNDLWRP
GXRPHQÐ ULQNPHQ SDJDO NRGH UHLNDODXMDPDV VSHFLILNDFLMDV 3DOHLVNLWH SURJUDP
3DSLOG\NLWHSURJUDPLãYHVWLPL³SXOW3DO\JLQNLWHVDYRSURJUDPVXSURJUDPD
// Example for data input from file on the directory of

// code location
//
//<applet code = ReadingFile width = 500 height = 500>
//</applet>
//
import java.awt.*;
import java.net.*; // for class URL
import java.io.*; // for all input classes
public class ReadingFile extends JApplet {

JTextField tf = new JTextField( "inputFile.java",20 );
public class ReadData implements ActionListener{
try{
URL url = new URL( getCodeBase( ), tf.getText( ) ); // location,
ta.setText( url + "\n" ); // added to text area
InputStream is = url.openStream( ); // input stream
BufferedReader in = new BufferedReader( new InputStreamReader( is ) );
String line;
while( (line=in.readLine() ) != null )
ta.append( line + "\n" );
} catch( Exception e) {
ta.append( e.toString( ) );
}
}
}
public class DeleteData implements ActionListener{
ta.setText( "" );
}
}
b1.addActionListener( new ReadData( ) );
b2.addActionListener( new DeleteData( ) );
c.add( new JScrollPane( ta ) );
164
c.add( b1 );
c.add( tf );
c.add( b2 );
}
}
165
21 programa
20SURJUDPDSDSLOG\WDLãYHVWLPL³SXOW
// Example for data input from file on the directory of

// code location. Printing to the client console
//
//<applet code = RWFile width = 500 height = 500>
//</applet>
//
import java.awt.*;
import java.net.*; // for class URL
import java.io.*; // for all input classes
public class RWFile extends JApplet {

b2 = new JButton( "Delete data" ),
b3 = new JButton( "Print data" );
JTextField tf = new JTextField( "inputFile.java",20 );
String s = "";
public class ReadData implements ActionListener{

try{
URL url = new URL( getCodeBase( ), tf.getText( ) ); // location,
ta.setText( url + "\n" ); // added to text area
InputStream is = url.openStream( ); // input stream
BufferedReader in = new BufferedReader( new InputStreamReader( is ) );
String line;
while( (line=in.readLine( ) ) != null ){
ta.append( line + "\n" );
s += line + "\n";
}
} catch( Exception e) {
ta.append( e.toString( ) );
}
}
}
public class DeleteData implements ActionListener{

ta.setText( "" );
s = "";
}
}
public class PrintData implements ActionListener{
166
PrintWriter out = new PrintWriter( System.out, true );
out.println( s );
}
}

b1.addActionListener( new ReadData( ) );
b2.addActionListener( new DeleteData( ) );
b3.addActionListener( new PrintData( ) );
c.add( new JScrollPane( ta ) );
c.add( b1 );
c.add( tf );
c.add( b2 );
c.add( b3 );
}
}
167
22 programa
Programa, nustatanti klaseLSULHLQDPÐPHWRGÐLUNRQVWUXNWRULÐVUDã3DNHWR

vardas metodams ir konstruktoriams iš java.lang SDNHWR ³ VUDãXV QHSHUGXRGDPDV
3DEDQG\NLWHSDQDLNLQWLSDNHWRYDUGNODV¡VStringTokenizer metodais. Panaikinkite ne
tik java.langEHWLUYLVÐNLWÐSDNHWÐYardus.
//
// Utility: list of methods for the indicated class
// [ possessing indicated substring ]
// to the screen and
// to the file "List.out" in the same directory
//
import java.lang.reflect.*; //for class Class

import java.io.*;
public class ML{
static final String usage =

"Use: java ML packageName.ClassName or\n"+
" java ML packageName.ClassName subnameOfMethod";
static String [ ] ls; //array for the list
static int count = 0; //counts the methods found
static String removeName( String s ) { //removes "java.lang." from

int sl = s.length( ); //the name of method
int first = s.indexOf( "java.lang." ); //see class String
if( first == -1 ) return s;
int last = first + 10;
return removeName(
s.substring( 0,first ) + s.substring( last,sl ) ); //see class String
}
public static void main( String args[ ]){

if( args.length < 1 ) {
System.out.println( usage );
System.exit( 1 ); //erroneous exit; see class System
}
try {
Class c = Class.forName( args[ 0 ] );
Method [ ] m = c.getMethods( ); //see class Class
Constructor [ ] cr = c.getConstructors( ); //same
ls = new String[ m.length+cr.length ];
if( args.length == 1 ) { //ie, full list of methods and constructors

for ( int i = 0; i < m.length; i++ ) //for class given in args[0]
ls[ count++ ] = "method "+ removeName( m[ i ].toString( ) );
for ( int i = 0; i < cr.length; i++ )
ls[ count++ ]= "constructor "+ removeName( cr[ i ].toString( ) );
168
}else { //ie, length==2; list of methods containing substring given
count = 0; //in args[1]
for ( int i = 0; i < m.length; i++ ) {
String ms = m[ i ].toString( );
if( ms.indexOf( args[ 1 ] )!= -1 )
ls[ count++ ]= "method "+ removeName( ms );
}
for ( int i = 0; i < cr.length; i++ ) {
String ms = cr[ i ].toString( );
if( ms.indexOf( args[ 1 ] )!= -1 )
ls[ count++ ]= "constructor "+ removeName( ms );
}
}
} catch( ClassNotFoundException e ) {
System.err.println( "Class "+e+" does not exist" ); //errors to the screen
}
try{ //output to the screen and file
PrintWriter out = new PrintWriter( new BufferedWriter( new FileWriter(
"List.out" ))),
con = new PrintWriter( System.out, true ); //true: empty
for( int i=0; i<count; i++) { //the buffer
out.println( i + " " + ls[ i ] );
con.println( i + " " + ls[ i ] );
}
out.close( );
System.err.println( e.toString( ) ); //errors to the screen
}
}
}
169
23 programa
.OLHQWLQ¡ SURJUDPD .DL NXULH NLWL Swing HOHPHQWDL OHQWHO¡ SDQHOLV

3HUGDU\NLWHSURJUDPNDGOHQWHO¡VSDYLGDOQXVWDW\WÐÄOHQWHO¡VPRGHOLV³
/*Applet with some new components:

JTable, JPanel, tool-tip.
Input file located on the same directory as code:
collection of lines, each of 3 String-type
elements divided by space. Later on first two elements
of each line are put to the array1 while the third one to array2.
array1 makes the model for the table; array2 plays role of
explanatory text.
Name of file may be supplied in the text field.
All the error stream is put to the text area. */
//<applet code = Table width =500 height=550>

//</applet>
import java.awt.*;
import java.net.*;
import java.io.*;
public class Table extends JApplet{

colHeads[ ] = { "Number","Name" };
JTextField tf = new JTextField( "Input.txt",20 );
return tip;
}
};

try{
String line = "";
170
int count = 0;
while( ( line=in.readLine( ))! = null ){
array2[ count ] = line.substring( line.lastIndexOf(" ")+1,line.length( ) );
array1[ count ][ 0 ] = line.substring( 0, line.indexOf(" ") );
array1[ count ][ 1 ] = line.substring( line.indexOf(" ")+1,
line.lastIndexOf(" ") );
count++;
}
ta.append( "Dimensions of table only until 20 rows allowed" );
ta.append( "Error reading data: "+ e );
}
repaint( );
}
}

for( int i=0; i<20; i++ ){
array1[i][0] = "";
array1[i][1] = "";
array2[i] = "";
}
repaint( );
}
}

Container c = getContentPane();
JScrollPane spt = new JScrollPane( table );
p1.add( tf );
p1.add( b1 );
p1.add( b2 );
JScrollPane spta = new JScrollPane( ta );
p2.add( spta );
c.add( spt,BorderLayout.NORTH );
c.add( p1,BorderLayout.CENTER );
}
}
171
24 programa
SURJUDPDVXVSDXVGLQLPRJDOLP\E¡PLV
//
//<applet code = Tabpr width =600 height=500>
//</applet>
import java.awt.*;
import java.net.*;
import java.io.*;
import java.awt.print.*;
import javax.swing.table.*;
public class Tabpr extends JApplet{

colHeads[ ] = { "Number","Name" };
b2 = new JButton( "Delete data" ),
b3 = new JButton( "Print data" );
JTextField tf = new JTextField( "Input.txt",20 );
return tip;
}
};

try{
String line = "";
int count = 0;
while( (line = in.readLine( ))! = null ){
array2[ count ] = line.substring( line.lastIndexOf(" ")+1,line.length( ) );
array1[ count ] [ 0 ] = line.substring( 0, line.indexOf(" ") );
array1[ count ][ 1 ] = line.substring( line.indexOf(" ") + 1,
line.lastIndexOf(" ") );
count++;
}
172
System.err.println( "Dimensions of table only until 20 rows allowed" );
System.err.println( "Error reading data: " + e );
}
repaint();
}
}

for( int i=0; i<20; i++ ){
array1[ i ][ 0 ] = "";
array1[ i ][ 1 ] = "";
array2[ i ] = "";
}
repaint( );
}
}
class PrintingData implements ActionListener, Printable{

public void actionPerformed( ActionEvent ae ) {
PrinterJob printJob = PrinterJob.getPrinterJob( );
printJob.setPrintable( this );
if ( printJob.printDialog( ) ) {
try {
printJob.print( );
} catch ( Exception e ) {
System.err.println( "Error printing data: " + e );
}
}
}
public int print( Graphics g, PageFormat pf, int pi )
throws PrinterException {
Graphics2D g2 = ( Graphics2D )g;
table.paint( g2 );
return Printable.PAGE_EXISTS;
}
}

b3.addActionListener( new PrintingData( ) );
173
JScrollPane sp = new JScrollPane( table );
JPanel p = new JPanel( );
p.setLayout( new FlowLayout( ) );
p.add( tf );
p.add( b1 );
p.add( b2 );
p.add( b3 );
c.add( sp,BorderLayout.NORTH );
c.add( p,BorderLayout.SOUTH );
}
}
174
25 programa
.OLHQWLQ¡ SURJUDPD -XGDQWL DQWUDãW¡ DWVNLUDPH QXR SURJUDPRV SDJULQGLQLR

Y\NG\PR VUDXWR VUDXWH 3HUUDã\NLWH SURJUDP QDXGRGDPL DOWHUQDW\YL VUDXWR
UHDOL]DYLPRVLQWDNV

//Applet with moving banner

//
//<applet code = Banner width =500 height=100>
//</applet>
import java.awt.*;
public class Banner extends JApplet{

JButton b1 = new JButton( "Start moving" ),
b2 = new JButton( "Stop moving" );
MovingBanner mb;
class MovingBanner implements Runnable{
String message = " A simple moving banner ";

Thread t;
volatile boolean moving;

moving = true;
t.start( );
}

moving = false;
}
public void run( ){

char c;
while( moving ){
try{
repaint( );
c = message.charAt( 0 );
message = message.substring( 1, message.length( ) );
message += c;
tf.setText( message );
175
}
}
}

mb = new MovingBanner( );
mb.start( );
}
});
mb.stop( );
}
});
c.add( tf );
c.add( b1 );
c.add( b2 );
}
176
26 programa
(LO¡ 3URJUDPD VX VUDXWÐ VLQFKURQL]DYLPX ,ãMXQNLWH VUDXWÐ VLQFKURQL]DFLM

SDEDQG\NLWH ³YDLULDV SDX]HV LU ³VLWLNLQNLWH NDG HLOHL UHDOL]XRWL VLQFKURQL]DYLPDV \UD
EÌWLQDV
//Model of queue Q: Producer produces number n, Consumer takes it

//Synchronization. Inter-thread collaboration
//
class Q{
int n;
boolean go = false;
synchronized int get( ){
if( !go )
try{
wait( );
System.out.println( "Got: "+ n );
go = false;
notify( );
return n;
}
synchronized void put( int n ){
if( go )
try{
wait( );
this.n = n;
System.out.println( "Put: "+ n );
go = true;
notify( );
}
}
class Producer implements Runnable{

Q q;
Producer( Q q ){
this.q = q;
new Thread( this,"Producer" ).start( );
}
public void run( ){
int i = 0;
while( true ){
q.put( i++ );
try{
}
}
}
177
class Consumer implements Runnable{
Q q;
Consumer( Q q ){
this.q = q;
new Thread( this,"Consumer" ).start( );
}
public void run( ){
while( true ) q.get( );
}
}
class InfiniteQueue{
public static void main( String [ ] args ){
System.out.println( "Ctrl-C for finish" );
Q q = new Q( );
new Producer( q );
new Consumer( q );
}
}
178
27 programa
.OLHQWLQ¡SURJUDPDSDOHLGåLDQWLQRULPNLHN³QHSULNODXVRPÐY\NG\PRVUDXWÐ
3HUWYDUN\NLWH SURJUDP NDG YLHQDPH VUDXWH EÌWÐ YDOGRPRV NHOLÐ ODXNHOLÐ VSDOYRV
3DåLÌU¡NLWHNLHNVUDXWÐSDM¡JLDSDOHLVWLMÌVÐNRPSLXWHULV
3DNHLVNLWHNOLHQWLQ
SURJUDPWDLSNDGYLHQXPHWXEÌWÐNHLþLDPDVSDOYDYLVRV
HLOXW¡VODXNHOLDPV
//Blinking random-colored boxes. <grid*grid> boxes in all.

//Blinking rate: <pause>, in milisec.
//Applet launches individual thread for each box.
//Applet illustrates the efficiency of multitasking.
//
//<applet code = MThreads width = 500 height = 500>
//</applet>
//
import java.awt.*;
class Box extends JPanel implements Runnable{ //separate colored box.

private Thread t; //Rendered in separate thread
private int pause;
boolean running = true;
private Color clr = gettingColor( );
private Color gettingColor( ){ //random color for the box

int red = ( int ) ( Math.random( ) * 255 ),
green = ( int ) ( Math.random( ) * 255 ),
blue = ( int ) ( Math.random( ) * 255 );
return new Color( red,green,blue ); //one of Color’s constructors
}
public void paintComponent( Graphics g ){ //painting the colored box

super.paintComponent( g );
g.setColor( clr );
Dimension d = getSize( ); //class has two fields: “width, height”
g.fillRect( 0,0,d.width-1,d.height-1 );
}
public Box( int pause ){

this.pause = pause;
t.start( );
}
public void run( ){

while( running ){ //will be stopped by closing frame-window for all boxes
clr = gettingColor( ); //re-coloring the box
179
repaint( );
try{
t.sleep( pause ); //<pause> milisec
}
}
}
class Boxes extends JFrame{ //panel for <grid*grid> boxes

int grid, pause;
public Boxes( int grid, int pause ){
this.grid = grid;
this.pause = pause;
setSize( 300,300 );
Container cf = getContentPane( );
cf.setLayout( new GridLayout( grid,grid ) );
for( int i=0; i<grid*grid; i++ )
cf.add( new Box( pause ) );
addWindowListener( new WindowAdapter( ){
public void windowClosing( WindowEvent we ) {
dispose( ); //response to the frame-window buttons: close the window
}
});
}
}
public class MThreads extends JApplet{ //monitor program

private int grid = 5;
private int pause = 100;
JLabel l1 = new JLabel( "Enter number of rows and columns" ),
l2 = new JLabel( "Enter delay time (milisec)" ),
l3 = new JLabel( "Messages" );
JTextField t1 = new JTextField( 10 ),
t2 = new JTextField( 10 );
JButton b1 = new JButton( "Start" ),
b2 = new JButton( "Re-enter" );
JFrame boxes;

JPanel p11 = new JPanel( ),
p12 = new JPanel( );
p11.setLayout( new GridLayout( 3,3 ) );
ta.setText("");
180
try{
grid = Integer.parseInt( s );
ta.append( "Erroneous input for number of rows."+
" Re-enter or use default: 5 \n" );
grid = 5;
}
if( grid<1 ) {
ta.append( "Erroneous input for number of rows \n"+
"Using default: 5 \n" );
grid = 5;
}
ta.append( "Entered: number of rows "+grid+"\n" );
}
});
ta.setText("");
try{
pause = Integer.parseInt( s );
ta.append( "Erroneous input for pause."+
" Re-enter or use default: 100 milisec \n" );
pause = 100;
}
if( pause<1 ) {
ta.append( "Erroneous input for pause \n"+
"Using default: 100 milisec \n" );
pause = 100;
}
ta.append( "Entered: pause (milisec) "+pause+"\n" );
}
});
p11.add( l1 ); p11.add( t1 ); p11.add( l2 ); p11.add( t2 );
p11.add( l3 ); p11.add( ta );

boxes = new Boxes( grid,pause );
boxes.setVisible( true );
}
});
t1.setText( "" );
t2.setText( "" );
ta.setText( "" );
boxes.dispose( );
181
repaint( );
}
});
p12.add( b1 );
p12.add( b2 );
c.add( p11,BorderLayout.NORTH );
}
}
182
28 programa
.OLHQWLQ¡SURJUDPDLOLXVWUXRMDQWLSULRULWHWÐ³WDNY\NGDQWVUDXWXV3DEDQG\NLWH
³YDLULXVSULRULWHWXV³YDLULDPVNDLWLNOLÐDXJLQLPRODLNXLWLNDtsiminkite, kad skaitiklio
formatas – int).
//Creating threads with different priorities

//in applet context
//Multiply re-evaluation of counters enabled.
//
//<applet code = Threads4 width =600 height=550>
//</applet>
import java.awt.*;
class Counter implements Runnable{
int count;
Thread t;
volatile boolean running;
public Counter( int priority ){
count = 0;
t.setPriority( priority );
}
public void run( ){

}

running = true;
t.start( );
}

running = false;
}
public class Threads4 extends JApplet{
Counter c1,c2;
JButton b1 = new JButton( "Start threads" ),
b2 = new JButton( "Stop threads " );
183

Thread.currentThread().setPriority( Thread.MAX_PRIORITY );
c1 = new Counter( Thread.NORM_PRIORITY+2 );
c2 = new Counter( Thread.NORM_PRIORITY-2 );
c1.start( );
c2.start( );
ta.append(" Threads started \n" );
}
});
c1.stop( );
c2.stop( );
ta.append( "Low-priority counter: "+c2.count+"\n" );
ta.append( "High-priority counter: "+c1.count+"\n" );
}
});
try{
c.add( b1 );
c.add( b2 );
c.add( ta );
}
}
184
29–30 programos
6HUYHULRLUNOLHQWRSURJUDPRV6HUYHULVDSWDUQDXMDWLNYLHQNOLHQW3DOHLVNLWH
SURJUDPÐÌN³
//The simplest server: getting messages from

//client and printing them
//
import java.io.*;
import java.net.*;
public class SimpleServer{

System.out.println( "Launched: "+ss );
try{
Socket s = ss.accept(); //waiting for connection
try{
System.out.println( "Connection got: "+s );
new BufferedWriter(
while( true ){ //server will be closed after
String str = in.readLine( ); //client's message "END"
System.out.println( "Got from client: "+str );
out.println( str );
}
System.out.println( "Disconnecting client" );
s.close( );
}
System.out.println( "Closing server" );
ss.close( );
}
}
}
185
//The simplest client: sending messages to
//server and getting messages from server
//
import java.io.*;
import java.net.*;
public class SimpleClient{

InetAddress ia = InetAddress.getByName( null ); //ie, server on the
//same machine
System.out.println( "Address of server: "+ia );
Socket s = new Socket( ia,SimpleServer.PORT ); //code "SimpleServer must
//be in the same package
System.out.println( "Launched socket: "+s );
try{
new BufferedWriter(
for( int i=0; i<10; i++ ){
String msg = "Client's message "+i;
out.println( msg );
System.out.println( "Sent to server: "+msg );
System.out.println( "Got from server: "+str );
}
out.println( "END" ); //"END" appointed for the finish
} finally{
System.out.println( "Closing client" );
s.close( );
}
}
}
186
31–32 programos
Serverio ir kliento programos. Serveris aptarnauja kelis klientus. Kiekvienas

klientas aptarnaujamas atskirame vykdymo sraute.
Pakeiskite programas taip, NDG VHUYHULV J\YXRWÐ QH DPåLQDL R WLN WDP WLNU
ODLNDUEDLãVLMXQJWÐDSWDUQDY
VQXURG\WNLHN³NOLHQWÐ
//The simplest multi-client server: getting messages from

//clients and printing them
//One server-thread for one client
//
import java.io.*;
import java.net.*;
class ServeOneClient extends Thread{

private Socket s;
private int id = counter++;
public ServeOneClient( Socket s ) throws IOException{
this.s = s;
new BufferedWriter(
start( );
}
public void run( ){
try{
while( true ){
System.out.println( "Got from client: "+str );
out.println( str );
}
System.err.println( "I/O error" );
} finally{
try{
System.out.println( "Disconnecting client "+id );
s.close( );
System.err.println( "Error while closing socket" );
}
}
187
}
}
public class SimpleMultiServer{

System.out.println( "\n Press Ctrl/C for termination \n" );
System.out.println( "Launched: "+ss );
try{
while( true ){ //endless loop!
try{
new ServeOneClient( s );
s.close( );
}
}
} finally{
ss.close( );
}
}
}
188
//Code generates simplest clients: sending messages to
//server and getting messages from server.
//Until MAX_CLIENTS clients may exist simultaneously.
//One thread for one client
//
//Results of code depend exclusively on the period
//pause. Experiment on it!
//
import java.io.*;
import java.net.*;
class OneClient extends Thread{

private Socket s;
private int id = counter++; //ID-number of client
private static int threadCount = 0; //number of "living" clients
public static int threadCounting( ){
return threadCount;
}
public OneClient( InetAddress ia,int PORT ){
System.out.println( "Creating client No "+id );
threadCount++; //count in this client
try{
s = new Socket( ia,PORT );
System.err.println( "Error while creating socket No " + id );
}
try{
new BufferedWriter(
start( );
try{
s.close( );
System.err.println( "Unable to close socket No "+id );
}
}
}
public void run( ){
try{
for( int i=0; i<10; i++ ){
189
String msg = "Client's No "+id+" message "+i;
out.println( msg );
System.out.println( "Sent to server: "+msg );
System.out.println( "Got from server: "+str );
}
out.println( "END" );
System.out.println( "I/O error" );
} finally{
try{
s.close( );
System.out.println( "Disconnecting socket No "+id );
System.out.println( "Unable to close socket No "+id );
}
threadCount- -; //client is closed; decrease the number of clients
}
}
}
public class SimpleMultiClient{

static final int MAX_CLIENTS = 3;
public static void main( String args[ ] ) throws IOException, InterruptedException{
InetAddress ia = InetAddress.getByName( null );
System.out.println( "Address of server: "+ia );
for( int i=0; i<20; i++ ){
if( OneClient.threadCounting() < MAX_CLIENTS )
new OneClient( ia,SimpleMultiServer.PORT );
Thread.currentThread().sleep( 1 );
}
}
}
190
5LPDQWDV%HOHYLþLXV
JAVA TECHNOLOGIJOS
Mokomoji knyga
5HGDNWRU¡/DLPD.HUWHQLHQ¡
24,0 apsk. leid. l.

Leido Vilniaus Gedimino technikos universiteto leidykla „Technika“
6DXO¡WHNLRDO/7-10223 Vilnius-40

Java Technologijos

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Java Technologijos

Uploaded by

Copyright:

Available Formats

VILNIAUS TECHNIKOS UNIVERSITETAS

/HLGLQ\MHQDJULQ¡MDPDJava programavimo kalba ir jos technologijos. Trumpai

ISBN 9986-05-859-0 5%HOHYLþLXV

Java technologijos konspekte aiškinamos remiantis programavimo kalba Java

Java – šiuo metu, matyt, pati populiariausia programavimo kalba. Ja galima

Trumpa Java istorija

1991 m. Sun Microsystems SUDG¡MR SURMHNW Green VNLUW EXLWLQ¡MH

1. Java – objektiškai orientuota kalba. Visi Java programos duomenys yra

Java programavimo instrumentai

KompiOLDWRULÐ LQWHUSUHWDWRULÐ Java ED]LQHV NODVHV NOLHQWLQLÐ SURJUDPÐ

âLDPH VN\ULXMH SDWHLNLDPD HOHPHQWDULÐ åLQLÐ DSLH SURJUDPDYLP Java, kad

1.1. Kalbos konstrukcijos

Kalbos konstrukcijos sudaroPRVLãOHNVHPÐ–VLPEROLÐJUXSLÐWXULQþLÐ

Java – „gryna“ objektiškai orientuoto programavimo (OOP) kalba. Pagrindinis

String s = “abc”; – šiam vidiniam Java GXRPHQÐ WLSXL

1.3. Primityvieji duomenys

Java WXULWRNLXVSULPLW\YLXRVLXVGXRPHQÐWLSXV SDYDGLQLPDVGXRPHQVLOJLV

Loginiai boolean 1B Boolean

Simboliniai char 2B Unicode simboliai Character

Aritmetiniai: kitimo diapazonas

boolean JDOLPRVUHLNãP¡Vtrue arba false

Java turi klases BigInteger ir BigDecimal su metodais, skirtais operuoti bet

Matomumo sritis objektams:

{ String s = new String( “abc” ); }

[modifikatorius ]class AclassName { NODV¡VNÌQDV }

.ODV¡VREMHNWDVSDY\]GåLXLYDUGXÄc“, sukuriamas metodu-konstruktoriumi:

AClassName c = new AClassName( );

>PRGLILNDWRULÐ VUDãDV@ JUåLQDPRV UHLNãP¡V WLSDV_void YDUGDV >DUJXPHQWÐ

Dabar sf1.i ir sf2.iWXULWRNLSDWUHLNãP

<UDDULWPHWLQLÐYHLNVPÐRSHUDWRULDL+, – ,* , /, % (dalybos likutis).

3ULHDXJLRLUPDåLQLPRYHLNVPÐRSHUDWRULDL++, – –. Abiem operatoriams yra

6DQW\NLRYHLNVPÐRSHUDWRULDL= =, !=, >, <, >=, <=.

Visi veiksmai atliHNDPL SDJDO YHLNVPÐ Y\UHVQXPR WYDUN 7DþLDX SDWRJLDX

Tam naudojamas metodas println( ):

System.out.println( “Row Number” ); // arba

Yra ir analogiškas metodas print( ),QHODXåLDQWLVHLOXþLÐ

6SHFLDOLHML VLPEROLDL LãYHVW\MH SDY\]GåLXL QDXMRV HLOXW¡V simbolio \n

System.out.println( “First row \n Second row” ); /* spausdins:

Analogiškai veikia ir kiti specialieji simboliai, esantys String tipo literaluose

âLSURJUDPD³SXOWRHNUDQLãYHGDWHNVW³The first application”.

Programos paleidimo etapai:

6XNRPSLOLXRWD ULQNPHQD DLãNX MHL WLN WHNVWH QHEXYR VLQWDNV¡V NODLGÐ

/\JLDLWSDW³DWOLHNDQþLRVNOLHQWLQ¡VSURJUDPRV DQJOapplet) pavyzdys:

+70/ NDOED QHVNLULD GLGåLÐMÐ LU PDåÐMÐ UDLGåLÐ QHNUHLSLD G¡PHVLR ³

<UD VSHFLDOXV ³UDQNLV NOLHQWLQ¡PV SURJUDPRPV WHVWXRWL appletviewer,

//<APPLET CODE = FirstApplet WIDTH=100 HEIGHT=100>

3DVWDERV .OLHQWLQ¡V SURJUDPRV J\YDYLPXL SDODLN\WL EÌWLQRV Java NODV¡V

JavaVO\JRVRSHUDWRULDL– lygiai tokie pat, kaip kitose kalbose:

2SHUDWRULDXVUHLãNLQLRUHLNãP¡WXULEÌWLWLNbyte, char, short arba intWLSR2SHUDWRULÐ

reiškinys1 VXWHLNLD SUDGLQ

for cikluose galima naudoti opHUDWRULÐ-NDEOHO³3DY\]GåLXL

2.4. Metodas-konstruktorius. Konstruktoriaus ir metodo

Metodas-konstruktRULXV JDUDQWXRMD NLHNYLHQR SURJUDPRV REMHNWR SUDGLQ¡V

Dabar new AClass( );NYLHþLDNRQVWUXNWRULÐLãVNLULDDWPLQW³REMektui –NODV¡V

public class PrimitiveOverloading{

void m1(char x){ prt("m1(char)"); }

void m2(byte x){ prt("m2(byte)"); }

void m3(short x){ prt("m3(short)"); }

void m4(int x){ prt("m4(int)"); }

void m5(long x){ prt("m5(long)");}

void m6(float x){ prt("m6(float)"); }

void m7(double x){ prt("m7(double)"); }

public static void main(String args[]){

ISBN 9986-05-859-0 5%HOHYLþLXV

1991 m. Sun Microsystems SUDG¡MR SURMHNW Green VNLUW EXLWLQ¡MH

KompiOLDWRULÐ LQWHUSUHWDWRULÐ Java ED]LQHV NODVHV NOLHQWLQLÐ SURJUDPÐ

âLDPH VN\ULXMH SDWHLNLDPD HOHPHQWDULÐ åLQLÐ DSLH SURJUDPDYLP Java, kad

Kalbos konstrukcijos sudaroPRVLãOHNVHPÐ–VLPEROLÐJUXSLÐWXULQþLÐ

Java WXULWRNLXVSULPLW\YLXRVLXVGXRPHQÐWLSXVSDYDGLQLPDVGXRPHQVLOJLV

[modifikatorius ]class AclassName { NODV¡VNÌQDV }

.ODV¡VREMHNWDVSDY\]GåLXLYDUGXÄc“, sukuriamas metodu-konstruktoriumi:

>PRGLILNDWRULÐ VUDãDV@ JUåLQDPRV UHLNãP¡V WLSDV_void YDUGDV >DUJXPHQWÐ

Dabar sf1.i ir sf2.iWXULWRNLSDWUHLNãP

<UDDULWPHWLQLÐYHLNVPÐRSHUDWRULDL+, – ,* , /, % (dalybos likutis).

3ULHDXJLRLUPDåLQLPRYHLNVPÐRSHUDWRULDL++, – –. Abiem operatoriams yra

6DQW\NLRYHLNVPÐRSHUDWRULDL= =, !=, >, <, >=, <=.

Visi veiksmai atliHNDPL SDJDO YHLNVPÐ Y\UHVQXPR WYDUN 7DþLDX SDWRJLDX

Yra ir analogiškas metodas print( ),QHODXåLDQWLVHLOXþLÐ

6SHFLDOLHML VLPEROLDL LãYHVW\MH SDY\]GåLXL QDXMRV HLOXW¡V simbolio \n

âLSURJUDPD³SXOWRHNUDQLãYHGDWHNVW³The first application”.

6XNRPSLOLXRWD ULQNPHQD DLãNX MHL WLN WHNVWH QHEXYR VLQWDNV¡V NODLGÐ

/\JLDLWSDW³DWOLHNDQþLRVNOLHQWLQ¡VSURJUDPRVDQJOapplet) pavyzdys:

+70/ NDOED QHVNLULD GLGåLÐMÐ LU PDåÐMÐ UDLGåLÐ QHNUHLSLD G¡PHVLR ³

3DVWDERV .OLHQWLQ¡V SURJUDPRV J\YDYLPXL SDODLN\WL EÌWLQRV Java NODV¡V

JavaVO\JRVRSHUDWRULDL– lygiai tokie pat, kaip kitose kalbose:

2SHUDWRULDXVUHLãNLQLRUHLNãP¡WXULEÌWLWLNbyte, char, short arba intWLSR2SHUDWRULÐ

for cikluose galima naudoti opHUDWRULÐ-NDEOHO³3DY\]GåLXL

Dabar new AClass( );NYLHþLDNRQVWUXNWRULÐLãVNLULDDWPLQW³REMektui –NODV¡V

âLRV SURJUDPRV VSDXVGLQLPDL DNLYDL]GåLDL URGR NXULV PHWRGDV SDVLUHQNDPDV

,U SDVNXWLQ¡ SDVWDED DSLH PHWRGÐ-NRQVWUXNWRUÐ SHUNURYLP 0HWRGDV-

3ULPHQDPH NODVLÐ NLQWDPLHVLHPV DXWRPDWLãNDL VNLULDPRV QXOLQ¡V UHLNãP¡V

Statiniams laukams SUDGLQ¡VUHLNãP¡VVNLULDPRVWLNWDGDNDLSURJUDPDVXNXULD

.LHNYLHQDV GYLPDþLR PDV\YR HOHPHQWDV m4[ i ] \UD YLHQPDWLV PDV\YDV ³ ã³

3DNHWDL YLVÐ SLUPD VNLUWL VXWYDUN\WLJava ULQNPHQÐ VLVWHPDL SDQDXGRMDQW 26

ýLD WDãNDV UHLãNLD GDUELQ³ DSODQN $UFK\YLQ¡PV ULQNPHQRPs, kaip matyti iš

bus galimaQDXGRWLWUXPSM³NODV¡VYDUGAClass. Beje, importuojamos tik viešosios

Klasei galimas tik modifikatorius public ir prieiWLV SDJDO QXW\O¡MLP friendly.

.DG EÌWÐ JUHLþLDX UDãRPDV SURJUDPRV NRGDV NLHNYLHQD SURJUDPDYLPR NDOED

Tai svarbiausias paveldimumo asSHNWDVNXU³JDOLPDLãUHLNãWLWHLJLQLXÄãLQDXMD

5DNWDåRGLV final YLVDGD UHLãNLD NDåN QHNLQWDQþLR 7DLNRPDV NODV¡PV

²SUDVWDSDVWRYÐGXRPHQ³YLVDLNODVHLVNHOEWLWDLSNDLSODXNXLI3. Tokio lauko

Polimorfizmas – vienas iš pagriQGLQLÐREMHNWLQLRSURJUDPDYLPRSULQFLSÐ'DU

7DLJL NYLHþLDQW PHWRG tune, ignoruojamas tikslus argumento tipas. Atrodo,

7DþLDX GDEDU SOHþLDQW SURJUDP QDXMDLV LQVWUXPHQWÐ WLSDLV Brass, Horn, …,

Pranešimas c[1].m3( ); NODLGLQJDVQHVPDV\YDVSDVNHOEWDVVXSHUNODV¡VWLSR

2.11 skyriaus paskutiniame pavyzd\MH NODV¡V Shape PHWRGDL EXYR ILNW\YÌV

Dabar programoje LãVN\ULDXVNODV

8åUDãDV ec.makeInnerClass1( ) URGR NDG YLGLQLÐ NODVLÐ REMHNWDL JDli

âLDPH SDY\]G\MH YLGLQ¡V NODV¡V UHDOL]XRMD VVDMÐ NODVHV WRG¡O Y¡OLDX

ýLD NODV¡ E QDXGRMD NODVLÐ C ir D IXQNFLRQDOXP .DL C ir D \UD NODV¡V –

7DLJL SURJUDPRMH SHU¡PXV LãLPW³ DWOLHNDPDV WR catch operatoriaus, kurio

ArithmeticException yra ExceptionVXENODV¡WRG¡OYLVDGDEXVSHULPWDSLUPRML