Java w szkole

Autor: Jan Bielecki

Format B5, 400 stron, ISBN: 83-7197-188-5
Zawiera dyskietk
Data wydania: 10/1999
Cena ksiki: 39.00 z

Przesyka gratis! Odbiorca pokrywa jedynie koszty pobrania (2,70 z)

w przypadku przesyki za zaliczeniem pocztowym

Wydawnictwo Helion
ul. Chopina 6, 44-100 Gliwice, POLAND
telefon: (32) 230-98-63, 231-22-19
fax: (32) 230-98-63 w.10
mail: helion@helion.com.pl
Niniejsza ksika to zarwno podrcznik do nauki programowania aplikacji bazodanowych,
jak i kompendium wiedzy o bibliotece VCL w czci, ktra dotyczy baz danych.
Studiujc t ksik mona samodzielnie zbudowa wasne komponenty bazodanowe
do edycji danych. Czytelnik znajdzie w niej wiadomoci midzy innymi na temat: narzdzi
tworzenia baz danych (Database Desktop, SQL Explorer), moliwoci klasy TDataSet,
uycia klasy TTable, uywania komponentu klasy TDatabase, serwera SQL Interbase,
ktry jest dostarczany wraz z pakietem Delphi, komponentw TServerSocket oraz TClientSocket,
zaawansowanych technik obsugi zdalnych serwerw SQL, w szczeglnoci bazy Interbase.

Zobacz fragment ksiki

Spis treci
Jeeli znasz t ksik oce j
Aktualny cennik ksiek e-mailem
Ksiki i "3D" Online
Informacje o nowociach e-mailem
Zamw najnowszy katalog
Zobacz opis doczonego pliku

Helion 1999

2G$XWRUD
&RUD]F]
FLHMJava VWDMHVL
ulubionym M
]\NLHPSURJUDPRZDQLD0R*QDRF]HNLZD
*H MX*ZNUyWFHVWDQLHVL
 M
]\NLHP powszechnym NWyU\ MDNR MHG\Q\ E
G]LH QDXF]DQ\
w klasach LQIRUPDW\F]Q\FK6]NyUHGQLFKRUD]QDSLHUZV]\PURNX8F]HOQL:\*V]\FK
-X*REHFQLHQLHLVWQLHMHZ3ROVFHUczelnia Akademicka, w ktrej nie nauczano by Javy.
2GODWG]LHMHVL
WDNZ3ROVNR-DSRVNLHM:\*V]HM6]NROH7HFKQLN.RPSXWHURZ\FKw WarV]DZLHRUD]ZW\FKXF]HOQLDFKZ\*V]\FKNWyU\FKG\GDNW\F\Z]RUHPNROHJyZ]USA,
zadali sobie trud przestawienia z C, C++, Delphi i Pascala na -DY
.
0LPRLVWQLHQLDMX*SRQDG1500NVL*HNQDWHPDWJavyNLONXSU]HWXPDF]RQ\FKQDM
]\N
polski oraz 5 QDSLVDQ\FKSU]H]HPQLHZFL*VSRW\NDPVL
]XW\VNLZDQLDPL*HEUDNXMH
DWZHJRWHNVWXQDWHPDWJavy.
6XFKDF]HPRLFKZ\NDGyZDMHVWLFKND*GHJRURNXSRQDG300QLHPDMWHJRSURblePXERZV]\VWNRFRMHVWZPRLFKNVL*NDFKWUXGQHF]\QL
SURVW\PQDZ\NDG]LH%LRUF
MHGQDN SRG XZDJ
 SR]RVWD\FK D ]ZDV]F]D W\FK XF]QLyZV]Ny UHGQLFK, ktrzy pod
NLHUXQNLHP VZRLFK QDXF]\FLHOL FKFLHOLE\ SR]QD -DY
 jeszcze przed SRGM
FLHP VWX
GLyZZ\*V]\FKQDSLVDHPNVL*N
XSRGVWDZNWyUHMOH*\QDVW
SXMFHZQLRVNRZDQLH
-HOL Z GRW\FKF]DVRZ\P QDXF]DQLX SURJUDPRZDQLD QDMSLHUZ Z\NDGD
VL
C i C++, a dopiero po nLFK-DY
WRGODF]HJRQLHRJUDQLF]\VL
GR-DY\
DOHQDMSLHUZSRGDMZSRVWDFLSRGREQHMGR&DQDVW
SQLHZSRVWDFLSRdoEQHMGR&:WHQVSRVyEPR*QDFDNRZLFLH]UH]\JQRZD]& L&D-DY

Z\R*\MDNRMHG\Q\M
]\NSURJUDPRZDQLD
$E\ ]DGDQLH WR ]UHDOL]RZD RSUDFRZDHP %LEOLRWHN
, ktra osobom praktycznie
bez przygotowaniaXPR*OLZLDQDW\FKPLDVWRZHSLVDQLHSURJUDPyZZJavie. Ten liF]
cy ok. 4000 wierszy produkt, ktry w postaci skompresowanego pliku *.jar zajmuje
ok. 40 .%PR*HE\X*\W\ZGRZROQ\PURGRZLVNXXUXFKRPLHQLRZ\P3-generacji.
1DSRGVWDZLHPRLFKGRZLDGF]Hpolecam MHGQDNW\ONRGZDWDNLHURGRZLVNDEH]SDtny
tandem Kawa 3.22 Java 2 PaltformRUD] NRV]WXMF\ Z ZHUVML HGXNDF\MQHM RN $100
kompilator JBuilder 3.0.
)\F]F&]\WHOQLNRPSR*\WHF]QHMLDWZHMOHNWXU\]SU]\MHPQRFLLQIRUPXM
*HZV]\
VWNLHRPDZLDQHZNVL*FHSURJUDP\(UyGRZHZUD]]ELEOLRWHN View.jarPR*QD]QD
OH(QDGRF]RQHMG\VNLHWFHRUD]ZVHUZHU]HWydawnictwa Helion.

prof. Jan Bielecki

3URJUDP\
Programowanie jest zapisywaniem F]\QQRFLprzewidzianych do wykonania przez komSXWHU=DSLVHPF]\QQRFLMHVWSURJUDP(UyGRZ\QDSU]\NDGQDSLVDQ\ZJavie. Program
(UyGRZ\ SRGGDMH VL
 kompilacji D QDVW
SQLH F]\ z podprogramami dostarczanymi
wraz z kompilatorem. Powstaje wwczas program wykonalny. Jego wykonanie powieU]D VL
 Maszynie Wirtualnej -HVW WR VSHFMDOQ\ SURJUDP NWyU\ LQWHUSUHWXMF LQVWUXNFMH
]DZDUWH Z SURJUDPLH Z\NRQDOQ\P UHDOL]XMH F]\QQRFL MDNLH Z\UD*RQR Z SURJUDPLH
(UyGRZ\P
: SURFHVLH WZRU]HQLD L LQWHUSUHWRZDQLD SURJUDPX VSHFMDOQ URO
 RGJU\ZDM 2 pliki:
Master.java ]DZLHUDMF\NODV
DSOHWRZoraz Project.html ]DZLHUDMF\opis apletu. PrzeJOGDUND ]DSR]QDMH VL
 ] RSLVHP DSOHWX WDNLP MDN SRGDQ\ Z WDEHOL Plik Project.html
i znajduje w nim:
1. 1D]Z
NODV\DSOHWRZHMcode).
2. 6]HURNRwidthLZ\VRNRheightSURVWRNWQHMUDPNLXGRVW
SQLRQHMSUR

JUDPRZLGRNRPXQLNRZDQLDVL
]X*\WNRZQLNLHP

7DEHOD
Plik Project.html
<applet code=Master.class
width=400 height=420>
</applet>
albo
<applet code=janb.java3.Master.class
width=400 height=420>
</applet>

1D]Z\0DVWHUL3URMHFWPRQD]DVWSLLQQ\PL1DOH\MHG\QLHSDPL
WDHMHOLQD]ZSXEOLF]QHMNODV\DSOHWRZHMMHVW1DPHWRGHILQLFMD
NODV\PXVLVL]QDMGRZDZSOLNX1DPHMDYD

6WUXNWXUDSURJUDPX
Program zapisany jako aplet Master]QDMGXMHVL
ZSOLNXMaster.java. Opis apletu znajGXMHVL
ZSOLNXProject.html3DUDPHWUDPLRSLVXV Master.class, 400 i 420. W dalV]\FKSU]\NDGDFKE
G]LHSRGDZDQDW\ONR]DZDUWRSOLNXMaster.java.

$SOHWPDSRVWDSU]HGVWDZLRQZWDEHOLStruktura apletu6NDGDVL
RQ]SROHFHLP
portu oraz z definicji klasy Master .ODVD WD VWDQRZL QDGEXGRZ
 QDG NODV ZLGRNX
(View). Napisy od pary znakw // (XNRQLN, XNRQLN GR NRFD ZLHUV]D ZF]QLH V
komentarzamiLMDNRWDNLHQLHPDM*DGQHJRZS\ZXQDSU]HELHJZ\NRQDQLDSURJUDPX
7DEHOD
Struktura apletu
package janb.java3;
import janb.view.*;

]DOHFDQHDOHQLHRERZL]NRZH

// tu jest miejsce na dodatkowe polecenia importu

public
class Master
extends View {
//********************************************************//
WXQDOH*\ZVWDZLZDVQHLQVWUXNFMHSURJUDPX
SRG*DGQ\PSR]RUHPQLHZVWDZLDMFIXQNFML
//
public void init()
//********************************************************//
}

GODGRFLHNOLZ\FK
1D]Z\ NODV PR*QD XSURFL GR identyfikatorw (np. Applet, Graphics albo Color).
$E\WRXPR*OLZLQDOH*\X*\SROHFHLPSRUWXQDSU]\NDG
import java.awt.Graphics;

albo
import java.awt.*;

']L
NLSROHFHQLX
import java.applet.Graphics;

QD]Z
NODV\java.awt.Graphics PR*QDXSURFLGRGraphicsDG]L
NLSROHFHQLX
import java.awt.*;

RGZRDQLDGRNODVSDNLHWXjava.awtNWyU\FKQD]Z\]DF]\QDMVL
RGjava.awtPR*QD
XSURFLGRLGHQW\ILNDWRUDNRF]FHJRWDNQD]Z
QSjava.awt.Graphics do Graphics).
$]DWHPGUXJLH]UR]SDWU]RQ\FKSROHFHLPSRUWXMHVWsilniejszeJG\*SLHUZV]H]QLHJR
wynika.

:LGRNLNODWND
W chwili odpalenia DSOHWX QD HNUDQLH SRMDZLD VL
 SURVWRNWQD ramka podzielona na
widok i NODWN
. Widok jest obszarem, w ktrym aplet przedstawia swoje wyniki, a klatka jest obszarem do wprowadzania danych:ND*GHMFKZLOLQDMHGHQ]W\FKREV]DUyZ
jest nastawiony celownik.
7X*SRUR]SRF]
FLXZ\NRQ\ZDQLDDSOHWXFHORZQLNMHVWQDVWDZLRQ\QDNODWN
. Objawia
VL
 WR Z\ZLHWOHQLHP Z QLHM karetki 1DFLQL
FLH NODZLV]D Enter gdy celownik jest
nastawiony na SXVW NODWN
 DOER NOLNQL
FLH Z REV]DU]H ZLGRNX SU]HQRVL FHORZQLN QD
widok,QQ\PVSRVREHPSU]HQLHVLHQLDFHORZQLNDQDZLGRNMHVWZ\ZRDQLHIXQNFMLrequestFocus.
void requestFocus()

Przenosi celownik na widok.

Na ekranie Widok i klatka SRND]DQRSRF]WNRZ\Z\JOGDSOHWX]FHORZQLNLHPQDstawioQ\PQDNODWN

(NUDQ
Widok i klatka

.ODVDZLGRNXMHVWGRVWDUF]RQDZF]FL%LEOLRWHND9LHZ=DSR]QDQLH
VL]MHMNRGHPMHVWSR\WHF]Q\PZLF]HQLHPNWUHJRZ\NRQDQLH]DOH
FDVLMHGQDNGRSLHURSRSU]HVWXGLRZDQLXFDHMNVLNL

1DMSURVWV]\DSOHW
0L
G]\ NRPHQWDU]DPL /* ... */ QDOH*\ ZVWDZL SURJUDP DSOHWX : QDMSURVWV]\P
przypadku jest to dowolny zestaw deklaracji pl i definicji funkcji, takich jak initView,
runView i drawViewZ\ZR\ZDQ\FK]NODV\ViewDOERZQ
WU]DDSOHWX
W initView XPLHV]F]DVL
F]\QQRFLLQLFMXMFH, a w drawViewF]\QQRFLregeneruM
ce ZLGRN'RGDWNRZRPR*QDX*\ZDIXQNFMLstartView, stopView i destroyView.
void initView()

:\ZR\ZDQDjednokrotnieEH]SRUHGQLRSRZ\ZLHWOHQLXDSOHWX
void drawView()

:\ZR\ZDQD wielokrotnie SR ND*G\P ]HZQ

WU]Q\P zniszczeniu widoku, spowodowaQ\PQDSU]\NDGSU]HMFLRZ\P]DVRQL
FLHPwidoku przez obce okno albo ikonizaFMRNQDSU]HJOGDUNL
void stopView()

:\ZR\ZDQDZyZF]DVJG\SU]HJOGDUNDSU]HVWDMHSRND]\ZDDSOHW
void startView()

:\ZR\ZDQD SU]HG ND*G\P SRND]DQLHP DSOHWX Z V]F]HJyOQRFL WX* SR Z\ZRDQLX

funkcji initView.
void destroyView()

:\ZR\ZDQDjednokrotnieWX*SU]HG]QLV]F]HQLHPDSOHWX
void runView()

:\ZR\ZDQD jednokrotnie EH]SRUHGQLR SR ]DNRF]HQLX Z\NRQ\ZDQLD IXQNFML initView1LH]DOHFDVL

MHMVWRVRZDMHGQRF]HQLH]drawViewJG\*MHVW]QLZ\NRQ\wana ZVSyELH*QLH D WR Z\PDJD XPLHM
WQHJR SRVXJLZDQLD VL
 synchronizowaniem
ZWNyZ
Pomocna w wyprowadzaniu rezultatu jest funkcja showResult. Jej argumentem jest dowolne Z\UD*HQLHDFXFKRZH.
void showResult(String result)
void showResult(int value)

:\SURZDG]DZDUWRresultSRFK\ORQLSRJUXELRQF]FLRQN30SXQNWRZZSRRZLH
Z\VRNRFLZLGRNX
void showResult(String result, int size)

:\SURZDG]DZDUWRresultSRJUXELRQF]FLRQNRUR]PLDU]HsizeZSRRZLHZ\VRNRFL
widoku.
&]FLRQNLSRQLHMSWVVDERZLGRF]QH

Na ekranie $E\ WUDG\FML VWDR VL

 ]DGR SRND]DQR DSOHW Z\ZLHWODMF\ QDSLV Hello
from JanB.

(NUDQ
Aby tradycji
VWDRVL
]DGR

import janb.view.*;
public
class Master
extends View {
// ****************************************************** //
public void drawView()
{
showResult("Hello from JanB");
}
// ****************************************************** //
}

'DQHZHMFLRZH
Aplet zazwyczaj oczekuje danychRGNWyU\FKX]DOH*QLDZ\NRQDQLHVZRLFKF]\QQRFL
'DQHVZSLV\ZDQHGRklatkiLZ\V\DQHGRDSOHWXSRQDFLQL
FLXNODZLV]DEnter. Powoduje to zainicjowanie parametru funkcji dataEntered GDQZSLVDQGRNODWNL
1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLHPozdrowienie z apletu, napisano w taki sposb,
*HMHOLGRNODWNLZSURZDG]LVL
LPL
X*\WNRZQLNDQS JanDQDVW
SQLHQDFLQLHNOD
wisz EnterWRQDSXOSLFLHZ\ZLHWOLVL
SR]GURZLHQLHWX Hello Jan).

(NUDQ
Pozdrowienie
z apletu

import janb.view.*;
public
class Master
extends View {
// ****************************************************** //
public void dataEntered(String data)
{
// wyprowadzenie pozdrowienia
showResult("Hello " + data);
}
// ****************************************************** //
}

.RPXQLNDW\
3U]HJOGDUNDGRGDWNRZRXGRVW
SLDSROHZNWyU\PPR*QDXPLHV]F]DNUyWNLHkomunikaty:SU]HJOGDUFHURGRZLVNDKawaSROHWRZ\VW
SXMHEH]SRUHGQLRSRGNODWNQDGDQH
void showMsg(String string)

Wyprowadza do pola komunikatw napis string.

1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLHPole komunikatwQDSLVDQRZWDNLVSRVyE*H
Z\ZLHWODSR]GURZLHQLHW\ONRZyZF]DVJG\ZNODWFHSRGDQRQDSLVliterowy. W przeciwnym razie informuje o niepoprawnej danej.

(NUDQ
Pole komunikatw

import janb.view.*;
public
class Master
extends View {
// ****************************************************** //
public void dataEntered(String data)
{
LILV$OSKDGDWDF]\GDQDVNDGDVL
]OLWHU
showResult("Hello " + data);
else {
showResult("? " + data);
showMsg(data + " is not a name");
}
}
// ****************************************************** //
}

'RVWDUF]DQLHGDQ\FK
'R UR]SR]QDZDQLD GDQ\FK GRVWDUF]RQ\FK Z NODWFH VX* IXQNFMH dataEntered -HOL
DSOHW]DZLHUDZL
FHMQL*MHGQWDNIXQNFM
WRZ\EyUIXQNFMLRGE\ZDVL
QDSRGVWDZLH
rodzaju argumentu: znaku (np. J), DFXFKD (np. JB) albo ]HVWDZX DFXFKyZ (np.
Jan Bielecki).
-HOL SR QDFLQLFLH NODZLV]D (QWHU DSOHW QLHSRGHMPLH SU]HWZRU]HQLD
GRVWDUF]RQ\FKGDQ\FKFRPRHZ\QLND]X\FLDIXQNFMLGDWD(QWHUHG
SU]\VWRVRZDQHM GR UR]SR]QDZDQLD SRMHG\QF]\FK DFXFKZ L GRVWDU

F]HQLD ZLFHM QL MHGQHJR DFXFKD QS-RKQQ\ :DONHU WR Z FHOX

SRLQIRUPRZDQLD H GDQH ]RVWD\ ]LJQRURZDQH UR]OHJQLH VL V\JQD
GZLNRZ\
void dataEntered(char data)

:\ZR\ZDQDSRND*G\PGRVWDUF]HQLXZNODWFHSRMHG\QF]HJRznaku8GRVW
SQLDZdata
kod znaku.
1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLHDane znakowe, rozpoznaje czy wprowadzona
GDQDMHVWPDOLWHUDOIDEHWXDQJLHOVNLHJR
(NUDQ
Dane znakowe

import janb.view.*;
public
class Master
extends View {
// ****************************************************** //
public void dataEntered(char data)
{
if(data >= 'a' && data <= 'z')
showResult("You entered small letter " + data);
else
showResult("You entered " + data);
}
// ****************************************************** //
}
void dataEntered(String data)

:\ZR\ZDQD SR ND*G\P GRVWDUF]HQLX Z NODWFH ZHMFLRZHM SRMHG\QF]HJR DFXFKD

znaNyZ8GRVW
SQLDZdata DFXFK]QDNyZ
int length(String string)

'RVWDUF]DOLF]E
]QDNyZODFXFKDstring.
1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLH'DQHDFXFKRZHZSURZDG]DDFXFKLSRGD
MHOLF]E
MHJR]QDNyZ
(NUDQ
'DQHDFXFKRZH

import janb.view.*;
public
class Master
extends View {
// ****************************************************** //
public void dataEntered(String data)
{
showResult(
"Length of \"" + data + "\" is " + length(data)
);
}
// ****************************************************** //
}
void dataEntered(String[] data)

:\ZR\ZDQD SR ND*G\PGRVWDUF]HQLX Z NODWFH ZHMFLRZHM ZL

FHM QL* MHGQHJR DcuFKD]QDNyZ8GRVW
SQLDZdata RGQRQLNGRWDEOLF\DFXFKyZ]QDNyZ

int length(String[] vector)

'RVWDUF]DOLF]E
DFXFKyZ]DZDUW\FKZWDEOLF\vector.
1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLH:LHOHDFXFKyZZSURZDG]DFLJDFXFKyZ
i podaje ostatni.
(NUDQ
:LHOHDFXFKyZ

import janb.view.*;
public
class Master
extends View {
// ****************************************************** //
public void dataEntered(String[] data)
{
int count = length(data);
showResult("The last string is " + data[count-1]);
}
// ****************************************************** //
}
String getString(String[] strings)

'RVWDUF]DDFXFKXWZRU]RQ\]SRF]HQLDDFXFKyZ]DZDUW\FKZWDEOLF\strings, po
X]XSHQLHQLXND*GHJRSRMHG\QF]VSDFM-HVWSU]\GDWQDZyZF]DVJG\DFXFK\ZSUR
ZDG]RQHGRNODWNLFKFHVL
WUDNWRZDMDNjedenDFXFK
1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLHF]HQLHDFXFKyZ, podaje jakie wprowadzoQRDFXFK\

(NUDQ
F]HQLHDFXFKyZ

import janb.view.*;
public
class Master
extends View {
// ****************************************************** //
public void dataEntered(String[] data)
{
showResult("The strings are: " + getString(data));
}
// ****************************************************** //
}

GODGRFLHNOLZ\FK
-HOLDSOHW]DZLHUDZL
FHMQL*MHGQIXQNFM
dataEnteredWRMHVWZ\ZR\ZDQDW\ONRWD
NWyUDMHVWSU]\VWRVRZDQDGRREVXJLZSURZDG]RQHMGDQHM-HOLWDNLHMQLHPDWRMHVWZ\
ZR\ZDQDIXQNFMDoglniejsza:V]F]HJyOQRFLMHOLDSOHW]DZLHUDW\ONRIXQNFM
]SD
rametrem typu char LIXQNFM
]SDUDPHWUHPW\SXString, to
1. 3RGRVWDUF]HQLXMHGQHJR]QDNX]RVWDQLHZ\ZRDQDIXQNFMD]SDUDPHWUHPW\SX

char.
2. 3RGRVWDUF]HQLXMHGQHJRDFXFKDNWyU\VNDGDVL
]ZL
FHMQL*]MHGQHJR]QD

NX]RVWDQLHZ\ZRDQDIXQNFMD]SDUDPHWUHPW\SXString.

3. 3RGRVWDUF]HQLXZL
FHMQL*MHGQHJRDFXFKDQLH]RVWDQLHZ\ZRDQD*DGQDz fun-

kcji dataEntered, a to spowoduje wygenerowanie V\JQDXG(ZL

NRZHJR.

)XQNFMDSU]\VWRVRZDQDGRSU]HWZDU]DQLDGDQ\FKRJOQLHMV]\FKQDGDMH
VL GR REVXJLZDQLD GDQ\FK PQLHM RJOQ\FK : V]F]HJOQRFL IXQNFMD
SU]\VWRVRZDQDGRSU]HWZDU]DQLDDFXFKZPRHE\X\WDGRSU]H

WZRU]HQLDSRMHG\QF]\FK]QDNZDIXQNFMDGRSU]HWZDU]DQLD]HVWDZZ
DFXFKZPRHE\X\WDGRSU]HWZRU]HQLD]QDNZDFXFKZL]H
VWDZZDFXFKZ
1DVW
SXMF\ DSOHW SRND]DQ\ QD HNUDQLH Rozpoznawanie danych, informuje o rodzaju
dostarczonej danej.
(NUDQ
Rozpoznawanie
danych

import janb.view.*;
public
class Master
extends View {
// ****************************************************** //
public void dataEntered(String[] data)
{
if(length(data) == 1)
dataEntered(data[0]);
showResult("Strings: " + getString(data));
}
public void dataEntered(String data)
{
if(length(data) == 1)
showResult("Char: " + data);
else
showResult("String: " + data);
}
// ****************************************************** //
}

2SHUDFMHQDNODWFH
'DQHPR*QDXPLHV]F]Dw klatce albo SRELHUDZSURVW]NODWNL6X*GRWHJRIXQNFMH
setData i getData. Funkcji setData QDOH*\X*\ZD]RVWUR*QRFLSRQLHZD*NROLGXM
zHG\FMNODWNL
void setData(String data)

8PLHV]F]DZNODWFHQDSLVRNUHORQ\SU]H]data.
String getData()

'RVWDUF]DQDSLV]QDMGXMF\VL
ZNODWFH
1DVW
SXMF\ DSOHW SRND]DQ\ QD HNUDQLH Operacje na klatce, rozpoznaje czy w klatce
]QDMGXMHVL
OLF]EDFDNRZLWDDMHOLWDNWRZ\ZLHWODMHMkwadrat.
(NUDQ
Operacje na klatce

import janb.view.*;
public
class Master
extends View {
public void runView()
{
boolean viewCleared = true;
int oldData = MinInt;
while(true) {
String data = getData();
if(isIntegral(data)) {
int val = getInt(data);

if(val != oldData) {
oldData = val;
clearView();
showResult(
" Square of (" + val + ") is "
+ val * val
);
viewCleared = false;
}
} else if(!viewCleared)
clearView();
}
}
}

2GWZDU]DQLHZLGRNX
$SOHWSRZLQLHQE\QDSLVDQ\ZWDNLVSRVyEDE\SRND*G\PZ\ZRDQLXIXQNFMLdrawViewQDVW
SRZDRSHQHodtworzenie widoku.
Funkcja drawView MHVW ]D]Z\F]DM Z\ZR\ZDQD SU]H] System ,VWQLHMH MHGQDN PR*liZRZ\ZRDQLDMHM]ZQ
WU]DSURJUDPX6X*\GRWHJRIXQNFMDredraw.
void redraw()

:\F]\V]F]DZLGRNNRORUHPWDLZ\ZRXMHIXQNFM
drawView.
void setBackground(Color color)

8VWDZLDNRORUWDDSOHWXQDcolor (np. setBackground(Red)).

*G\E\]PLHQQDUHVXOWQLH]RVWDD]DLQLFMRZDQDWRSRGF]DVSLHUZV]H
JR Z\ZRDQLD IXQNFML GUDZ9LHZ ]RVWDE\ Z\SURZDG]RQ\ NRPXQLNDW
6WULQJ SRLQWHU LV 18// .RPXQLNDW WHQ MHVW VZRLVW\P NXULR]XP SR
QLHZDZ-DYLHQLHPDZVNDQLNZSRZLQLHQEU]PLH6WULQJUHIHUHQ
FHLV18//
1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLHOdtwarzanie widokuZ\ZLHWODQDSLVZSURwaG]RQ\GRNODWNLDOHG]L
NLX*\FLXIXQNFMLredraw i drawView ]DSHZQLD*HQDSLVWHQ
po]RVWDMH QD ZLGRNX QDZHW MHOL QDVWSL SU]HMFLRZH ]DVRQL
FLH ZLGRNX SU]H] REFH
okno.
import janb.view.*;
public
class Master
extends View {
private String result = "John von Neuman";

(NUDQ
Odtwarzanie widoku

public void dataEntered(String[] data)

{
result = getString(data);
redraw();
}
public void drawView()
{
showResult(result, 20);
}
}

URGRZLVNR
-HOLSURJUDPod razu dziaD, to albo jest banalnie prosty albo zawiera E
G\ORJLF]QH.
%
G\WHQDOH*\UR]SR]QD i XVXQ&]\QQRFLWHZ\NRQXMHprogramista.
:EUHZ SRZV]HFKQHPX PQLHPDQLX SURJUDPLVW QLH MHVW WHQ NWR XPLH
QDSLVDSURJUDPDOHWHQNWRXPLHJRXUXFKRPLSU]HWHVWRZDLXVX
Q ]DZDUWH Z QLP EG\ 'ODWHJR FKRFLD ZLHOH RVE XPLH SURJUDPR

ZDW\ONRQLHOLF]QLVSURJUDPLVWDPL
Programista nowoczesny D ]ZDV]F]D SURJUDPLVWD zawodowy jest przyzwyczajony do
NRPIRUWX NWyU\ RIHUXM ]LQWHJURZDQH URGRZLVND XUXFKRPLHQLRZH. Pod wsplnym
daFKHPXPR*OLZLDMRQHZ\NRQ\ZDQLHedycji SURJUDPyZ(UyGRZ\FKRUD]kompilowanie, F]HQLHi budowanie programw.
:UyGZLHOXURGRZLVNXUXFKRPLHQLRZ\FKXDWZLDMF\FKSURJUDPRZDQLHZJavie znajGXM VL
 WDNLH NWyUH NRV]WXM SR NLOND W\VL
F\ GRODUyZ MDN L WDNLH NWyUH PR*QD
za darmo FLJQ ] Internetu :UyG W\FK RVWDWQLFK ]QDMGXMH VL
 URGRZLVNR Kawa,
ktrego przez 3 PLHVLFHPR*QDX*\ZDEH]SRWU]HE\]DNXSX

=DLQVWDORZDQLHELEOLRWHNL
%LEOLRWHNDLPSOHPHQWXMFDNODV
View wraz z jej dodatkami zajmuje ok. 40 KB i znajGXMHVL
ZSOLNXView.jarQDG\VNLHWFHGRF]RQHMGRNVL*NL3OLNWHQPR*QDXPLHFL
w katalogu UR]V]HU]H pakietu JDK albo po ewentualnym rozpakowaniu do katalogu
janb\viewVNRSLRZD
4. 'ODURGRZLVNDKawa

do katalogu projektowego.

5. 'ODURGRZLVNDJBuilder

do katalogu Z\MFLRZHJR.

.DWDORJLHPUR]V]HU]HGOD-'.]DLQVWDORZDQHJRZG?-'.5XQMHVW
G?-'.5XQ?MUH?OLE?H[W D GOD NRPSLODWRUD -%XLOGHU  ]DLQVWDOR
ZDQHJRZG?-%XLOGHUMHVWG?-%XLOGHU?MDYD?MUH?OLE?H[W

*UDILND
1D ZLGRNX PR*QD Z\NUHOD napisy, odcinki, figury i obszary : FHOX Z\NUHOHQLD
obieNWXJUDILF]QHJRQDOH*\SRGDZVSyU]
GQHZLGRNXLZ\EUDQDU]
G]LDdo wyNUHlaQLD:\NUHODQLHPR*HVL
RGE\ZDZkolorachDQDSLV\PRJE\Z\NUHODQHczcionkami o dowolnie obranym kroju, stylu i rozmiarze.

/LQLH V Z\NUHODQH pirami D QDSLV\ REV]DU\ V ]DPDORZ\ZDQH S

G]ODPL 3
G]OH
PRJPDORZDREV]DU\farbami, gradientami i teksturami.

:VSU]GQH
:VSyU]
GQHVOLF]RQHZ]JO
GHPOHZHJRJyUQHJRQDUR*QLNDZLGRNX
:FHOXZ\NUHOHQLD
1. Napisu SRGDMHVL
ZVSyU]
GQHOHZHJRNRFDGRP\OQHJRRGFLQNDED]RZHJR

na ktrym napis spoczywaDOERZVSyU]

GQHOHZHJRJyUQHJRZLHU]FKRNDGR
P\OQHJRSURVWRNWDZNWyU\WHQQDSLVwpisano.
2. OdcinkaSRGDMHVL
ZVSyU]
GQHMHJRNRFyZ
3. Figury, Obszaru i Obiektu SRGDMH VL
 ZVSyU]
GQH OHZHJRJyUQHJR ZLHU]

FKRNDGRP\OQHJRSURVWRNWDZNWyU\ZSLVDQRW
ILJXU
REV]DUDOERRELHNW
'ODRNUJZSRGDMHVLUHGQLFDGODNZDGUDWZERN

1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLH:\NUHODQLHSLNVHOLZ\NUHODSLNVHOHZSU]\
padkowych punktach widoku.
(NUDQ
:\NUHODQLHSLNVHOL

import janb.view.*;
public
class Master
extends View {
public void drawView()
{

int w = getWidth(),
h = getHeight();
while(true) {
int x = getRandom(0, w),
y = getRandom(0, h);
if(x == h/2 && y == h/2){
clearView();
setColor(getColor());
}
drawPixel(x, y);
}
}
}

:\NUHV\
1DMSURVWV]\PLILJXUDPLJUDILF]Q\PLV pixel, napis,RNUJ, kwadrat i odcinek2NU
JL
LNZDGUDW\PR*QDZ\NUHODMDNR
Cienkie

(Thin)

Liniowe

(Line)

3LHUFLHQLRZH

(Ring)

:\SHQLRQH

(Full)

void drawPixel(int x, int y)

:\NUHODSLNVHOZSXQNFLHRZVSyU]
GQ\FKx, y).
void drawString(String string, int x, int y)

:\NUHODQDSLVstringVSRF]\ZDMF\QDRGFLQNXED]RZ\PRlewym NRFXZx, y).

void drawString(int x, int y, String string)
void drawString(int x, int y, String string, Font font)

:\NUHODQDSLVstringF]FLRQNELH*FDOERF]FLRQNfontZGRP\OQ\PSURVWRNFLH
RQDUR*QLNXZx, y).
void drawLine(int xA, int yA, int xZ, int yZ)

:\NUHOD RGFLQHN F]F\ SXQNW\ xA, yA) i (xZ, yZ). Punkt (xZ, yZ) definiuje jako
NRFRZ\.
void moveTo(int x, int y)

Punkt (x, y) definiuje jako NRFRZ\.

void lineTo(int x, int y)

:\NUHODRGFLQHNF]F\SXQNWNRFRZ\]SXQNWHPx, y). Punkt (x, y) definiuje jako

NRFRZ\.
void drawCircle(int x, int y, int d)

:\NUHODRNUJRUHGQLF\dZSLVDQ\ZGRP\OQ\SURVWRNWRZLHU]FKRNXZx, y).
void drawSquare(int x, int y, int s)

:\NUHODNZDGUDWRERNXsLZLHU]FKRNXZx, y).
void drawEllipse(int x, int y, int w, int h)

:\NUHODHOLSV
RUHGQLFDFKw x hZSLVDQZGRP\OQ\SURVWRNWRZLHU]FKRNXZ (x, y).
void drawRectangle(int x, int y, int w, int h

:\NUHODSURVWRNWRUR]PLDUDFKw x hLZLHU]FKRNXZ (x, y).

void drawDiamond(int x, int y, int w, int h

:\NUHODURPERUR]PLDUDFKw x hZSLVDQ\ZGRP\OQ\SURVWRNWRZLHU]FKRNXZ (x, y).

void setFill(int fill)

Ustawia na fill (Thin, Line, Ring, Full VSRVyE Z\NUHODQLD RNU

JyZ, kwadratw,
elips i SURVWRNWyZ.
void setFont(Font font)

Ustawia na fontF]FLRQN
GRZ\NUHODQLDQDSLVyZ
void setStroke(int width)
void setStroke(int width, double ratio)
void setStroke(int width, double ratio, int cap, int join)

Ustawia na width V]HURNR SLyUD X*\ZDQHJR GR Z\NUHODQLD OLQLL 3

G]OHP Z\SHQLD
tylNR F]
FL SRGOLQLL RNUHORQH SU]H] ratio /LQLH NRF]\ ]JRGQLH ] cap (CapMiter,
CapRound, CapBevelDF]\MH]JRGQLH]join (JoinButt, JoinRound, JoinSquare).
void setPaint(Paint paint)

Ustawia na paintURG]DMS
G]ODX*\ZDQHJRGRZ\SHQLDQLDREV]DUyZ
void setColor(Color color)

Ustawia na colorURG]DMIDUE\X*\ZDQHMGRZ\NUHODQLDOLQLLLZ\SHQLDQLDREV]DUyZ
3RQLHZDPDORZDQLHIDUEZ\NOXF]DVL]PDORZDQLHPWHNVWXULJUD
GLHQWHP ZLF Z NDGHM FKZLOL RERZL]XMH W\ONR RVWDWQLH ] Z\ZRD
IXQNFMLVHW&RORULVHW3DLQW
1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLH'RELHUDQLHSLyULS
G]OL, ilustruje zastosowanie
IXQNFMLGRZ\ELHUDQLDSLyULS
G]OL

(NUDQ
Dobieranie pir
iS
G]OL

import janb.view.*;
import java.awt.*;
public
class Master
extends View {
private int r= 100,
w, h;
private Paint paint;
private Font font;
public void initView()
{
w = getWidth();
h = getHeight();
setFill(Ring);
setStroke(50, 0.75);
paint = getGradient(Blue, Green);
setPaint(paint);
font = getFont("Serif", Bold, 150);
setFont(font);
}
public void dataEntered(String data)
{
showResult("Hello");
}
public void drawView()
{
drawCircle(w/2-r+50, h/2-r+50, 2*r);
drawString(10, 10, "Kaja");
setStroke(30, 0.5, JoinRound, CapRound);
drawLine(50, 200, 50, 250);
drawLine(50, 250, 100, 300);
}
}

&]FLRQNL
&]FLRQN
 RSLVXMH krj, styl i rozmiar : ND*G\P Systemie PR*QD VL
 SRVXJLZD VL

czcionkami o nazwach: Serif, Sansserif, Monospaced i Dialog, o stylach: Bold, Italic,

BoldItalic, Plain RUD]RUR]PLDUDFKZ\UD*RQ\FKZpunktach (1 pt = 1/72 cala).
'RXWZRU]HQLDF]FLRQNLX*\ZDVL
IXQNFMLgetFont, a do jej wybrania funkcji setFont.
Font getFont(String face, int style, int size)

'RVWDUF]DF]FLRQN
RNURMXface, stylu style i rozmiarze size.
void setFont(Font font)

8VWDZLDF]FLRQN
X*\ZDQGRZ\NUHODQLDQDSLVyZQDfont.
Font getCurrentFont()

'RVWDUF]DDNWXDOQF]FLRQN

0HWU\ND
=QDSLVHPNWyU\PDE\Z\NUHORQ\Z\EUDQF]FLRQNMHVW]ZL]DQDMHJRmetryka. Do
XWZRU]HQLDPHWU\NLX*\ZDVL
IXQNFMLgetMetrics, a do wykonania operacji na metryce,
funkcji getWidth, getHeight, getAscent i getDescent.
Metrics getMetrics(String string)

'RVWDUF]DPHWU\N
QDSLVXNWyU\ZGDQHMFKZLOL]RVWDE\Z\NUHORQ\]DSRPRFIXQNFML
drawString.
int getWidth(Metrics metrics)

Dostarcza V]HURNRGRP\OQHJRSURVWRNWDZNWyU\PE
G]LHZ\NUHORQ\QDSLVRPH
tryce metrics.
int getHeight(Metrics metrics)

Dostarcza Z\VRNRGRP\OQHJRSURVWRNWDZNWyU\PE
G]LHZ\NUHORQ\QDSLVRPH
tryce metrics.
int getAscent(Metrics metrics)

Dostarcza uniesienie Z]JO

GHPodcinka bazowegoJyUQHMSRGVWDZ\GRP\OQHJRSUR
stoNWDZNWyU\PE
G]LHZ\NUHORQ\QDSLVRPHWU\FHmetrics
int getDescent(Metrics metrics)

Dostarcza REQL*HQLHZ]JO
GHPodcinka bazowegoGROQHMSRGVWDZ\GRP\OQHJRSUR
stoNWDZNWyU\PE
G]LHZ\NUHORQ\QDSLVRPHWU\FHmetrics.
1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLH:\NUHODQLHILJXUZ\NUHODQDURGNXZLGRNX
kwadrat o podanym boku, opisuje na nim RNUJLZ\NUHODMHJRSU]HNWQH. W grnej
F]
FL ZLGRNX Z\NUHOD napis VSRF]\ZDMF\ QD RGFLQNX ED]RZ\P RUD] QDSLV String
otoczony jego REZLHGQL.

(NUDQ
:\NUHODQLHILJXU

import janb.view.*;
import java.awt.*;
public
class Master
extends View {
private String string = "String";
private int side = 100,
w, h;
private double sqrt2 = sqrt(2);
public void dataEntered(String data)
{
if(!isIntegral(data)) {
beep();
return;
}
side = getInt(data);
redraw();
}
public void initView()
{
w = getWidth();
h = getHeight();
}
public void drawView()
{
int x = (w - side) >> 1,
y = (h - side) >> 1;
drawSquare(x, y, side);
drawLine(x, y, x+side, y+side);

drawLine(x+side, y, x, y+side);
int dd = (int)(side * (sqrt2-1)/2);
drawCircle(x-dd, y-dd, side + 2*dd);
drawString("Side = " + side, 10, 50);
drawLine(10, 50, w, 50);
setStroke(30);
setColor(Red);
Font font = getFont("Serif", Bold, 30);
drawString(x, y, string, font);
Metrics metrics = getMetrics(string, font);
int a = getAscent(metrics),
d = getDescent(metrics),
w = getWidth(metrics),
h = getHeight(metrics);
setStroke(1);
setColor(Blue);
drawRectangle(x, y, w, h);
}
}

2EUD]\
-HOL ]DPLHU]D VL
 Z\NUHOL REUD] XSU]HGQLR SU]\JRWRZDQ\ Z SOLNX ] UR]V]HU]HQLHP
GIFWRQDOH*\
1. :FHOX]DDGRZDQLDREUD]XGRSDPL
FLX*\IXQNFMLgetImage.
2. :FHOXZ\NUHOHQLDREUD]XX*\IXQNFMLdrawImage.

$E\RNUHOLUR]PLDU\]DDGRZDQHJRREUD]XPR*QDX*\IXQNFMLgetWidth i getHeight.
Image getImage(String file)

DGXMHREUD]]SOLNXfileLGRVWDUF]DRGQRQLNGRUHSUH]HQWXMFHJRJRRELHNWX
void drawImage(Image image, int x, int y, int w, int h)
void drawImage(Image image, int x, int y)

Obraz identyfikowany przez image Z\NUHOD Z WDNL VSRVyE *H ZVSyU]

GQH MHJR
lewego-grnego naUR*QLND]QDMGVL
ZSXQNFLH (x, yDMHOLSRGDQRSDUDPHWU\w i h,
to przeskalowuje obra]LZ\ZLHWODJRZSURVWRNFLHRUR]PLDUDFKw x h.
int getWidth(Image image)

Dostarcza V]HURNRobrazu image.

int getHeight(Image image)

Dostarcza Z\VRNRobrazu image.

1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLH:\NUHOHQLHREUD]XZ\NUHODQDURGNXZLGR
NXREUD]RQD]ZLHSRGDQHMZNODWFH:SROXNRPXQLNDWyZSRGDMHLQIRUPDFM
RUR]miarach obrazu.

(NUDQ
:\NUHOHQLHREUD]X

import janb.view.*;
import java.awt.*;
public
class Master
extends View {
private String defData = "Roger.gif";
public void initView()
{
setData(defData);
}
public void dataEntered(String data)
{
// pobranie obrazu
Image img = getImage(data);
// sprawdzenie, czy obraz istnieje
if(data == null) {
showMsg("Image does not exist");
return;
}
LQWLPJ:
LPJ+
YLHZ:
YLHZ+

JHW:LGWKLPJV]HURNRREUD]X

JHW+HLJKWLPJZ\VRNRREUD]X
JHW:LGWKV]HURNRZLGRNX
JHW+HLJKWZ\VRNRZLGRNX

// wyprowadzenie komunikatu
showMsg("Width = " + imgW + ", Height = " + imgH);
imgW = 200;
imgH = 200;
Z\]QDF]HQLHZVSyU]
GQ\FK
// lewego-grnego

QDUR*QLNDREUD]X
int x = (viewW - imgW) / 2,
y = (viewH - imgH) / 2;
Z\NUHOHQLHREUD]X
drawImage(img, x, y, imgW, imgH);
}
public void dataEntered(String[] data)
{
clearView();
// wyprowadzenie informacji,
*HSRGDQRZL
FHMQL*DFXFK
showMsg("Error: filename please!");
}
}

2ELHNW\
)LJXU]H JUDILF]QHM PR*QD QDGD FHFK\ obiektu. Obiekt figurowy przechowuje inforPDFMHRZDFLZRFLDFKILJXU\XPR*OLZLDkolekcjonowanie figur oraz odtwarzanie ich
EH]SRUHGQLR]NROHNFML
:FKZLOLXWZRU]HQLDRELHNWXILJXURZHJRZVWDZLDVLGRQLHJRELHFD
F]FLRQNSLURSG]HOLVSRVEZ\SHQLDQLD7HZVWSQHXVWDZLHQLD
PRQD]PLHQL]DSRPRFIXQNFMLVHW;;;
Figure getPixel(int x, int y)

'RVWDUF]DRGQRQLNGRRELHNWXpikselaRZVSyU]
GQ\FKx, y).
Figure getString(int x, int y, String string)

'RVWDUF]D RGQRQLN GR napisu, zdefiniowanego przez string ZSLVDQHJR Z GRP\OQ\

SURVWRNWRZLHU]FKRNXZ (x, y).
Figure getImage(int x, int y, Image image)
Figure getImage(int x, int y, int w, int h, Image image)

'RVWDUF]D RGQRQLN GR obrazu zdefiniowanego przez image R ZVSyU]

GQ\FK x, y)
i rozmiarach w x h (do przeskalowania).
Figure getLine(int xA, int yA, int xZ, int yZ)

'RVWDUF]DRGQRQLNGRodcinka F]FHJRSXQNW\xA, yA) i (xZ, yZ).

Figure getCircle(int x, int y, int d)
Figure getEllipse(int x, int y, int w, int h)

'RVWDUF]DRGQRQLNGRNRDalbo elipsy RZVSyU]

GQ\FKx, y) i rozmiarach d x d albo
w x h.
Figure getSquare(int x, int y, int s)
Figure getRectangle(int x, int y, int w, int h)

'RVWDUF]DRGQRQLNGRkwadratu albo SURVWRNWDRZVSyU]

GQ\FKx, y) i rozmiarach
s x s albo w x h.
Figure getDiamond(int x, int y, int s)
Figure getDiamond(int x, int y, int w, int h)

'RVWDUF]D RGQRQLN GR rombu albo UyZQROHJRERNX R ZVSyU]

GQ\FK x, y) i
rozmiarach s x s albo w x h.
Metrics getMetrics(Figure figure)

-HOLILJXUDfigure MHVWQDSLVHPGRVWDUF]DMHJRPHWU\N
:SU]HFLZQ\PUD]LHGRVWDUF]D
null.
void drawFigure(Figure figure)

:\NUHODRELHNWJUDILF]Q\figure.
void setXY(Figure figure, int x, int y)

Ustawia na (x, yZVSyU]

GQH QDUR*QLNDSURVWRNWDZNWyU\ZSLVDQRILJXU
figure.
void setSize(Figure figure, int w, int h)

Ustawia na w x hUR]PLDU\SURVWRNWDZNWyU\ZSLVDQRfigure.
void setStroke(Figure figure, Stroke stroke)

Ustawia na stroke piro NWyU\PE

G]LHZ\NUHODQDILJXUDfigure.
void setPaint(Figure figure, Paint paint)

Ustawia na paint S
G]HONWyU\PE
G]LHZ\NUHODQDILJXUDfigure.
void setColor(Figure figure, Color color)

Ustawia na (Paint)color S
G]HONWyU\PE
G]LHZ\NUHODQDILJXUDfigure.
void setFont(Figure figure, Font font)

Ustawia na font F]FLRQN

MDNE
G]LHZ\NUHODQ\QDSLVILJXU\figure.
void setFill(Figure figure, int fill)

Ustawia na fill (Thin, Line, Ring, FullVSRVyEZ\SHQLHQLDILJXU\figure.

int getX(Figure figure)

Dostarcza RGFL
WQDUR*QLNDSURVWRNWDZNWyU\ZSLVDQRILJXU
figure.
int getY(Figure figure)

Dostarcza U]
GQQDUR*QLNDSURVWRNWDZNWyU\ZSLVDQRILJXU
figure.
int getWidth(Figure figure)

Dostarcza V]HURNRSURVWRNWDZNWyU\ZSLVDQRILJXU
figure.
int getHeight(Figure figure)

Dostarcza Z\VRNRSURVWRNWDZNWyU\ZSLVDQRILJXU
figure.
Stroke getStroke(Figure figure)

'RVWDUF]DRGQRQLNGRpira, NWyU\PE
G]LHZ\NUHODQDILJXUDfigure.
Paint getPaint(Figure figure)

'RVWDUF]DRGQRQLNGRS
G]ODNWyU\PE
G]LHZ\NUHODQDILJXUDfigure.
Paint getColor(Figure figure)

'RVWDUF]DRGQRQLNGRS
G]ODNWyU\PE
G]LHZ\NUHODQDILJXUDfigure-HOLS
G]HOIL
guU\QLHZ\NUHODIDUEGRVWDUF]DRGQRQLNpusty.
Font getFont(Figure figure)

'RVWDUF]DRGQRQLNGRczcionkiMDNE
G]LHZ\NUHODQ\QDSLVILJXU\figure.
int getFill(Figure figure)

'RVWDUF]DLQIRUPDFMLRVSRVRELHZ\SHQLHQLDThin, Line, Ring, Full) figury figure.

-HOLGRILJXU\QLHVWRVXMHVLIXQNFMDJHW3DLQWDOERJHW)RQWWRNDGD
]QLFKGRVWDUF]DQXOO
1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLH:\NUHODQLHRELHNWyZZ\NUHODSU]\NDGRZH
obiekty figurowe.
(NUDQ
:\NUHODQLH
obiektw

import janb.view.*;
public
class Master
extends View {
private Figure figure;
private int r = 40, d = 2*r, s = d, s2 = s/2,
w = 80, w2 = w/2,
h = 50, h2 = h/2;

public void mouseReleased(int x, int y, int flags)

{
if(isMeta(flags)) {
int what = getRandom(2);
if(what == 0)
figure = getCircle(x-r, y-r, d);
else
figure = getSquare(x-s2, y-s2, s);
} else {
int what = getRandom(3);
switch(what) {
case 0:
// elipsa
figure = getEllipse(x-w2, y-h2, w, h);
break;
FDVHSURVWRNW
figure = getRectangle(x-w2, y-h2, w, h);
break;
case 2:
// romb
figure = getDiamond(x-w2, y-h2, w, h);
}
}
RNUHOHQLHZ\JOGXILJXU\
setColor(figure, getColor());
setFill(figure, Ring);
setStroke(figure, getStroke(10));
Z\NUHOHQLHILJXU\
drawFigure(figure);
}
}

:LGRNL
3RZ\NUHOHQLXILJXU\SR]RVWDMHRQDQDZLGRNXDOHQLHGX*HMQL*GRFKZLOLJG\ZLGRN
zostanie uszkodzony na skutek SU]HVRQL
FLDprzez obce okno albo na skutek ikonizacji
RNQDSU]HJOGDUNL'ODWHJRND*G\Z\NUHORQ\RELHNWJUDILF]Q\SRZLQLHQE\]DSDPL
tany
w bazie danych apletu i odtworzony]QLHMSRND*G\PZ\ZRDQLXIXQNFMLdrawView.
'R XWZRU]HQLD ED]\ GDQ\FK VX*\ IXQNFMD getFigures, a do jej przetwarzania funkcje
addFigure, setFigure, getFigure, drawFigures i length.
Figures getFigures()

'RVWDUF]DRGQRQLNGRSXVWHMNROHNFML
void addFigure(Figures figures, Figure figure)

Do kolekcji figuresGRNDGDILJXU
figure.
void setFigure(Figures figures, int pos, Figure figure)

8PLHV]F]DILJXU
figure w kolekcji figures, na pozycji pos.

Figure getFigure(Figures figures, int pos)

'RVWDUF]DRGQRQLNGRILJXU\NWyUDZNROHNFMLfigures ]QDMGXMHVL
QDSR]\FMLpos.
void drawFigures(Figures figures)

:\NUHODZV]\VWNLHILJXU\NROHNFMLfigures.
int length(Figures figures)

'RVWDUF]DOLF]E
HOHPHQWyZNROHNFMLfigures.
1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLHOdtwarzanie widoku, napisano w taki sposb,
*HZV]\VWNLHZ\NUHORQHQDQLPRELHNW\]RVWDQDXWRPDW\F]QLHRGWZRU]RQHZZ\SDGNX
uszkodzenia widoku.
(NUDQ
Odtwarzanie widoku

import janb.view.*;
public
class Master
extends View {
private Figures dataBase = getFigures();
private Figure figure;
private int r = 40, d = 2*r, s = d, s2 = s/2,
w = 80, w2 = w/2,
h = 50, h2 = h/2;
public void drawView()
{
drawFigures(dataBase);
}

public void mouseReleased(int x, int y, int flags)

{
if(isMeta(flags)) {
int what = getRandom(2);
if(what == 0)
figure = getCircle(x-r, y-r, d);
else
figure = getSquare(x-s2, y-s2, s);
} else {
int what = getRandom(3);
switch(what) {
case 0:
// elipsa
figure = getEllipse(x-w2, y-h2, w, h);
break;
FDVHSURVWRNW
figure = getRectangle(x-w2, y-h2, w, h);
break;
case 2:
// romb
figure = getDiamond(x-w2, y-h2, w, h);
}
}
]DSDPL
WDQLHZED]LH
addFigure(dataBase, figure);
Z\NUHOHQLHILJXU\
drawFigure(figure);
}
}

1DU]G]LD
1DU]
G]LDPLGRZ\NUHODQLDVpiro i S
G]HO3LyURVX*\GRZ\NUHODQLDlinii, a S

dzel do Z\SHQLDQLDREV]DUyZ2EV]DU\PR*QDZ\SHQLDIDUE, gradientem i tekstuU. Do
GHILQLRZDQLDSLyULS
G]OLVX*IXQNFMHsetStroke i setPaint.
Color getColor(int red, int green, int blue)

'RVWDUF]D NRORU IDUE\ ]GHILQLRZDQ\ SU]H] VNDGQLNL RGB: red, green, blue ND*G\
RZDUWRFL]SU]HG]LDX0.. 255. Np. getColor(255,255,0) dostarcza kolor *yW\.
Color getColor()

Dostarcza kolor przypadkowyDOHQLHF]DUQ\QLHV]DU\LQLHELD\

void setColor(Color color)

8VWDZLDNRORUELH*F\QDcolor.
0RQD SRVXJLZD VL QDVWSXMF\PL V\PEROLF]Q\PL R]QDF]HQLDPL
NRORUZ
Red

Green

Blue

Cyan

Magenta Yellow

Black

White

1DVW
SXMF\ DSOHW SRND]DQ\ QD HNUDQLH Dobieranie kolorw Z\NUHOD ZRNy SXQNWX
NOLNQL
FLDSLHUFLHZNRORU]HSU]\SDGNRZ\PRUD]SRGDMHMHJRVNDGRZHRGB.
(NUDQ
Dobieranie kolorw

import janb.view.*;
import java.awt.*;
public
class Master
extends View {
private int rad = 50;
public void mouseReleased(int x, int y)
{
x -= rad;
y -= rad;
Color color = getColor();
setColor(color);
setStroke(10);
drawCircle(x, y, 2 * rad);
int r = getRed(color),
g = getGreen(color),
b = getBlue(color);
showMsg("" + r + ' ' + g + ' ' + b);
}
}

3LUR
3LyUR PR*H U\VRZD FLHQN OLQL FLJ DOER GRZROQHM JUXERFL OLQL FLJ DOER
SU]HU\ZDQ.

/LQLD SU]HU\ZDQD VNDGD VL ] SRGOLQLL  Z NWU\FK Z\VWSXM NUHVNL

LSU]HUZ\-DNRXG]LDNUHVNLRNUHODVLVWRVXQHNGXJRFLNUHVNLGR
GXJRFLSRGOLQLL
void setStroke(int width, double ratio)
void setStroke(int width)

8VWDZLDV]HURNROLQLLQDwidth LXG]LDNUHVNLQDratio8G]LDGRP\OQ\Z\QRVL1.0.
Stroke getStroke(int width)

'RVWDUF]DSLyURRV]HURNRFLwidth.
Stroke getCurrentStroke()

Dostarcza aktualne piro.

1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLHWybieranie pirZ\NUHOD]HVWDZOLQLL SR]LR
P\FKQDU\VRZDQ\FK]DSRPRFNLONXSLyU
(NUDQ
Wybieranie pir

import janb.view.*;
public
class Master
extends View {
public void drawView()
{
for(int i = 1; i < 10; i++) {
int j = 10 * i;
setColor(Blue);
setStroke(1);
drawLine(10, 50+j, 120, 50+j);
setColor(Red);

setStroke(i);
drawLine(10, 150+j, 120, 150+j);
setColor(Green);
setStroke(i, 0.75);
drawLine(10, 250+j, 120, 250+j);
}
drawCircle(200, 50, 100, Line);
drawCircle(150, 100, 200, Ring);
drawCircle(200, 150, 100, Full);
}
}

3G]HO
3
G]HOPR*HPDORZDIDUE, gradientem i WHNVWXU. Do tworzenia farb, gradientw i teNVWXU X*\ZD VL
 IXQNFML getColor, getGradient i getTexture D GR Z\EUDQLD S
G]OD
funkcji setColor i setPaint.
)XQNFMH VHW&RORU L VHW3DLQW Z]DMHPQLH VL Z\NOXF]DM JG\ SG]HO
PRHPDORZDW\ONRIDUEW\ONRJUDGLHQWHPDOERW\ONRWHNVWXU
Paint getGradient(Color from, Color to)
Paint getGradient(Color from, Color to,
int x, int y, int w, int h)

Dostarcza gradient od koloru from do koloru to ] UR]ZLQL

FLHP JUDGLHQWX Z FD\P
ZLGRNXDOERZSURVWRNFLHRSLVDQ\PSU]H]x, y) i w x h.
Paint getTexture(Image image)

'RVWDUF]D WHNVWXU
 ]GHILQLRZDQ SU]H] REV]DU 8 x 8 QDUR*QLNRZ\FK SLNVHOL REUD]X
image.
void setPaint(Paint paint)

8VWDZLDS
G]HOQDPDORZDQLHRNUHORQHSU]H]paint.
void setPaint(Color from, Color to)

8VWDZLDS
G]HOQDPDORZDQLHJUDGLHQWHPRGNRORUXfrom do koloru to.
void setPaint(Image image)

8VWDZLDS
G]HOQDPDORZDQLHWHNVWXU]GHILQLRZDQSU]H]REUD]image.
Paint getCurrentPaint()

'RVWDUF]DDNWXDOQ\S
G]HO
1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLH:\ELHUDQLHS
G]OLZ\NUHOD]HVWDZNyQDmaloZDQ\FK]DSRPRFS
G]ODJUDGLHQWRZHJRLWHNVWXURZHJR

(NUDQ
:\ELHUDQLHS
G]OL

import janb.view.*;
import java.awt.*;
public
class Master
extends View {
private Image image;
public void initView()
{
image = getImage("Carpet.gif");
}
public void drawView()
{
for(int i = 0; i < 5; i++) {
int j = 50 * (i+1);
Color a = getColor(),
z = getColor();
Paint grad = getGradient(a, z);
setPaint(grad);
drawCircle(j, j, 100, Full);
}
Paint paint = getTexture(image);
setPaint(paint);
drawCircle(50, 250, 100, Full);
}
}

&]FLRQND
1DSLV\PR*QDZ\NUHOD F]FLRQNDPL R Z\EUDQ\Pkroju, stylu i rozmiarze, a ponadto
mo*QDMHPDORZD: IDUE, gradientem oraz WHNVWXU.
1DVW
SXMF\ DSOHW SRND]DQ\ QD HNUDQLH Dobieranie czcionek Z\NUHOD ]HVWDZ QDSL
VyZSRVXJXMFVL
F]FLRQNDPLRUy*Q\FKNURMDFKUR]PLDUDFKLVW\ODFK
(NUDQ
Dobieranie czcionek

import janb.view.*;
import java.awt.*;
public
class Master
extends View {
private Font serif = getFont("Serif", Bold, 30),
mono = getFont(
"Monospaced", Italic, 20
),
sans;
private Image image;
public void initView()
{
image = getImage("Carpet.gif");
}
public void drawView()
{
setFont(serif);
drawString("Serif = Times Roman", 20, 80);
setFont(mono);
setColor(Red);
drawString("Monospaced = Courier", 100, 130);

sans = getFont(
"Sansserif", Font.BOLD | Font.ITALIC, 20
);
setFont(sans);
setColor(Color.blue);
drawString("Sansserif = Helvetica", 100, 180);
// napis gradientowy
Paint paint = getGradient(Red, Green);
setPaint(paint);
Font font = getFont("Serif", BoldItalic, 80);
setFont(font);
drawString("Serif", 5, 350);
// napis teksturowy
paint = getTexture(image);
setPaint(paint);
drawString("Serif", 205, 350);
}
}

%XIRURZDQLH
.D*GD]IXQNFMLZ\NUHODMF\FKPR*HZ\NRQ\ZDVZRMHF]\QQRFLQLHW\ONRQDwidoku,
DOH UyZQLH* Z buforze XWZRU]RQ\P Z SDPL
FL RSHUDF\MQHM 'R SU]HF]DQLD Z\NUH
ODQLDPL
G]\ZLGRNLHPLEXIRUHPVX*IXQNFMHtoBuffer i toScreen. Po skompletowaQLXREUD]XZEXIRU]HPR*QD]DSRPRFIXQNFMLdrawBufferZ\NUHOLJRQDZLGRNX
&]\QQRWDPR*HE\Z\NRQDQDEH]NRQLHF]QRFLSU]HF]HQLDZ\NUHODQLD
void toBuffer()
void toBuffer(int w, int h)
void toBuffer(Image image)

3U]HF]DZ\NUHODQLHQDZ\F]\V]F]RQ\EXIRURUR]PLDUDFKLGHQW\F]Q\FK]UR]PLDUDPL
widoku, na bufor o rozmiarach w x h DOER QD MX* LVWQLHMF\ EXIRU image, bez zmiany
MHJR]DZDUWRFL
void toScreen()

3U]HF]DZ\NUHODQLHQDZLGRNSRXSU]HGQLP]QLV]F]HQLXEXIRUD
void toScreen(boolean keep)

3U]HF]DZ\NUHODQLHQDZLGRNX]DOH*QLDMFRGkeep zachowanie bufora.

void drawBuffer()
void drawBuffer(int x, int y)

:\NUHODEXIRUQDZLGRNXZSURVWRNFLHRQDUR*QLNXZSXQNFLH(x,y)GRP\OQLH(0,0).
Image getBuffer()

'RVWDUF]DRGQRQLNGRREUD]XZEXIRU]H

:NDGHMFKZLOLMHVWDNW\ZQ\W\ONREXIRUDOHXPLHMWQHSRVXJLZD
QLHVLIXQNFMDPLJHW%XIIHULWR%XIIHU,PDJHXPROLZLDMHGQRF]HVQH
X\ZDQLHZLFHMQLMHGQHJREXIRUD
1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLH%XIRURZDQLHZ\NUHODQLDZ\NUHODQDSXOpiFLHSLHUFLHLXPR*OLZLDMHJRSU]HFLJDQLH]DSRPRFNODZLV]\NLHUXQNRZ\FK*G\E\
] SURJUDPX XVXQL
WR Z\ZRDQLH IXQNFML toBuffer WR SRGF]DV SU]HFLJDQLD SLHUFLHQLD
Z\VWSLRE\ migotanie 0R*OLZR XVXQL
FLD WHJR QLHPLHJR GOD RND HIHNWX MHVW MHGQ
z zalet buforowania.
%DUG]LHMVSRVWU]HJDZF]\]DXZDHZ\JOGSLHUFLHQLDZ\NUHORQHJR
SRSU]H]EXIRUMHVWQLHFRLQQ\QLZ\NUHORQHJREH]SRUHGQLR:\QLND
WRVWGHSRGF]DVEXIRURZDQLDRNUJMHVWZ\NUHODQ\MDNRZLHORNW
R]QDF]QHMDOHQLHGRVWDWHF]QHMOLF]ELHERNZ
import janb.view.*;
public
class Master
extends View {
private int x, y,
w, h;
public void initView()
{
w = getWidth();
h = getHeight();
x = (w-100) >> 1;
y = (h-100) >> 1;
drawView();
toBuffer();
}

(NUDQ
Buforowanie
Z\NUHODQLD

public void drawView()

{
setColor(Blue);
setStroke(1);
drawLine(0, 0, w, h);
drawLine(w, 0, 0, h);
setStroke(10);
setColor(Red);
drawCircle(x, y, 100, Ring);
}
public void keyPressed(int key)
{
switch(key) {
case UpKey:
y--; break;
case DnKey:
y++; break;
case LtKey:
x--; break;
case RtKey:
x++; break;
default:
beep();
}
redraw();
drawBuffer();
}
}

.XUVRU\
=SDQHOHPZV]F]HJyOQRFL]widokiemPR*QD]ZL]Dkursor, zdefiniowany za poPRFprzezroczystego obrazu GIF'R]DU]G]DQLDNXUVRUDPLVX*IXQNFMHgetCursor
i setCursor.
Cursor getCursor(String file, int x, int y)

Dostarcza kursor zaprojektowany w pliku file ]SXQNWHPZ\Uy*QLRQ\PZx, y). Plik poZLQLHQ PLH UR]V]HU]HQLH .gif L ]DZLHUD SU]H]URF]\VW\ REUD] Z IRUPDFLH GIF, o rozmiarach 16 x 16 pikseli.
void setCursor(Cursor cursor)

=ZL]XMH]ZLGRNLHPNXUVRUcursor.
1DVW
SXMF\DSOHWSRND]DQ\QDHNUDQLH:DVQ\NXUVRU]DVW
SXMHVWDQGDUGRZ\NXUVRU
kursorem zdefiniowanym w pliku Cursor.gif.
(NUDQ
:DVQ\NXUVRU

import janb.view.*;
import java.awt.*;
public
class Master
extends View {
JRUF\SXQNWNXUVRUD
private int xHot = 0,
yHot = 0;

public void initView()

{
// utworzenie kursora
Cursor cursor = getCursor("Cursor.gif", xHot, yHot);
]ZL]DQLHNXUVRUD]ZLGRNLHP
setCursor(cursor);
}
}