Issuu on Google+

ƁƈƁƍƁƒƉƏƒ ƅ. ƊƏƔƓƒƏƍƉƊƏƋƁƒ

ȂǹĬǾȂǹȉǹ JAVA

ƮƭƧƷƳ 2003


ȂĮșȒµĮIJĮ Java -1-

1. ǼǿȈǹīȍīǾ 1.1 Ǿ ǿıIJȠȡȓĮ IJȘȢ Java ȉȠ 1990, Ƞ James Gosling, ʌȠȣ İȡȖĮȗȩIJĮȞ ıIJȘȞ İIJĮȚȡȓĮ Sun Microsystems, ȑȜĮȕİ IJȘȞ İȞIJȠȜȒ ȞĮ įȘµȚȠȣȡȖȒıİȚ ʌȡȠȖȡȐµµĮIJĮ ʌȠȣ ȞĮ İȜȑȖȤȠȣȞ įȚȐijȠȡİȢ ȠȚțȚĮțȑȢ ȘȜİțIJȡȠȞȚțȑȢ ıȣıțİȣȑȢ, ȩʌȦȢ IJȠ ȕȓȞIJİȠ, IJȘȞ IJȘȜİȩȡĮıȘ țĮȚ IJȠȞ ijȠȪȡȞȠ µȚțȡȠțȣµȐIJȦȞ, µİ ıțȠʌȩ IJȘȞ įȚțIJȪȦıȘ IJȦȞ ıȣıțİȣȫȞ ĮȣIJȫȞ. ǹȡȤȚțȐ Ƞ Gosling țĮȚ Ș ȠµȐįĮ IJȠȣ ȤȡȘıȚµȠʌȠȓȘıĮȞ ȖȚĮ IJȠ ıțȠʌȩ ĮȣIJȩ IJȘȞ ȖȜȫııĮ ʌȡȠȖȡĮµµĮIJȚıµȠȪ C++, Ș ȠʌȠȓĮ İțİȓȞȘ IJȘȞ İʌȠȤȒ ȒIJĮȞ ʌȠȜȪ įȘµȠijȚȜȒȢ ıIJȠȣȢ ʌȡȠȖȡĮµµĮIJȚıIJȑȢ ȜȩȖȦ IJȘȢ įȣȞĮIJȩIJȘIJĮȢ IJȠȣ ĮȞIJȚțİȚµİȞȠıIJȡĮijȠȪȢ ʌȡȠȖȡĮµµĮIJȚıµȠȪ ʌȠȣ ʌĮȡİȓȤİ. ǵµȦȢ, ĮȡțİIJȐ ȖȡȒȖȠȡĮ, Ƞ Gosling, įȚĮʌȓıIJȦıİ ȩIJȚ Ș C++ įİȞ ȒIJĮȞ țĮIJȐȜȜȘȜȘ ȖȚĮ IJȠȞ ıțȠʌȩ IJȠȣ İʌİȚįȒ ȒIJĮȞ ĮȡțİIJȐ ʌİȡȓʌȜȠțȘ. DzIJıȚ ĮʌȠijȐıȚıİ ȞĮ įȘµȚȠȣȡȖȒıİȚ µȓĮ įȚțȒ IJȠȣ ȖȜȫııĮ ʌȡȠȖȡĮµµĮIJȚıµȠȪ. īȚĮ IJȘȞ įȘµȚȠȣȡȖȓĮ ĮȣIJȒȢ IJȘȢ ȞȑĮȢ ȖȜȫııĮȢ ʌȡȠȖȡĮµµĮIJȚıµȠȪ Ƞ Gosling ȤȡȘıȚµȠʌȠȓȘıİ IJȘȞ C++ ȦȢ ʌȡȩIJȣʌȠ, țȡĮIJȫȞIJĮȢ Įʌȩ ĮȣIJȒ IJȘȞ ȕĮıȚțȒ ıȪȞIJĮȟȘ IJȦȞ İȞIJȠȜȫȞ țĮșȫȢ țĮȚ IJȠȞ ĮȞIJȚțİȚµİȞȠıIJȡĮijȒ ȤĮȡĮțIJȒȡĮ IJȘȢ. ȉȠ ĮʌȠIJȑȜİıµĮ ĮȣIJȒȢ IJȘȢ ʌȡȠıʌȐșİȚĮȢ ȒIJĮȞ Ș ȖȜȫııĮ Oak. ǹȡȖȩIJİȡĮ, Ș Sun ĮȞIJİȜȒijșȘ ȩIJȚ IJȠ ȩȞȠµĮ Oak ȒIJĮȞ ȒįȘ ıȒµĮ țĮIJĮIJİșȑȞ țȐʌȠȚȠȣ ȐȜȜȠȣ țĮȚ ȑIJıȚ µİIJȠȞȩµĮıİ IJȘȞ ȖȜȫııĮ ıİ Java. ȉĮ ʌȡȠȖȡȐµµĮIJĮ ʌȠȣ İȓȞĮȚ ȖȡĮµµȑȞĮ ıİ Java İȓȞĮȚ ĮȞİȟȐȡIJȘIJĮ Įʌȩ IJȠȞ IJȪʌȠ IJȠȣ ȣʌȠȜȠȖȚıIJȒ ıIJȠȞ ȠʌȠȓȠ șĮ İțIJİȜİıIJȠȪȞ (ĮȞİȟȐȡIJȘIJĮ ʌȜĮIJijȩȡµĮȢ). ǹȣIJȩ İʌȚIJȣȖȤȐȞİIJĮȚ ȤȐȡȚȢ ıIJȘȞ İȚįȚțȒ µȠȡijȒ ʌȠȣ ȑȤȠȣȞ IJĮ ĮȡȤİȓĮ µİIJĮijȡĮıµȑȞȦȞ ʌȡȠȖȡĮµµȐIJȦȞ IJȘȢ Java, ĮȣIJȒ Ș µȠȡijȒ țĮȜİȓIJĮȚ țȫįȚțĮȢ byte (byte-code). ǹȡȤİȓĮ ĮȣIJȒȢ IJȘȢ µȠȡijȒȢ µʌȠȡȠȪȞ ȞĮ įȚĮȕĮıIJȠȪȞ țĮȚ ȞĮ İțIJİȜİıIJȠȪȞ Įʌȩ ȠʌȠȚȠȞįȒʌȠIJİ ȣʌȠȜȠȖȚıIJȒ ʌȠȣ ȑȤİȚ İȖțĮIJİıIJȘµȑȞȠ IJȠȞ įȚİȡµȘȞİȣIJȒ (interpreter) IJȘȢ Java. ĭȣıȚțȐ Ƞ įȚİȡµȘȞİȣIJȒȢ IJȘȢ Java İȓȞĮȚ ĮȞȐȜȠȖȠȢ µİ IJȠ ıȪıIJȘµĮ ıIJȠ ȠʌȠȓȠ șĮ ȤȡȘıȚµȠʌȠȚȘșİȓ, įȘȜĮįȒ ȐȜȜȠȢ İȓȞĮȚ Ƞ įȚİȡµȘȞİȣIJȒȢ ȖȚĮ ʌİȡȚȕȐȜȜȠȞ DOS, ȐȜȜȠȢ ȖȚĮ UNIX ț.Ȝ.ʌ. ȉȠ 1993, ȩIJĮȞ Ƞ ȆĮȖțȩıµȚȠȢ ǿıIJȩȢ (WWW: World Wide Web) ȐȡȤȚȗİ ȞĮ ĮʌȠțIJȐ ȩȜȠ țĮȚ ʌİȡȚııȩIJİȡȠ ȖȡĮijȚțȩ ʌİȡȚȕȐȜȜȠȞ, Ș ȠµȐįĮ ĮȞȐʌIJȣȟȘȢ IJȘȢ Java įȚĮʌȓıIJȦıİ ȩIJȚ Ș ȖȜȫııĮ ʌȠȣ İȓȤİ ĮȞĮʌIJȪȟİȚ ȒIJĮȞ țĮIJȐȜȜȘȜȘ ȖȚĮ ʌȡȠȖȡĮµµĮIJȚıµȩ ıIJȠȞ ǿıIJȩ. DzIJıȚ ʌȡȠȑțȣȥĮȞ µȚțȡȐ ʌȡȠȖȡȐµµĮIJĮ IJĮ ȠʌȠȓĮ µʌȠȡȠȪȞ ȞĮ İȞıȦµĮIJȦșȠȪȞ ıİ ȚıIJȠıİȜȓįİȢ, ĮȣIJȐ ȠȞȠµȐıIJȘțĮȞ applets (µȚțȡȠİijĮȡµȠȖȑȢ Ȓ µȓȞȚ İijĮȡµȠȖȑȢ). ȉĮȣIJȩȤȡȠȞĮ țĮIJĮıțİȣȐıIJȘțİ țĮȚ Ƞ ʌȡȫIJȠȢ ijȣȜȜȠµİIJȡȘIJȒȢ ʌȠȣ µʌȠȡȠȪıİ ȞĮ ݵijĮȞȓıİȚ ȚıIJȠıİȜȓįİȢ ʌȠȣ ʌİȡȚİȓȤĮȞ applets, ʌȠȣ ȠȞȠµȐıIJȘțİ HotJava. ȈȒµİȡĮ ȩȜȠȚ ȠȚ įȘµȠijȚȜİȓȢ ijȣȜȜȠµİIJȡȘIJȑȢ (ȩʌȦȢ Ƞ Microsoft Internet Explorer – MIE țĮȚ Ƞ Netscape Navigator - NN) ȣʌȠıIJȘȡȓȗȠȣȞ ȚıIJȠıİȜȓįİȢ ʌȠȣ ʌİȡȚȑȤȠȣȞ applets. ȈIJȚȢ 23 ȂĮǸȠȣ IJȠȣ 1995, Ș Sun Microsystems țȣțȜȠijȩȡȘıİ İʌȓıȘµĮ IJȘȞ Java, ȦȢ ȖȜȫııĮ ʌȡȠȖȡĮµµĮIJȚıµȠȪ IJȠȣ ǻȚĮįȚțIJȪȠȣ.

1.2 ȉĮ ȋĮȡĮțIJȘȡȚıIJȚțȐ IJȘȢ Java ȈȪµijȦȞĮ µİ IJȘȞ Sun Microsystems, IJĮ țȣȡȚȩIJİȡĮ ȤĮȡĮțIJȘȡȚıIJȚțȐ IJȘȢ Java İȓȞĮȚ: x

ǹʌȜȩIJȘIJĮ.

x

ǹȞIJȚțİȚµİȞȠıIJȡȑijİȚĮ. ȉĮ ʌȐȞIJĮ ıIJȘȞ Java İȓȞĮȚ İȓIJİ țȜȐıȘ (class), İȓIJİ µȑșȠįȠȢ (method), İȓIJİ ĮȞIJȚțİȓµİȞo (object). ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java -2-

x

ǹȞİȟĮȡIJȘıȓĮ Įʌȩ IJȠ ıȪıIJȘµĮ. ȉĮ ʌȡȠȖȡȐµµĮIJĮ ıİ Java µʌȠȡȠȪȞ ȞĮ įȚĮȕĮıIJȠȪȞ țĮȚ ȞĮ IJȡȑȟȠȣȞ Įʌȩ įȚİȡµȘȞİȣIJȑȢ ıİ įȚȐijȠȡİȢ ʌȜĮIJijȩȡµİȢ ȩʌȦȢ Windows 98, Windows 2000 țĮȚ UNIX.

x

ǹıijȐȜİȚĮ

x

ȆȠȜȣȞȘµĮIJȚțȩIJȘIJĮ. DzȞĮ ʌȡȩȖȡĮµµĮ ıİ Java µʌȠȡİȓ ȞĮ țȐȞİȚ IJĮȣIJȩȤȡȠȞĮ ʌȠȜȜȐ, įȚĮijȠȡİIJȚțȐ ʌȡȐȖµĮIJĮ, ĮȞİȟȐȡIJȘIJĮ țĮȚ ĮȜȜȘȜİʌȚįȡȫȞIJĮ.

1.3 ȉĮ ȆȡȠȖȡȐµµĮIJĮ IJȘȢ Java Ǿ ȖȜȫııĮ Java µʌȠȡİȓ ȞĮ ȤȡȘıȚµȠʌȠȚȘșİȓ ȖȚĮ IJȘȞ įȘµȚȠȣȡȖȓĮ įȪȠ IJȪʌȦȞ ʌȡȠȖȡĮµµȐIJȦȞ: IJȦȞ applets (ȩʌȦȢ İȓʌĮµİ țĮȚ ʌȡȠȘȖȠȣµȑȞȦȢ) țĮȚ IJȦȞ İijĮȡµȠȖȫȞ ʌȠȣ µʌȠȡȠȪȞ ȞĮ İțIJİȜİıIJȠȪȞ ıIJȠ ʌİȡȚȕȐȜȜȠȞ țȐʌȠȚȠȣ ȁİȚIJȠȣȡȖȚțȠȪ ȈȣıIJȒµĮIJȠȢ (ȩʌȦȢ IJĮ ʌȡȠȖȡȐµµĮIJĮ IJȦȞ ȐȜȜȦȞ ȖȜȦııȫȞ ʌȡȠȖȡĮµµĮIJȚıµȠȪ, ʌ.Ȥ. C, C++, Pascal ț.Ȝ.ʌ.). DzȞĮ applet ĮʌȠIJİȜİȓ ĮʌȜȫȢ IJµȒµĮ µȚĮȢ ȚıIJȠıİȜȓįĮȢ, ȩʌȦȢ µȓĮ İȚțȩȞĮ Ȓ µȓĮ ȖȡĮµµȒ țİȚµȑȞȠȣ. Ȃİ IJȠȞ ȓįȚȠ IJȡȩʌȠ ʌȠȣ ijȣȜȜȠµİIJȡȘIJȒȢ ijȡȠȞIJȓȗİȚ ȫıIJİ ȞĮ ݵijĮȞȚıIJİȓ ıȦıIJȐ µȓĮ İȚțȩȞĮ ıİ µȓĮ ȚıIJȠıİȜȓįĮ, ȑȞĮȢ ijȣȜȜȠµİIJȡȘIJȒȢ ʌȠȣ ȣʌȠıIJȘȡȓȗİȚ Java µʌȠȡİȓ ȞĮ İțIJİȜİȓ IJȠ applet. ȋȡȘıȚµȠʌȠȚȫȞIJĮȢ applets, µʌȠȡȠȪµİ ȞĮ țȐȞȠȣµİ ʌȠȜȜȐ ʌȡȐȖµĮIJĮ, Įʌȩ IJȠ ȞĮ ʌȡȠıșȑıȠȣµİ țȚȞȠȪµİȞĮ ȖȡĮijȚțȐ ıIJȘȞ ȚıIJȠıİȜȓįĮ µĮȢ, µȑȤȡȚ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ʌĮȚȤȞȓįȚĮ ʌȠȣ șĮ ʌĮȓȗȠȞIJĮȚ ıİ ʌİȡȚȕȐȜȜȠȞ ǿıIJȠȪ.

1.4 ǼȖțĮșȚıIJȫȞIJĮȢ IJȘ JAVA ȅȚ įȚȐijȠȡİȢ İțįȩıİȚȢ IJȘȢ Java ıİ įȚĮijȠȡİIJȚțȐ ıIJȐįȚĮ ȠȜȠțȜȒȡȦıȘȢ įȚĮIJȓșİȞIJĮȚ Įʌȩ IJȘ Sun, µİ IJȘȞ µȠȡijȒ ʌĮțȑIJȠȣ ʌȠȣ țĮȜİȓIJĮȚ Java Developers Kit (JDK). ȀĮIJȐ IJȘȞ İȖțĮIJȐıIJĮıȘ ĮȞIJȚȖȡȐijȠȞIJĮȚ IJĮ țĮIJȐȜȜȘȜĮ ĮȡȤİȓĮ ıİ ȑȞĮȞ țĮIJȐȜȠȖȠ IJȠȣ ıțȜȘȡȠȪ µĮȢ įȓıțȠȣ ʌȠȣ ȜȑȖİIJĮȚ JDK1.3 (1.3 İȓȞĮȚ Ș IJȡȑȤȠȣıĮ ȑțįȠıȘ IJȘȢ Java). ȅ țĮIJȐȜȠȖȠȢ ĮȣIJȩȢ ʌİȡȚȑȤİȚ ȠȡȚıµȑȞȠȣȢ ȣʌȠțĮIJĮȜȩȖȠȣȢ, įȪȠ Įʌȩ IJȠȣȢ ȠʌȠȓȠȣȢ ȜȑȖȠȞIJĮȚ lib țĮȚ bin. ȅ țĮIJȐȜȠȖȠȢ lib ʌİȡȚȑȤİȚ įȚȐijȠȡİȢ ȕȠȘșȘIJȚțȑȢ țȜȐıİȚȢ ʌȠȣ ȤȡİȚȐȗİIJĮȚ Ƞ įȚİȡµȘȞİȣIJȒȢ ȩIJĮȞ µİIJĮijȡȐȗİȚ IJȠ ʌȡȩȖȡĮµµȐ µĮȢ. ȅ țĮIJȐȜȠȖȠȢ bin ʌİȡȚȑȤİȚ ȩȜĮ IJĮ ĮʌĮȡĮȓIJȘIJĮ ʌȡȠȖȡȐµµĮIJĮ ȖȚĮ IJȘȞ µİIJȐijȡĮıȘ, IJȘȞ İțIJȑȜİıȘ, IJȘȞ İțıijĮȜµȐIJȦıȘ ț.Ȝ.ʌ. IJȦȞ ʌȡȠȖȡĮµµȐIJȦȞ Java. īȚĮ IJȠ ȜȩȖȠ ĮȣIJȩ, țĮȜȩ șĮ ȒIJĮȞ ȞĮ ʌȡȠıșȑıȠȣµİ ĮȣIJȠȪȢ IJȠȣȢ įȪȠ țĮIJĮȜȩȖȠȣȢ ıIJȘȞ µİIJĮȕȜȘIJȒ ʌİȡȚȕȐȜȜȠȞIJȠȢ Path IJȠȣ ĮȡȤİȓȠȣ Autoexec.bat. ȉȠ ȕĮıȚțȩ ʌİȡȚȕȐȜȜȠȞ IJȘȢ Java ĮʌȠIJİȜİȓIJĮȚ Įʌȩ ȑȞĮ ʌȡȩȖȡĮµµĮ ʌȠȣ µĮȢ İʌȚIJȡȑʌİȚ ȞĮ ȕȜȑʌȠȣµİ IJĮ įȚȐijȠȡĮ applets ʌȠȣ șĮ țĮIJĮıțİȣȐȗȠȣµİ (ȜȑȖİIJĮȚ appletviewer.exe), ȑȞĮȞ įȚİȡµȘȞİȣIJȒ ʌȠȣ µİIJĮIJȡȑʌİȚ IJȠȞ ʌȘȖĮȓȠ țȫįȚțĮ IJȘȢ Java ıİ țȫįȚțĮ byte (ȜȑȖİIJĮȚ javac.exe), țȚ ȑȞĮȞ įȚİȡµȘȞİȣIJȒ IJȘȢ Java ȖȚĮ ȞĮ İțIJİȜİȓ IJĮ ʌȡȠȖȡȐµµĮIJĮ (ȜȑȖİIJĮȚ java.exe). ǼʌȓıȘȢ ĮʌĮȡĮȓIJȘIJȠ ȑȞĮ ʌȡȩȖȡĮµµĮ ıȪȞIJĮȟȘȢ țİȚµȑȞȠȣ, ȩʌȦȢ IJȠ ıȘµİȚȦµĮIJȐȡȚȠ IJȦȞ Windows Ȓ Ƞ Edit IJȠȣ DOS, IJȠ ȠʌȠȓȠ șĮ ȤȡȘıȚµȠʌȠȚȠȪµİ ȖȚĮ IJȘȞ ıȣȖȖȡĮijȒ IJȠȣ ʌȘȖĮȓȠȣ țȫįȚțĮ IJȦȞ ʌȡȠȖȡĮµµȐIJȦȞ.

2. ȈȊȃȉǹȄǾ 2.1 ȉȠ ȆȡȫIJȠ ȆȡȩȖȡĮµµĮ ǼȓȞĮȚ ʌȚĮ ıȣȞȘșȚıµȑȞȠ, IJȠ ʌȡȫIJȠ ʌȡȩȖȡĮµµĮ ʌȠȣ ȖȡȐijİȚ țĮȞİȓȢ ıİ µȓĮ ȖȜȫııĮ ʌȡȠȖȡĮµµĮIJȚıµȠȪ ȞĮ İȓȞĮȚ IJȠ ʌȡȩȖȡĮµµĮ HelloWorld, ȑȞĮ ʌȡȩȖȡĮµµĮ ʌȠȣ IJȣʌȫȞİȚ ıIJȘ ȠșȩȞȘ IJȠ ĮȜijĮȡȚșµȘIJȚțȩ "Hello World". ĬĮ ȟİțȚȞȒıȠȣµİ țȚ ݵİȓȢ µİ IJȠȞ ȓįȚȠ IJȡȩʌȠ, ȤȦȡȓȢ ȞĮ įȚĮijȠȡȠʌȠȚȘșȠȪµİ Įʌȩ IJȘȞ ʌĮȡȐįȠıȘ.

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java -3-

ǹțȠȜȠȣșİȓ IJȠ ʌȡȩȖȡĮµµĮ HelloWorld ȖȡĮµµȑȞȠ ıİ Java. ȆȜȘțIJȡȠȜȠȖİȓıIJİ IJȠ ıİ ȑȞĮ ĮȡȤİȓȠ țİȚµȑȞȠȣ țĮȚ ıȫıIJİ IJȠ ı’ ȑȞĮ ĮȡȤİȓȠ µİ IJȠ ȩȞȠµĮ HelloWorld.java. ǹȣIJȩ İȓȞĮȚ IJȠ ĮȡȤİȓȠ ʌȘȖĮȓȠȣ țȫįȚțĮ. class HelloWorld { public static void main (String args[]) { System.out.println("Hello World!"); } } ȆȡȠıȠȤȒ ʌȡȑʌİȚ ȞĮ įȠșİȓ țĮIJȐ IJȘȞ ʌȜȘțIJȡȠȜȩȖȘıȘ, İȚįȚțȩIJİȡĮ: x

ȂȘȞ ȟİȤȞȐIJİ IJȠ İȜȜȘȞȚțȩ İȡȦIJȘµĮIJȚțȩ µİIJȐ IJȠ System.out.println("Hello World");

x

ȉȘȡȒıIJİ µİ ĮțȡȓȕİȚĮ IJĮ țİijĮȜĮȓĮ țĮȚ IJĮ ʌİȗȐ ȖȡȐµµĮIJĮ. Ǿ Java țȐȞİȚ įȚȐțȡȚıȘ µİIJĮȟȪ țİijĮȜĮȓȦȞ țĮȚ ʌİȗȫȞ ȖȡĮµµȐIJȦȞ. īȚĮ ʌĮȡȐįİȚȖµĮ, IJĮ class țĮȚ Class įİȞ İȓȞĮȚ ȓįȚĮ!

īȚĮ ȞĮ µİIJĮȖȜȦIJIJȓıİIJİ ĮȣIJȩ IJȠ ʌȡȩȖȡĮµµĮ, µİIJĮȕİȓIJİ ıIJȘȞ ȖȡĮµµȒ İȞIJȠȜȫȞ IJȠȣ MS-DOS țĮȚ ıIJȠȞ ȓįȚȠ țĮIJȐȜȠȖȠ µİ IJȠ HelloWorld.java, ıIJȘ ıȣȞȑȤİȚĮ ʌȜȘțIJȡȠȜȠȖȒıIJİ: javac HelloWorld.java ǵIJĮȞ IJȠ ʌȡȩȖȡĮµµĮ µİIJĮȖȜȦIJIJȚıIJİȓ İʌȚIJȣȤȫȢ, įȘµȚȠȣȡȖİȓIJĮȚ ȑȞĮ ĮȡȤİȓȠ ʌȠȣ ȠȞȠµȐȗİIJĮȚ HelloWorld.class ıIJȠȞ ȓįȚȠ țĮIJȐȜȠȖȠ, ĮȣIJȩ İȓȞĮȚ IJȠ µİIJĮȖȜȦIJIJȚıµȑȞȠ ĮȡȤİȓȠ. DzIJıȚ İıİȓȢ µʌȠȡİȓIJİ ȞĮ IJȡȑȤİIJİ IJȠ ʌȡȩȖȡĮµµĮ ʌȜȘțIJȡȠȜȠȖȫȞIJĮȢ ıIJȘ ȖȡĮµµȒ İȞIJȠȜȫȞ: java HelloWorld ǵʌȦȢ ʌȚșĮȞȩȞ ȞĮ µĮȞIJȑȥĮIJİ IJȠ ʌȡȩȖȡĮµµĮ ĮȞIJĮʌȠțȡȓȞİIJĮȚ IJȣʌȫȞȠȞIJĮȢ IJȠ µȒȞȣµĮ Hello World! ıIJȘȞ ȠșȩȞȘ. ǼȟİIJȐȗȠȞIJĮȢ IJȠ HelloWorld ȉȠ HelloWorld İȓȞĮȚ ȓıȦȢ IJȠ ʌȚȠ ĮʌȜȩ ʌȡȩȖȡĮµµĮ ʌȠȣ µʌȠȡİȓ țĮȞİȓȢ ȞĮ ijĮȞIJĮıIJİȓ. ȆĮȡȩȜĮ ĮȣIJȐ µĮȢ İȞįȚĮijȑȡİȚ ȖȚĮ ʌȠȜȜȠȪȢ ȜȩȖȠȣȢ. ǹȢ IJȠ İȟİIJȐıȠȣµİ ȖȡĮµµȒ ʌȡȠȢ ȖȡĮµµȒ. Ǿ ĮȡȤȚțȒ įȒȜȦıȘ class µʌȠȡİȓ ȞĮ șİȦȡİȓIJĮȚ ȩIJȚ ʌȡȠıįȚȠȡȓȗİȚ IJȠ ȩȞȠµĮ IJȠȣ ʌȡȠȖȡȐµµĮIJȠȢ, ıIJȘ ıȣȖțİțȡȚµȑȞȘ ʌİȡȓʌIJȦıȘ HelloWorld. O µİIJĮȖȜȦIJIJȚıIJȒȢ ĮʌȠșȘțİȪİȚ IJȠȞ µİIJĮȖȜȦIJIJȚıµȑȞȠ țȫįȚțĮ ıİ ȑȞĮ ĮȡȤİȓȠ µİ ȩȞȠµĮ IJȠ ȩȞȠµĮ ʌȠȣ ȣʌȐȡȤİȚ ıIJȘ įȒȜȦıȘ class HelloWorld țĮȚ ʌȡȠȑțIJĮıȘ .class. ǹȞ ȣʌȐȡȤȠȣȞ ʌĮȡĮʌȐȞȦ Įʌȩ µȓĮ țȜȐıİȚȢ ıİ ȑȞĮ ĮȡȤİȓȠ ʌȘȖĮȓȠȣ țȫįȚțĮ, IJȩIJİ Ƞ µİIJĮȖȜȦIJIJȚıIJȒȢ șĮ ĮʌȠșȘțİȪıİȚ IJȠ țĮșȑȞĮ ı’ ȑȞĮ ȟİȤȦȡȚıIJȩ .class ĮȡȤİȓȠ. īȚĮ ȜȩȖȠȣȢ ʌȠȣ șĮ įȠȪµİ ʌĮȡĮțȐIJȦ İȓȞĮȚ ıȣȞİIJȩ ȞĮ įȓȞȠȣµİ ıIJȠ ĮȡȤİȓȠ IJȠȣ ʌȘȖĮȓȠȣ țȫįȚțĮ, IJȠ ȓįȚȠ ȩȞȠµĮ µİ ĮȣIJȩ IJȘȢ țȜȐıȘȢ țĮȚ țĮIJȐȜȘȟȘ .java. Ǿ țȜȐıȘ HelloWorld ʌİȡȚȜĮµȕȐȞİȚ µȓĮ µȑșȠįȠ, IJȘ main (ȠȚ µȑșȠįȠȚ İȓȞĮȚ ȩµȠȚİȢ µİ IJȚȢ ıȣȞĮȡIJȒıİȚȢ IJȘȢ C). ǵʌȦȢ țĮȚ ıIJȘ C, Ș µȑșȠįȠȢ main µĮȢ įİȓȤȞİȚ Įʌȩ ʌȠȣ ȟİțȚȞȐ ȞĮ İțIJİȜİȓIJĮȚ µȓĮ İijĮȡµȠȖȒ. Ǿ µȑșȠįȠȢ įȘȜȫȞİIJĮȚ įȘµȩıȚĮ (public), įȘȜĮįȒ µʌȠȡİȓ ȞĮ țȜȘșİȓ Įʌȩ ʌĮȞIJȠȪ µȑıĮ ıIJȠ ʌȡȩȖȡĮµµĮ. ǻȘȜȫȞİIJĮȚ ıIJĮIJȚțȒ (static), įȘȜĮįȒ ıİ įȚĮįȠȤȚțȑȢ țȜȒıİȚȢ IJȘȢ įȚĮIJȘȡİȓ IJȚȢ IJȚµȑȢ IJȘȢ. ǻȘȜȫȞİIJĮȚ țİȞȒ (void), ʌȠȣ ıȘµĮȓȞİȚ ȩIJȚ ĮȣIJȒ Ș µȑșȠįȠȢ įİȞ İʌȚıIJȡȑijİȚ IJȚµȒ, ȩʌȦȢ țĮȚ ıIJȘ C. ǵIJĮȞ țĮȜİȓIJĮȚ Ș µȑșȠįȠȢ main, IJȣʌȫȞİȚ IJȠ "Hello World!" ıIJȘȞ ȠșȩȞȘ. ǹȣIJȩ İʌȚIJȣȖȤȐȞİIJĮȚ µİ IJȘȞ țȜȒıȘ IJȘȢ µİșȩįȠȣ System.out.println. īȚĮ ȞĮ İȓµĮıIJİ ʌȚȠ ĮțȡȚȕİȓȢ, ĮȣIJȩ İʌȚIJȣȖȤȐȞİIJĮȚ țĮȜȫȞIJĮȢ IJȘȞ println() IJȠȣ ʌİįȓȠȣ out ʌȠȣ ĮȞȒțİȚ ıIJȘȞ țȜȐıȘ System. ǹȜȜȐ ȖȚĮ IJȘȞ ȫȡĮ șĮ IJȘȞ șİȦȡȠȪµİ ıĮȞ µȓĮ µȑșȠįȠ. ȀĮȚ

µȚĮ

IJİȜİȣIJĮȓĮ

ıȘµİȓȦıȘ.

ǹȞIJȓșİIJĮ

µİ

IJȘȞ

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ

printf

IJȘȢ

C,

Ș

µȑșȠįȠȢ


ȂĮșȒµĮIJĮ Java -4-

System.out.println ʌȡȠıșȑIJİȚ µȚĮ țĮȚȞȠȪȡȚĮ ȖȡĮµµȒ ıIJȠ IJȑȜȠȢ IJȘȢ İȟȩįȠȣ. DzIJıȚ įİȞ İȓȞĮȚ ĮȞȐȖțȘ ȞĮ ıȣµʌİȡȚȜȐȕȠȣµİ IJȠ "\n" ıIJȠ IJȑȜȠȢ țȐșİ ĮȜijĮȡȚșµȘIJȚțȠȪ.

2.2 DZȖțȚıIJȡĮ țĮȚ ȂʌȜȠț ǹȢ İȟİIJȐıȠȣµİ IJȠ ʌȡȩȖȡĮµµĮ HelloWorld ȜȓȖȠ ʌȚȠ ĮȞĮȜȣIJȚțȐ. ȈIJȘ Java IJȠ ĮȡȤİȓȠ ʌȘȖĮȓȠȣ țȫįȚțĮ ıʌȐİȚ ıİ țȠµµȐIJȚĮ ʌȠȣ ȤȦȡȓȗȠȞIJĮȚ µİIJĮȟȪ IJȠȣȢ µİ ȐȖțȚıIJȡĮ. ǵ,IJȚ ȣʌȐȡȤİȚ µİIJĮȟȪ { țĮȚ } İȓȞĮȚ ȑȞĮ µʌȜȠț țĮȚ ȣʌȐȡȤİȚ ȜȓȖȠ Ȓ ʌȠȜȪ ĮȞİȟȐȡIJȘIJĮ Įʌȩ ȠIJȚįȒʌȠIJİ ȐȜȜȠ ȑȟȦ Įʌȩ IJĮ ȐȖțȚıIJȡĮ. ȉĮ µʌȜȠț ȑȤȠȣȞ µİȖȐȜȘ ıȣȞIJĮțIJȚțȒ țĮȚ ȜȠȖȚțȒ ıȘµĮıȓĮ. ȋȦȡȓȢ IJĮ ȐȖțȚıIJȡĮ Ƞ țȫįȚțĮȢ įİȞ șĮ µʌȠȡȠȪıİ ȞĮ ıȣȞIJĮȤșİȓ. ȅ µİIJĮȖȜȦIJIJȚıIJȒȢ șĮ įȣıțȠȜİȣȩIJĮȞ ȞĮ ȟİȤȦȡȓıİȚ IJȠ IJȑȜȠȢ IJȘȢ µȚĮȢ µİșȩįȠȣ țĮȚ IJȘȞ ĮȡȤȒ IJȘȢ İʌȩµİȞȘȢ. ȆĮȡȐȜȜȘȜĮ șĮ ȒIJĮȞ ʌȠȜȪ įȪıțȠȜȠ ȖȚĮ țȐʌȠȚȠȞ ʌȠȣ įȚȐȕĮȗİ IJȠȞ țȫįȚțȐ ıĮȢ ȞĮ țĮIJĮȜȐȕİȚ IJȚ ıȣµȕĮȓȞİȚ Ȓ ĮțȩµĮ șĮ ȒIJĮȞ įȪıțȠȜȠ țĮȚ ȖȚĮ İıȐȢ IJȠȣȢ ȓįȚȠȣȢ. ȉĮ ȐȖțȚıIJȡĮ ȤȡȘıȚµȠʌȠȚȠȪȞIJĮȚ ȖȚĮ ȞĮ ȠµĮįȠʌȠȚȠȪȞ IJȚȢ ıȤİIJȚȗȩµİȞİȢ įȘȜȫıİȚȢ. īİȞȚțȩIJİȡĮ, ȩ,IJȚ ȕȡȓıțİIJĮȚ µİIJĮȟȪ ĮȖțȓıIJȡȦȞ İțIJİȜİȓIJĮȚ ıĮȞ µȓĮ İȞIJȠȜȒ. ȉĮ µʌȜȠț µʌȠȡİȓ ȞĮ İȓȞĮȚ ȚİȡĮȡȤȚțȐ. DzȞĮ µʌȜȠț µʌȠȡİȓ ȞĮ ʌİȡȚȑȤİȚ ȑȞĮ Ȓ ʌİȡȚııȩIJİȡĮ ȑȞșİIJĮ µʌȜȠț. ȈIJȘȞ ʌİȡȓʌIJȦıȘ IJȠȣ ʌȡȠȖȡȐµµĮIJȩȢ µĮȢ, ȑȤȠȣµİ ȑȞĮ İȟȦIJİȡȚțȩ µʌȜȠț ʌȠȣ ʌȡȠıįȚȠȡȓȗİȚ IJȘȞ țȜȐıȘ ǾelloWorld. ȂȑıĮ ıIJȘȞ țȜȐıȘ ǾelloWorld, ȑȤȠȣµİ ȑȞĮ ȐȜȜȠ µʌȜȠț ʌȠȣ ʌȡȠıįȚȠȡȓȗİȚ IJȘȞ µȑșȠįȠ main.

2.3 ȈȤȩȜȚĮ ȉĮ ıȤȩȜȚĮ µʌȠȡȠȪȞ ȞĮ ȣʌȐȡȟȠȣȞ ȠʌȠȣįȒʌȠIJİ ı’ ȑȞĮ ĮȡȤİȓȠ. ȉĮ ıȤȩȜȚĮ įȘȜȫȞȠȞIJĮȚ µİ IJȠȞ ȓįȚȠ IJȡȩʌȠ ȩʌȦȢ ıIJȘ C țĮȚ ıIJȘ C++. ǵ,IJȚ ȣʌȐȡȤİȚ µİIJĮȟȪ /* țĮȚ */ ĮȖȞȠİȓIJĮȚ Įʌȩ IJȠȞ µİIJĮȖȜȦIJIJȚıIJȒ. ǵ,IJȚ ȣʌȐȡȤİȚ ıİ µȓĮ ȖȡĮµµȒ µİIJȐ Įʌȩ įȪȠ ıȣȞİȤȩµİȞİȢ țĮșȑIJȠȣȢ //, İʌȓıȘȢ șİȦȡİȓIJĮȚ ıĮȞ ıȤȩȜȚȠ. īȚ’ ĮȣIJȩ țĮȚ IJȠ ĮțȩȜȠȣșȠ ʌȡȩȖȡĮµµĮ İȓȞĮȚ, ȩıȠ ĮijȠȡȐ IJȠȞ µİIJĮȖȜȦIJIJȚıIJȒ ȓįȚȠ µİ IJȠ ʌȡȫIJȠ: // ǹȣIJȩ İȓȞĮȚ IJȠ ʌȡȫIJȠ µȠȣ ʌȡȩȖȡĮµµĮ ıİ Java class HelloWorld1 { public static void main (String args[]) { /* Ǿ İʌȩµİȞȘ İȞIJȠȜȒ IJȣʌȫȞİȚ ıIJȘȞ ȠșȩȞȘ IJȠ: Hello World*/ System.out.println("Hello World"); } }

2.4 ǻİįȠµȑȞĮ țĮȚ ȂİIJĮȕȜȘIJȑȢ ȅȚ µȑșȠįȠȚ İȓȞĮȚ IJȠ µȚıȩ IJȘȢ Java. ȉȠ ȐȜȜȠ µȚıȩ İȓȞĮȚ IJĮ įİįȠµȑȞĮ. ĬİȦȡİȓıIJİ IJȘȞ ʌĮȡĮțȐIJȦ ȖİȞȓțİȣıȘ IJȠȣ ʌȡȠȖȡȐµµĮIJȠȢ HelloWorld : // ȆȡȩȖȡĮµµĮ HelloJohn class HelloJohn { public static void main (String args[]) { // ȂʌȠȡİȓIJİ ȞĮ ĮȞIJȚțĮIJĮıIJȒıİIJİ IJȠ ȩȞȠµĮ John // µİ IJȠ įȚțȩ ıĮȢ String name="John"; /* ǹȢ ʌȠȪµİ hello ıIJȠȞ John */ System.out.print("Hello "); System.out.println(name); } } Ǽįȫ, İʌȚȜȑȖȠȣµİ IJȠȞ ȤĮȚȡİIJȚıµȩ İȞȩȢ ıȣȖțİțȡȚµȑȞȠȣ ĮIJȩµȠȣ țĮȚ ȩȤȚ ȖİȞȚțȐ IJȠȣ țȩıµȠȣ. ǹȣIJȩ ȖȓȞİIJĮȚ įȘµȚȠȣȡȖȫȞIJĮȢ µȓĮ µİIJĮȕȜȘIJȒ ĮȜijĮȡȚșµȘIJȚțȠȪ ʌȠȣ IJȘȞ ȠȞȠµȐȗȠȣµİ name țĮȚ ĮʌȠșȘțİȪȠȞIJĮȢ IJȘȞ IJȚµȒ "John" ı’ ĮȣIJȒȞ (ȈIJȘ șȑıȘ IJȘȢ IJȚµȒȢ John µʌȠȡȠȪµİ ȞĮ İʌȚȜȑȟȠȣµİ ȠʌȠȚȠįȒʌȠIJİ ȩȞȠµĮ). ȂİIJȐ IJȣʌȫȞȠȣµİ IJȠ "Hello". ȆĮȡĮIJȘȡȒıIJİ ȩIJȚ ĮȜȜȐȟĮµİ IJȘ µȑșȠįȠ ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java -5-

System.out.println µİ IJȘȞ ʌĮȡȩµȠȚĮ System.out.print. H System.out.print İȓȞĮȚ ĮțȡȚȕȫȢ ȓįȚĮ µİ IJȘȞ System.out.println µİ IJȘ µȩȞȘ įȚĮijȠȡȐ ȩIJȚ įİȞ ĮȜȜȐȗİȚ ȖȡĮµµȒ ĮijȠȪ IJİȜİȚȫıİȚ. īȚ’ ĮȣIJȩ, ȩIJĮȞ ijIJȐȞȠȣµİ ıIJȘȞ İʌȩµİȞȘ ȖȡĮµµȒ IJȠȣ țȫįȚțĮ, Ƞ įȡȠµȑĮȢ ȕȡȓıțİIJĮȚ ĮțȩµĮ ıIJȘ ȖȡĮµµȒ IJȘȢ ȜȑȟȘȢ "Ǿello" țĮȚ İȓµĮıIJİ ȑIJȠȚµȠȚ ȞĮ IJȣʌȫıȠȣµİ IJȠ ȩȞȠµĮ. ǺȜȑʌȠȣµİ ȜȠȚʌȩȞ ȩIJȚ ıIJȘȞ Java µʌȠȡȠȪµİ ȞĮ ȤȡȘıȚµȠʌȠȚȠȪµİ IJȠȞ IJȪʌȠ String ȖȚĮ IJȘȞ įȒȜȦıȘ İȞȩȢ ĮȜijĮȡȚșµȘIJȚțȠȪ.

2.5 ȅȡȓıµĮIJĮ īȡĮµµȒȢ ǼȞIJȠȜȫȞ ȉȠ ʌȡȩȖȡĮµµȐ µĮȢ įİȞ İȓȞĮȚ ĮțȩµĮ ʌȠȜȪ ȖİȞȚțȩ, įİ µʌȠȡȠȪµİ ȞĮ ĮȜȜȐȟȠȣµİ IJȠ ȩȞȠµĮ ıIJȠ ȠʌȠȓȠ Ȝȑµİ Hello, ȤȦȡȓȢ ȞĮ İʌĮȞĮıȣȞIJȐȟȠȣµİ țĮȚ ȞĮ µİIJĮȖȜȦIJIJȓıȠȣµİ IJȠȞ țȫįȚțĮ. ĬĮ İʌȚșȣµȠȪıĮµİ IJȠ ʌȡȩȖȡĮµµĮ ȞĮ ȜȑİȚ Hello ıİ ȩʌȚȠ ȐIJȠµȠ șȑȜȠȣµİ, țĮIJȐ IJȘȞ įȚȐȡțİȚĮ İțIJȑȜİıȒȢ IJȠȣ. ǹȣIJȩ ʌȠȣ ȤȡİȚȐȗİIJĮȚ İȓȞĮȚ ȑȞĮȢ IJȡȩʌȠȢ ȞĮ ĮȜȜȐȗȠȣµİ IJȠ ȩȞȠµĮ țĮIJȐ IJȘ įȚȐȡțİȚĮ ʌȠȣ IJȡȑȤİȚ IJȠ ʌȡȩȖȡĮµµĮ (įȘȜĮįȒ ȩIJĮȞ ʌȜȘțIJȡȠȜȠȖȠȪµİ java HelloJohn). īȚĮ ȞĮ ȖȓȞİȚ ĮȣIJȩ șĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ IJĮ ȠȡȓıµĮIJĮ ȖȡĮµµȒȢ İȞIJȠȜȫȞ (command line arguments). ȂĮȢ İʌȚIJȡȑʌȠȣȞ ȞĮ ʌȜȘțIJȡȠȜȠȖȠȪµİ Java Hello Gloria țĮȚ IJȠ ʌȡȩȖȡĮµµĮ ȞĮ ĮȞIJĮʌȠțȡȓȞİIJĮȚ įȓȞȠȞIJĮȢ ıĮȞ ȑȟȠįȠ "Hello Gloria". ǹțȠȜȠȣșİȓ Ƞ țȫįȚțĮȢ : // ȆȡȩȖȡĮµµĮ Hello class Hello { public static void main (String args[]) { /* ǹȢ ʌȠȪµİ hello */ System.out.print("Hello "); System.out.println(args[0]); } } MİIJĮȖȜȦIJIJȓıIJİ IJȠ ʌȡȩȖȡĮµµĮ ȩʌȦȢ ıȣȞȒșȦȢ țĮȚ µİIJȐ ʌȜȘțIJȡȠȜȠȖȒıIJİ java Hello Gloria. ȈIJȘȞ ʌȡĮȖµĮIJȚțȩIJȘIJĮ ĮʌĮȜȜĮȤIJȒțĮµİ Įʌȩ IJȘ µİIJĮȕȜȘIJȒ ȠȞȩµĮIJȠȢ IJȠȣ ʌȡȠȖȡȐµµĮIJȠȢ HelloJohn. ȈIJȘ șȑıȘ IJȘȢ ȤȡȘıȚµȠʌȠȚȠȪµİ IJȘȞ args[0]. Args İȓȞĮȚ ȑȞĮȢ µȠȞȠįȚȐıIJĮIJȠȢ ʌȓȞĮțĮȢ µİ ıIJȠȚȤİȓĮ ĮȜijĮȡȚșµȘIJȚțȐ. ȀȐșİ ıIJȠȚȤİȓȠ IJȠȣ ʌȓȞĮțĮ ĮȣIJȠȪ ʌĮȓȡȞİȚ IJȚµȒ Įʌȩ IJȠ ĮȞIJȓıIJȠȚȤȠ ȩȡȚıµĮ IJȘȢ ȖȡĮµµȒȢ İȞIJȠȜȫȞ. ȉȠ args[0] țȡĮIJȐİȚ IJȠ ʌȡȫIJȠ ȩȡȚıµĮ ȖȡĮµµȒȢ İȞIJȠȜȫȞ. ȉȠ args[1] țȡĮIJȐİȚ IJȠ įİȪIJİȡȠ ȩȡȚıµĮ ȖȡĮµµȒȢ İȞIJȠȜȫȞ țĮȚ ȠȪIJȦ țĮșİȟȒȢ. ǹȣIJȒ IJȘ ıIJȚȖµȒ ȓıȦȢ țȐIJȚ ȞĮ µȘȞ ıĮȢ ijĮȓȞİIJĮȚ ıȦıIJȩ. ȆȡȠıȠȤȒ: IJȠ ʌȡȫIJȠ ıIJȠȚȤİȓȠ IJȠȣ ʌȓȞĮțĮ İȓȞĮȚ ıIJȘ șȑıȘ 0, IJȠ įİȪIJİȡȠ ıIJȘ șȑıȘ 1, IJȠ IJȡȓIJȠ ıIJȘ șȑıȘ 2 țĮȚ ȠȪIJȦ țĮșİȟȒȢ. ǹȣIJȩ ıȣµȕĮȓȞİȚ țĮȚ ıIJȘ C. ȉȫȡĮ, ĮȢ ʌİȚȡĮµĮIJȚıIJȠȪµİ ȜȓȖȠ µİ IJȠ ʌȡȩȖȡĮµµĮ. ȉȚ ıȣµȕĮȓȞİȚ ĮȞ ĮȞIJȓ ȞĮ ʌȜȘțIJȡȠȜȠȖȒıȠȣµİ java Hello Gloria, ʌȜȘțIJȡȠȜȠȖȒıȠȣµİ java Hello Gloria and Beth; ȉȚ ıȣµȕĮȓȞİȚ ĮȞ įİȞ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ țĮșȩȜȠȣ ȩȞȠµĮ ʌ.Ȥ. java Hello; ȈIJȘȞ ʌİȡȓʌIJȦıȘ ĮȣIJȒ, ȕȜȑʌȠȣµİ țȐIJȚ ıĮȞ IJȠ ʌĮȡĮțȐIJȦ: HelloException in java.lang.ArrayIndexOutOfBoundsException at Hello.main(Hello.java:4)

thread

"main"

ǹȣIJȩ ʌȠȣ ıȣµȕĮȓȞİȚ İȓȞĮȚ ȩIJȚ Įʌȩ IJȘ ıIJȚȖµȒ ʌȠȣ įİȞ įȓȞȠȣµİ ıIJȠ Hello țĮȞȑȞĮ ȩȡȚıµĮ ȖȡĮµµȒȢ İȞIJȠȜȫȞ, įİȞ ȣʌȐȡȤİȚ IJȓʌȠIJĮ ıIJȠ args[0].

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java -6-

Ȉİ ȩȜĮ IJĮ ʌĮȡĮʌȐȞȦ ʌȡȠȖȡȐµµĮIJĮ, ȩʌȠȣ ȑȤȠȣµİ įȪȠ İȞIJȠȜȑȢ İțIJȪʌȦıȘȢ, șĮ µʌȠȡȠȪıĮµİ ȞĮ ȑȤȠȣµİ µȓĮ İȞIJȠȜȒ µİ įȪȠ ȠȡȓıµĮIJĮ, İȞȦµȑȞĮ µİIJĮȟȪ IJȠȣȢ µİ IJȠ +, ʌ.Ȥ. IJȠ ʌĮȡĮʌȐȞȦ ʌȡȩȖȡĮµµĮ șĮ µʌȠȡȠȪıİ ȞĮ ȖȓȞİȚ: // ȆȡȩȖȡĮµµĮ Hello class Hello { public static void main (String args[]) { /* ǹȢ ʌȠȪµİ hello */ System.out.println("Hello " + args[0]); } }

2.6 ǼȞIJȠȜȒ if-else AțȩµĮ țĮȚ IJĮ ʌȚȠ ĮıȒµĮȞIJĮ ʌȡȠȖȡȐµµĮIJĮ ʌȡȑʌİȚ ȞĮ ʌĮȓȡȞȠȣȞ ĮʌȠijȐıİȚȢ. ȆȡȑʌİȚ ȞĮ İȜȑȖȤȠȣȞ țȐʌȠȚİȢ ıȣȞșȒțİȢ țĮȚ ȞĮ ȜİȚIJȠȣȡȖȠȪȞ įȚĮijȠȡİIJȚțȐ, ȕĮıȚȗȩµİȞĮ ı’ ĮȣIJȑȢ IJȚȢ ıȣȞșȒțİȢ. ǵȜİȢ ȠȚ ȖȜȫııİȢ ʌȡȠȖȡĮµµĮIJȚıµȠȪ ȑȤȠȣȞ µȠȡijȑȢ İȞIJȠȜȫȞ if ʌȠȣ İʌȚIJȡȑʌȠȣȞ ȞĮ İȟİIJȐȗȠȣµİ ıȣȞșȒțİȢ. ȈIJȠȞ ʌȡȠȘȖȠȪµİȞȠ țȫįȚțĮ șĮ ȑʌȡİʌİ ȞĮ İȓȤĮµİ İȜȑȖȟİȚ ĮȞ ȣʌȒȡȤĮȞ ȠȡȓıµĮIJĮ ȖȡĮµµȒȢ İȞIJȠȜȫȞ, ʌȡȠIJȠȪ ʌȡȠıʌĮșȒıȠȣµİ ȞĮ IJĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ. ǵȜȠȚ ȠȚ ʌȓȞĮțİȢ ȑȤȠȣȞ µȒțȘ țĮȚ ȖȚ’ ĮȣIJȩ ȤȡȘıȚµȠʌȠȚȠȪµİ arrayname.length. ǼȜȑȖȤȠȣµİ IJȠ µȒțȠȢ IJȠȣ args ʌĮȡĮțȐIJȦ:

IJȘ

µİIJĮȕȜȘIJȒ

// ȆȡȩȖȡĮµµĮ Hello class Hello1 { public static void main (String args[]) { /* ǹȢ ʌȠȪµİ hello */ System.out.print("Hello "); if (args.length>0) { System.out.println(args[0]); } } } MİIJĮȖȜȦIJIJȓıIJİ țĮȚ IJȡȑȟIJİ IJȠ ʌȡȩȖȡĮµµĮ, įȓȞȠȞIJĮȢ įȚĮijȠȡİIJȚțȑȢ İȚıȩįȠȣȢ țȐșİ ijȠȡȐ. ĬĮ ʌȡȑʌİȚ ȞĮ ʌĮȡĮIJȘȡȒıİIJİ ȩIJȚ įİȞ ݵijĮȞȓȗİIJĮȚ ʌȚĮ ȑȞĮ ArrayIndexOutOfBoundsException ĮȞ įİȞ įȫıİIJİ ȠȡȓıµĮIJĮ ȖȡĮµµȒȢ İȞIJȠȜȫȞ. ǹȣIJȩ ʌȠȣ țȐȞĮµİ ȒIJĮȞ ȞĮ ȕȐȜȠȣµİ IJȘȞ İȞIJȠȜȒ System.out.println(args[0]) ıİ ȑȞĮȞ ȑȜİȖȤȠ ıȣȞșȒțȘȢ if (args.length>0){ }. ȅ țȫįȚțĮȢ µİIJĮȟȪ IJȦȞ ĮȖțȓıIJȡȦȞ, System.out.println(args[0]), IJȫȡĮ ʌȚĮ İțIJİȜİȓIJĮȚ ĮȞ țĮȚ µȩȞȠ ĮȞ IJȠ µȒțȠȢ IJȦȞ args İȓȞĮȚ µİȖĮȜȪIJİȡȠ Įʌȩ IJȠ 0. ȈIJȘȞ Java ȤȡȘıȚµȠʌȠȚȠȪµİ IJȠȣȢ ʌĮȡĮțȐIJȦ IJİȜİıIJȑȢ ıȪȖțȡȚıȘȢ: ȉİȜİıIJȒȢ > >= < <= == !=

ȈȘµĮıȓĮ ȂİȖĮȜȪIJİȡȠ ȂİȖĮȜȪIJİȡȠ Ȓ ȓıȠ ȂȚțȡȩIJİȡȠ ȂȚțȡȩIJİȡȠ Ȓ ȓıȠ ǴıȠ ǻȚȐijȠȡȠ

ĬĮ ʌİȡȚµȑȞĮIJİ ȩIJȚ Ƞ ȑȜİȖȤȠȢ IJȘȢ ȚıȩIJȘIJĮȢ įȪȠ ĮȡȚșµȫȞ ʌȡĮȖµĮIJȠʌȠȚİȓIJĮȚ µİ IJȠ ıȪµȕȠȜȠ =. ǼµİȓȢ ȒįȘ ȤȡȘıȚµȠʌȠȚȒıĮµİ IJȠ ıȪµȕȠȜȠ = ȖȚĮ ȞĮ șȑıȠȣµİ IJȚµȒ ıİ µȓĮ µİIJĮȕȜȘIJȒ. īȚ’ ĮȣIJȩ ȤȡİȚĮȗȩµĮıIJİ ȑȞĮ țĮȚȞȠȪȡȚȠ ıȪµȕȠȜȠ ȖȚĮ ȞĮ İȜȑȖȤȠȣµİ IJȘȞ ȚıȩIJȘIJĮ. DzIJıȚ Ș Java įĮȞİȓȗİIJĮȚ Įʌȩ IJȘ C IJȠȞ ıȣµȕȠȜȚıµȩ ==. ǵȜȠȚ ȠȚ ȑȜİȖȤȠȚ ıȣȞșȒțȘȢ ıIJȘ Java ȗȘIJȠȪȞ IJȚµȑȢ boolean țȚ ĮȣIJȑȢ İʌȚıIJȡȑijȠȣȞ ȠȚ IJİȜİıIJȑȢ ıȪȖțȡȚıȘȢ ʌȠȣ İȓįĮµİ ʌĮȡĮʌȐȞȦ. Ǿ Java ȣʌȠıIJȘȡȓȗİȚ IJȠȞ IJȪʌȠ Boolean (ıİ ĮȞIJȓșİıȘ µİ IJȘȞ C). ȂȓĮ µİIJĮȕȜȘIJȒ Ȓ ȑțijȡĮıȘ IJȪʌȠȣ boolean, µʌȠȡİȓ ȞĮ ʌȐȡİȚ IJȚȢ IJȚµȑȢ true țĮȚ false. ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java -7-

ǴıȦȢ ȞĮ ʌĮȡĮIJȘȡȒıĮIJİ ȑȞĮ ȜȠȖȚțȩ ıijȐȜµĮ ıIJȠ ʌȡȠȘȖȠȪµİȞȠ ʌȡȩȖȡĮµµĮ: ǹȞ įİȞ ʌİȡȚȜĮµȕȐȞĮµİ țĮȞȑȞĮ ȩȡȚıµĮ ȖȡĮµµȒȢ İȞIJȠȜȫȞ, IJȠ ʌȡȩȖȡĮµµĮ șĮ IJȪʌȦȞİ IJȠ "Hello" țĮȚ įİȞ șĮ ȐȜȜĮȗİ ȖȡĮµµȒ. To ʌȡȩȕȜȘµĮ ȒIJĮȞ ȩIJȚ ȤȡȘıȚµȠʌȠȚȒıĮµİ System.out.print țĮȚ ȩȤȚ System.out.println. ǻİȞ ȣʌȒȡȤİ ȤĮȡĮțIJȒȡĮȢ IJȑȜȠȣȢ ȖȡĮµµȒȢ. AȣIJȩ șĮ µʌȠȡȠȪıİ ȞĮ įȚȠȡșȦșİȓ ĮȞ IJȠʌȠșİIJȠȪıĮµİ IJȠ System.out.println(""); ıIJȠ IJȑȜȠȢ IJȘȢ µİșȩįȠȣ main ĮȜȜȐ ȑIJıȚ șĮ İȓȤĮµİ ʌȠȜȜȠȪȢ ȤĮȡĮțIJȒȡİȢ IJȑȜȠȣȢ ȖȡĮµµȒȢ ĮȞ Ƞ ȤȡȒıIJȘȢ ʌȜȘțIJȡȠȜȠȖȠȪıİ ȑȞĮ ȩȞȠµĮ. ĬĮ µʌȠȡȠȪıĮµİ ȞĮ ʌȡȠıșȑıȠȣµİ µȓĮ ĮțȩµĮ İȞIJȠȜȒ if. DzIJıȚ șĮ İȓȤĮµİ: // ȆȡȩȖȡĮµµĮ Hello2 class Hello2 { public static void main (String args[]) { /* ǹȢ ʌȠȪµİ hello */ System.out.print("Hello "); if (args.length>0) { System.out.println(args[0]); } if (args.length <= 0) { System.out.println("whoever you are"); } } } ǹȣIJȩ įȚȠȡșȫȞİȚ IJȠ ıijȐȜµĮ, ĮȜȜȐ ȤȡȘıȚµȠʌȠȚȠȪȞIJĮȚ įȪȠ İȞIJȠȜȑȢ if. ĬĮ µʌȠȡȠȪıĮµİ ȞĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ µȓĮ İȞIJȠȜȒ if ʌȠȣ ȞĮ ʌİȡȚȜĮµȕȐȞİȚ țĮȚ IJȠ ĮȞIJȓıIJȠȚȤȩ IJȘȢ else, ȩʌȦȢ ʌĮȡĮțȐIJȦ: // ȆȡȩȖȡĮµµĮ Hello3 class Hello3 { public static void main (String args[]) { /* ǹȢ ʌȠȪµİ hello */ System.out.print("Hello "); if (args.length>0) { System.out.println(args[0]); } else { System.out.println("whoever you are"); } } } Ȃİ IJȚȢ ȜȪıİȚȢ ʌȠȣ įȫıĮµİ ȑȦȢ IJȫȡĮ, ĮʌȠijİȪȖİIJĮȚ IJȠ ArrayIndexOutOfBoundsException, ȩµȦȢ įİȞ ȑȤȠȣµİ IJİȜİȚȫıİȚ ĮțȩµĮ. ȉȠ java Hello țĮȚ IJȠ Java Hello John įȠȣȜİȪȠȣȞ, ĮȜȜȐ ĮȞ ʌȜȘțIJȡȠȜȠȖȒıȠȣµİ java Hello Elliotte John Harold, Ș Java IJȣʌȫȞİȚ µȩȞȠ Hello Elliotte. ǹȢ IJȠ įȚȠȡșȫıȠȣµİ. ǻİȞ ʌİȡȚȠȡȚȗȩµĮıIJİ ıİ įȪȠ ʌİȡȚʌIJȫıİȚȢ. ȂʌȠȡȠȪµİ ȞĮ ıȣȞįȣȐıȠȣµİ ȑȞĮ else țĮȚ ȑȞĮ if įȘµȚȠȣȡȖȫȞIJĮȢ ȑȞĮ else if țĮȚ ȞĮ IJȠ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ ȖȚĮ ȞĮ İȟİIJȐıȠȣµİ µȚĮ ʌȜȘșȫȡĮ Įʌȩ ĮµȠȚȕĮȓĮ ĮʌȠțȜİȚȩµİȞİȢ ʌİȡȚʌIJȫıİȚȢ. īȚĮ ʌĮȡȐįİȚȖµĮ, ĮțȠȜȠȣșİȓ µȓĮ ȑțįȠıȘ IJȠȣ ʌȡȠȖȡȐµµĮIJȠȢ Hello ʌȠȣ ȤİȚȡȓȗİIJĮȚ IJȑııİȡĮ ȠȞȩµĮIJĮ : // ȆȡȩȖȡĮµµĮ Hello4 class Hello4 { public static void main (String args[]) { /* ǹȢ ʌȠȪµİ hello */ System.out.print("Hello "); if (args.length ==0) { ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java -8-

System.out.print("whoever you are"); } else if (args.length == 1) { System.out.println(args[0]); } else if (args.length == 2) { System.out.print(args[0]); System.out.print(" "); System.out.print(args[1]); } else if (args.length == 3) { System.out.print(args[0]); System.out.print(" "); System.out.print(args[1]); System.out.print(" "); System.out.print(args[2]); } else if (args.length == 4) { System.out.print(args[0]); System.out.print(" "); System.out.print(args[1]); System.out.print(" "); System.out.print(args[2]); System.out.print(" "); System.out.print(args[3]); } else { System.out.print(args[0]); System.out.print(" "); System.out.print(args[1]); System.out.print(" "); System.out.print(args[2]); System.out.print(" "); System.out.print(args[3]); System.out.print(" and all the rest!"); } System.out.println(); } } Ȃİ IJȠȞ ʌĮȡĮʌȐȞȦ IJȡȩʌȠ ȤİȚȡȚȗȩµĮıIJİ µȑȤȡȚ IJȑııİȡĮ ȠȡȓıµĮIJĮ ȖȡĮµµȒȢ İȞIJȠȜȫȞ, ıIJȘȞ ʌĮȡĮțȐIJȦ İȞȩIJȘIJĮ șĮ įȠȪµİ ʌȫȢ ȞĮ ȤİȚȡȚȗȩµĮıIJİ ʌȐȞȦ Įʌȩ įȪȠ įȚıİțĮIJȠµµȪȡȚĮ ȠȡȓıµĮIJĮ ȖȡĮµµȒȢ İȞIJȠȜȫȞ µİ ĮʌȜȩ IJȡȩʌȠ. ǹȈȀǾȈǾ ȄĮȞĮȖȡȐȥIJİ ȠȜȩțȜȘȡȠ IJȠ ʌĮȡĮʌȐȞȦ ʌȡȩȖȡĮµµĮ ȤȡȘıȚµȠʌȠȚȫȞIJĮȢ µȓĮ µȩȞȠ İȞIJȠȜȒ İțIJȪʌȦıȘȢ ıİ țȐșİ µʌȜȠț (ȣʌȩįİȚȟȘ: ȤȡȘıȚµȠʌȠȚȒıIJİ IJȠ +).

2.7 ǼȞIJȠȜȒ for ȈIJȘȞ İȞȩIJȘIJĮ ĮȣIJȒ șĮ İȚıȐȖȠȣµİ IJȘȞ ȑȞȞȠȚĮ IJȠȣ ȕȡȩȤȠȣ (loop). ǺȡȩȤȠȢ İȓȞĮȚ ȑȞĮ IJµȒµĮ țȫįȚțĮ ʌȠȣ İțIJİȜİȓIJĮȚ ıȣȞİȤȫȢ µȑȤȡȚ ȞĮ ıȣȞĮȞIJȒıİȚ µȚĮ ıȣȞșȒțȘ IJİȡµĮIJȚıµȠȪ. ȊʌȐȡȤȠȣȞ ʌȠȜȜȐ, įȚĮijȠȡİIJȚțȐ İȓįȘ ȕȡȩȤȦȞ ıIJȘ Java, ıȣµʌİȡȚȜĮµȕĮȞȠµȑȞȦȞ IJȦȞ while, for țĮȚ do while (ȩʌȦȢ țĮȚ ıIJȘ C).

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java -9-

Ǿ İȞIJȠȜȒ for İțIJİȜİȓ ȑȞĮ ʌȡȠțĮșȠȡȚıµȑȞȠ ĮȡȚșµȩ İʌĮȞĮȜȒȥİȦȞ țĮȚ µİIJȐ ıIJĮµĮIJȐ. H while țĮȚ Ș do while, İʌĮȞĮȜĮµȕȐȞȠȣȞ ıȣȞİȤȫȢ ȑȞĮȞ ȕȡȩȤȠ µȑȤȡȚ µȚĮ ıȣȖțİțȡȚµȑȞȘ ıȣȞșȒțȘ ȞĮ ʌȐȥİȚ ȞĮ ȚıȤȪİȚ. īȚĮ IJȘȞ ʌİȡȓʌIJȦıȘ IJȠȣ ʌĮȡĮʌȐȞȦ ʌȡȠȖȡȐµµĮIJȠȢ, Hello4, șȑȜȠȣµİ ȞĮ ȖȡȐȥȠȣµİ ȑȞĮ ȕȡȩȤȠ ʌȠȣ șĮ IJȣʌȫȞİȚ țĮșȑȞĮ Įʌȩ IJĮ ȠȡȓıµĮIJĮ ȖȡĮµµȒȢ İȞIJȠȜȫȞ, ȟİțȚȞȫȞIJĮȢ Įʌȩ IJȠ ʌȡȫIJȠ. ǻİȞ ȟȑȡȠȣµİ ʌȡȠȘȖȠȣµȑȞȦȢ ʌȩıĮ ȠȡȓıµĮIJĮ ȖȡĮµµȒȢ İȞIJȠȜȫȞ șĮ ȑȤȠȣµİ, ĮȜȜȐ µʌȠȡȠȪµİ ȞĮ IJȠ µȐșȠȣµİ İȪțȠȜĮ, µİ IJȘȞ ȤȡȒıȘ IJȠȣ args.length. īȚ’ ĮȣIJȩ țĮȚ șĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ IJȠȞ ȕȡȩȤȠ for. ǹțȠȜȠȣșİȓ Ƞ țȫįȚțĮȢ: // ȆȡȩȖȡĮµµĮ Hello5 class Hello5 { public static void main (String args[]) { int i; /* ǹȢ ʌȠȪµİ hello */ System.out.print("Hello "); for (i=0; i<args.length; i=i+1) { System.out.print(args[i]); System.out.print(" "); } System.out.println(); } } ȄİțȚȞȐµİ IJȠȞ țȫįȚțĮ įȘȜȫȞȠȞIJĮȢ IJ��Ȣ µİIJĮȕȜȘIJȑȢ µĮȢ. Ȉ’ ĮȣIJȒȞ IJȘȞ ʌİȡȓʌIJȦıȘ ȑȤȠȣµİ µȓĮ µȩȞȠ µİIJĮȕȜȘIJȒ, IJȘȞ ĮțȑȡĮȚĮ i. ȈIJȘ ıȣȞȑȤİȚĮ ݵijĮȞȓȗȠȣµİ ıIJȘȞ ȠșȩȞȘ IJȠ "Hello" ȩʌȦȢ ʌȡȠȘȖȠȣµȑȞȦȢ. DzʌİȚIJĮ ȤȡȘıȚµȠʌȠȚȠȪµİ IJȠȞ ȕȡȩȤȠ for. ȅ ȕȡȩȤȠȢ ȟİțȚȞȐ ĮȡȤȚțȠʌȠȚȫȞIJĮȢ IJȠȞ µİIJȡȘIJȒ i, įȓȞȠȞIJȐȢ IJȠȣ IJȘȞ IJȚµȒ 0. AȣIJȩ ıȣµȕĮȓȞİȚ µȓĮ ijȠȡȐ ıIJȘȞ ĮȡȤȒ IJȠȣ ȕȡȩȤȠȣ. ǹțȠȜȠȣșİȓ Ș İȟȑIJĮıȘ IJȘȢ ıȣȞșȒțȘȢ. Ȉ’ ĮȣIJȒȞ IJȘȞ ʌİȡȓʌIJȦıȘ İȟİIJȐȗȠȣµİ ĮȞ IJo i İȓȞĮȚ µȚțȡȩIJİȡȠ Įʌȩ IJȠȞ ĮȡȚșµȩ IJȦȞ ȠȡȚıµȐIJȦȞ ȖȡĮµµȒȢ İȞIJȠȜȫȞ. ǵIJĮȞ IJȠ i ȖȓȞİȚ ȓıȠ µİ IJȠȞ ĮȡȚșµȩ ĮȣIJȩȞ, ȕȖĮȓȞȠȣµİ Įʌȩ IJȠȞ ȕȡȩȤȠ țĮȚ ʌȘȖĮȓȞȠȣµİ ıIJȘȞ ʌȡȫIJȘ İȞIJȠȜȒ µİIJȐ IJȠ țȜİȓıȚµȠ IJȠȣ ȕȡȩȤȠȣ. ĬȣµȘșİȓIJİ ȩIJȚ ȟİțȚȞȒıĮµİ ȞĮ µİIJȡȐµİ Įʌȩ IJȠ 0, ȩȤȚ Įʌȩ IJȠ 1. ȉȑȜȠȢ, ȑȤȠȣµİ IJȠ ʌȡȠıĮȣȟȘIJȚțȩ ȕȒµĮ i=i+1. ǹȣIJȩ İțIJİȜİȓIJĮȚ ıIJȠ IJȑȜȠȢ țȐșİ İʌĮȞȐȜȘȥȘȢ IJȠȣ ȕȡȩȤȠȣ. ȋȦȡȓȢ ĮȣIJȩ șĮ ʌĮȡĮµȑȞĮµİ ıIJȠȞ ȕȡȩȤȠ ȖȚĮ ʌȐȞIJĮ ĮijȠȪ IJȠ i șĮ ȒIJĮȞ µȩȞȚµĮ µȚțȡȩIJİȡȠ Įʌȩ IJȠ args.length (İțIJȩȢ ijȣıȚțȐ ĮȞ IJȠ args.length ȒIJĮȞ µȚțȡȩIJİȡȠ Ȓ ȓıȠ µİ IJȠ 0). ǹȈȀǾȈǾ ȉȚ ȖȓȞİIJĮȚ ĮȞ įİȞ įȫıȠȣµİ ıIJȠ ʌȡȩȖȡĮµµĮ Hello țĮȞȑȞĮ ȩȡȚıµĮ ȖȡĮµµȒȢ İȞIJȠȜȫȞ;

2.8 ǹȡȚșµȘIJȚțȑȢ ȂİIJĮȕȜȘIJȑȢ ǹțȑȡĮȚȠȚ ǹȡȚșµȠȓ TȠ ʌȡȩȖȡĮµµĮ ʌȠȣ ĮțȠȜȠȣșİȓ ʌĮȡȐȖİȚ ȑȞĮȞ ʌȓȞĮțĮ șİȡµȠțȡĮıȚȫȞ Fahrenheit µİ IJȚȢ ȚıȠįȪȞĮµİȢ șİȡµȠțȡĮıȓİȢ Celsius. //ǼțIJȪʌȦıȘ ʌȓȞĮțĮ Fahrenheit - Celsius class FahrToCelsius { public static void main (String args[]) { int fahr, celsius; int lower, upper, step; lower = 0; //țȐIJȦ ȩȡȚȠ IJȠȣ ʌȓȞĮțĮ șİȡµȠțȡĮıȚȫȞ upper = 300; //ʌȐȞȦ ȩȡȚȠ IJȠȣ ʌȓȞĮțĮ șİȡµȠțȡĮıȚȫȞ step = 20; //ȕȒµĮ ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 10 -

fahr = lower; while (fahr <= upper) { celsius = 5*(fahr-32)/9; System.out.print(fahr); System.out.print(" "); System.out.println(celsius); fahr = fahr+step; } } } ȈIJȚȢ įȪȠ ʌȡȫIJİȢ ȖȡĮµµȑȢ IJȘȢ µİșȩįȠȣ main, įȘȜȫȞȠȞIJĮȚ ȠȚ µİIJĮȕȜȘIJȑȢ ʌȠȣ șĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ. ȈȣȖțİțȡȚµİȞȠʌȠȚȠȪȞIJĮȚ IJĮ ȠȞȩµĮIJĮ țĮȚ ȠȚ IJȪʌȠȚ. īȚĮ IJȘȞ ȫȡĮ ȤȡȘıȚµȠʌȠȚȠȪµİ µȩȞȠ ĮțȑȡĮȚȠȣȢ (int). ȈIJȘȞ Java ȑȞĮȢ ĮțȑȡĮȚȠȢ µʌȠȡİȓ ȞĮ ʌȐȡİȚ IJȚµȑȢ ıIJȠ įȚȐıIJȘµĮ: Įʌȩ -2147483648 µȑȤȡȚ 2147483647. ȂİIJȐ IJȘȞ įȒȜȦıȘ IJȦȞ µİIJĮȕȜȘIJȫȞ, ĮȡȤȚțȠʌȠȚȠȪµİ IJȚȢ IJȚµȑȢ IJȠȣȢ ȤȡȘıȚµȠʌȠȚȫȞIJĮȢ İȞIJȠȜȑȢ ĮʌȩįȠıȘȢ IJȚµȒȢ, ȩʌȦȢ lower=0. ǹijȠȪ șȑıȠȣµİ ĮȡȤȚțȑȢ IJȚµȑȢ ıİ ȩȜİȢ µĮȢ IJȚȢ µİIJĮȕȜȘIJȑȢ, ʌȘȖĮȓȞȠȣµİ ıIJȠȞ ȕȡȩȤȠ ʌȠȣ țȐȞİȚ IJȘ ȕĮıȚțȒ įȠȣȜİȚȐ ıIJȠ ʌȡȩȖȡĮµµȐ µĮȢ. ȈIJȘȞ ĮȡȤȒ țȐșİ İʌĮȞȐȜȘȥȘȢ IJȠȣ ȕȡȩȤȠȣ (fahr <= upper) İȜȑȖȤȠȣµİ ȞĮ įȠȪµİ ĮȞ Ș IJȚµȒ IJȠȣ fahr İȓȞĮȚ ʌȡȐȖµĮIJȚ µȚțȡȩIJİȡȘ Ȓ ȓıȘ µİ IJȘȞ IJȡȑȤȠȣıĮ IJȚµȒ IJȠȣ upper. ǹȞ İȓȞĮȚ, IJȩIJİ İțIJİȜȠȪȞIJĮȚ ȠȚ İȞIJȠȜȑȢ IJȠȣ. Ǿ ȖȡĮµµȒ: celsius=5*(fahr-32)/9; ȊʌȠȜȠȖȓȗİȚ IJȠȣȢ ȕĮșµȠȪȢ Celsius ȑȤȠȞIJĮȢ IJȠȣȢ ȕĮșµȠȪȢ Fahrenheit. ȅȚ ĮȡȚșµȘIJȚțȠȓ IJİȜİıIJȑȢ țȐȞȠȣȞ ĮțȡȚȕȫȢ ĮȣIJȩ ʌȠȣ ȖȞȦȡȓȗİIJİ. ȉȠ * ıȣµȕȠȜȓȗİȚ IJȠȞ ʌȠȜȜĮʌȜĮıȚĮıµȩ, IJȠ - IJȘȞ ĮijĮȓȡİıȘ, IJȠ / IJȘȞ įȚĮȓȡİıȘ țĮȚ IJȠ + ʌĮȡȩȜȠ ʌȠȣ įİȞ IJȠ ıȣȞĮȞIJȒıĮµİ İįȫ, ıȣµȕȠȜȓȗİȚ IJȘȞ ʌȡȩıșİıȘ. Ǿ ʌȡȠIJİȡĮȚȩIJȘIJĮ IJȦȞ ʌȡȐȟİȦȞ ĮțȠȜȠȣșİȓ IJȠȣȢ țĮȞȠȞȚțȠȪȢ ĮȜȖİȕȡȚțȠȪȢ țĮȞȩȞİȢ. Ǿ İțIJȪʌȦıȘ IJȘȢ İȟȩįȠȣ İȓȞĮȚ ʌȠȜȪ ĮʌȜȒ. ȋȡȘıȚµȠʌȠȚȠȪµİ IJȠ System.out.print(fahr) ȖȚĮ ȞĮ IJȣʌȫıȠȣµİ IJȚȢ IJȚµȑȢ Fahrenheit, µİIJȐ IJȠ System.out.print(" ") ȖȚĮ ȞĮ IJȣʌȫıȠȣµİ IJȠ țİȞȩ țĮȚ IJİȜȚțȐ IJȠ System.out.println(Celsius) ȖȚĮ ȞĮ IJȣʌȫıȠȣµİ IJȚȢ IJȚµȑȢ Celsius. ǵȜȠȚ ȠȚ ĮțȑȡĮȚȠȚ IJȪʌȠȚ ʌȠȣ ȣʌȠıIJȘȡȓȗİȚ Ș Java, ijĮȓȞȠȞIJĮȚ ʌĮȡĮțȐIJȦ: ǵȞȠµĮ byte short int long

ȂȑȖİșȠȢ (bits) 8 16 32 64

ǼȜȐȤȚıIJȘ IJȚµȒ

ȂȑȖȚıIJȘ IJȚµȒ

-128 -32768 -2147483648 -9223372036854775808

127 32767 2147483647 9223372036854775807

ǹȡȚșµȠȓ ȀȚȞȘIJȒȢ ȊʌȠįȚĮıIJȠȜȒȢ ĬĮ ʌĮȡĮIJȘȡȒıĮIJİ țȐIJȚ ĮȞȠȡșȩįȠȟȠ ıIJȘȞ ʌĮȡĮʌȐȞȦ ȑȟȠįȠ. ȅȚ ĮȡȚșµȠȓ įİȞ ȒIJĮȞ ĮțȡȚȕȫȢ ıȦıIJȠȓ. ȉȠ 0 ıİ ȕĮșµȠȪȢ Fahrenheit İȓȞĮȚ ıIJȘȞ ʌȡĮȖµĮIJȚțȩIJȘIJĮ -17.778 ȕĮșµȠȓ Celsius țĮȚ ȩȤȚ -18 ȩʌȦȢ µĮȢ įȓȞİȚ IJȠ ʌȡȩȖȡĮµµĮ. ȉȠ ʌȡȩȕȜȘµĮ İȓȞĮȚ ȩIJȚ ȤȡȘıȚµȠʌȠȚȒıĮµİ µȩȞȠ ĮțȑȡĮȚȠȣȢ, ȩȤȚ įİțĮįȚțȠȪȢ ĮȡȚșµȠȪȢ. ȈIJȘ ȖȜȫııĮ IJȦȞ ȣʌȠȜȠȖȚıIJȫȞ ȠȚ įİțĮįȚțȠȓ ĮȡȚșµȠȓ ȠȞȠµȐȗȠȞIJĮȚ ĮȡȚșµȠȓ țȚȞȘIJȒȢ ȣʌȠįȚĮıIJȠȜȒȢ.

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 11 -

ȅȚ ĮȡȚșµȠȓ țȚȞȘIJȒȢ ȣʌȠįȚĮıIJȠȜȒȢ µʌȠȡȠȪȞ ȞĮ ĮȞĮʌĮȡĮıIJȒıȠȣȞ µİȖĮȜȪIJİȡȠ ʌȜȒșȠȢ IJȚµȫȞ Įʌ’ ȩIJȚ ȠȚ ĮțȑȡĮȚȠȚ. īȚĮ ʌĮȡȐįİȚȖµĮ, µʌȠȡİȓIJİ ȞĮ ȖȡȐȥİIJİ ʌȠȜȪ µİȖȐȜĮ ȞȠȪµİȡĮ, ȩʌȦȢ Ș IJĮȤȪIJȘIJĮ IJȠȣ ijȦIJȩȢ (2.998Ǽ8 µȑIJȡĮ ĮȞȐ įİȣIJİȡȩȜİʌIJȠ) ĮȜȜȐ țĮȚ ʌȠȜȪ µȚțȡȐ, ȩʌȦȢ Ș ıIJĮșİȡȐ IJȠȣ Plank, ȤȡȘıȚµȠʌȠȚȫȞIJĮȢ IJȠȞ ȓįȚȠ ĮȡȚșµȩ ȥȘijȓȦȞ. ǹʌȩ IJȘȞ ȐȜȜȘ µİȡȚȐ ȤȐȞİIJĮȚ µȑȡȠȢ Įʌȩ IJȘȞ ĮțȡȓȕİȚĮ, ʌȠȣ ʌȚșĮȞȩȞ ȩµȦȢ ȞĮ µȘȞ ȒIJĮȞ ĮʌĮȡĮȓIJȘIJȘ ȖȚĮ IJȩıȠ µİȖȐȜĮ Ȓ IJȩıȠ µȚțȡȐ ȞȠȪµİȡĮ. H Java ȣʌȠıIJȘȡȓȗİȚ įȪȠ IJȪʌȠȣȢ ĮȡȚșµȫȞ țȚȞȘIJȒȢ ȣʌȠįȚĮıIJȠȜȒȢ: IJȠȞ float țĮȚ IJȠȞ double. Ǿ ȤȡȒıȘ ĮȡȚșµȫȞ țȚȞȘIJȒȢ ȣʌȠįȚĮıIJȠȜȒȢ įİȞ İȓȞĮȚ įȣıțȠȜȩIJİȡȘ Įʌȩ IJȘ ȤȡȒıȘ ĮțİȡĮȓȦȞ. ȂʌȠȡȠȪµİ ȞĮ țȐȞȠȣµİ IJȠ ʌȡȩȖȡĮµµȐ µĮȢ ʌȚȠ ĮțȡȚȕȑȢ µİIJĮIJȡȑʌȠȞIJĮȢ ȩȜİȢ IJȚȢ int µİIJĮȕȜȘIJȑȢ ıİ double. //ǼțIJȪʌȦıȘ ʌȓȞĮțĮ Fahrenheit – Celsius µİ ʌİȡȚııȩIJİȡȘ ĮțȡȓȕİȚĮ class FahrToCelsius1 { public static void main (String args[]) { double fahr, celsius; double lower, upper, step;

}

lower = 0.0; upper = 300.0; step = 20.0; fahr = lower; while (fahr <= upper) { celsius=5.0*(fahr-32.0)/9.0; System.out.print(fahr); System.out.print(" "); System.out.println(celsius); fahr = fahr + step; }

} ȆȡȠıȑȟIJİ IJȘȞ ĮȜȜĮȖȒ ıIJȠ ʌȡȩȖȡĮµµĮ. ǵȜİȢ ȠȚ ĮțȑȡĮȚİȢ ıIJĮșİȡȑȢ ȩʌȦȢ IJȠ 5 țĮȚ IJȠ 9 ȑȖȚȞĮȞ 5.0, 9.0 ț.Ȝ.ʌ. ǹȞ ȑȞĮȢ ıIJĮșİȡȩȢ ĮȡȚșµȩȢ ʌİȡȚȑȤİȚ IJȘȞ ȣʌȠįȚĮıIJȠȜȒ, IJȩIJİ Ƞ µİIJĮȖȜȦIJIJȚıIJȒȢ șİȦȡİȓ ȩIJȚ İȓȞĮȚ ȑȞĮȢ ĮȡȚșµȩȢ țȚȞȘIJȒȢ ȣʌȠįȚĮıIJȠȜȒȢ. ǹȞ ȩȤȚ, IJȩIJİ Ƞ µİIJĮȖȜȦIJIJȚıIJȒȢ șİȦȡİȓ ȩIJȚ İȓȞĮȚ ĮțȑȡĮȚȠȢ. ǵIJĮȞ ȩµȦȢ įȪȠ ĮȡȚșµȠȓ įȚĮijȠȡİIJȚțȠȪ IJȪʌȠȣ, ȖȚĮ ʌĮȡȐįİȚȖµĮ ȑȞĮȢ ĮțȑȡĮȚȠȢ țĮȚ ȑȞĮȢ țȚȞȘIJȒȢ ȣʌȠįȚĮıIJȠȜȒȢ, ȕȡȓıțȠȞIJĮȚ ıIJȘ įİȟȚȐ ʌȜİȣȡȐ µȚĮȢ ȚıȩIJȘIJĮȢ IJȩIJİ Ƞ µİIJĮȖȜȦIJIJȚıIJȒȢ ʌȡȠȐȖİȚ IJȠȞ ĮȡȚșµȩ µİ IJȠȞ ʌȚȠ µȚțȡȩ IJȪʌȠ ıIJȠȞ ʌȚȠ µİȖȐȜȠ ʌȡȠIJȠȪ țȐȞİȚ IJȠȞ ȣʌȠȜȠȖȚıµȩ. ȉȚ țȐȞİȚ IJȠȞ IJȪʌȠ İȞȩȢ ĮȡȚșµȠȪ µİȖĮȜȪIJİȡȠ Įʌȩ țȐʌȠȚȠȞ ȐȜȜȠ; Ǿ įȣȞĮIJȩIJȘIJĮ ȞĮ ĮȞĮʌĮȡĮıIJȒıİȚ µȚĮ ʌȚȠ įȚİȣȡȣµȑȞȘ țȜȓµĮțĮ ĮȡȚșµȫȞ. ǼijȩıȠȞ ȑȞĮ byte µʌȠȡİȓ ȞĮ ĮȞĮʌĮȡĮıIJȒıİȚ µȩȞȠ 256 ĮȡȚșµȠȪȢ İȓȞĮȚ ʌȚȠ µȚțȡȩ Įʌȩ ȑȞĮȞ short ʌȠȣ µʌȠȡİȓ ȞĮ ĮȞĮʌĮȡĮıIJȒıİȚ 65537 įȚĮijȠȡİIJȚțȠȪȢ ĮȡȚșµȠȪȢ, ıȣµʌİȡȚȜĮµȕĮȞȠµȑȞȦȞ țȚ İțİȓȞȦȞ ʌȠȣ ĮȞĮʌĮȡȚıIJȐ ȑȞĮ byte. ǵµȠȚĮ, ȑȞĮȢ int İȓȞĮȚ µİȖĮȜȪIJİȡȠȢ Įʌȩ ȑȞĮȞ short. ȅȚ ĮȡȚșµȠȓ țȚȞȘIJȒȢ ȣʌȠįȚĮıIJȠȜȒȢ İȓȞĮȚ µİȖĮȜȪIJİȡȠȚ Įʌȩ ȠʌȠȚȠȞįȒʌȠIJİ ĮțȑȡĮȚȠ IJȪʌȠ țĮȚ Ƞ double İȓȞĮȚ Ƞ ʌȚȠ µİȖȐȜȠȢ IJȪʌȠȢ Įʌ’ ȩȜȠȣȢ. ĬĮ µʌȠȡȠȪıĮµİ ȞĮ ĮijȒıȠȣµİ ȩȜİȢ IJȚȢ µȚțȡȑȢ ıIJĮșİȡȑȢ ıĮȞ ĮțȑȡĮȚȠȣȢ țĮȚ Ș ȑȟȠįȠȢ IJȠȣ ʌȡȠȖȡȐµµĮIJȠȢ ȞĮ µȘȞ ȐȜȜĮȗİ țĮșȩȜȠȣ. ǼȓȞĮȚ țĮȜȪIJİȡĮ ȩµȦȢ ȞĮ ȕȐȗȠȣµİ IJȘȞ ȣʌȠįȚĮıIJȠȜȒ ʌȡȠțİȚµȑȞȠȣ ȞĮ șȣµȓȗȠȣµİ ıİ ȩȜȠȣȢ IJȚ ıȣµȕĮȓȞİȚ. ǹȣIJȐ İijĮȡµȩȗȠȞIJĮȚ ıİ ȣʌȠȜȠȖȚıµȠȪȢ ʌȠȣ ıȣµȕĮȓȞȠȣȞ ıIJȘ įİȟȚȐ ʌȜİȣȡȐ IJȠȣ =. Ȃİ IJȘȞ ĮȡȚıIJİȡȒ ʌȜİȣȡȐ ıȣµȕĮȓȞİȚ țȐIJȚ ȐȜȜȠ. ȅȚ ʌȡȠȖȡĮµµĮIJȚıIJȑȢ ȑȤȠȣȞ įȫıİȚ İȚįȚțȑȢ ȠȞȠµĮıȓİȢ ıIJȘȞ țȐșİ ʌȜİȣȡȐ. Ǿ ĮȡȚıIJİȡȒ ʌȜİȣȡȐ ȠȞȠµȐȗİIJĮȚ lvalue, İȞȫ Ș įİȟȚȐ ȠȞȠµȐȗİIJĮȚ rvalue. ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 12 -

H rvalue İȓȞĮȚ ȑȞĮ ĮȡȚșµȘIJȚțȩ ĮʌȠIJȑȜİıµĮ țĮȚ ȩʌȦȢ ĮȞĮijȑȡșȘțİ ʌȚȠ ʌȐȞȦ, ȜĮµȕȐȞİȚ IJȠȞ µİȖĮȜȪIJİȡȠ IJȪʌȠ IJȦȞ ĮȡȚșµȫȞ ʌȠȣ ıȣµµİIJȑȤȠȣȞ ıIJȠȞ ȣʌȠȜȠȖȚıµȩ. ǹʌȩ IJȘȞ ȐȜȜȘ µİȡȚȐ Ș lvalue ȑȤİȚ ȑȞĮȞ IJȪʌȠ ʌȠȣ ʌȡȑʌİȚ ȞĮ ʌȡȠıįȚȠȡȚıIJİȓ ʌȡȠIJȠȪ ȤȡȘıȚµȠʌȠȚȘșİȓ. ǹȣIJȩ țȐȞȠȣȞ ȠȚ įȘȜȫıİȚȢ IJȪʌȠȣ float fahr, celsius; ǹʌȩ IJȘ ıIJȚȖµȒ ʌȠȣ Ƞ IJȪʌȠȢ IJȘȢ lvalue įȘȜȦșİȓ, įİȞ ĮȜȜȐȗİȚ ʌȠIJȑ. īȚ’ ĮȣIJȩ ĮȞ įȘȜȫıȠȣµİ IJȠ fahr ıĮȞ int, IJȩIJİ ıIJȘȞ ĮȡȚıIJİȡȒ ʌȜİȣȡȐ IJȘȢ ȚıȩIJȘIJĮȢ IJȠ fahr șĮ İȓȞĮȚ ʌȐȞIJĮ int, ʌȠIJȑ float Ȓ double Ȓ long. ȆȡȠțȪʌIJİȚ IJȠ İȟȒȢ İȡȫIJȘµĮ : ȉȚ ȖȓȞİIJĮȚ ȩIJĮȞ Ƞ IJȪʌȠȢ ıIJĮ ĮȡȚıIJİȡȐ įİȞ ıȣµʌȓʌIJİȚ µİ IJȠȞ IJȪʌȠ ıIJĮ įİȟȚȐ; īȚĮ ʌĮȡȐįİȚȖµĮ, ȑȤȠȣµİ IJȠȞ ʌĮȡĮțȐIJȦ țȫįȚțĮ : class FloatToInt { public static void main (String args[]) { int myInteger; myInteger = 9.7; } } ǻȪȠ ʌȡȐȖµĮIJĮ µʌȠȡİȓ ȞĮ ıȣµȕȠȪȞ. ǹȞ ȩʌȦȢ ʌȚȠ ʌȐȞȦ ʌȡȠıʌĮșȠȪµİ ȞĮ µİIJĮIJȡȑȥȠȣµİ ȑȞĮȞ ĮȡȚșµȩ ıİ ʌȚȠ µȚțȡȩ IJȪʌȠ, IJȩIJİ Ƞ µİIJĮȖȜȦIJIJȚıIJȒȢ ĮȞĮȖȞȦȡȓȗİȚ IJȠ ȜȐșȠȢ. ǹȞIJȓșİIJĮ, ĮȞ ʌȡȠıʌĮșȠȪµİ ȞĮ µİIJĮIJȡȑȥȠȣµİ ȑȞĮȞ µȚțȡȩ IJȪʌȠ ıİ ʌȚȠ µİȖȐȜȠ IJȩIJİ Ƞ µİIJĮȖȜȦIJIJȚıIJȒȢ țȐȞİȚ IJȘ µİIJĮIJȡȠʌȒ. īȚĮ ʌĮȡȐįİȚȖµĮ, įİȓIJİ IJȠȞ ʌĮȡĮțȐIJȦ țȫįȚțĮ: class IntToFloat { public static void main (String args[]) { float myFloat; int myInteger; myInteger = 9; myFloat = myInteger; System.out.println(myFloat); }

}

ĭȣıȚțȐ șĮ µʌȠȡȠȪıĮµİ ȞĮ ȖȡȐȥȠȣµİ IJȠ ʌȡȩȖȡĮµµĮ µİIJĮIJȡȠʌȒȢ șİȡµȠțȡĮıȚȫȞ, ȤȡȘıȚµȠʌȠȚȫȞIJĮȢ ȕȡȩȤȠ for ıIJȘ șȑıȘ IJȠȣ ȕȡȩȤȠȣ while. //ǼțIJȪʌȦıȘ ʌȓȞĮțĮ Fahrenheit - Celsius class FahrToCelsius2 { public static void main (String args[]) { double fahr, celsius; double lower, upper, step;

}

lower = 0.0; upper = 300.0; step = 20.0; for (fahr=lower; fahr<=upper; fahr=fahr+step) { celsius = 5 * (fahr-32)/9; System.out.println(fahr+" "+celsius); }

} ǹȈȀǾȈǾ īȡȐȥIJİ ȑȞĮ ʌȡȩȖȡĮµµĮ ʌȠȣ ȞĮ µİIJĮIJȡȑʌİȚ IJȠȣȢ ȕĮșµȠȪȢ Celsius ıİ Fahrenheit.

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 13 -

2.9 ȉİȜİıIJȑȢ ǹȪȟȘıȘȢ țĮȚ ȂİȓȦıȘȢ H Java, ȩʌȦȢ țĮȚ Ș C, ʌİȡȚȜĮµȕȐȞİȚ IJİȜİıIJȑȢ ĮȪȟȘıȘȢ țĮȚ µİȓȦıȘȢ IJȘȢ IJȚµȒȢ țȐʌȠȚĮȢ µİIJĮȕȜȘIJȒȢ. ǻȪȠ Įʌȩ ĮȣIJȠȪȢ, IJȠ ++ țĮȚ -- ȜİȚIJȠȣȡȖȠȪȞ ȩʌȦȢ ıIJȠ ĮțȩȜȠȣșȠ ʌĮȡȐįİȚȖµĮ. //ȂȑIJȡȘıȘ µȑȤȡȚ IJȠ 10 class CountToTen { public static void main (String args[]) { int i; for (i=1; i <=10; i++) { System.out.println(i); } System.out.println("O.K."); } } //ȂȑIJȡȘıȘ Įʌȩ IJȠ 10 class CountFromTen { public static void main (String args[]) { int i; for (i=10; i >=0; i--) { System.out.println(i); } System.out.println("O.K."); } } ȉȠ i++ İȓȞĮȚ ıȣȞIJȠµİȣµȑȞȘ Ș ȑțijȡĮıȘ i=i+1. ǹȞIJȓıIJȠȚȤĮ, ȩIJĮȞ ȖȡȐijȠȣµİ i--, İȓȞĮȚ ıĮȞ ȞĮ ȖȡȐijȠȣµİ µİ ıȣȞIJȠµȓĮ IJȠ i=i-1. ȅ ȜȩȖȠȢ ʌȠȣ ʌȡȠıIJȑșȘțĮȞ ĮȣIJȠȓ ȠȚ IJİȜİıIJȑȢ ıIJȚȢ ȖȜȫııİȢ ʌȡȠȖȡĮµµĮIJȚıµȠȪ İȓȞĮȚ ȩIJȚ ʌȠȜȪ ıȣȤȞȐ ʌȡȠıșȑIJȠȣµİ Ȓ ĮijĮȚȡȠȪµİ IJȘ µȠȞȐįĮ ı’ ȑȞĮ ĮȡȚșµȩ. DzIJıȚ Ƞ țȫįȚțĮȢ ȖȓȞİIJĮȚ ʌȚȠ ĮʌȜȩȢ. ȉȚ ȖȓȞİIJĮȚ ȩµȦȢ ȩIJĮȞ șȑȜȠȣµİ Ȟ’ ĮȣȟȒıȠȣµİ ȑȞĮ µȑȖİșȠȢ ȩȤȚ țĮIJȐ 1 ĮȜȜȐ țĮIJȐ 2, 3 Ȓ 15; ĬĮ µʌȠȡȠȪıĮµİ ijȣıȚțȐ ȞĮ ȖȡȐȥȠȣµİ i=i+15, ĮȜȜȐ ĮȣIJȩ ıȣµȕĮȓȞİȚ IJȩıȠ ıȣȤȞȐ, ʌȠȣ ȣʌȐȡȤİȚ ȑȞĮȢ ȐȜȜȠȢ IJİȜİıIJȒȢ ʌȡȩıșİıȘȢ țĮȚ İțȤȫȡȘıȘȢ, IJȠ +=. DzIJıȚ șĮ ȖȡȐȥȠȣµİ i+=15. ǹȞ șȑȜĮµİ ȞĮ µİIJȡȒıȠȣµİ Įʌȩ IJȠ 0 ȦȢ IJȠ 20 ĮȞȐ įȪȠ, șĮ ȖȡȐijĮµİ: class CountToTwentyByTwos { public static void main (String args[]) { int i; for (i=0; i <=20; i += 2) { System.out.println(i); } System.out.println("ȅ.Ȁ."); } } ǵʌȦȢ ʌȚșĮȞȩȞ ȞĮ µĮȞIJȑȥĮIJİ ȣʌȐȡȤİȚ țĮȚ Ƞ ĮȞIJȓıIJȠȚȤȠȢ -= IJİȜİıIJȒȢ. ǹȞ șȑȜĮµİ ȞĮ µİIJȡȒıȠȣµİ Įʌȩ IJȠ 20 ȦȢ IJȠ 0 ĮȞȐ įȪȠ șĮ ȖȡȐijĮµİ : class CountToZeroByTwos { public static void main (String args[]) { int i; for (i=20; i >= 0; i -= 2) { System.out.println(i); } System.out.println("ȅ.Ȁ."); } } ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 14 -

ȊʌȐȡȤȠȣȞ İʌȓıȘȢ țĮȚ ȠȚ IJİȜİıIJȑȢ *= țĮȚ /= ʌȠȣ ʌȠȜȜĮʌȜĮıȚȐȗȠȣȞ țĮȚ įȚĮȚȡȠȪȞ Įʌȩ IJȘ įİȟȚȐ ʌȜİȣȡȐ ʌȡȚȞ IJȘȞ ĮʌȩįȠıȘ. ȆĮȡĮțȐIJȦ ȑȤȠȣµİ ȑȞĮ ʌĮȡȐįİȚȖµĮ. ȆȡȚȞ ʌȠȜȜȐ ȤȡȩȞȚĮ, țȐʌȠȚȠȢ İijİȪȡİ IJȠ ʌĮȚȤȞȓįȚ IJȠȣ ıțĮțȚȠȪ. ǹȣIJȩ IJȠ ʌĮȚȤȞȓįȚ İȓȤİ İȞșȠȣıȚȐıİȚ IJȩıȠ ʌȠȜȪ IJȠ ǺĮıȚȜȚȐ ʌȠȣ ȒIJĮȞ įȚĮIJİșİȚµȑȞȠȢ ȞĮ ȤĮȡȓıİȚ ıIJȠȞ İijİȣȡȑIJȘ IJȠȣ IJȠ µȚıȩ IJȠȣ ȕĮıȓȜİȚȠ țĮȚ IJȠ ȤȑȡȚ IJȘȢ țȩȡȘȢ IJȠȣ. ȅ İijİȣȡȑIJȘȢ ʌȠȣ ȒIJĮȞ ʌȠȜȪ ȑȟȣʌȞȠȢ țĮȚ țĮșȩȜȠȣ ʌȜİȠȞȑțIJȘȢ įİȞ ȚțĮȞȠʌȠȚȒșȘțİ µİ IJȠ µȚıȩ ȕĮıȓȜİȚȠ țĮȚ İȓʌİ ıIJȠ ǺĮıȚȜȚȐ: "ǺĮıȚȜȚȐ µȠȣ, İȓµĮȚ ȑȞĮȢ IJĮʌİȚȞȩȢ ȐȞșȡȦʌȠȢ ț��Ț įİȞ ȟȑȡȦ IJȚ ȞĮ țȐȞȦ IJȠ µȚıȩ ıȠȣ ȕĮıȓȜİȚȠ. DzȜĮ ȞĮ ȣʌȠȜȠȖȓıȠȣµİ IJȠ įȫȡȠ µȠȣ ĮȜȜȚȫȢ. ǺȐȜİ ıIJȠ ʌȡȫIJȠ IJİIJȡȐȖȦȞȠ IJȠȣ ıțĮțȚȠȪ ȑȞĮ ıʌȩȡȠ ıȚIJȐȡȚ. ȂİIJȐ, ıIJȠ įİȪIJİȡȠ IJİIJȡȐȖȦȞȠ įȪȠ ıʌȩȡȠȣȢ ıȚIJȐȡȚ, ıIJȠ IJȡȓIJȠ IJİIJȡȐȖȦȞȠ įȪȠ ijȠȡȑȢ Įʌȩ įȪȠ ıʌȩȡȠȣȢ ț.Ȝ.ʌ. µȑȤȡȚ ȞĮ țĮȜȣijșİȓ ȠȜȩțȜȘȡȠ IJȠ ıțȐțȚ Įʌȩ ıʌȩȡȠȣȢ. ǵIJĮȞ IJȠ ȐțȠȣıİ ĮȣIJȩ Ƞ ǺĮıȚȜȚȐȢ ȤȐȡȘțİ ʌȠȜȪ ʌȠȣ șĮ ȖȜȓIJȦȞİ µİ IJȩıȠ ȜȓȖĮ ȑȟȠįĮ țĮȚ ıȣµijȫȞȘıİ ĮµȑıȦȢ. ǽȒIJȘıİ ȞĮ IJȠȣ ijȑȡȠȣȞ µȚĮ ıĮțȠȪȜĮ ıȚIJȐȡȚ țĮȚ ȩIJĮȞ IJȠȣ IJȘȞ ȑijİȡĮȞ ȐȡȤȚıİ ȞĮ IJȠ IJȠʌȠșİIJİȓ. ȈȪȞIJȠµĮ IJȠ ıȚIJȐȡȚ IJİȜİȓȦıİ țĮȚ įİȞ İȓȤİ țĮȜȪȥİȚ ȠȪIJİ IJȠ µȚıȩ ıțȐțȚ. ǽȒIJȘıİ țĮȚ įİȪIJİȡȘ țĮȚ IJȡȓIJȘ țĮȚ ȐȜȜİȢ ʌȠȜȜȑȢ ıĮțȠȪȜİȢ, µȑȤȡȚ ʌȠȣ ĮȞĮȖțȐıIJȘțİ ȞĮ ʌĮȡĮįİȤIJİȓ IJȘȞ ȒIJIJĮ IJȠȣ. ȆȩıȠ ıȚIJȐȡȚ ȤȡİȚĮȗȩIJĮȞ Ƞ ȕĮıȚȜȚȐȢ; ǹȢ ʌȡȠıʌĮșȒıȠȣµİ ȞĮ ȣʌȠȜȠȖȓıȠȣµİ. ĬȣµȘșİȓIJİ ȩIJȚ IJȠ ıțȐțȚ ȑȤİȚ 64 IJİIJȡȐȖȦȞĮ. class CountWheat { public static void main (String args[]) { int i, j, k; j = 1; k = 0; for (i=1; i <= 64; i++) { k += j; System.out.println(k); j *= 2; } System.out.println(j); } } ȉȡȑȟIJİ IJȠ ʌȡȩȖȡĮµµĮ. ȉȚ ʌĮȡĮIJȘȡİȓIJİ; ȂʌȠȡȠȪµİ ȞĮ ȕİȜIJȚȫıȠȣµİ İȜĮijȡȫȢ IJĮ ĮʌȠIJİȜȑıµĮIJĮ ĮȜȜȐȗȠȞIJĮȢ IJȠȣȢ int µİ long. DzȞĮȢ long İȓȞĮȚ ȑȞĮȢ ĮțȑȡĮȚȠȢ IJȪʌȠȢ ʌȠȣ µʌȠȡİȓ ȞĮ İțijȡȐıİȚ 9223372036854775807 ĮȡȚșµȠȪȢ. ǹțȩµĮ țȚ ȑȞĮȢ long ȩµȦȢ įİȞ µʌȠȡİȓ ȞĮ µİIJȡȒıİȚ IJȠ ıȚIJȐȡȚ ʌȠȣ ȤȡİȚĮȗȩIJĮȞ Ƞ ȕĮıȚȜȚȐȢ. ǹȢ ʌȡȠıʌĮșȒıȠȣµİ ȞĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ IJȫȡĮ ȑȞĮȞ double. DzȞĮȢ double µʌȠȡİȓ ȞĮ țȡĮIJȒıİȚ ȑȞĮȞ ĮȡȚșµȩ µİȖȑșȠȣȢ 1.79769313486231570e+308. DzIJıȚ İȓȞĮȚ ȚțĮȞȩȢ ȞĮ µİIJȡȒıİȚ IJȠ ȤȡȑȠȢ IJȠȣ ǺĮıȚȜȚȐ ʌȠȣ ĮȞȑȡȤİIJĮȚ ıİ 1.84467e+019 ıʌȩȡȠȣȢ Įʌȩ ıȚIJȐȡȚ.

2.10 ȀȜȐıİȚȢ, ǹȞIJȚțİȓµİȞĮ țĮȚ ǻȚİʌĮijȑȢ (µȚĮ ʌȡȫIJȘ µĮIJȚȐ) ȅȚ țȜȐıİȚȢ (classes) İȓȞĮȚ IJĮ ʌȚȠ ıȘµĮȞIJȚțȐ ıIJȠȚȤİȓĮ IJȘȢ Java. ȉĮ ʌȐȞIJĮ ıIJȘ Java İȓȞĮȚ µȚĮ țȜȐıȘ, Ȓ ȑȞĮ IJµȒµĮ µȚĮȢ țȜȐıȘȢ Ȓ ʌİȡȚȖȡȐijȠȣȞ IJȠ ʌȫȢ ıȣµʌİȡȚijȑȡİIJĮȚ µȓĮ țȜȐıȘ. ȆĮȡȩȜȠ ʌȠȣ ȠȚ țȜȐıİȚȢ șĮ µİȜİIJȘșȠȪȞ µİ ȜİʌIJȠµȑȡİȚĮ ıIJȠ ȀİijȐȜĮȚȠ 4, İȓȞĮȚ IJȩıȠ șݵİȜȚȫįİȚȢ ȖȚĮ IJȘȞ țĮIJĮȞȩȘıȘ IJȦȞ ʌȡȠȖȡĮµµȐIJȦȞ ʌȠȣ µȚĮ µȚțȡȒ İȚıĮȖȦȖȒ ı’ ĮȣIJȩ IJȠ ıȘµİȓȠ İȓȞĮȚ ĮʌĮȡĮȓIJȘIJȘ. ǵȜȠ IJȠ ȞȩȘµĮ ıIJĮ ʌȡȠȖȡȐµµĮIJĮ IJȘȢ Java ȕȡȓıțİIJĮȚ ıIJĮ ȩȡȚĮ IJȦȞ µʌȜȠț IJȦȞ įȚĮijȩȡȦȞ țȜȐıİȦȞ, ıIJȘȞ ʌİȡȓʌIJȦıȘ µĮȢ ȑȤȠȣµİ µȩȞȠ µȚĮ țȜȐıȘ, IJȘȞ HelloWorld. ȅȚ µȑșȠįȠȚ ʌȡȠıįȚȠȡȓȗȠȞIJĮȚ Įʌȩ țȜȐıİȚȢ ıIJȚȢ ȠʌȠȓİȢ ĮȞȒțȠȣȞ.

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 15 -

ǹțȩµĮ țĮȚ IJĮ ʌȚȠ ȕĮıȚțȐ įİįȠµȑȞĮ ȩʌȦȢ ȠȚ ĮțȑȡĮȚȠȚ, ıȣȤȞȐ İȓȞĮȚ ĮʌĮȡĮȓIJȘIJȠ ȞĮ İȞıȦµĮIJȦșȠȪȞ ıİ țȜȐıİȚȢ ʌȡȠIJȠȪ ȤȡȘıȚµȠʌȠȚȘșȠȪȞ ĮʌȠIJİȜİıµĮIJȚțȐ. ȀȜȐıȘ İȓȞĮȚ Ș șݵİȜȚȫįȘȢ µȠȞȐįĮ IJȦȞ ʌȡȠȖȡĮµµȐIJȦȞ IJȘȢ Java. īȚĮ ʌĮȡȐįİȚȖµĮ, ʌĮȡĮțȠȜȠȣșȒıIJİ IJȠ ʌĮȡĮțȐIJȦ ʌȡȩȖȡĮµµĮ : class HelloWorld { public static void main (String args[]) { System.out.println("Hello World"); }

} class GoodbyeWorld { public static void main (String args[]) { System.out.println("Goodbye Cruel World!"); } } ȈȫıIJİ IJȠȞ țȫįȚțĮ ıİ ȑȞĮ ĮȡȤİȓȠ ʌȠȣ șĮ ȠȞȠµȐıİIJİ hellogoodbye.java ıIJȠȞ țĮIJȐȜȠȖȠ İȡȖĮıȓĮȢ ıĮȢ (directory) țĮȚ µİIJĮȖȜȦIJIJȓıIJİ IJȠ µİ IJȠ javac hellogoodbye.java. ȈIJȘ ıȣȞȑȤİȚĮ įİȓIJİ IJĮ ʌİȡȚİȤȩµİȞĮ IJȠȣ țĮIJĮȜȩȖȠȣ. ĬĮ ʌĮȡĮIJȘȡȒıİIJİ ȩIJȚ Ƞ µİIJĮȖȜȦIJIJȚıIJȒȢ įȘµȚȠȪȡȖȘıİ įȪȠ ȟİȤȦȡȚıIJȐ ĮȡȤİȓĮ țȜȐıȘȢ, IJȠ HelloWorld.class țĮȚ IJȠ GoodbyeWorld.class. Ǿ įİȪIJİȡȘ țȜȐıȘ İȓȞĮȚ ȑȞĮ ĮȞİȟȐȡIJȘIJȠ ʌȡȩȖȡĮµµĮ. ȆȜȘțIJȡȠȜȠȖİȓıIJİ java GoodbyeWorld țĮȚ µİIJȐ java HelloWorld. ǹȣIJȐ IJĮ ʌȡȠȖȡȐµµĮIJĮ IJȡȑȤȠȣȞ țĮȚ İțIJİȜȠȪȞIJĮȚ ĮȞİȟȐȡIJȘIJĮ IJȠ ȑȞĮ Įʌȩ IJȠ ȐȜȜȠ ʌĮȡȩȜȠ ʌȠȣ ȣʌȐȡȤȠȣȞ ıIJȠ ȓįȚȠ ĮȡȤİȓȠ ʌȘȖĮȓȠȣ țȫįȚțĮ. ǺȑȕĮȚĮ įİȞ ȣʌȐȡȤİȚ țȐʌȠȚȠȢ ȜȩȖȠȢ ȞĮ șȑȜȠȣµİ įȪȠ įȚĮijȠȡİIJȚțȐ ʌȡȠȖȡȐµµĮIJĮ ıIJȠ ȓįȚȠ ĮȡȤİȓȠ, ĮȜȜȐ ȑȤȠȣµİ IJȘ įȣȞĮIJȩIJȘIJĮ ȞĮ IJȠ ʌȡĮȖµĮIJȠʌȠȚȒıȠȣµİ. ǼȓȞĮȚ ʌȚȠ ʌȚșĮȞȩ ȞĮ șİȜȒıȠȣµİ ʌİȡȚııȩIJİȡİȢ Įʌȩ µȓĮ țȜȐıȘ ıIJȠ ȓįȚȠ ĮȡȤİȓȠ. ĬĮ ıȣȞĮȞIJȒıȠȣµİ ĮȡȤİȓȠ ʌȘȖĮȓȠȣ țȫįȚțĮ µİ ʌȠȜȜȑȢ țȜȐıİȚȢ țĮȚ µİșȩįȠȣȢ. ȈIJȘȞ ʌȡĮȖµĮIJȚțȩIJȘIJĮ ȣʌȐȡȤȠȣȞ İȞIJȠȜȑȢ ʌȠȣ µʌȠȡȠȪȞ ȞĮ ݵijĮȞȚıIJȠȪȞ ȑȟȦ Įʌȩ µȚĮ țȜȐıȘ. ȅȚ İȞIJȠȜȑȢ İȚıȩįȠȣ ݵijĮȞȓȗȠȞIJĮȚ ıIJȘȞ ĮȡȤȒ İȞȩȢ ĮȡȤİȓȠȣ ȑȟȦ Įʌȩ țȐșİ țȜȐıȘ. O µİIJĮȖȜȦIJIJȚıIJȒȢ ȩµȦȢ IJȚȢ ĮȞIJȚțĮșȚıIJȐ µİ IJĮ ʌİȡȚİȤȩµİȞĮ IJȠȣ ĮȡȤİȓȠȣ ʌȠȣ ĮʌȠIJİȜİȓIJĮȚ Įʌȩ ʌİȡȚııȩIJİȡİȢ țȜȐıİȚȢ. ǻȚİʌĮijȑȢ (Intefaces) ǵʌȦȢ İȓʌĮµİ, ȠȚ țȜȐıİȚȢ İȓȞĮȚ ʌȠȜȪ ȕĮıȚțȩ ıIJȠȚȤİȓȠ IJȘȢ Java. ȆĮȡȩȜĮ ĮȣIJȐ ȣʌȐȡȤİȚ țȐIJȚ ıIJȠȞ țȫįȚțĮ IJȘȢ Java ʌȠȣ įİȞ İȓȞĮȚ ȠȪIJİ țȜȐıȘ, ȠȪIJİ IJµȒµĮ µȚĮȢ țȜȐıȘȢ. ǹȣIJȩ ȜȑȖİIJĮȚ įȚİʌĮijȒ. ǻİȞ șĮ ʌȠȪµİ ʌȠȜȜȐ ȖȚĮ IJȚȢ įȚİʌĮijȑȢ µȚĮ țĮȚ ĮijȠȡȠȪȞ ʌȚȠ İȟİȚįȚțİȣµȑȞȠ țİijȐȜĮȚȠ. ǹʌȜȐ șĮ ıȘµİȚȫıȠȣµİ ȩIJȚ µȚĮ įȚİʌĮijȒ ʌȡȠıįȚȠȡȓȗİȚ IJȚȢ µİșȩįȠȣȢ ʌȠȣ İijĮȡµȩȗİȚ µȓĮ țȜȐıȘ. Ȃİ ȐȜȜĮ ȜȩȖȚĮ įȘȜȫȞİȚ IJȚ țȐȞȠȣȞ ıȣȖțİțȡȚµȑȞİȢ țȜȐıİȚȢ. ȂȚĮ įȚİʌĮijȒ Įʌȩ µȩȞȘ IJȘȢ įİȞ țȐȞİȚ IJȓʌȠIJĮ. ǵȜȘ Ș įȡȐıȘ IJȘȢ ʌȡĮȖµĮIJȠʌȠȚİȓIJĮȚ µȑıĮ ıIJȚȢ țȜȐıİȚȢ.

2.11 ȂȑșȠįȠȚ ǵȜĮ IJĮ ʌĮȡĮʌȐȞȦ ʌȡȠȖȡȐµµĮIJĮ ʌȠȣ ȑȤȠȣµİ ȖȡȐȥİȚ µȑȤȡȚ IJȫȡĮ İȓȞĮȚ ʌȠȜȪ ĮʌȜȐ țȚ ȑȤȠȣȞ ȜȚȖȩIJİȡȠ Įʌȩ 50 ȖȡĮµµȑȢ țȫįȚțĮ IJȠ țĮșȑȞĮ. ȀĮșȫȢ IJĮ ʌȡȠȖȡȐµµĮIJĮ µİȖĮȜȫȞȠȣȞ ıİ ȑțIJĮıȘ İȓȞĮȚ ȜȠȖȚțȩ ȞĮ IJĮ ȤȦȡȓȗȠȣµİ ıİ IJµȒµĮIJĮ. ȀȐșİ IJµȒµĮ µʌȠȡİȓ ȞĮ ʌȡĮȖµĮIJȠʌȠȚȒıİȚ ȑȞĮȞ ȣʌȠȜȠȖȚıµȩ țĮȚ ʌȚșĮȞȩIJĮIJĮ ȞĮ İʌȚıIJȡȑȥİȚ µȓĮ IJȚµȒ. ǹȣIJȩ İȓȞĮȚ ʌȠȜȪ ȤȡȒıȚµȠ, İȚįȚțȐ ȩIJĮȞ Ƞ ȣʌȠȜȠȖȚıµȩȢ șĮ İʌĮȞĮȜȘijșİȓ ıİ įȚȐijȠȡĮ ȐȜȜĮ µȑȡȘ IJȠȣ ʌȡȠȖȡȐµµĮIJȠȢ. ǼʌȓıȘȢ ȕȠȘșȐİȚ ıIJȠ ȞĮ ʌȡȠıįȚȠȡȚıIJİȓ µİ ʌȚȠ ıĮijȒ IJȡȩʌȠ Ș ȡȠȒ İȞȩȢ ʌȡȠȖȡȐµµĮIJȠȢ, ȩʌȦȢ Ș ʌİȡȓȜȘȥȘ ʌȡȠıįȚȠȡȓȗİȚ IJȘ ȡȠȒ İȞȩȢ ȕȚȕȜȓȠȣ. ȀȐșİ ȣʌȠȜȠȖȚıIJȚțȩ IJµȒµĮ İȞȩȢ ʌȡȠȖȡȐµµĮIJȠȢ ȠȞȠµȐȗİIJĮȚ µȑșȠįȠȢ. ȅȚ µȑșȠįȠȚ İȓȞĮȚ ĮȞIJȓıIJȠȚȤİȢ µİ IJȚȢ ıȣȞĮȡIJȒıİȚȢ (functions) IJȘȢ C.

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 16 -

ȉĮ ʌĮȡĮʌȐȞȦ ʌȡȠȖȡȐµµĮIJĮ ȤȡȘıȚµȠʌȠȓȘıĮȞ ȑȞĮȞ ĮȡȚșµȩ µİșȩįȦȞ, ʌĮȡȩȜȠ ʌȠȣ ȠȚ µȑșȠįȠȚ ĮȣIJȑȢ ʌĮȡȑȤȠȞIJĮȚ Įʌȩ IJȠ ıȪıIJȘµĮ. ǵIJĮȞ ȖȡȐȥĮµİ: System.out.println("Hello World!"); ȈIJȠ ʌȡȫIJȠ ʌȡȩȖȡĮµµĮ ȤȡȘıȚµȠʌȠȚȒıĮµİ IJȘ µȑșȠįȠ System.out.println(). (īȚĮ ȞĮ İȓµĮıIJİ ʌȚȠ ıȣȖțİțȡȚµȑȞȠȚ, ȤȡȘıȚµȠʌȠȚȒıĮµİ IJȘ µȑșȠįȠ println() IJȠȣ IJµȒµĮIJȠȢ out ıIJȘȞ țȜȐıȘ System. ĬĮ µȚȜȒıȠȣµİ ȖȚ’ ĮȣIJȩ ıIJȠ țİijȐȜĮȚȠ 4). H µȑșȠįȠȢ System.out.println() ĮʌĮȚIJİȓ ĮȡțİIJȩ țȫįȚțĮ Ƞ ȠʌȠȓȠȢ ȣʌȐȡȤİȚ ıIJȚȢ ȕȚȕȜȚȠșȒțİȢ IJȠȣ ıȣıIJȒµĮIJȠȢ. DzIJıȚ, ĮȞIJȓ ȞĮ ıȣµʌİȡȚȜĮµȕȐȞȠȣµİ IJȠȞ țȫįȚțĮ țȐșİ ijȠȡȐ ʌȠȣ șȑȜȠȣµİ ȞĮ IJȣʌȫıȠȣµİ, ĮʌȜȐ țĮȜȠȪµİ IJȘ µȑșȠįȠ System.out.println(). ȂʌȠȡİȓIJİ ȞĮ ȖȡȐȥİIJİ țĮȚ ȞĮ țĮȜȑıİIJİ IJȚȢ įȚțȑȢ ıĮȢ µİșȩįȠȣȢ. ǹȢ įȠȪµİ ȑȞĮ ĮʌȜȩ ʌĮȡȐįİȚȖµĮ. ȉȠ ʌĮȡĮțȐIJȦ İȓȞĮȚ ȑȞĮ ĮʌȜȩ ʌȡȩȖȡĮµµĮ ʌȠȣ ȗȘIJȐ ȑȞĮȞ ĮȡȚșµȩ Įʌȩ IJȠȞ ȤȡȒıIJȘ țĮȚ µİIJȐ ȣʌȠȜȠȖȓȗİȚ IJȠ ʌĮȡĮȖȠȞIJȚțȩ IJȠȣ ĮȡȚșµȠȪ. ȉȠ ʌĮȡĮȖȠȞIJȚțȩ İȞȩȢ ĮȡȚșµȠȪ n ıȣµȕȠȜȓȗİIJĮȚ µİ n! țĮȚ İȓȞĮȚ ȓıȠ µİ: n!=1*2*3*4*…*n ȖȚĮ n>0 țĮȚ 0!=1 ĬĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ įȪȠ µİșȩįȠȣȢ ıIJȠ ʌȡȩȖȡĮµµĮ, µȓĮ ʌȠȣ İȜȑȖȤİȚ ĮȞ Ƞ ȤȡȒıIJȘȢ İȚıȒȖĮȖİ ȑȞĮȞ ȑȖțȣȡȠ, șİIJȚțȩ ĮțȑȡĮȚȠ țĮȚ µȓĮ ȐȜȜȘ ʌȠȣ ȣʌȠȜȠȖȓȗİȚ IJȠ ʌĮȡĮȖȠȞIJȚțȩ. ĬĮ ȟİțȚȞȒıȠȣµİ ȖȡȐijȠȞIJĮȢ IJȘȞ țȪȡȚĮ µȑșȠįȠ IJȠȣ ʌȡȠȖȡȐµµĮIJȠȢ: class Factorial { public static void main(String args[]) { int n; while ((n = getNextInteger()) >= 0) { System.out.println(factorial(n)); } } } ǼțIJȩȢ IJȦȞ ȐȜȜȦȞ, Ƞ țȫįȚțĮȢ ĮȣIJȩȢ ĮʌȠįİȚțȞȪİȚ ȩIJȚ ȠȚ µȑșȠįȠȚ țĮșȚıIJȠȪȞ įȣȞĮIJȩ ȞĮ ıȤİįȚĮıIJİȓ Ș ȡȠȒ IJȠȣ ʌȡȠȖȡȐµµĮIJȠȢ ȤȦȡȓȢ ʌİȡȚIJIJȑȢ ȜİʌIJȠµȑȡİȚİȢ. ǹʌȜȐ ȠȞȠµȐıĮµİ įȪȠ µİșȩįȠȣȢ getNextInteger() țĮȚ factorial(), ȤȦȡȓȢ ȞĮ ĮȞȘıȣȤȠȪµİ ȖȚĮ IJȘȞ İijĮȡµȠȖȒ IJȠȣȢ. ȂʌȠȡȠȪµİ ȞĮ ʌȡȠıșȑıȠȣµİ IJȠȞ ȣʌȩȜȠȚʌȠ țȫįȚțĮ ıİ µȚțȡȩIJİȡĮ, İȣțȠȜȠȞȩȘIJĮ IJµȒµĮIJĮ. ǹȢ ȖȡȐȥȠȣµİ ʌȡȫIJĮ IJȘ µȑșȠįȠ factorial: long factorial (long n) { int i; long result=1; for (i=1; i <= n; i++) { result *= i; } return result; } ĬĮ µʌȠȡȠȪıĮµİ ȞĮ ıȣµʌİȡȚȜȐȕȠȣµİ ĮȣIJȩ IJȠȞ țȫįȚțĮ ıIJȘ µȑșȠįȠ main ĮȜȜȐ İȓȞĮȚ ʌȚȠ İȪțȠȜȠ ȞĮ țĮIJĮȞȠȒıȠȣµİ IJȠȞ ĮȜȖȩȡȚșµȠ ıʌȐȗȠȞIJĮȢ IJȠȞ țȫįȚțĮ ıİ µȚțȡȩIJİȡĮ IJµȒµĮIJĮ. ǼȓȞĮȚ İʌȓıȘȢ ʌȚȠ İȪțȠȜȠ ȞĮ İȜȑȖȟȠȣµİ țĮȚ ȞĮ įȚȠȡșȫıȠȣµİ. ȂʌȠȡȠȪµİ ȞĮ ȖȡȐȥȠȣµİ ȑȞĮ ĮʌȜȩ ʌȡȩȖȡĮµµĮ ʌȠȣ șĮ µĮȢ İʌȚIJȡȑʌİȚ ȞĮ İȜȑȖȤȠȣµİ IJȘ µȑșȠįȠ factorial ʌȡȠIJȠȪ µĮȢ ĮʌĮıȤȠȜȒıİȚ IJȠ ĮȞ İȓȞĮȚ ĮʌȠįİțIJȒ țĮȚ ȑȖțȣȡȘ Ș İȓıȠįȠȢ IJȠȣ ȤȡȒıIJȘ. ǹțȠȜȠȣșİȓ IJȠ ʌȡȩȖȡĮµµĮ İȜȑȖȤȠȣ: class FactorialTest { public static void main(String args[]) { int n; int i; ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 17 -

long result; for (i=1; i <=10; i++) { result = factorial(i); System.out.println(result); } } static long factorial (int n) { int i; long result=1; for (i=1; i <= n; i++) { result *= i; } return result; } } ȅȚ ʌȡȠȖȡĮµµĮIJȚıIJȑȢ IJȘȢ C șĮ ʌȡȑʌİȚ ȞĮ ʌȡȠıȑȟȠȣȞ ȩIJȚ țĮȚ ȠȚ įȪȠ µȑșȠįȠȚ ʌȡȠıįȚȠȡȓȗȠȞIJĮȚ µȑıĮ ıİ ȠȡȚıµȩ țȜȐıȘȢ (class definition). ȆĮȡĮIJȘȡȠȪµİ ȖȚĮ ȐȜȜȘ µȚĮ ijȠȡȐ ȩIJȚ IJĮ ʌȐȞIJĮ ıIJȘ Java ĮȞȒțȠȣȞ ıİ țȜȐıİȚȢ. ǹȢ įȠȪµİ µİ µȚĮ ʌȚȠ ʌȡȠıİțIJȚțȒ µĮIJȚȐ IJȘ ıȪȞIJĮȟȘ IJȘȢ µİșȩįȠȣ: static long factorial (int n) { int i; long result=1; for (i=1; i <= n; i++) { result *= i; } return result; } ȅȚ µȑșȠįȠȚ ȟİțȚȞȠȪȞ µİ µȓĮ įȒȜȦıȘ. ǹȣIJȩ µʌȠȡİȓ ȞĮ ʌİȡȚȜĮµȕȐȞİȚ Įʌȩ 3 ȑȦȢ 5 IJµȒµĮIJĮ. ȆȡȫIJĮ İȓȞĮȚ ȑȞĮȢ ʌȡȠĮȚȡİIJȚțȩȢ țĮșȠȡȚıIJȒȢ ʌȡȩıȕĮıȘȢ (optional access specifier), ʌȠȣ µʌȠȡİȓ ȞĮ İȓȞĮȚ įȘµȩıȚȠȢ (public), ȚįȚȦIJȚțȩȢ (private) Ȓ ʌȡȠıIJĮIJİȣȩµİȞȠȢ (protected). ȂȓĮ įȘµȩıȚĮ µȑșȠįȠ µʌȠȡȠȪµİ ȞĮ IJȘȞ țĮȜȑıȠȣµİ Įʌȩ ʌĮȞIJȠȪ. ȂȓĮ ȚįȚȦIJȚțȒ µȑșȠįȠȢ µʌȠȡİȓ ȞĮ ȤȡȘıȚµȠʌȠȚȘșİȓ µȩȞȠ Įʌȩ IJȘȞ țȜȐıȘ ʌȠȣ ʌȡȠıįȚȠȡȓȗİIJĮȚ. ȂȓĮ ʌȡȠıIJĮIJİȣµȑȞȘ µȑșȠįȠȢ µʌȠȡİȓ ȞĮ ȤȡȘıȚµȠʌȠȚȘșİȓ ȠʌȠȣįȒʌȠIJİ İȞIJȩȢ IJȠȣ ʌĮțȑIJȠȣ ʌȠȣ ʌȡȠıįȚȠȡȓȗİIJĮȚ. ȅȚ µȑșȠįȠȚ ʌȠȣ įİȞ ȑȤȠȣȞ įȘȜȦșİȓ ıĮȞ įȘµȩıȚİȢ Ȓ ȚįȚȦIJȚțȑȢ șİȦȡȠȪȞIJĮȚ ʌȡȠıIJĮIJİȣȩµİȞİȢ. ȈIJȘ ıȣȞȑȤİȚĮ ĮʌȠijĮıȓȗȠȣµİ ĮȞ µȚĮ µȑșȠįȠȢ İȓȞĮȚ ıIJĮIJȚțȒ (static) Ȓ ȩȤȚ. ȅȚ ıIJĮIJȚțȑȢ µȑșȠįȠȚ ȑȤȠȣȞ ȑȞĮ ıIJȚȖµȚȩIJȣʌȠ ĮȞȐ țȜȐıȘ țĮȚ ȩȤȚ ȑȞĮ ıIJȚȖµȚȩIJȣʌȠ ĮȞȐ ĮȞIJȚțİȓµİȞȠ. ǵȜĮ IJĮ ĮȞIJȚțİȓµİȞĮ µȚĮȢ țȜȐıȘȢ µȠȚȡȐȗȠȞIJĮȚ ȑȞĮ ĮȞIJȓȖȡĮijȠ IJȘȢ ıIJĮIJȚțȒȢ µİșȩįȠȣ. Ǽȟ’ ȠȡȚıµȠȪ ȠȚ µȑșȠįȠȚ įİȞ İȓȞĮȚ ıIJĮIJȚțȑȢ. ȈIJȘ ıȣȞȑȤİȚĮ įȘȜȫȞȠȣµİ IJȠȞ IJȪʌȠ IJȠȣ İʌȚıIJȡİijȩµİȞȠȣ ĮʌȠIJİȜȑıµĮIJȠȢ. ǹȣIJȩ İȓȞĮȚ Ș IJȚµȒ ʌȠȣ șĮ İʌȚıIJȡĮijİȓ ıIJȘȞ țĮȜȠȪµİȞȘ µȑșȠįȠ ȩIJĮȞ IJİȜİȚȫıȠȣȞ ȩȜȠȚ ȠȚ ȣʌȠȜȠȖȚıµȠȓ µȑıĮ ıIJȘ µȑșȠįȠ. īȚĮ ʌĮȡȐįİȚȖµĮ, ĮȞ Ƞ IJȪʌȠȢ İʌȚıIJȡȠijȒȢ İȓȞĮȚ int, µʌȠȡȠȪµİ ȞĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ IJȘ µȑșȠįȠ ȩʌȠȣ ȤȡȘıȚµȠʌȠȚȠȪµİ ȑȞĮȞ ıIJĮșİȡȩ ĮțȑȡĮȚȠ. ǹȞ Ƞ IJȪʌȠȢ İʌȚıIJȡȠijȒȢ İȓȞĮȚ void, IJȩIJİ įİȞ İʌȚıIJȡȑijİIJĮȚ țĮµȓĮ IJȚµȒ. DzʌİȚIJĮ ĮțȠȜȠȣșİȓ IJȠ ȩȞȠµĮ IJȘȢ µİșȩįȠȣ. ȈIJȘ ıȣȞȑȤİȚĮ ȑȤȠȣµİ IJȚȢ ʌĮȡİȞșȑıİȚȢ. ȂȑıĮ ıIJȚȢ ʌĮȡİȞșȑıİȚȢ įȓȞȠȣµİ ȠȞȩµĮIJĮ țĮȚ IJȪʌȠȣȢ ıIJȚȢ ʌĮȡĮµȑIJȡȠȣȢ IJȘȢ µİșȩįȠȣ. ȂȓĮ µȑșȠįȠȢ µʌȠȡİȓ ȞĮ ȑȤİȚ țĮµȓĮ, µȓĮ Ȓ ʌȠȜȜȑȢ ʌĮȡĮµȑIJȡȠȣȢ. ȅȚ ʌĮȡȐµİIJȡȠȚ ĮȣIJȑȢ, µʌȠȡȠȪȞ ȞĮ ȤȡȘıȚµȠʌȠȚȘșȠȪȞ µȑıĮ ıIJȘ µȑșȠįȠ ȩʌȦȢ ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 18 -

ȠȚ IJȠʌȚțȑȢ µİIJĮȕȜȘIJȑȢ. ȉȑȜȠȢ IJȠ ȣʌȩȜȠȚʌȠ IJȘȢ µİșȩįȠȣ ʌİȡȚțȜİȓİIJĮȚ µȑıĮ ıİ ȐȖțȚıIJȡĮ IJĮ ȠʌȠȓĮ IJȠ țȐȞȠȣȞ ȑȞĮ ĮʌȜȩ µʌȜȠț. ȉȠ IJµȒµĮ µȑıĮ ıIJĮ ȐȖțȚıIJȡĮ İȓȞĮȚ ȩʌȦȢ ȠȚ țȪȡȚİȢ µȑșȠįȠȚ. ȊʌȐȡȤȠȣȞ įȘȜȫıİȚȢ µİIJĮȕȜȘIJȫȞ, țȫįȚțĮȢ țĮȚ IJȑȜȠȢ țȐIJȚ ȞȑȠ, µȓĮ įȒȜȦıȘ İʌȚıIJȡȠijȒȢ, Ș ȠʌȠȓĮ ıIJȑȜȞİȚ µȚĮ IJȚµȒ ʌȓıȦ ıIJȘȞ țĮȜȠȪıĮ µȑșȠįȠ. ȅ IJȪʌȠȢ IJȘȢ IJȚµȒȢ ĮȣIJȒȢ ʌȡȑʌİȚ ȞĮ ıȣµijȦȞ��ȓ µİ IJȠȞ IJȪʌȠ ʌȠȣ įȘȜȫșȘțİ ıIJȘ µȑșȠįȠ. ǹȞĮįȡȠµȚțȑȢ ȂȑșȠįȠȚ Ǿ Java ȣʌȠıIJȘȡȓȗİȚ IJȚȢ ĮȞĮįȡȠµȚțȑȢ µİșȩįȠȣȢ. īȚĮ ʌĮȡȐįİȚȖµĮ, ĮȞ ȕȡȓıțİıIJİ ȒįȘ ıIJȘ µȑșȠįȠǹ() µʌȠȡİȓIJİ ȞĮ țĮȜȑıİIJİ IJȘ µȑșȠįȠǹ(). ǵIJĮȞ ȖȡȐijİIJİ ĮȞĮįȡȠµȚțȑȢ µİșȩįȠȣȢ ʌȡȑʌİȚ ȞĮ İȓıIJİ ʌȡȠıİțIJȚțȠȓ țĮȚ ȞĮ ıȣµʌİȡȚȜĮµȕȐȞİIJİ ıȣȞșȒțİȢ IJİȡµĮIJȚıµȠȪ. ȆĮȡȩȜȠ ʌȠȣ Ș Java įİȞ șȑIJİȚ ȩȡȚĮ ȖȚĮ IJȠ ȕȐșȠȢ µȚĮȢ İʌĮȞȐȜȘȥȘȢ İȓȞĮȚ ʌȚșĮȞȩȞ țȐIJȚ IJȑIJȠȚȠ ȞĮ ȤȡȘıȚµȠʌȠȚȒıİȚ ȩȜȘ IJȘ µȞȒµȘ IJȠȣ ȣʌȠȜȠȖȚıIJȒ ıĮȢ. Ǿ ʌĮȡĮțȐIJȦ µȑșȠįȠȢ ȣʌȠȜȠȖȓȗİȚ µİ ĮȞĮįȡȠµȚțȩ IJȡȩʌȠ IJȠ ʌĮȡĮȖȠȞIJȚțȩ İȞȩȢ ĮțİȡĮȓȠȣ, ȤȡȘıȚµȠʌȠȚȫȞIJĮȢ IJȠ ȖİȖȠȞȩȢ ȩIJȚ: n!=n*(n-1)! ȖȚĮ n>0 țĮȚ 0!=1 public static long factorial (int n) { if (n == 0) { return 1; } else { return n*factorial(n-1); } }

2.12 ȆȓȞĮțİȢ OȚ ʌȓȞĮțİȢ (Arrays) İȓȞĮȚ ȑȞĮȢ ĮʌȠIJİȜİıµĮIJȚțȩȢ IJȡȩʌȠȢ ĮʌȠșȒțİȣıȘȢ ıȣȞȩȜȦȞ µİIJĮȕȜȘIJȫȞ. DzȞĮȢ ʌȓȞĮțĮȢ İȓȞĮȚ ȑȞĮ ıȪȞȠȜȠ µİIJĮȕȜȘIJȫȞ ʌȠȣ µȠȚȡȐȗȠȞIJĮȚ IJȠ ȓįȚȠ ȩȞȠµĮ țĮȚ ıȣȞIJȐııȠȞIJĮȚ µİ IJȘ ıİȚȡȐ Įʌȩ IJȠ 0 µȑȤȡȚ IJȠ ʌȜȒșȠȢ IJȦȞ µİIJĮȕȜȘIJȫȞ µİȚȦµȑȞȠ țĮIJȐ 1. ȅ ĮȡȚșµȩȢ IJȦȞ µİIJĮȕȜȘIJȫȞ ʌȠȣ µʌȠȡİȓ ȞĮ ĮʌȠșȘțİȣIJİȓ ȠȞȠµȐȗİIJĮȚ įȚȐıIJĮıȘ IJȠȣ ʌȓȞĮțĮ. ȀȐșİ µİIJĮȕȜȘIJȒ ȠȞȠµȐȗİIJĮȚ ıIJȠȚȤİȓȠ IJȠȣ ʌȓȞĮțĮ. DzȞĮȢ ʌȓȞĮțĮȢ µʌȠȡİȓ ȞĮ ʌĮȡĮıIJĮșİȓ ıĮȞ ıIJȒȜȘ įİįȠµȑȞȦȞ ȩʌȦȢ ʌȚȠ țȐIJȦ: I[0] I[1] I[2] I[3] I[4]

4 2 76 -90 6

Ȉ’ ĮȣIJȒ IJȘȞ ʌİȡȓʌIJȦıȘ ȕȜȑʌȠȣµİ ȑȞĮȞ ĮțȑȡĮȚȠ ʌȓȞĮțĮ ʌȠȣ ȠȞȠµȐȗİIJĮȚ I µİ 5 ıIJȠȚȤİȓĮ. ȅ IJȪʌȠȢ IJȠȣ ʌȓȞĮțĮ İȓȞĮȚ int țĮȚ ȑȤİȚ įȚȐıIJĮıȘ 5. 2.12.1 ǻȘµȚȠȣȡȖȓĮ ȆȚȞȐțȦȞ ȊʌȐȡȤȠȣȞ IJȡȓĮ ıIJȐįȚĮ ȖȚĮ IJȘ įȘµȚȠȣȡȖȓĮ ʌȚȞȐțȦȞ: 1. ȃĮ įȘȜȫıȠȣµİ IJȠȞ ʌȓȞĮțĮ 2. ȃĮ ȠȡȓıȠȣµİ IJȠȞ ʌȓȞĮțĮ

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 19 -

3. ȃĮ ĮȡȤȚțȠʌȠȚȒıȠȣµİ IJȠȞ ʌȓȞĮțĮ ǻȒȜȦıȘ ȆȚȞȐțȦȞ. ǵʌȦȢ țĮȚ ȠȚ ȐȜȜİȢ µİIJĮȕȜȘIJȑȢ ıIJȘ Java, ȑȞĮȢ ʌȓȞĮțĮȢ ʌȡȑʌİȚ ȞĮ ȑȤİȚ ȑȞĮ ıȣȖțİțȡȚµȑȞȠ IJȪʌȠ ȩʌȦȢ byte, int, string, double ț.Ȝ.ʌ.. ȂȩȞȠ µİIJĮȕȜȘIJȑȢ IJȠȣ ĮȞIJȓıIJȠȚȤȠȣ IJȪʌȠȣ µʌȠȡȠȪȞ ȞĮ ĮʌȠșȘțİȣIJȠȪȞ ıİ ȑȞĮȞ ʌȓȞĮțĮ. īȚĮ ʌĮȡȐįİȚȖµĮ įİȞ µʌȠȡȠȪµİ ȞĮ ȑȤȠȣµİ ȑȞĮȞ ʌȓȞĮțĮ ʌȠȣ ȞĮ ĮʌȠșȘțİȪİȚ țĮȚ ints țĮȚ strings. ǵIJĮȞ įȘȜȫȞȠȣµİ ȑȞĮȞ ʌȓȞĮțĮ ȕȐȗȠȣµİ ıIJȠȞ IJȪʌȠ țĮȚ IJȠ [] ʌȠȣ įİȓȤȞİȚ ȩIJȚ Ș µİIJĮȕȜȘIJȒ İȓȞĮȚ ȑȞĮȢ ʌȓȞĮțĮȢ. ǹțȠȜȠȣșȠȪȞ µİȡȚțȐ ʌĮȡĮįİȓȖµĮIJĮ: int[] k; float[] yt; String[] names; Ȃİ ȐȜȜĮ ȜȩȖȚĮ įȘȜȫȞȠȣµİ ȑȞĮȞ ʌȓȞĮțĮ ȩʌȦȢ įȘȜȫȞȠȣµİ ȠʌȠȚĮįȒʌȠIJİ ȐȜȜȘ µİIJĮȕȜȘIJȒ µȩȞȠ ʌȠȣ ȕȐȗȠȣµİ țĮȚ ĮȖțȪȜİȢ ıIJȠ IJȑȜȠȢ IJȠȣ IJȪʌȠȣ IJȘȢ µİIJĮȕȜȘIJȒȢ. ȅȡȚıµȩȢ ȆȚȞȐțȦȞ. īȚĮ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ȑȞĮȞ ʌȓȞĮțĮ ȤȡȘıȚµȠʌȠȚȠȪµİ IJȠȞ IJİȜİıIJȒ new. ȆȡȑʌİȚ ȞĮ ʌȠȪµİ ıIJȠȞ µİIJĮȖȜȦIJIJȚıIJȒ ʌȩıĮ ıIJȠȚȤİȓĮ șĮ ĮʌȠșȘțİȣIJȠȪȞ ıIJȠȞ ʌȓȞĮțĮ. ȆȚȠ țȐIJȦ ȕȜȑʌȠȣµİ ʌȫȢ įȘµȚȠȣȡȖȠȪµİ IJȚȢ µİIJĮȕȜȘIJȑȢ IJȪʌȠȣ ʌȓȞĮțĮ: k = new int[3]; yt = new float[7]; names = new String[50]; ȅȚ ĮȡȚșµȠȓ ıIJȚȢ ĮȖțȪȜİȢ țĮșȠȡȓȗȠȣȞ IJȘ įȚȐıIJĮıȘ IJȠȣ ʌȓȞĮțĮ, įȘȜĮįȒ ʌȩıİȢ șȑıİȚȢ ȑȤİȚ. ȅ k µʌȠȡİȓ ȞĮ țȡĮIJȒıİȚ IJȡİȚȢ ĮțİȡĮȓȠȣȢ, Ƞ yt µʌȠȡİȓ ȞĮ țȡĮIJȒıİȚ İʌIJȐ ʌȡĮȖµĮIJȚțȠȪȢ ĮȡȚșµȠȪȢ țĮȚ Ƞ names µʌȠȡİȓ ȞĮ țȡĮIJȒıİȚ ʌİȞȒȞIJĮ ĮȜijĮȡȚșµȘIJȚțȐ. ȈȣȞȒșȦȢ ĮȣIJȩ ȠȞȠµȐȗİIJĮȚ ȠȡȚıµȩȢ IJȠȣ ʌȓȞĮțĮ ĮijȠȪ țĮșȠȡȓȗİȚ IJȠ IJµȒµĮ IJȘȢ RAM ʌȠȣ ȤȡİȚȐȗİIJĮȚ Ƞ ʌȓȞĮțĮȢ. Ǽįȫ İȓįĮµİ ȖȚĮ ʌȡȫIJȘ ijȠȡȐ țĮȚ IJȠȞ IJİȜİıIJȒ new. O new İȓȞĮȚ įİıµİȣµȑȞȘ ȜȑȟȘ ıIJȘ Java țĮȚ ȤȡȘıȚµȠʌȠȚİȓIJĮȚ ȩȤȚ µȩȞȠ ȖȚĮ ȞĮ ȠȡȓıİȚ ʌȓȞĮțİȢ ĮȜȜȐ țĮȚ ȐȜȜĮ İȓįȘ ĮȞIJȚțİȚµȑȞȦȞ. ǹȡȤȚțȠʌȠȓȘıȘ ȆȚȞȐțȦȞ. ȀȐșİ ıIJȠȚȤİȓȠ IJȠȣ ʌȓȞĮțĮ ʌȡȠıįȚȠȡȓȗİIJĮȚ Įʌȩ IJȠ ȩȞȠµĮ IJȠȣ ʌȓȞĮțĮ țĮȚ Įʌȩ ȑȞĮȞ ĮțȑȡĮȚȠ ʌȠȣ ijĮȞİȡȫȞİȚ IJȘ șȑıȘ IJȠȣ ıIJȠȞ ʌȓȞĮțĮ. ȅȚ ĮȡȚșµȠȓ ʌȠȣ ȤȡȘıȚµȠʌȠȚȠȪȞIJĮȚ ȠȞȠµȐȗȠȞIJĮȚ įİȓțIJİȢ IJȠȣ ʌȓȞĮțĮ. ȅȚ įİȓțIJİȢ İȓȞĮȚ ıȣȞİȤȩµİȞȠȚ ĮȡȚșµȠȓ ʌȠȣ ȟİțȚȞȠȪȞ Įʌȩ IJȠ 0. īȚ’ ĮȣIJȩ țĮȚ Ƞ ʌȓȞĮțĮȢ k ȑȤİȚ IJĮ ıIJȠȚȤİȓĮ k[0], k[1] țĮȚ k[2]. ǼijȩıȠȞ ȟİțȚȞȐµİ Įʌȩ IJȠ 0 įİȞ ȣʌȐȡȤİȚ k[3] țĮȚ ĮȞ ʌȡȠıʌĮșȒıȠȣµİ ȞĮ ȑȤȠȣµİ ʌȡȩıȕĮıȘ ı’ ĮȣIJȩ șĮ įȘµȚȠȣȡȖȒıȠȣµİ ȑȞĮ ArrayIndexOutOfBoundsException. ȆĮȡĮțȐIJȦ ȕȜȑʌȠȣµİ ʌȫȢ ĮʌȠșȘțİȪȠȣµİ IJȚµȑȢ ıIJȠȣȢ ʌȓȞĮțİȢ: k[0] = 2; k[1] = 5; k[2] = -2; yt[6] = 7.5f; names[4] = "Fred"; ǹȣIJȩ IJȠ ȕȒµĮ ȠȞȠµȐȗİIJĮȚ ĮȡȤȚțȠʌȠȓȘıȘ IJȠȣ ʌȓȞĮțĮ Ȓ țĮȜȪIJİȡĮ ĮȡȤȚțȠʌȠȓȘıȘ IJȦȞ ıIJȠȚȤİȓȦȞ IJȠȣ ʌȓȞĮțĮ. ǹțȩµĮ țĮȚ ȖȚĮ IJȠȣȢ ʌȓȞĮțİȢ µİıĮȓȠȣ µİȖȑșȠȣȢ İȓȞĮȚ ıʌȐȞȚȠ ȞĮ ĮȡȤȚțȠʌȠȚȠȪµİ țȐșİ ıIJȠȚȤİȓȠ ȟİȤȦȡȚıIJȐ. ȈȣȤȞȐ İȓȞĮȚ ʌȚȠ İȪțȠȜȠ ȞĮ ȤȡȘıȚµȠʌȠȚȠȪµİ IJȠȞ ȕȡȩȤȠ for. īȚĮ ʌĮȡȐįİȚȖµĮ ĮțȠȜȠȣșİȓ ȑȞĮȢ ȕȡȩȤȠȢ ʌȠȣ ȖݵȓȗİȚ ȑȞĮȞ ʌȓȞĮțĮ µİ IJĮ IJİIJȡȐȖȦȞĮ IJȦȞ ĮȡȚșµȫȞ Įʌȩ IJȠ 0 ȦȢ IJȠ 100. float[] squares = new float[101]; for (int i=0, i <= 100; i++) { squares[i] = i*i; } ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 20 -

ĬĮ ʌȡȑʌİȚ ȞĮ ʌȡȠıȑȟİIJİ įȪȠ ıȘµİȓĮ IJȠȣ țȫįȚțĮ: x

ǼijȩıȠȞ ȠȚ įİȓțIJİȢ ȟİțȚȞȠȪȞ Įʌȩ IJȠ 0, ȤȡİȚĮȗȩµĮıIJİ 101 ıIJȠȚȤİȓĮ ĮȞ șȑȜȠȣµİ ȞĮ ıȣµʌİȡȚȜȐȕȠȣµİ țĮȚ IJȠ IJİIJȡȐȖȦȞȠ IJȠȣ 100.

x

ȆĮȡȩȜȠ ʌȠȣ IJȠ i İȓȞĮȚ int, ȖȓȞİIJĮȚ float ȩIJĮȞ ĮʌȠșȘțİȪİȚ IJİIJȡȐȖȦȞȠ ĮijȠȪ įȘȜȫıĮµİ IJĮ IJİIJȡȐȖȦȞĮ ıĮȞ ʌȓȞĮțĮ float.

ȅ IJȡȩʌȠȢ ȖȚĮ ȞĮ ĮʌȠijȪȖȠȣµİ IJȠ ʌȡȫIJȠ ıȘµİȓȠ İȓȞĮȚ IJȠ ʌĮȡȐįİȚȖµĮ ʌȠȣ ĮțȠȜȠȣșİȓ: float[] squares = new float[101]; for (int i=0, i < squares.length; i++) { squares[i] = i*i; } ȈȘµİȚȫıIJİ ȩIJȚ IJȠ <= ȖȓȞİIJĮȚ <. ȈȣȞIJȠµİȪıİȚȢ ȆȚșĮȞȩȞ ȞĮ ijĮȓȞİIJĮȚ įȪıțȠȜȘ ȣʌȩșİıȘ Ș įȒȜȦıȘ, Ƞ ȠȡȚıµȩȢ țĮȚ Ș ĮȡȤȚțȠʌȠȓȘıȘ İȞȩȢ ʌȓȞĮțĮ. ǵµȦȢ Ș Java ʌĮȡȑȤİȚ ʌȠȜȜȑȢ İȣțȠȜȓİȢ ȖȚĮ IJȘ įȒȜȦıȘ, IJȠȞ ȠȡȚıµȩ țĮȚ IJȘȞ ĮȡȤȚțȠʌȠȓȘıȘ ʌȚȞȐțȦȞ. ȂʌȠȡȠȪµİ ȞĮ įȘȜȫıȠȣµİ țĮȚ ȞĮ ȠȡȓıȠȣµİ ȑȞĮȞ ʌȓȞĮțĮ IJȘȞ ȓįȚĮ ıIJȚȖµȒ: int[] k = new int[3]; float[] yt = new float[7]; String[] names = new String[50]; ȂʌȠȡȠȪµİ ĮțȩµĮ ȞĮ įȘȜȫıȠȣµİ, ȞĮ ȠȡȓıȠȣµİ țĮȚ ȞĮ ĮȡȤȚțȠʌȠȚȒıȠȣµİ ȑȞĮȞ ʌȓȞĮțĮ IJȘȞ ȓįȚĮ ıIJȚȖµȒ įȘµȚȠȣȡȖȫȞIJĮȢ µȚĮ ȜȓıIJĮ µİ IJȚȢ ĮȡȤȚțȑȢ IJȚµȑȢ µȑıĮ ıİ ĮȖțȪȜİȢ ȩʌȦȢ ʌȚȠ țȐIJȦ: int[] k = {1, 2, 3}; float[] yt = {0.0f, 1.2f, 3.4f, -9.87f, 65.4f, 0.0f, 567.9f}; ȆĮȡȐįİȚȖµĮ: ȉȠ ʌĮȡĮțȐIJȦ ʌȡȩȖȡĮµµĮ µİIJȡȐ ʌȩıİȢ ijȠȡȑȢ İʌĮȞĮȜĮµȕȐȞȠȞIJĮȚ IJĮ ȥȘijȓĮ 0-9, ĮȞ țĮȜȑıȠȣµİ 1000000 ijȠȡȑȢ IJȘȞ ȖİȞȞȒIJȡȚĮ IJȣȤĮȓȦȞ ĮȡȚșµȫȞ IJȘȢ Java. ǹȞĮµȑȞȠȣµİ ȩIJȚ IJĮ ȥȘijȓĮ șĮ ʌȡȑʌİȚ ȞĮ İʌĮȞĮȜĮµȕȐȞȠȞIJĮȚ µİ IJȘȞ ȓįȚĮ ʌİȡȓʌȠȣ ıȣȤȞȩIJȘIJĮ. ǹȣIJȩ șĮ IJȠ įȠȪµİ įȘµȚȠȣȡȖȫȞIJĮȢ ȑȞĮȞ ʌȓȞĮțĮ Įʌȩ 10 ĮȡȚșµȠȪȢ long ʌȠȣ ȠȞȠµȐȗİIJĮȚ ndigit. ȈIJȠ µȘįİȞȚțȩ ıIJȠȚȤİȓȠ IJȠȣ ndigit șĮ ĮʌȠșȘțİȪȠȣµİ IJȠ ʌȜȒșȠȢ IJȦȞ µȘįİȞȚțȫȞ, ıIJȠ ʌȡȫIJȠ ıIJȠȚȤİȓȠ IJȠȣ ndigit șĮ ĮʌȠșȘțİȪȠȣµİ IJȠ ʌȜȒșȠȢ IJȦȞ ȐııȦȞ țĮȚ ȠȪIJȦ țĮșİȟȒȢ. import java.util.*; class RandomTest { public static void main (String args[]) { int[] ndigits = new int[10]; double x; int n; Random myRandom = new Random(); // ǹȡȤȚțȠʌȠȓȘıȘ ʌȓȞĮțĮ for (int i = 0; i < 10; i++) { ndigits[i] = 0; } ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 21 -

// ȉİıIJȐȡȚıµĮ IJȘȢ ȖİȞȞȒIJȡȚĮȢ IJȣȤĮȓȦȞ ĮȡȚșµȫȞ for (long i=0; i < 100000; i++) { // ʌĮȡĮȖȦȖȒ IJȣȤĮȓȠȣ ĮȡȚșµȠȪ µİIJĮȟȪ 0 țĮȚ 9 x = myRandom.nextDouble() * 10.0; n = (int) x; // ĮȪȟȘıȘ IJȠȣ µİIJȡȘIJȒ ndigits[n]++; }

}

// Print the results for (int i = 0; i <= 9; i++) { System.out.println(i+": " + ndigits[i]); }

} 2.12.2 ǻȚįȚȐıIJĮIJȠȚ ȆȓȞĮțİȢ ȅ ʌȚȠ ıȣȞȘșȚıµȑȞȠȢ IJȪʌȠȢ ʌȠȜȣįȚȐıIJĮIJȠȣ ʌȓȞĮțĮ İȓȞĮȚ Ƞ įȚįȚȐıIJĮIJȠȢ. DzȞĮȞ įȚįȚȐıIJĮIJȠ ʌȓȞĮțĮ µʌȠȡȠȪµİ ȞĮ IJȠȞ ijĮȞIJĮȗȩµĮıIJİ ȩʌȦȢ ʌĮȡĮțȐIJȦ: r0 r1 r2 r3 r4

c0 0 1 2 3 4

c1 1 2 3 4 5

c2 2 3 4 5 6

c3 3 4 5 6 7

Ǽįȫ ȑȤȠȣµİ ȑȞĮȞ ʌȓȞĮțĮ µİ 5 ȖȡĮµµȑȢ țĮȚ 4 ıIJȒȜİȢ, ʌȠȣ ijȣıȚțȐ ȑȤİȚ ıȣȞȠȜȚțȐ 20 ıIJȠȚȤİȓĮ. ȆȡȑʌİȚ ȞĮ ȤȡȘıȚµȠʌȠȚȠȪµİ 2 įİȓțIJİȢ ȖȚĮ ȞĮ țĮșȠȡȓıȠȣµİ IJȘ șȑıȘ İȞȩȢ ıIJȠȚȤİȓȠȣ ıİ ȑȞĮ įȚįȚȐıIJĮIJȠ ʌȓȞĮțĮ. ǹȣIJȠȓ ȠȚ įİȓțIJİȢ țĮșȠȡȓȗȠȣȞ IJȘȞ ȖȡĮµµȒ țĮȚ IJȘȞ ıIJȒȜȘ ʌȠȣ ȕȡȓıțİIJĮȚ IJȠ ıIJȠȚȤİȓȠ. īȚĮ ʌĮȡȐįİȚȖµĮ ĮȞ Ƞ ʌĮȡĮʌȐȞȦ ʌȓȞĮțĮȢ ȜȑȖİIJĮȚ J IJȩIJİ IJȠ ıIJȠȚȤİȓȠ J[0][0] İȓȞĮȚ 0, IJȠ J[0][1] İȓȞĮȚ 1, IJȠ J[0][2] İȓȞĮȚ 2, IJȠ J[0][3] İȓȞĮȚ 3, IJȠ J[1][0] İȓȞĮȚ 1 ț.Ȝ.ʌ. ȅȚ įȚįȚȐıIJĮIJȠȚ ʌȓȞĮțİȢ įȘȜȫȞȠȞIJĮȚ, ȠȡȓȗȠȞIJĮȚ țĮȚ ĮȡȤȚțȠʌȠȚȠȪȞIJĮȚ ȩʌȦȢ țĮȚ ȠȚ µȠȞȠįȚȐıIJĮIJȠȚ ʌȓȞĮțİȢ. īȚ’ ĮȣIJȩ ʌȡȑʌİȚ ȞĮ țĮșȠȡȓȗȠȣµİ įȪȠ įȚĮıIJȐıİȚȢ ĮȞIJȓ ȖȚĮ µȓĮ țĮȚ ȖȚ’ ĮȣIJȩ ȤȡȘıȚµȠʌȠȚȠȪµİ įȪȠ ijȦȜȚĮıµȑȞĮ for ȖȚĮ ȞĮ ȖݵȓıȠȣµİ IJȠȞ ʌȓȞĮțĮ. ȈIJȠ ʌĮȡĮțȐIJȦ ʌĮȡȐįİȚȖµĮ Ƞ ʌȓȞĮțĮȢ Ȃ ȖݵȓȗİIJĮȚ ȦȢ İȟȒȢ: Ș IJȚµȒ IJȠȣ țȐșİ ıIJȠȚȤİȓȠȣ IJȠȣ İȓȞĮȚ ȓıȘ µİ IJȠ ȐșȡȠȚıµĮ IJȦȞ įİȚțIJȫȞ IJȘȢ ȖȡĮµµȒȢ țĮȚ IJȘȢ ıIJȒȜȘȢ ĮȣIJȠȪ IJȠȣ ıIJȠȚȤİȓȠȣ. class FillArray { public static void main (String args[]) { int[][] M; M = new int[4][5]; for (int row=0; row < 4; row++) { for (int col=0; col < 5; col++) { M[row][col] = row+col; } } } ȈIJȠȣȢ įȚįȚȐıIJĮIJȠȣȢ ʌȓȞĮțİȢ IJȠ ȜȐșȠȢ ArrayIndexOutOfBounds ıȣµȕĮȓȞİȚ ȩIJĮȞ ȣʌİȡȕĮȓȞȠȣµİ IJȠ µȑȖȚıIJȠ įİȓțIJȘ ȖȡĮµµȒȢ Ȓ ıIJȒȜȘȢ.

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 22 -

2.12.3 ȆȠȜȣįȚȐıIJĮIJȠȚ ȆȓȞĮțİȢ Ǿ Java µĮȢ İʌȚIJȡȑʌİȚ ȞĮ ȑȤȠȣµİ ʌȓȞĮțİȢ IJȡȚȫȞ, IJİııȐȡȦȞ Ȓ țĮȚ ʌİȡȚııȩIJİȡȦȞ įȚĮıIJȐıİȦȞ. ǼȓȞĮȚ ʌȠȜȪ ʌȚșĮȞȩ ĮȞ ȤȡİȚȐȗİıIJİ ȑȞĮȞ ʌȓȞĮțĮ µİ ʌİȡȚııȩIJİȡİȢ Įʌȩ 3 įȚĮıIJȐıİȚȢ ȞĮ ȤȡȘıȚµȠʌȠȚȒıİIJİ ȜĮȞșĮıµȑȞȘ įȠµȒ įİįȠµȑȞȦȞ. ǹțȩµĮ țĮȚ ȠȚ IJȡȚıįȚȐıIJĮIJȠȚ ʌȓȞĮțİȢ İȓȞĮȚ ıʌȐȞȚȠȚ ȑȟȦ Įʌȩ IJȚȢ İʌȚıIJȘµȠȞȚțȑȢ țĮȚ µȘȤĮȞȚțȑȢ İijĮȡµȠȖȑȢ. Ǿ ıȪȞIJĮȟȘ ȖȚĮ IJȠȣȢ IJȡȚıįȚȐıIJĮIJȠȣȢ ʌȓȞĮțİȢ İȓȞĮȚ µȚĮ İʌȑțIJĮıȘ ĮȣIJȒȢ ʌȠȣ ȤȡȘıȚµȠʌȠȚȒıĮµİ ıIJȠȣȢ įȚįȚȐıIJĮIJȠȣȢ. ǹțȠȜȠȣșİȓ ȑȞĮ ʌȡȩȖȡĮµµĮ ʌȠȣ įȘȜȫȞİȚ, ȠȡȓȗİȚ țĮȚ ĮȡȤȚțȠʌȠȚİȓ ȑȞĮȞ IJȡȚıįȚȐıIJĮIJȠ ʌȓȞĮțĮ: public static void main (String args[]) { int[][][] M; M = new int[4][5][3]; for (int row=0; row < 4; row++) { for (int col=0; col < 5; col++) { for (int ver=0; ver < 3; ver++) { M[row][col][ver] = row+col+ver; } } } } 2.12.4 ǹȞĮȗȒIJȘıȘ ǼȓȞĮȚ ʌȠȜȪ ıȣȞȘșȚıµȑȞȠ ȞĮ ȥȐȤȞȠȣµİ ı’ ȑȞĮȞ ʌȓȞĮțĮ µȚĮ ıȣȖțİțȡȚµȑȞȘ IJȚµȒ. ȂİȡȚțȑȢ ijȠȡȑȢ ĮȣIJȒ Ș IJȚµȒ İȓȞĮȚ ȖȞȦıIJȒ İț IJȦȞ ʌȡȠIJȑȡȦȞ. DZȜȜİȢ ijȠȡȑȢ ĮȞĮȗȘIJȐµİ IJȠ µȚțȡȩIJİȡȠ Ȓ IJȠ µİȖĮȜȪIJİȡȠ ıIJȠȚȤİȓȠ. ǼțIJȩȢ Įʌȩ IJȘȞ ʌİȡȓʌIJȦıȘ ʌȠȣ ȟȑȡȠȣµİ țȐIJȚ ȖȚĮ IJȠ ʌİȡȚİȤȩµİȞȠ İȞȩȢ ʌȓȞĮțĮ, ıİ ȩȜİȢ IJȚȢ ȐȜȜİȢ ʌİȡȚʌIJȫıİȚȢ Ƞ ĮȜȖȩȡȚșµȠȢ ĮȞĮȗȒIJȘıȘȢ İȞȩȢ ʌȓȞĮțĮ İȓȞĮȚ Ș ȖȡĮµµȚțȒ ĮȞĮȗȒIJȘıȘ. ȋȡȘıȚµȠʌȠȚȠȪµİ ȑȞĮȞ ȕȡȩȤȠ for țĮȚ İȜȑȖȤȠȣµİ țȐșİ ıIJȠȚȤİȓȠ IJȠȣ ʌȓȞĮțĮ µȑȤȡȚ ȞĮ ȕȡȠȪµİ IJȠ ıIJȠȚȤİȓȠ ʌȠȣ șȑȜȠȣµİ. ǹțȠȜȠȣșİȓ µȚĮ ĮʌȜȒ µȑșȠįȠȢ ʌȠȣ IJȣʌȫȞİȚ IJȠ µİȖĮȜȪIJİȡȠ țĮȚ IJȠ µȚțȡȩIJİȡȠ ıIJȠȚȤİȓȠ İȞȩȢ ʌȓȞĮțĮ. static void printLargestAndSmallestElements (int[] n) { int max = n[0]; int min = n[0]; for (int i=1; i < n.length; i++) { if (max < n[i]) { max = n[i]; } if (min > n[i]) { min = n[i]; } } System.out.println("Maximum: " + max); System.out.println("Minimum: " + min); } 2.12.5 ȉĮȟȚȞȩµȘıȘ ǵȜȠȚ ȠȚ ĮȜȖȩȡȚșµȠȚ IJĮȟȚȞȩµȘıȘȢ ȕĮıȓȗȠȞIJĮȚ ıİ įȪȠ șݵİȜȚȫįİȚȢ ȜİȚIJȠȣȡȖȓİȢ: IJȘ ıȪȖțȡȚıȘ țĮȚ IJȘȞ ĮȞIJȚµİIJȐșİıȘ (swapping). Ǿ ıȪȖțȡȚıȘ İȓȞĮȚ ĮʌȜȒ. Ǿ ĮȞIJȚµİIJȐșİıȘ İȓȞĮȚ ȜȓȖȠ ʌȚȠ ʌȠȜȪʌȜȠțȘ. ĬİȦȡİȓıIJİ IJȠ ĮțȩȜȠȣșȠ ʌȡȩȕȜȘµĮ: șȑȜȠȣµİ ȞĮ ĮȞIJȚµİIJĮșȑıȠȣµİ IJȚȢ IJȚµȑȢ IJȦȞ µİIJĮȕȜȘIJȫȞ a țĮȚ b. ȅȚ ʌȚȠ ʌȠȜȜȠȓ șĮ ʌȡȩIJİȚȞĮȞ µȚĮ ȜȪıȘ ıĮȞ IJȘȞ ĮțȩȜȠȣșȘ: ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 23 -

class Swap1 { public static void main(String args[]) { int a = 1; int b = 2;

}

System.out.println("a System.out.println("b a = b; b = a; System.out.println("a System.out.println("b

= "+a); = "+b); = "+a); = "+b);

} ǹȣIJȒ șĮ įȘµȚȠȣȡȖȠȪıİ IJȘȞ ʌĮȡĮțȐIJȦ ȑȟȠįȠ: a b a b

= = = =

1 2 2 2

ǻİȞ ʌİȡȚµȑȞĮµİ ȩµȦȢ ĮȣIJȩ! ȉȠ ʌȡȩȕȜȘµĮ İȓȞĮȚ ȩIJȚ ȤȐıĮµİ IJȘȞ IJȚµȒ 1 țĮșȫȢ ȕȐȜĮµİ IJȘȞ IJȚµȒ IJȠȣ b ıIJȠ a. īȚĮ ȞĮ įȚȠȡșȦșİȓ ĮȣIJȩ ʌȡȑʌİȚ ȞĮ İȚıȐȖȠȣµİ µȚĮ IJȡȓIJȘ µİIJĮȕȜȘIJȒ, IJȘȞ temp, Ș ȠʌȠȓĮ șĮ țȡĮIJȐİȚ IJȘȞ ĮȡȤȚțȒ IJȚµȒ IJȠȣ a. class Swap2 { public static void main(String args[]) { int a = 1; int b = 2; int temp; System.out.println("a System.out.println("b temp = a; a = b; b = temp; System.out.println("a System.out.println("b }

= "+a); = "+b);

= "+a); = "+b);

}

AȣIJȩȢ Ƞ țȫįȚțĮȢ ʌĮȡȐȖİȚ IJȠ ĮʌȠIJȑȜİıµĮ ʌȠȣ ʌİȡȚµȑȞĮµİ. a b a b

= = = =

1 2 2 1

Ǿ µȑșȠįȠȢ IJȘȢ ijȣıĮȜȓįĮȢ (Bubble Sort) TȫȡĮ ʌȠȣ İȓįĮµİ ʌȫȢ ȞĮ ĮȞIJȚµİIJĮșȑIJȠȣµİ IJȚȢ IJȚµȑȢ įȪȠ µİIJĮȕȜȘIJȫȞ, ĮȢ ʌȡȠȤȦȡȒıȠȣµİ ıIJȘȞ IJĮȟȚȞȩµȘıȘ. ȊʌȐȡȤȠȣȞ ʌȠȜȜȠȓ įȚĮijȠȡİIJȚțȠȓ ĮȜȖȩȡȚșµȠȚ IJĮȟȚȞȩµȘıȘȢ. DzȞĮȢ Įʌȩ IJȠȣȢ ʌȚȠ ĮʌȜȠȪȢ țĮȚ įȘµȠijȚȜȒȢ ĮȜȖȩȡȚșµȠȣȢ İȓȞĮȚ ĮȣIJȩȢ IJȘȢ ijȣıĮȜȓįĮȢ (bubble sort). Ǿ ȑȞȞȠȚĮ IJȠȣ bubble sort İȓȞĮȚ ȞĮ ȟİțȚȞȒıȠȣµİ Įʌȩ IJȘȞ țȠȡȣijȒ IJȠȣ ʌȓȞĮțĮ. ȈȣȖțȡȓȞȠȣµİ țȐșİ ıIJȠȚȤİȓȠ µİ IJȠ İʌȩµİȞȠ ıIJȠȚȤİȓȠ. ǹȞ İȓȞĮȚ µİȖĮȜȪIJİȡȠ Įʌȩ ĮȣIJȩ IJȩIJİ IJĮ µİIJĮșȑIJȠȣµİ. ǹȣIJȒ IJȘ įȚĮįȚțĮıȓĮ IJȘȞ țȐȞȠȣµİ ȩıİȢ ijȠȡȑȢ ȤȡİȚĮıIJİȓ. Ǿ µȚțȡȩIJİȡȘ IJȚµȒ ݵijĮȞȓȗİIJĮȚ ıIJȘȞ țȠȡȣijȒ IJȠȣ ʌȓȞĮțĮ İȞȫ Ș µİȖĮȜȪIJİȡȘ ıIJȠ IJȑȜȠȢ. ǹțȠȜȠȣșİȓ Ƞ țȫįȚțĮȢ:

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 24 -

import java.util.*; class BubbleSort { public static void main(String args[]) { int[] n; n = new int[10]; Random myRand = new Random(); // ĮȡȤȚțȠʌȠȓȘıȘ ʌȓȞĮțĮ µİ IJȣȤĮȓİȢ IJȚµȑȢ for (int i = 0; i < 10; i++) { n[i] = myRand.nextInt(); } // İțIJȪʌȦıȘ ʌȓȞĮțĮ ʌȡȚȞ IJȘȞ IJĮȟȚȞȩµȘıȘ System.out.println("Before sorting:"); for (int i = 0; i < 10; i++) { System.out.println("n["+i+"] = " + n[i]); } boolean sorted = false; // IJĮȟȚȞȩµȘıȘ ʌȓȞĮțĮ while (!sorted) { sorted = true; for (int i=0; i < 9; i++) { if (n[i] > n[i+1]) { int temp = n[i]; n[i] = n[i+1]; n[i+1] = temp; sorted = false; } } } // İțIJȪʌȦıȘ ʌȓȞĮțĮ µİIJȐ IJȘȞ IJĮȟȚȞȩµȘıȘ System.out.println(); System.out.println("After sorting:"); for (int i = 0; i < 10; i++) { System.out.println("n["+i+"] = " + n[i]); } }

}

Ȉ’ ĮȣIJȒȞ IJȘȞ ʌİȡȓʌIJȦıȘ IJĮȟȚȞȠµȒıĮµİ ȑȞĮȞ ʌȓȞĮțĮ µİ ĮȪȟȠȣıĮ ıİȚȡȐ. ȉȠ µȚțȡȩIJİȡȠ ıIJȠȚȤİȓȠ µʌĮȓȞİȚ ʌȡȫIJȠ. ĬĮ ȒIJĮȞ İȪțȠȜȠ ȞĮ IJȠ ĮȜȜȐȟȠȣµİ ıİ IJĮȟȚȞȩµȘıȘ µİ ijșȓȞȠȣıĮ ıİȚȡȐ.

2.13 ȋİȚȡȚıµȩȢ ǼȟĮȚȡȑıİȦȞ ǹȢ șȣµȘșȠȪµİ IJȠ ʌĮȡĮțȐIJȦ ʌȡȩȖȡĮµµĮ, ʌȠȣ İȓȤĮµİ įİȚ ıIJȘȞ § 2.5: // ȆȡȩȖȡĮµµĮ Hello class Hello { public static void main (String args[]) { /* ǹȢ ʌȠȪµİ hello */ System.out.print("Hello "); System.out.println(args[0]); } } ĬȣµȐıIJİ IJȓ ȖȚȞȩIJĮȞ ȩIJĮȞ IJȡȑȤĮµİ IJȠ ʌȡȩȖȡĮµµĮ ȤȦȡȓȢ ȞĮ įȓȞȠȣµİ ȠȡȓıµĮIJĮ ȖȡĮµµȒȢ İȞIJȠȜȫȞ; ȉȠ ıȪıIJȘµĮ İțIJȑȜİıȘȢ (runtime system) įȘµȚȠȣȡȖȠȪıİ µȓĮ İȟĮȓȡİıȘ (ȑȞĮ ȜȐșȠȢ): ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 25 -

HelloException in java.lang.ArrayIndexOutOfBoundsException at Hello.main(Hello.java:4)

thread

"main"

ǹȣIJȩ ʌȠȣ ıȣȞȑȕĮȚȞİ ȒIJĮȞ ȩIJȚ Įʌȩ IJȘ ıIJȚȖµȒ ʌȠȣ įİȞ įȓȞĮµİ ıIJȠ Ǿello țĮȞȑȞĮ ȩȡȚıµĮ ȖȡĮµµȒȢ İȞIJȠȜȫȞ, įİȞ ȣʌȒȡȤİ IJȓʌȠIJĮ ıIJȠ args[0]. īȚ’ ĮȣIJȩ țĮȚ Ș Java ȑȕȖĮȗİ IJȠ ʌĮȡĮʌȐȞȦ µȒȞȣµĮ ȜȐșȠȣȢ. ȆȡȠȘȖȠȣµȑȞȦȢ İȓȤĮµİ įȚȠȡșȫıİȚ ĮȣIJȩ IJȠ ʌȡȩȕȜȘµĮ İȜȑȖȤȠȞIJĮȢ IJȠ µȒțȠȢ IJȠȣ ʌȓȞĮțĮ ʌȡȠIJȠȪ ʌȡȠıʌĮșȒıȠȣµİ ȞĮ ʌȡȠıʌİȜȐıȠȣµİ IJȠ ʌȡȫIJȠ IJȠȣ ıIJȠȚȤİȓȠ. Ǿ ȜȪıȘ ȒIJĮȞ țĮȜȒ ȖȚĮ µȚĮ ĮʌȜȒ ʌİȡȓʌIJȦıȘ. ǹȞ ȩµȦȢ ȑʌȡİʌİ ȞĮ İȜȑȖȤȠȣµİ ȖȚĮ țȐșİ ʌȚșĮȞȒ ȜĮȞșĮıµȑȞȘ ıȣȞșȒțȘ ıİ țȐșİ ȖȡĮµµȒ IJȠȣ țȫįȚțĮ, IJȩIJİ Ƞ țȫįȚțĮȢ șĮ İȓȤİ ʌİȡȚııȩIJİȡȠȣȢ İȜȑȖȤȠȣȢ ȜĮșȫȞ ʌĮȡȐ țĮșĮȣIJȫ țȫįȚțĮ. ǼʌȚʌȜȑȠȞ șĮ ȑʌȡİʌİ ȞĮ ĮȡȤȓıİIJİ ȞĮ İȜȑȖȤİIJİ ȖȚĮ ȜȐșȘ ıIJȚȢ ıȣȞșȒțİȢ ȜĮșȫȞ. ȅȚ İȟĮȚȡȑıİȚȢ "İțʌȑµʌȠȞIJĮȚ" Įʌȩ IJȠ ıȪıIJȘµĮ İțIJȑȜİıȘȢ, ȩIJĮȞ ĮȣIJȩ įİȞ ȖȞȦȡȓȗİȚ ʌȫȢ ȞĮ ȤİȚȡȚıIJİȓ µȓĮ țĮIJȐıIJĮıȘ. ȂȓĮ ıȣȤȞȒ ʌİȡȓʌIJȦıȘ İȟĮȓȡİıȘȢ İȓȞĮȚ ȩIJĮȞ ʌȡȠıʌĮșȠȪµİ ȞĮ įȚĮȚȡȑıȠȣµİ µȓĮ ʌĮȡȐıIJĮıȘ µİ IJȠ µȘįȑȞ. ȈIJȩȤȠȢ IJȠȣ ȤİȚȡȚıµȠȪ IJȦȞ İȟĮȚȡȑıİȦȞ İȓȞĮȚ ȞĮ ʌȡȠıįȚȠȡȓıȠȣµİ IJȘȞ țĮȞȠȞȚțȒ ȡȠȒ IJȠȣ ʌȡȠȖȡȐµµĮIJȠȢ ıİ IJµȒµĮ IJȠȣ țȫįȚțĮ, ȤȦȡȓȢ ȞĮ ĮȞȘıȣȤȠȪµİ ȖȚĮ ȩȜİȢ IJȚȢ İȚįȚțȑȢ ʌİȡȚʌIJȫıİȚȢ. DzʌİȚIJĮ, ı’ ȑȞĮ ȟİȤȦȡȚıIJȩ µʌȜȠț IJȠȣ țȫįȚțĮ, șĮ țĮȜȪȥȠȣµİ IJȚȢ ʌİȡȚʌIJȫıİȚȢ IJȦȞ İȟĮȚȡȑıİȦȞ. DzIJıȚ ʌĮȡȐȖȠȣµİ ʌİȡȚııȩIJİȡȠ İȣĮȞȐȖȞȦıIJȠ țȫįȚțĮ ĮijȠȪ įİȞ ȤȡİȚȐȗİIJĮȚ ȞĮ įȚĮțȩʌIJȠȣµİ IJȘ ȡȠȒ IJȠȣ ĮȜȖȩȡȚșµȠȣ ȖȚĮ ȞĮ İȜȑȖȟȠȣµİ țĮȚ ȞĮ ĮȞIJĮʌȠțȡȚșȠȪµİ ıİ țȐșİ ʌİȡȓİȡȖȘ țĮIJȐıIJĮıȘ. ȉȠ ʌİȡȚȕȐȜȜȠȞ İțIJȑȜİıȘȢ İȓȞĮȚ ȣʌİȪșȣȞȠ ȖȚĮ IJȘ µİIJĮțȓȞȘıȘ Įʌȩ IJȘȞ țĮȞȠȞȚțȒ ȡȠȒ IJȠȣ ʌȡȠȖȡȐµµĮIJȠȢ ıIJȠȣȢ ȤİȚȡȚıIJȑȢ İȟĮȚȡȑıİȦȞ, ȩIJĮȞ ʌȡȠțȪʌIJİȚ µȚĮ IJȑIJȠȚĮ ıȣȞșȒțȘ. ȅ ȤİȚȡȚıµȩȢ IJȦȞ İȟĮȚȡȑıİȦȞ, ȣȜȠʌȠȚİȓIJĮȚ µİ IJȚȢ İȞIJȠȜȑȢ try țĮȚ catch. ȅȚ İȞIJȠȜȑȢ ĮȣIJȑȢ țĮșȠȡȓȗȠȣȞ IJµȒµĮIJĮ IJȠȣ țȫįȚțĮ IJĮ ȠʌȠȓĮ ȣʌĮȖȠȡİȪȠȣȞ ʌȦȢ șĮ ȖȓȞİȚ Ƞ ȤİȚȡȚıµȩȢ µȚĮȢ İȟĮȓȡİıȘȢ. ȈIJȘȞ ȠȣıȓĮ, țĮșȠȡȓȗȠȣµİ ȑȞĮ IJµȒµĮ țȫįȚțĮ ʌȠȣ șĮ ʌȡȠıʌĮșȒıİȚ (try) țĮȚ ıIJȘ ıȣȞȑȤİȚĮ șĮ ʌȚȐıİȚ (catch) țȐșİ İȟĮȓȡİıȘ ʌȠȣ șĮ ʌȡȠțȜȘșİȓ. ǹțȠȜȠȣșİȓ ȑȞĮ ʌĮȡȐįİȚȖµĮ ȤİȚȡȚıµȠȪ İȟĮȚȡȑıİȦȞ ȖȚĮ IJȠ ʌĮȡĮʌȐȞȦ ʌȡȩȖȡĮµµĮ: // ȆȡȩȖȡĮµµĮ Hello class ExceptionalHello { public static void main (String args[]) { /* ǹȢ ʌȠȪµİ hello */ try { System.out.println("Hello " + args[0]); } catch (Exception e) { System.out.println("Hello whoever you are"); } } } ǵIJĮȞ įȘµȚȠȣȡȖİȓIJĮȚ µȓĮ İȟĮȓȡİıȘ, IJȠ ıȪıIJȘµĮ İțIJȑȜİıȘȢ țȠȚIJȐȗİȚ ȖȚĮ İȞIJȠȜȑȢ catch ʌȠȣ µʌȠȡȠȪȞ ȞĮ IJȘȞ ȤİȚȡȚıIJȠȪȞ. KȐʌȠȚİȢ İȟĮȚȡȑıİȚȢ İȓȞĮȚ įȣȞĮIJȩȞ ȞĮ IJȚȢ ĮȞIJȚȜȘijșȠȪµİ țĮȚ ȞĮ IJȚȢ ȤİȚȡȚıIJȠȪµİ, İȞȫ țȐʌȠȚİȢ ȐȜȜİȢ İȓȞĮȚ IJȩıȠ įȪıțȠȜİȢ ʌȠȣ IJȠ ıȪıIJȘµĮ İțIJȑȜİıȘȢ ʌĮȡĮȚIJİȓIJĮȚ. Ǿ µİIJĮȕȜȘIJȒ e, ʌȠȣ ȣʌȐȡȤİȚ ıIJȠ catch, ʌİȡȚȑȤİȚ IJȠ µȒȞȣµĮ ȜȐșȠȣȢ ʌȠȣ ıȣȞȑȕȘ țĮȚ µʌȠȡȠȪµİ ȞĮ IJȠ IJȣʌȫıȠȣµİ, ĮȞ șȑȜȠȣµİ, µİ IJȘȞ ʌĮȡĮțȐIJȦ İȞIJȠȜȒ: System.out.println("Error: " + e);

2.14 ǹȡȤİȓĮ țĮȚ ȇȠȑȢ ǼȚıȩįȠȣ/ǼȟȩįȠȣ Ȉİ ĮȣIJȒ IJȘȞ ʌĮȡȐȖȡĮijȠ șĮ įȠȪµİ ʌȦȢ Ș Java µĮȢ İʌȚIJȡȑʌİȚ ȞĮ İʌȚțȠȚȞȦȞȠȪµİ µİ IJȠ ȤȡȒıIJȘ, ȞĮ ȖȡȐijȠȣµİ țĮȚ ȞĮ įȚĮȕȐȗȠȣµİ ĮȡȤİȓĮ. ȈIJȘȞ ʌȡĮȖµĮIJȚțȩIJȘIJĮ Ș µȑșȠįȠȢ ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 26 -

System.out.println() ʌȠȣ ȤȡȘıȚµȠʌȠȚȠȪµİ ıȣȞİȤȫȢ İȓȞĮȚ µȚĮ İijĮȡµȠȖȒ IJȦȞ ȡȠȫȞ (streams) İȚıȩįȠȣ/İȟȩįȠȣ. DZµİıȘ ǼʌȚțȠȚȞȦȞȓĮ µİ IJȠ ȋȡȒıIJȘ ĬĮ ȟİțȚȞȒıȠȣµİ µİ ȑȞĮ ʌȠȜȪ ĮʌȜȩ ʌȡȩȖȡĮµµĮ IJȠ ȠʌȠȓȠ ȗȘIJȐ IJĮ ȠȞȩµĮIJĮ IJȦȞ ȤȡȘıIJȫȞ țĮȚ ȑʌİȚIJĮ IJȣʌȫȞİȚ ȑȞĮȞ ʌȡȠıȦʌȚțȩ ȤĮȚȡİIJȚıµȩ. import java.io.*; class PersonalHello { public static void main (String args[]) { byte name[] = new byte[100]; int nr_read = 0; System.out.println("ǻȫıİ IJȠ ȩȞȠµȐ ıȠȣ"); try { nr_read = System.in.read(name); System.out.print("Hello "); System.out.write(name,0,nr_read); } catch (IOException e) { System.out.print("ǻȣıIJȣȤȫȢ įİȞ µʌȩȡİıĮ ıȠȣ."); } } }

ȞĮ

įȚĮȕȐıȦ

IJȠ

ȩȞȠµȐ

ȉȠ import java.io.*; İȓȞĮȚ IJȠ ĮȞIJȓıIJȠȚȤȠ #include <stdio.h> IJȘȢ C. ȉĮ ʌİȡȚııȩIJİȡĮ Įʌ’ ĮȣIJȐ ʌȠȣ įȚĮȕȐȗİIJİ țĮȚ ȖȡȐijİIJİ ıIJȘ Java İȚȞĮȚ ıİ bytes. (ǹȡȖȩIJİȡĮ șĮ įȠȪµİ ȩIJȚ ȖȓȞİIJĮȚ ȞĮ įȚĮȕȐȗȠȣµİ ĮȡȤİȓĮ țİȚµȑȞȠȣ ıİ strings. Ǽįȫ ȟİțȚȞȒıĮµİ µİ ȑȞĮȞ ʌȓȞĮțĮ Įʌȩ bytes ʌȠȣ șĮ țȡĮIJȐİȚ IJȠ ȩȞȠµĮ IJȠȣ ȤȡȒıIJȘ. ȆȡȫIJĮ IJȣʌȫȞȠȣµİ ȑȞĮ İȡȫIJȘµĮ ȗȘIJȫȞIJĮȢ IJȠ ȩȞȠµĮ IJȠȣ ȤȡȒıIJȘ. DzʌİȚIJĮ įȚĮȕȐȗȠȣµİ IJȠ ȩȞȠµĮ ȤȡȘıȚµȠʌȠȚȫȞIJĮȢ IJȘ µȑșȠįȠ System.in.read(). ǹȣIJȒ Ș µȑșȠįȠȢ ʌĮȓȡȞİȚ ȑȞĮȞ ʌȓȞĮțĮ byte ıĮȞ ȩȡȚıµĮ ıIJȠ ȠʌȠȓȠ IJȠʌȠșİIJİȓ ĮȣIJȩ ʌȠȣ ʌȜȘțIJȡȠȜȠȖİȓ Ƞ ȤȡȒıIJȘȢ țĮȚ İʌȚıIJȡȑijİȚ ȑȞĮȞ ĮțȑȡĮȚȠ ĮȡȚșµȩ ʌȠȣ İțijȡȐȗİȚ IJȠ ʌȜȒșȠȢ IJȦȞ ȤĮȡĮțIJȒȡȦȞ ʌȠȣ įȚĮȕȐıIJȘțĮȞ. DzʌİȚIJĮ ȩʌȦȢ țĮȚ ʌȡȚȞ IJȣʌȫȞȠȣµİ "Hello". ȉȑȜȠȢ IJȣʌȫȞȠȣµİ IJȠ ȩȞȠµĮ IJȠȣ ȤȡȒıIJȘ ȤȡȘıȚµȠʌȠȚȫȞIJĮȢ IJȘȞ µȑșȠįȠ System.out.write(), Ș ȠʌȠȓĮ ʌĮȓȡȞİȚ IJȡȓĮ ȠȡȓıµĮIJĮ: IJȠȞ ʌȓȞĮțĮ, țĮȚ IJȚȢ șȑıİȚȢ ʌȠȣ ȑȤȠȣȞ µȑıĮ ıIJȠȞ ʌȓȞĮțĮ Ƞ ʌȡȫIJȠȢ țĮȚ Ƞ IJİȜİȣIJĮȓȠȢ ȤĮȡĮțIJȒȡĮȢ IJȠȣ ĮȜijĮȡȚșµȘIJȚțȠȪ ʌȠȣ șȑȜȠȣµİ ȞĮ IJȣʌȫıȠȣµİ. ǻȚĮȕȐȗȠȞIJĮȢ ǹȡȚșµȠȪȢ ȈȣȤȞȐ IJĮ ĮȜijĮȡȚșµȘIJȚțȐ įİȞ ĮȡțȠȪȞ. ȆȠȜȜȑȢ ijȠȡȑȢ ȗȘIJȐµİ Įʌȩ IJȠ ȤȡȒıIJȘ ȑȞĮȞ ĮȡȚșµȩ ıĮȞ İȓıȠįȠ. ǵȜİȢ ȠȚ İȓıȠįȠȚ IJȠȣ ȤȡȒıIJȘ ȑȡȤȠȞIJĮȚ ıĮȞ ĮȜijĮȡȚșµȘIJȚțȐ, IJĮ ȠʌȠȓĮ șȑȜȠȣµİ ȞĮ IJĮ µİIJĮIJȡȑȥȠȣµİ ıİ ĮȡȚșµȠȪȢ. ȉȫȡĮ ȖȡȐijȠȣµİ IJȘ µȑșȠįȠ getNextInteger() ʌȠȣ įȑȤİIJĮȚ ȑȞĮȞ ĮțȑȡĮȚȠ Įʌȩ IJȠ ȤȡȒıIJȘ. static int getNextInteger() { String line; DataInputStream in = new DataInputStream(System.in); try { line = in.readLine(); int i = Integer.valueOf(line).intValue(); return i; ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 27 -

} catch (Exception e) { return -1; } } īȡȐijȠȞIJĮȢ ıİ ȑȞĮ ǹȡȤİȓȠ ȀİȚµȑȞȠȣ ȀȐʌȠȚİȢ ijȠȡȑȢ ĮȞIJȓ IJĮ įİįȠµȑȞĮ ȞĮ İțIJȣʌȫȞȠȞIJĮȚ ıIJȘ ȠșȩȞȘ, ȞĮ ĮʌȠșȘțİȪȠȞIJĮȚ ıİ ȑȞĮ ĮȡȤİȓȠ țİȚµȑȞȠȣ. īȚĮ ȞĮ IJȠ țȐȞȠȣµİ ĮȣIJȩ ʌȡȑʌİȚ ȞĮ µȐșȠȣµİ ʌȫȢ ȞĮ ȖȡȐijȠȣµİ įİįȠµȑȞĮ ı’ ȑȞĮ ĮȡȤİȓȠ. ǹȞIJȓ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ȑȞĮ țĮȚȞȠȪȡȚȠ ʌȡȩȖȡĮµµĮ șĮ IJȡȠʌȠʌȠȚȒıȠȣµİ IJȠ FahrȉȠCelsius, ʌȠȣ İȓįĮµİ ıIJȘȞ § 2.8. // īȡȐȥȚµȠ IJȠȣ ʌȓȞĮțĮ Fahrenheit-Celsius ıİ ĮȡȤİȓȠ import java.io.*; class FahrToCelsius { public static void main (String args[]) { double fahr, celsius; double lower, upper, step; lower = 0.0; // țȐIJȦ ȩȡȚȠ IJȠȣ ʌȓȞĮțĮ șİȡµȠțȡĮıȚȫȞ upper = 300.0; // ʌȐȞȦ ȩȡȚȠ IJȠȣ ʌȓȞĮțĮ șİȡµȠțȡĮıȚȫȞ step = 20.0; // ȕȒµĮ fahr = lower; try { FileOutputStream fout = new FileOutputStream("test.out"); PrintStream myOutput = new PrintStream(fout); while (fahr <= upper) { celsius = 5.0 * (fahr-32.0) / 9.0; myOutput.println(fahr + " " + celsius); fahr = fahr + step; } } catch (IOException e) { System.out.println("Error: " + e); System.exit(1); } }

}

ȊʌȐȡȤȠȣȞ 3 ĮʌĮȡĮȓIJȘIJİȢ ıȣȞșȒțİȢ ȖȚĮ ȞĮ ȖȡȐȥȠȣµİ µȠȡijȠʌȠȚȘµȑȞȘ ȑȟȠįȠ ıİ ȑȞĮ ĮȡȤİȓȠ: 1. ǹȞȠȓȟIJİ ȑȞĮ FileOutputStream ȤȡȘıȚµȠʌȠȚȫȞIJĮȢ µȓĮ ȖȡĮµµȒ ȩʌȦȢ ʌĮȡĮțȐIJȦ: FileOutputStream fout =

new FileOutputStream("test.out");

ǹȣIJȒ Ș ȖȡĮµµȒ ĮȡȤȚțȠʌȠȚİȓ IJȠ FileOutputStream µİ IJȠ ȩȞȠµĮ IJȠȣ ĮȡȤİȓȠȣ ʌȠȣ șȑȜİIJİ ȞĮ ȖȡȐȥİIJİ µȑıĮ. 2. ȂİIJĮIJȡȑȥIJİ IJȠ FileOutputStream ıİ PrintStream ȤȡȘıȚµȠʌȠȚȫȞIJĮȢ µȓĮ įȒȜȦıȘ ȩʌȦȢ: PrintStream myOutput = new PrintStream(fout); 3. ǹȞIJȓ ȞĮ ȤȡȘıȚµȠʌȠȚȒıİIJİ IJȠ: System.out.println() ȤȡȘıȚµȠʌȠȚİȓıIJİ IJȠ myOutput.println(). System.out țĮȚ myOutput, İȓȞĮȚ įȚĮijȠȡİIJȚțȐ ʌĮȡĮįİȓȖµĮIJĮ IJȘȢ țȜȐıȘȢ PrintStream. īȚĮ ȞĮ IJȣʌȫıȠȣµİ ıİ ȑȞĮ įȚĮijȠȡİIJȚțȩ PrintStream țȡĮIJȐµİ ȓįȚĮ IJȘ ıȪȞIJĮȟȘ ĮȜȜȐ ĮȜȜȐȗȠȣµİ IJȠ ȩȞȠµĮ IJȠȣ PrintStream. ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 28 -

ǻȚĮȕȐȗȠȞIJĮȢ Įʌȩ ȑȞĮ ǹȡȤİȓȠ ȀİȚµȑȞȠȣ ȉȫȡĮ ʌȠȣ ȟȑȡȠȣµİ ʌȫȢ ȞĮ ȖȡȐȥȠȣµİ ȑȞĮ ĮȡȤİȓȠ țİȚµȑȞȠȣ ĮȢ ʌȡȠıʌĮșȒıȠȣµİ ȞĮ įȚĮȕȐıȠȣµİ ȑȞĮ. ȅ ʌĮȡĮțȐIJȦ țȫįȚțĮȢ ʌȡȠıȠµȠȚȐȗİȚ IJȘȞ İȞIJȠȜȒ Type IJȠȣ DOS. ǻȑȤİIJĮȚ µȚĮ ıİȚȡȐ Įʌȩ ȠȞȩµĮIJĮ ĮȡȤİȓȦȞ ıIJȘ ȖȡĮµµȒ İȞIJȠȜȫȞ țĮȚ µİIJȐ IJȣʌȫȞİȚ IJĮ ʌİȡȚİȤȩµİȞĮ IJȦȞ ĮȡȤİȓȦȞ ĮȣIJȫȞ ıIJȘȞ ȠșȩȞȘ. // ʌȡȠıȠµȠȚȐȗİȚ IJȘȞ İȞIJȠȜȒ Type IJȠȣ DOS import java.io.*; class cat { public static void main (String args[]) { String thisLine; // īȚĮ ȩȜĮ IJĮ ȠȡȓıµĮIJĮ IJȘȢ ȖȡĮµµȒȢ İȞIJȠȜȫȞ for (int i=0; i < args.length; i++) { // DZȞȠȚȖµĮ IJȠȣ ĮȡȤİȓȠȣ ȖȚĮ įȚȐȕĮıµĮ try { FileInputStream fin = new FileInputStream(args[i]); // µİIJĮIJȡȠʌȒ IJȠȣ FileInputStream ıİ DataInputStream try { DataInputStream myInput = new DataInputStream(fin); try { while ((thisLine = myInput.readLine()) != null) { System.out.println(thisLine); } } catch (Exception e) { System.out.println("Error: " + e); } } catch (Exception e) { System.out.println("Error: " + e); } } catch (Exception e) { System.out.println("failed to open file " + args[i]); System.out.println("Error: " + e); } } } }

3. ȂǿȀȇȅǼĭǹȇȂȅīǼȈ ( Applets) ȅȚ µȚțȡȠİijĮȡµȠȖȑȢ (applets), İȓȞĮȚ ʌȡȠȖȡȐµµĮIJĮ ʌȠȣ ȖȡȐijȠȞIJĮȚ ıİ Java țĮȚ İȞıȦµĮIJȩȞȠȞIJĮȚ ıİ ȚıIJȠıİȜȓįİȢ. īȚĮ IJȘȞ țȦįȚțȠʌȠȓȘıȒ IJȠȣ, ȤȡȘıȚµȠʌȠȚİȓIJĮȚ ʌȡȠȖȡĮµµĮIJȚıµȩȢ țĮșȠįȘȖȠȪµİȞȠȢ Įʌȩ ȖİȖȠȞȩIJĮ (event driven). Ȉ’ ĮȣIJȩȞ IJȠȞ IJȪʌȠ ʌȡȠȖȡĮµµĮIJȚıµȠȪ, Ș ȜȠȖȚțȒ IJȠȣ ʌȡȠȖȡȐµµĮIJȠȢ įİȞ ȡȑİȚ Įʌȩ IJȘȞ țȠȡȣijȒ ıIJȘ ȕȐıȘ IJȠȣ ʌȡȠȖȡȐµµĮIJȠȢ ȩʌȦȢ ıIJȠȣȢ ʌȚȠ įȚĮįȚțĮıIJȚțȠȪȢ țȫįȚțİȢ. ȉȠ ȜİȚIJȠȣȡȖȚțȩ ıȪıIJȘµĮ ıȣȜȜȑȖİȚ IJĮ ȖİȖȠȞȩIJĮ (ȑȞĮ ȖİȖȠȞȩȢ µʌȠȡİȓ ʌ.Ȥ. ȞĮ İȓȞĮȚ IJȠ ʌȐIJȘµĮ IJȠȣ ʌȠȞIJȚțȚȠȪ ıȑȞĮ ıȘµİȓȠ IJȘȢ ȠșȩȞȘȢ) țĮȚ IJȠ ʌȡȩȖȡĮµµĮ ĮȞIJĮʌȠțȡȓȞİIJĮȚ ı’ ĮȣIJȐ. ȀȐșİ ʌȡȩȖȡĮµµĮ ȑȤİȚ ȑȞĮ ȕȡȩȤȠ ȖİȖȠȞȩIJȦȞ (event loop). ǹȣIJȩȢ İȓȞĮȚ ȑȞĮȢ ȕȡȩȤȠȢ while ʌȠȣ įȠȣȜİȪİȚ ĮıIJĮµȐIJȘIJĮ. Ȉİ țȐșİ ʌȑȡĮıµĮ µȑıĮ Įʌȩ IJȠ ȕȡȩȤȠ, Ș İijĮȡµȠȖ�� ĮȞĮțIJȐ IJȠ İʌȩµİȞȠ ȖİȖȠȞȩȢ Įʌȩ IJȘ ıİȚȡȐ ȖİȖȠȞȩIJȦȞ țĮȚ ĮȞIJĮʌȠțȡȓȞİIJĮȚ ĮȞȐȜȠȖĮ. ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 29 -

ȉȠ ʌİȡȚȕȐȜȜȠȞ İțIJȑȜİıȘȢ IJȦȞ applets (ʌ.Ȥ. Ƞ browser) ijȡȠȞIJȓȗİȚ ȖȚĮ IJȠȞ ȕȡȩȤȠ IJȘȢ İijĮȡµȠȖȒȢ.

3.1 Ǿ ȆȡȫIJȘ ȂȚțȡȠİijĮȡµȠȖȒ (Applet) Ǿ ʌĮȡĮțȐIJȦ µȚțȡȠİijĮȡµȠȖȒ, İȓȞĮȚ ĮȞIJȓıIJȠȚȤȘ IJȠȣ ʌȡȠȖȡȐµµĮIJȠȢ HelloWorld, ʌȠȣ İȓįĮµİ ıIJȘȞ § 2.1. import java.applet.Applet; import java.awt.Graphics; public class HelloWorldApplet extends Applet { public void paint(Graphics g) { g.drawString("Hello world!", 50, 25); } } ȆȜȘțIJȡȠȜȠȖȒıIJİ IJȠȞ țȫįȚțĮ țĮȚ ıȫıIJİ IJȠ ı’ ȑȞĮ ĮȡȤİȓȠ µİ ȩȞȠµĮ HelloWorldApplet.java. ȂİIJĮȖȜȦIJIJȓıIJİ IJȠ ʌȡȩȖȡĮµµĮ ʌȜȘțIJȡȠȜȠȖȫȞIJĮȢ: javac HelloWorldApplet.java ıIJȘȞ ȖȡĮµµȒ İȞIJȠȜȫȞ IJȠȣ DOS. ǹȞ ȩȜĮ ʌȐȞİ țĮȜȐ șĮ įȘµȚȠȣȡȖȘșİȓ ȑȞĮ ĮȡȤİȓȠ µİ IJȠ ȩȞȠµĮ HelloWorldApplet.class. ȉȫȡĮ ʌȡȑʌİȚ ȞĮ įȘµȚȠȣȡȖȒıİIJİ ȑȞĮ ĮȡȤİȓȠ HTML ʌȠȣ șĮ ıȣµʌİȡȚȜĮµȕȐȞİȚ IJȘȞ µȚțȡȠİijĮȡµȠȖȒ ıĮȢ. ǹțȠȜȠȣșİȓ IJȠ ĮʌȜȩ ĮȡȤİȓȠ HTML. <HTML> <HEAD> <TITLE> Hello World </TITLE> </HEAD> <BODY> ǹȣIJȩ İȓȞĮȚ IJȠ ʌȡȫIJȠ µȠȣ applet:<P> <APPLET CODE="HelloWorldApplet.class" WIDTH=200 HEIGHT=200> </APPLET> </BODY> </HTML> ȈȫıIJİ ĮȣIJȩ IJȠ ĮȡȤİȓȠ ȦȢ HelloWorldApplet.html ıIJȠȞ ȓįȚȠ țĮIJȐȜȠȖȠ ʌȠȣ ȣʌȐȡȤİȚ țĮȚ IJȠ HelloWorldApplet.class. ȈIJȘ ıȣȞȑȤİȚĮ ĮȞȠȓȟIJİ IJȠȞ ijȣȜȜȠµİIJȡȘIJȒ țĮȚ ijȠȡIJȫıIJİ IJȠ ĮȡȤİȓȠ HTML. ĬĮ ʌȡȑʌİȚ ȞĮ įİȓIJİ țȐIJȚ ıĮȞ IJȠ ĮțȩȜȠȣșȠ: ǹȣIJȩ İȓȞĮȚ IJȠ ʌȡȫIJȠ µȠȣ applet: Hello World! ǼȟİIJȐȗȠȞIJĮȢ IJȠ applet HelloWorldApplet ȉȠ HelloWorldApplet, ıİ ıȤȑıȘ µİ IJȠ ʌȡȩȖȡȐµµĮ HelloWorld, ʌȠȣ İȓįĮµİ ıIJȘȞ § 2.1, ȑȤİȚ țȐʌȠȚİȢ įȚĮijȠȡȑȢ. ȄİțȚȞȫȞIJĮȢ Įʌȩ ʌȐȞȦ ʌȡȠȢ IJĮ țȐIJȦ, IJȠ ʌȡȫIJȠ ʌȡȐȖµĮ ʌȠȣ ʌȡȠıȑȤȠȣµİ İȓȞĮȚ ȠȚ įȪȠ ȖȡĮµµȑȢ: import java.applet.Applet; import java.awt.Graphics; Ǿ įȒȜȦıȘ import ıIJȘ Java İȓȞĮȚ ʌĮȡȩµȠȚĮ µİ IJȘ įȒȜȦıȘ #include ıIJȘȞ C Ȓ ıIJȘȞ C++. ǼȚıȐȖİȚ IJȚȢ țȜȐıİȚȢ ʌȠȣ ʌİȡȚȑȤȠȞIJĮȚ ı’ ȑȞĮ ʌĮțȑIJȠ țȐʌȠȣ ĮȜȜȠȪ. DzȞĮ ʌĮțȑIJȠ İȓȞĮȚ ȑȞĮ ıȪȞȠȜȠ Įʌȩ ıȤİIJȚȗȩµİȞİȢ țȜȐıİȚȢ. Ȉ’ ĮȣIJȒȞ IJȘȞ ʌİȡȓʌIJȦıȘ ȗȘIJȐµİ ʌȡȩıȕĮıȘ ıIJȚȢ țȜȐıİȚȢ ʌȠȣ ıȣµʌİȡȚȜĮµȕȐȞȠȞIJĮȚ ıIJȠ java.applet.Applet țĮȚ java.awt.Graphics. Ǿ İʌȩµİȞȘ įȚĮijȠȡȐ ʌȠȣ ʌĮȡĮIJȘȡȠȪµİ İȓȞĮȚ Ƞ ȠȡȚıµȩȢ IJȘȢ țȜȐıȘȢ: public class HelloWorldApplet extends Applet Ǿ ȜȑȟȘ țȜİȚįȓ extends ȣʌȠȞȠİȓ ȩIJȚ ĮȣIJȒ Ș țȜȐıȘ İȓȞĮȚ µȚĮ ȣʌȠțȜȐıȘ IJȘȢ țȜȐıȘȢ Applet. dz ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 30 -

ĮȜȜȚȫȢ Ș Applet İȓȞĮȚ Ș ȣʌİȡțȜȐıȘ IJȠȣ HelloWorldApplet. Ǿ țȜȐıȘ Applet ʌȡȠıįȚȠȡȓȗİIJĮȚ ıIJȠ ʌĮțȑIJȠ java.applet.Applet. ǼijȩıȠȞ IJȠ HelloWorldApplet İȓȞĮȚ ȣʌȠțȜȐıȘ IJȠȣ Applet, IJȩIJİ IJȠ HelloWorldApplet țȜȘȡȠȞȠµİȓ (extends) ȩȜȘ IJȘ ȜİȚIJȠȣȡȖȚțȩIJȘIJĮ (ȩȜİȢ IJȚȢ µİșȩįȠȣȢ) IJȠȣ ĮȡȤȚțȠȪ Applet. ǵ,IJȚ µʌȠȡİȓ ȞĮ țȐȞİȚ Ș Applet, µʌȠȡİȓ ȞĮ IJȠ țȐȞİȚ țĮȚ IJȠ HelloWorldApplet İʌȓıȘȢ. Ǿ İʌȩµİȞȘ įȚĮijȠȡȐ İȓȞĮȚ ȩIJȚ įİȞ ȣʌȐȡȤİȚ țȪȡȚĮ µȑșȠįȠȢ (main), ȩʌȦȢ ıȣµȕĮȓȞİȚ µİ IJȚȢ İijĮȡµȠȖȑȢ, țĮȚ ȑIJıȚ įİȞ ȣʌȐȡȤİȚ țĮȞȑȞĮ ıȘµİȓȠ İțțȓȞȘıȘȢ ȖȚĮ IJȠ ʌȡȩȖȡĮµµĮ. ǹȞIJȓ ȞĮ ĮȡȤȓıȠȣȞ Įʌȩ ȑȞĮ ıȣȖțİțȡȚµȑȞȠ ıȘµİȓȠ IJȠȣ țȫįȚțĮ, ȠȚ µȚțȡȠİijĮȡµȠȖȑȢ ȠįȘȖȠȪȞIJĮȚ Įʌȩ ȖİȖȠȞȩIJĮ. ȂȓĮ µȚțȡȠİijĮȡµȠȖȒ ʌİȡȚµȑȞİȚ ȖȚĮ ȑȞĮ ȖİȖȠȞȩȢ ȩʌȦȢ IJȠ ʌȐIJȘµĮ İȞȩȢ ʌȜȒțIJȡȠȣ Ȓ IJȠ țȜȚț IJȠȣ ʌȠȞIJȚțȚȠȪ țĮȚ ȑʌİȚIJĮ İțIJİȜİȓ IJȠȞ țĮIJȐȜȜȘȜȠ ȤİȚȡȚıIJȒ ȖİȖȠȞȩIJȦȞ (event handler). Ǿ ʌĮȡĮʌȐȞȦ µȚțȡȠİijĮȡµȠȖȒ, ȑȤİȚ µȩȞȠ ȑȞĮȞ ȤİȚȡȚıIJȒ ȖİȖȠȞȩIJȦȞ, IJȘȞ µȑșȠįȠ paint. Ǿ µȑșȠįȠȢ paint ȤȡȘıȚµȠʌȠȚİȓ ȑȞĮ ĮȞIJȚțİȓµİȞȠ IJȪʌȠȣ Graphics, ʌȠȣ İʌȚȜȑȖȠȣµİ ȞĮ IJȠ Ȝȑµİ g. Ǿ țȜȐıȘ Graphics ȠȡȓȗİIJĮȚ ıIJȠ ʌĮțȑIJȠ java.awt.Graphics. ȂȑıĮ ıIJȘ µȑșȠįȠ paint țĮȜȠȪµİ IJȘȞ µȑșȠįȠ drawString ȞĮ ȖȡȐȥİȚ IJȠ ĮȜijĮȡȚșµȘIJȚțȩ "Hello World" ıIJȠ ıȘµİȓȠ µİ ıȣȞIJİIJĮȖµȑȞİȢ (50,25). ǹȣIJȩ ȕȡȓıțİIJĮȚ 50 pixels ĮȡȚıIJİȡȐ țĮȚ 25 pixels țȐIJȦ Įʌȩ IJȘȞ ʌȐȞȦ ĮȡȚıIJİȡȒ ȖȦȞȓĮ IJȘȢ µȚțȡȠİijĮȡµȠȖȒȢ. ĬĮ µȚȜȒıȠȣµİ ʌİȡȚııȩIJİȡȠ ȖȚĮ IJȠ ıȪıIJȘµĮ ıȣȞIJİIJĮȖµȑȞȦȞ ĮȡȖȩIJİȡĮ.

3.2 ȅȚ ȂȑșȠįȠȚ IJȦȞ ȂȚțȡȠİijĮȡµȠȖȫȞ ǵʌȦȢ İȓįĮµİ ʌĮȡĮʌȐȞȦ, µİ IJȘȞ İȞIJȠȜȒ import java.applet.Applet Ș µȚțȡȠİijĮȡµȠȖȒ (applet) țȜȘȡȠȞȠµİȓ (extends) ȩȜİȢ IJȚȢ µİșȩįȠȣȢ ʌȠȣ ݵijĮȞȓȗȠȞIJĮȚ ĮȣIJȩµĮIJĮ ȩIJĮȞ ȤȡİȚĮıșİȓ țĮȚ ʌȠȣ İȓȞĮȚ ȠȚ init(), paint(), start(), stop() țĮȚ destroy(). ǹȞ șȑȜȠȣµİ ȞĮ ıȣµȕİȓ țȐIJȚ ı' ȑȞĮ applet, șĮ ʌȡȑʌİȚ ȞĮ ȣʌİȡțĮȜȪȥȠȣµİ (override) ĮȣIJȑȢ IJȚȢ µİșȩįȠȣȢ țĮȚ ȠȚ µȑșȠįȠȚ ʌȠȣ ȣʌİȡțĮȜȪʌIJȠȣµİ ıȣȤȞȩIJİȡĮ İȓȞĮȚ ȠȚ paint() țĮȚ init(). Ǿ µȑșȠįȠȢ paint() ĮʌȠIJİȜİȓ µȑȡȠȢ țȐșİ applet ʌȠȣ șĮ įȘµȚȠȣȡȖȠȪµİ țĮȚ ȤȦȡȓȢ ĮȣIJȒȞ įİȞ µʌȠȡȠȪµİ ȞĮ ݵijĮȞȓıȠȣµİ IJȓʌȠIJĮ ıIJȘȞ ȠșȩȞȘ. ȋȡȘıȚµȠʌȠȚİȓ ȑȞĮ ȩȡȚıµĮ IJȘȢ țȜȐıȘȢ Graphics țĮȚ Ș ıȪȞIJĮȟȒ IJȘȢ İȓȞĮȚ ȦȢ İȟȒȢ : public void paint(Graphics g){ ... } ĬĮ ʌȡȑʌİȚ ȞĮ ȑȤȠȣµİ ʌȡȠıșȑıİȚ ȞȦȡȓIJİȡĮ IJȘȞ İȞIJȠȜȒ import java.awt.Graphics ıIJȘȞ ĮȡȤȒ IJȠȣ țȫįȚțĮ țĮȚ ʌȡȚȞ Įʌȩ IJȠȞ ȠȡȚıµȩ IJȘȢ țȜȐıȘȢ. Ǿ µȑșȠįȠȢ init() țĮȜİȓIJĮȚ µȩȞȠ µȓĮ ijȠȡȐ ȩIJĮȞ İțIJİȜİȓIJĮȚ IJȠ applet țĮȚ ȤȡȘıȚµȠʌȠȚİȓIJĮȚ ȖȚĮ ȞĮ ȠȡȓıİȚ µİIJĮȕȜȘIJȑȢ ʌȠȣ ȤȡİȚȐȗȠȞIJĮȚ ıIJȠ applet, ȩʌȦȢ ȖȚĮ ʌĮȡȐįİȚȖµĮ ȖȡĮµµĮIJȠıİȚȡȑȢ (fonts), ȤȡȫµĮIJĮ (colors) ț.Ȑ. Ǿ µȑșȠįȠȢ start() țĮȜİȓIJĮȚ ȩIJĮȞ IJȠ applet ĮȡȤȓȗİȚ ȞĮ İțIJİȜİȓIJĮȚ țĮȚ ȖȚĮ ȞĮ țȜȘșİȓ ȖȚĮ įİȪIJİȡȘ ijȠȡȐ, ʌȡȑʌİȚ ȞĮ ıIJĮµĮIJȒıİȚ Ș İțIJȑȜİıȘ IJȠȣ applet. Ǿ µȑșȠįȠȢ stop() țĮȜİȓIJĮȚ ȩIJĮȞ ıIJĮµĮIJȐİȚ Ș İțIJȑȜİıȘ IJȠȣ applet, įȘȜĮįȒ ȩIJĮȞ ijİȪȖȠȣµİ Įʌȩ IJȘȞ ȚıIJȠıİȜȓįĮ. Ǿ µȑșȠįȠȢ destroy() țĮȜİȓIJĮȚ ĮµȑıȦȢ ʌȡȚȞ IJİȡµĮIJȚıșİȓ IJȠ applet. ǹțȠȜȠȣșİȓ ȑȞĮ ĮʌȜȩ ʌĮȡȐįİȚȖµĮ applet. import java.applet.Applet; import java.awt.Graphics; public class message extends Applet{ int Value; ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 31 -

public void init(){ Value = 300000; } public void paint(Graphics g){ g.drawString("Ǿ ĮȟȓĮ IJȠȣ ĮȣIJȠțȚȞȒIJȠȣ İȓȞĮȚ: " + Value, 10, 30); } } Ǿ µȑșȠįȠȢ drawString() ȤȡȘıȚµȠʌȠȚİȓIJĮȚ ȖȚĮ ȞĮ ݵijĮȞȓıȠȣµİ µȘȞȪµĮIJĮ ı' ȑȞĮ applet IJȘȢ Java ĮȞIJȓ ȖȚĮ IJȘȞ System.out.println(). ȂȑıĮ ı' ȑȞĮ applet µʌȠȡȠȪµİ ȞĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ IJȘȞ µȑșȠįȠ repaint() ȖȚĮ ȞĮ țĮȜȑıȠȣµİ ȟĮȞȐ IJȘȞ µȑșȠįȠ paint() ıIJȘȞ ʌİȡȓʌIJȦıȘ ʌȠȣ ȑȤİȚ ȖȓȞİȚ țȐʌȠȚĮ ĮȜȜĮȖȒ ıIJȘȞ IJȚµȒ țȐʌȠȚĮȢ µİIJĮȕȜȘIJȒȢ. īȚĮ ʌĮȡȐįİȚȖµĮ, µʌȠȡȠȪµİ ȞĮ ȟĮȞĮȖȡȐȥȠȣµİ IJȘȞ ʌĮȡĮʌȐȞȦ µȚțȡȠİijĮȡµȠȖȒ ĮȜȜȐȗȠȞIJĮȢ µȩȞȠ IJȘȞ µȑșȠįȠ paint(), ȦȢ İȟȒȢ : public void paint(Graphics g){ g.drawString("Ǿ ĮȟȓĮ IJȠȣ ĮȣIJȠțȚȞȒIJȠȣ İȓȞĮȚ: " + Value, 10, 30); Value++; repaint(); } Ǿ IJȚµȒ IJȠȣ Value șĮ ĮȜȜȐȗİȚ ıȣȞȑȤİȚĮ țĮȚ șĮ țĮȜȠȪµİ IJȘȞ µȑșȠįȠ repaint(), ʌȠȣ ıIJȘȞ ȠȣıȓĮ İȓȞĮȚ Ș ȓįȚĮ Ș µȑșȠįȠȢ paint(), ȖȚĮ ȞĮ ݵijĮȞȚıșİȓ Ș ȞȑĮ IJȚµȒ IJȘȢ Value.

3.3 Ǿ ǼIJȚțȑIJĮ APPLET IJȘȢ HTML ȉĮ applets ıȣµʌİȡȚȜĮµȕȐȞȠȞIJĮȚ ıIJȚȢ ȚıIJȠıİȜȓįİȢ µİ ȤȡȒıȘ IJȘȢ İIJȚțȑIJĮȢ <APPLET> IJȘȢ HTML, ȦȢ İȟȒȢ: <APPLET CODE = "…" CODEBASE = "…" NAME = "…" WIDTH = … HEIGHT = … ALIGN = … HSPACE = … VSPACE = … > </APPLET> Ǿ ʌĮȡȐµİIJȡȠȢ CODE ĮȞĮijȑȡİȚ IJȠ ȩȞȠµĮ IJȠȣ applet ʌȠȣ șĮ İțIJİȜİıșİȓ, Ș CODEBASE IJȠȞ ijȐțİȜȠ ȩʌȠȣ ȣʌȐȡȤİȚ Ƞ țȫįȚțĮȢ IJȠȣ applet ĮȞ įİȞ İȓȞĮȚ Ƞ IJȡȑȤȠȞ ijȐțİȜȠȢ, ȠȚ HEIGHT țĮȚ WIDTH IJȠ ȪȥȠȢ țĮȚ IJȠ ʌȜȐIJȠȢ (ıİ pixels Ȓ ıİ ʌȠıȠıIJȩ) ĮȞIJȓıIJȠȚȤĮ IJȠȣ ȠȡșȠȖȦȞȓȠȣ ʌȠȣ șĮ ݵijĮȞȓıİȚ IJȠ applet ıIJȘȞ ȠșȩȞȘ. Ǿ ʌĮȡȐµİIJȡȠȢ ALIGN, țĮșȠȡȓȗİȚ IJȠȞ IJȡȩʌȠ ıIJȠȓȤȚıȘȢ țĮȚ IJȠʌȠșȑIJȘıȘȢ IJȠȣ applet ıIJȘȞ ȚıIJȠıİȜȓįĮ. ȊʌȐȡȤȠȣȞ 9 İʌȚȜȠȖȑȢ ʌȠȣ ĮijȠȡȠȪȞ IJȘȞ ALIGN: x

LEFT: ȉȠ applet IJȠʌȠșİIJİȓIJĮȚ ıIJȠ ĮȡȚıIJİȡȩ ʌİȡȚșȫȡȚȠ IJȘȢ ıİȜȓįĮȢ țĮȚ ȩȜȠ IJȠ țİȓµİȞȠ ʌȠȣ ĮțȠȜȠȣșİȓ IJȘȞ įȒȜȦıȘ IJȠȣ applet, įȚĮȤȑİIJĮȚ įİȟȚȐ IJȠȣ.

x

RIGHT: ǹȞIJȓıIJȠȚȤĮ ȩʌȦȢ ıIJȘȞ LEFT.

x

TOP: ȈIJȠȚȤȓȗİȚ IJȠ applet, ıȪµijȦȞĮ µİ IJȠ µȑȖȚıIJȠ ȪȥȠȢ IJȘȢ ıȣȖțİțȡȚµȑȞȘȢ ȖȡĮµµȒȢ.

x

TEXTTOP: ȈIJȠȚȤȓȗİȚ IJȘȞ țȠȡȣijȒ IJȠȣ applet µİ IJȠ ȥȘȜȩIJİȡȠ ıȘµİȓȠ țİȚµȑȞȠȣ IJȘȢ ȖȡĮµµȒȢ.

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 32 -

x

ABSMIDDLE: ȈIJȠȚȤȓȗİȚ IJȠ µȑıȠȞ IJȠȣ applet, ıȪµijȦȞĮ µİ IJȠ µȑıȠ IJȠȣ µİȖĮȜȪIJİȡȠȣ ĮȞIJȚțİȚµȑȞȠȣ IJȘȢ ȖȡĮµµȒȢ.

x

MIDDLE: ȈIJȠȚȤȓȗİȚ IJȠ µȑıȠȞ IJȠȣ applet, µİ IJȠ µȑıȠ IJȘȢ ȖȡĮµµȒȢ ȕȐıȘȢ IJȠȣ țİȚµȑȞȠȣ.

x

BOTTOM: ȈIJȠȚȤȓȗİȚ IJȠ applet ıIJȘ ȕȐıȘ IJȠȣ țİȚµȑȞȠȣ.

x

ABSBOTTOM: ȈIJȠȚȤȓȗİȚ IJȘ ȕȐıȘ IJȠȣ applet, ıȪµijȦȞĮ µİ IJȠ ȤĮµȘȜȩIJİȡȠ ĮȞIJȚțİȓµȑȞȠ IJȘȢ ȖȡĮµµȒȢ.

x

BASELINE: ǵʌȦȢ țĮȚ Ș BOTTOM.

ȅȚ ʌĮȡȐµİIJȡȠȚ HSPACE țĮȚ VSPACE, țĮșȠȡȓȗȠȣȞ IJȠȞ ȤȫȡȠ (ıİ pixels) ʌȠȣ ʌĮȡݵȕȐȜȜİIJĮȚ µİIJĮȟȪ IJȦȞ ȠȡȓȦȞ IJȠȣ applet țĮȚ IJȠȣ țİȚµȑȞȠȣ ʌȠȣ IJȠ ʌİȡȚȕȐȜȜİȚ. Ǿ HSPACE țĮșȠȡȓȗİȚ IJȠȞ ȠȡȚȗȩȞIJȚȠ ȤȫȡȠ (įİȟȚȐ țĮȚ ĮȡȚıIJİȡȐ IJȠȣ applet), İȞȫ Ș VSPACE IJȠȞ țĮIJĮțȩȡȣijȠ ȤȫȡȠ (ʌȐȞȦ țĮȚ țȐIJȦ IJȠȣ applet). ǹȞȐµİıĮ ıIJȚȢ İIJȚțȑIJİȢ <APPLET> țĮȚ </ APPLET> µʌȠȡȠȪµİ ȞĮ ȖȡȐȥȠȣµİ ȑȞĮ țİȓµİȞȠ ȖȚĮ ȞĮ ݵijĮȞȚıșİȓ ıİ ijȣȜȜȠµİIJȡȘIJȑȢ ʌȠȣ įİȞ ȣʌȠıIJȘȡȓȗȠȣȞ Java.

3.4 ȆȑȡĮıµĮ ȆĮȡĮµȑIJȡȦȞ ıIJȚȢ ȂȚțȡȠİijĮȡµȠȖȑȢ Ǿ ʌİȡȚȠȤȒ ĮȞȐµİıĮ ıIJȠ ȐȞȠȚȖµĮ țĮȚ IJȠ țȜİȓıȚµȠ IJȘȢ İIJȚțȑIJĮȢ <APPLET> ȤȡȘıȚµȠʌȠȚİȓIJĮȚ, İʌȓıȘȢ, ȖȚĮ ȞĮ ʌİȡĮıIJȠȪȞ ʌĮȡȐµİIJȡȠȚ ıIJĮ applets. ǹȣIJȩ İʌȚIJȣȖȤȐȞİIJĮȚ µİ IJȘ ȤȡȒıȘ IJȘȢ İIJȚțȑIJĮȢ PARAM IJȘȢ HTML țĮȚ IJȘȢ µİșȩįȠȣ getParameter. īȚĮ ȞĮ IJȠ įİȓȟȠȣµİ ĮȣIJȩ șĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ IJȠ HelloWorldApplet ıİ µȚĮ ȖİȞȚțȐ ıȤİįȚĮıµȑȞȘ İijĮȡµȠȖȒ. īȚĮ ȞĮ IJȠ țȐȞȠȣµİ ĮȣIJȩ șĮ ʌİȡȐıȠȣµİ ıIJȠ applet, ȦȢ ʌĮȡȐµİIJȡȠ, IJȠ ĮȜijĮȡȚșµȘIJȚțȩ ʌȠȣ șĮ IJȣʌȫȞİIJĮȚ. import java.applet.Applet; import java.awt.Graphics; public class DrawStringApplet extends Applet { String input_from_page; public void init() { input_from_page = getParameter("String"); } public void paint(Graphics g) { g.drawString(input_from_page, 50, 25); } } ȉȫȡĮ șĮ įȘµȚȠȣȡȖȒıȠȣµİ ȑȞĮ HTML ĮȡȤİȓȠ ʌȠȣ șĮ ʌİȡȚȜĮµȕȐȞİȚ IJȠ applet, ȦȢ İȟȒȢ: <HTML> <HEAD> <TITLE> Draw String </TITLE> </HEAD> <BODY> ǹȣIJȩ İȓȞĮȚ IJȠ applet:<P> <APPLET code="DrawStringApplet.class" width=200 height=200> <PARAM name="String" value="Good morning, there!"> </APPLET> </BODY> </HTML> ĭȣıȚțȐ İȓµĮıIJİ İȜİȪșİȡȠȚ ȞĮ ĮȜȜȐȟȠȣµİ IJȠ ‘Good morning, there!’ µİ ȑȞĮ ĮȜijĮȡȚșµȘIJȚțȩ IJȘȢ İʌȚȜȠȖȒȢ µĮȢ. ȈȘµİȚȫıIJİ ȩIJȚ ĮȣIJȩ µĮȢ İʌȚIJȡȑʌİȚ ȞĮ ĮȜȜȐȟȠȣµİ IJȘȞ ȑȟȠįȠ IJȠȣ applet ȤȦȡȓȢ ȞĮ ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 33 -

ĮȜȜȐȟȠȣµİ Ȓ ȞĮ ȟĮȞĮįȚȠȡșȫıȠȣµİ IJȠȞ țȫįȚțȐ IJȠȣ. ǻİȞ İȓµĮıIJİ ʌİȡȚȠȡȚıµȑȞȠȚ ıİ µȚĮ µȩȞȠ ʌĮȡȐµİIJȡȠ, µʌȠȡȠȪµİ ȞĮ ʌİȡȐıȠȣµİ ʌȠȜȜȑȢ ʌĮȡĮµȑIJȡȠȣȢ ıİ ȑȞĮ applet. Ǿ µȑșȠįȠȢ getParameter İȓȞĮȚ ĮʌȜȒ. ȉȘȢ įȓȞȠȣµİ ȑȞĮ string IJȠ ȠʌȠȓȠ İȓȞĮȚ IJȠ ȩȞȠµĮ IJȘȢ ʌĮȡĮµȑIJȡȠȣ ʌȠȣ șȑȜȠȣµİ. ȂĮȢ İʌȚıIJȡȑijİȚ ȑȞĮ string, ʌȠȣ İȓȞĮȚ Ș IJȚµȒ IJȘȢ ʌĮȡĮµȑIJȡȠȣ. Ș µȑșȠįȠȢ getParameter İʌȚıIJȡȑijİȚ ȩȜİȢ IJȚȢ ʌĮȡĮµȑIJȡȠȣȢ ıĮȞ strings. ǼȐȞ șȑȜȠȣµİ ȞĮ ʌȐȡȠȣµİ țȐIJȚ ȐȜȜȠ, ȩʌȦȢ ȑȞĮȞ ĮțȑȡĮȚȠ, șĮ ʌȡȑʌİȚ ȞĮ țȐȞȠȣµİ µİIJĮIJȡȠʌȑȢ IJȪʌȠȣ, ȦȢ İȟȒȢ: <PARAM name="age" value="36"> ... int age; String ageParam = getParameter("age"); age = Integer.parseInt(ageParam); Ǿ İIJȚțȑIJĮ PARAM IJȘȢ HTML İȓȞĮȚ İʌȓıȘȢ ĮʌȜȒ. ȉȠʌȠșİIJİȓIJĮȚ ĮȞȐµİıĮ ıIJȠ <APPLET> țĮȚ ıIJȠ </APPLET>. DzȤİȚ įȣȠ ʌĮȡĮµȑIJȡȠȣȢ įȚțȑȢ IJȘȢ, IJȚȢ NAME țĮȚ VALUE. Ǿ NAME țĮșȠȡȓȗİȚ IJĮ ȠȞȩµĮIJĮ IJȦȞ ʌĮȡĮµȑIJȡȦȞ țĮȚ Ș VALUE IJȚȢ IJȚµȑȢ IJȠȣȢ.

3.5 īİȖȠȞȩIJĮ (events) țĮȚ ȂȚțȡȠİijĮȡµȠȖȑȢ ȉȠ ĮțȩȜȠȣșȠ applet İȓȞĮȚ ıȤİįȚĮıµȑȞȠ ȖȚĮ ȞĮ ıĮȢ įȫıİȚ țȐʌȠȚĮ ĮȓıșȘıȘ ȖȚĮ IJȠ IJȚ İȓȞĮȚ ʌȡȠȖȡĮµµĮIJȚıµȩȢ țĮșȠįȘȖȠȪµİȞȠȢ Įʌȩ ȖİȖȠȞȩIJĮ țĮȚ ʌȠȚĮ İȓȞĮȚ IJĮ įȚȐijȠȡĮ ȖİȖȠȞȩIJĮ ʌȠȣ ʌȚșĮȞȩȞ șĮ ıȣȞĮȞIJȒıİIJİ. ǵIJĮȞ ıȣµȕĮȓȞİȚ ȑȞĮ ȖİȖȠȞȩȢ IJȠ applet ĮȞIJĮʌȠțȡȓȞİIJĮȚ ʌȡȠıĮȡIJȫȞIJĮȢ IJȠ ȩȞȠµĮ IJȠȣ ȖİȖȠȞȩIJȠȢ ıİ µȓĮ ȜȓıIJĮ. ȂȚĮ ȜȓıIJĮ (List) İȓȞĮȚ µȚĮ țȣȜȚȩµİȞȘ ıİȚȡȐ Įʌȩ ĮȜijĮȡȚșµȘIJȚțȐ ʌȠȣ ȠȡȓȗİIJĮȚ ıIJȠ java.awt.List. ĬĮ įȘµȚȠȣȡȖȒıȠȣµİ µȚĮ țĮȚȞȠȪȡȖȚĮ ȜȓıIJĮ, ĮțȡȚȕȫȢ ȩʌȦȢ įȘµȚȠȣȡȖȠȪµİ ȑȞĮ ĮȞIJȚțİȓµİȞȠ. ȅ ıȣȖțİțȡȚµȑȞȠȢ țĮIJĮıțİȣĮıIJȒȢ (constructor) ʌȠȣ ȤȡȘıȚµȠʌȠȚȠȪµİ, įȑȤİIJĮȚ ȦȢ ʌĮȡȐµİIJȡȠ ȑȞĮȞ ĮțȑȡĮȚȠ (int), ʌȠȣ İțijȡȐȗİȚ IJȠ ʌȜȒșȠ�� IJȦȞ ȠȡĮIJȫȞ ȖȡĮµµȫȞ IJȘȢ ȜȓıIJĮȢ țĮȚ ȑȞĮ boolean, IJȠ ȠʌȠȓȠ İțijȡȐȗİȚ IJȠ ĮȞ İʌȚIJȡȑʌȠȞIJĮȚ Ȓ ȩȤȚ ʌȠȜȜĮʌȜȑȢ İʌȚȜȠȖȑȢ. ĬĮ įȘµȚȠȣȡȖȒıȠȣµİ IJȘȞ ȜȓıIJĮ µİ 25 ȠȡĮIJȑȢ ȖȡĮµµȑȢ țĮȚ ȤȦȡȓȢ ʌȠȜȜĮʌȜȑȢ İʌȚȜȠȖȑȢ. List theList; theList = new List(25, false); ĬĮ ʌȡȠıșȑIJȠȣµİ ĮȜijĮȡȚșµȘIJȚțȐ ıIJȘȞ ȜȓıIJĮ ȤȡȘıȚµȠʌȠȚȫȞIJĮȢ IJȘȞ µȑșȠįȠ addItem Įʌȩ IJȠ List. theList.addItem("This is a list item"); ȉȑȜȠȢ ȤȡİȚȐȗİIJĮȚ ȞĮ ʌȡȠıșȑıȠȣµİ ĮȣIJȒȞ IJȘȞ ȜȓıIJĮ ıIJȠ applet µĮȢ. ǹȣIJȩ IJȠ țȐȞȠȣµİ µİ IJȘ ȖȡĮµµȒ: add(theList); ıIJȘȞ µȑșȠįȠ init. import import public List

java.applet.Applet; java.awt.*; class EventList extends Applet { theList;

public void init() { theList = new List(25, false); add(theList); theList.addItem("init event"); } ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 34 -

public void paint(Graphics g) { theList.addItem("paint event"); } public void start() { theList.addItem("start event"); } public void destroy() { theList.addItem("destroy event"); } public void update(Graphics g) { theList.addItem("update event"); } public boolean mouseUp(Event e, int x, int y) { theList.addItem("mouseUp event"); return false; } public boolean mouseDown(Event e, int x, int y) { theList.addItem("mouseDown event"); return false; } public boolean mouseDrag(Event e, int x, int y) { theList.addItem("mouseDrag event"); return false; } public boolean mouseMove(Event e, int x, int y) { theList.addItem("mouseMove event"); return false; } public boolean mouseEnter(Event e, int x, int y) { theList.addItem("mouseEnter event"); return false; } public boolean mouseExit(Event e, int x, int y) { theList.addItem("mouseExit event"); return false; }

}

public boolean keyDown(Event e, int x) { theList.addItem("keyDown event"); return true; } public boolean keyUp(Event e, int x) { theList.addItem("keyUp event"); return true; }

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 35 -

ȀĮșȫȢ șĮ ȑȤİIJİ µİIJĮȖȜȦIJIJȓıİȚ țĮȚ ijȠȡIJȫıİȚ ĮȣIJȩ IJȠ applet ıIJȠȞ ijȣȜȜȠµİIJȡȘIJȒ, ʌĮȓȟİ µĮȗȓ IJȠȣ. ȀȐȞIJİ țȜȚț ıIJȠ ʌĮȡȐșȣȡȠ IJȠȣ applet. ȀȐȞIJİ įȚʌȜȩ țȜȚț µİ IJȠ ʌȠȞIJȓțȚ. ȀȐȞIJİ țȜȚț țĮȚ ıȪȡİIJİ IJȠ ʌȠȞIJȓțȚ. ȆĮIJȒıIJİ țȐʌȠȚĮ ʌȜȒțIJȡĮ IJȠȣ ʌȜȘțIJȡȠȜȠȖȓȠȣ. ȂİȖȚıIJȠʌȠȚȒıIJİ, İȜĮȤȚıIJȠʌȠȚȒıIJİ, ȟĮȞĮȞȠȓȟIJİ IJȠ ʌĮȡȐșȣȡȠ IJȠȣ ijȣȜȜȠµİIJȡȘIJȒ. ȀĮșȫȢ șĮ țȐȞİIJİ IJĮ ʌĮȡĮʌȐȞȦ, įİȓIJİ ʌȦȢ ĮȜȜȐȗȠȣȞ IJĮ įİįȠµȑȞĮ IJȘȢ ȜȓıIJĮȢ. ȊʌȐȡȤȠȣȞ ĮȡțİIJȐ ȞȑĮ ʌȡȐȖµĮIJĮ ı’ ĮȣIJȩȞ IJȠȞ țȫįȚțĮ. ȆȡȫIJȠȞ, İȓȞĮȚ Ș įȒȜȦıȘ import java.awt.*. ǹȣIJȒȞ IJȘ ijȠȡȐ ȤȡİȚĮȗȩµĮıIJİ ʌĮȡĮʌȐȞȦ Įʌȩ µȚĮ țȜȐıȘ Įʌȩ IJȠ ʌĮțȑIJȠ awt. īȚĮ ȞĮ µȘȞ ĮȞȘıȣȤȠȪµİ ʌȠȚĮ ȞĮ İȚıȐȖȠȣµİ IJȚȢ ʌĮȓȡȞȠȣµİ ȩȜİȢ µİ IJȠ *. ȅ µİIJĮȖȜȦIJIJȚıIJȒȢ İȓȞĮȚ ĮȡțİIJȐ ‘ȑȟȣʌȞȠȢ’ ȖȚĮ ȞĮ ıȣȞįȑıİȚ µȩȞȠ ĮȣIJȑȢ ʌȠȣ ʌȡĮȖµĮIJȚțȐ ȤȡİȚȐȗİIJĮȚ. ȊʌȐȡȤİȚ țĮȚ ȑȞĮ ıȪȞȠȜȠ Įʌȩ ȞȑİȢ µİșȩįȠȣȢ ȖİȖȠȞȩIJȦȞ, IJȚȢ ȠʌȠȓİȢ țĮȜȪʌIJȠȣµİ ʌĮȡĮțȐIJȦ: ȉĮ īİȖȠȞȩIJĮ ǼțIJȩȢ Įʌȩ IJȚȢ µİșȩįȠȣȢ ʌȠȣ ĮȞĮijȑȡĮµİ ıIJȘȞ § 3.2, IJȠ ʌĮȡĮʌȐȞȦ applet ʌİȡȚȑȤİȚ țĮȚ IJȚȢ ʌĮȡĮțȐIJȦ: update Ǿ µȑșȠįȠȢ update() țĮȜİȓIJĮȚ ĮȣIJȩµĮIJĮ Įʌȩ IJȠ ıȪıIJȘµĮ. public void update(Graphics g) { theList.addItem("update event"); } mouseUp Ǿ µȑșȠįȠȢ mouseUp() țĮȜİȓIJĮȚ ȩIJĮȞ IJȠ țȠȣµʌȓ IJȠȣ ʌȠȞIJȚțȚȠȪ ĮʌİȜİȣșİȡȫȞİIJĮȚ ıIJȠ applet. ȈIJȚȢ ʌİȡȚııȩIJİȡİȢ ʌİȡȚʌIJȫıİȚȢ ĮȣIJȩ İȓȞĮȚ IJȠ ȖİȖȠȞȩȢ ʌȠȣ șĮ șȑȜĮµİ ȞĮ ʌĮȡĮțȠȜȠȣșȒıȠȣµİ țĮȚ ȩȤȚ IJȠ mouseDown. DzȞĮ țȠȣµʌȓ İȓȞĮȚ IJȣʌȚțȐ İʌȚȜİȖµȑȞȠ ȩIJĮȞ IJȠ țȠȣµʌȓ IJȠȣ ʌȠȞIJȚțȚȠȪ ʌĮIJȚȑIJĮȚ ʌȐȞȦ ı’ ĮȣIJȩ, ĮȜȜȐ įİȞ İȓȞĮȚ İȞİȡȖȠʌȠȚȘµȑȞȠ µȑȤȡȚ Ƞ ȤȡȒıIJȘȢ ȞĮ IJȠ ĮʌİȜİȣșİȡȫıİȚ. ǹȣIJȩ įȓȞİȚ ıIJȠ ȤȡȒıIJȘ IJȘȞ İȣțĮȚȡȓĮ ȞĮ ĮȜȜȐȟİȚ IJȘ ȖȞȫµȘ IJȠȣ µİIJĮțȚȞȫȞIJĮȢ IJȠȞ įİȓțIJȘ IJȠȣ ʌȠȞIJȚțȚȠȪ Įʌȩ IJȠ ĮȞIJȚțİȓµİȞȠ ȤȦȡȓȢ ȞĮ IJȠ ĮʌİȜİȣșİȡȫıİȚ. Ǿ µȑșȠįȠȢ mouseUp() ȜĮµȕȐȞİȚ İʌȓıȘȢ IJȚȢ ıȣȞIJİIJĮȖµȑȞİȢ IJȠȣ ıȘµİȓȠȣ ıIJȠ ȠʌȠȓȠ IJȠ ʌȠȞIJȓțȚ ĮʌİȜİȣșİȡȫșȘțİ. public boolean mouseUp(Event e, int x, int y) { theList.addItem("mouseUp event at ("+x+","+y+ ")"); return false; } mouseDown Ǿ µȑșȠįȠȢ mouseDown() țĮȜİȓIJĮȚ ȩIJĮȞ IJȠ țȠȣµʌȓ IJȠȣ ʌȠȞIJȚțȚȠȪ ʌĮIJȚȑIJĮȚ ʌȐȞȦ ıIJȠ applet. Ǿ µȑșȠįȠȢ mouseDown() ȜĮµȕȐȞİȚ İʌȓıȘȢ IJȚȢ ıȣȞIJİIJĮȖµȑȞİȢ IJȠȣ ıȘµİȓȠȣ ȩʌȠȣ IJȠ ʌȠȞIJȓțȚ ʌĮIJȒșȘțİ. public boolean mouseDown(Event e, int x, int y) { theList.addItem("mouseDown event at (" + x + "," + y + ")"); return false; } mouseDrag Ǿ µȑșȠįȠȢ mouseDrag()țĮȜİȓIJĮȚ ȩIJĮȞ µİIJĮțȚȞİȓIJĮȚ IJȠ ʌȠȞIJȓțȚ µİ ʌĮIJȘµȑȞȠ IJȠ țȠȣµʌȓ IJȠȣ. Ǿ µȑșȠįȠȢ mouseDrag()ȜĮµȕȐȞİȚ IJȚȢ ıȣȞIJİIJĮȖµȑȞİȢ IJȠȣ ıȘµİȓȠȣ ʌȠȣ ȕȡȓıțİIJĮȚ IJȠ ʌȠȞIJȓțȚ ȩIJĮȞ ıȣµȕĮȓȞİȚ IJȠ ȖİȖȠȞȩȢ.

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 36 -

public boolean mouseDrag(Event e, int x, int y) { theList.addItem("mouseDrag event at (" + x + "," + y + ")"); return false; } mouseMove Ǿ µȑșȠįȠȢ mouseMove() ıȣµȕĮȓȞİȚ ȩIJĮȞ µİIJĮțȚȞİȓIJĮȚ IJȠ ʌȠȞIJȓțȚ ȤȦȡȓȢ ʌĮIJȘµȑȞȠ țȠȣµʌȓ. Ǿ µȑșȠįȠȢ mouseMove() ȜĮµȕȐȞİȚ IJȚȢ ıȣȞIJİIJĮȖµȑȞİȢ IJȠȣ ıȘµİȓȠȣ ıIJȠ ȠʌȠȓȠ ȕȡȓıțİIJĮȚ IJȠ ʌȠȞIJȓțȚ ȩIJĮȞ ıȣµȕĮȓȞİȚ IJȠ ȖİȖȠȞȩȢ. public boolean mouseMove(Event e, int x, int y) { theList.addItem("mouseMove event at (" + x + "," + y + ")"); return false; } mouseEnter Ǿ µȑșȠįȠȢ mouseEnter()ıȣµȕĮȓȞİȚ ȩIJĮȞ Ƞ įİȓțIJȘȢ IJȠȣ ʌȠȞIJȚțȚȠȪ İȚıȑȡȤİIJĮȚ ıIJȘȞ ʌİȡȚȠȤȒ IJȠȣ applet. ȁĮµȕȐȞİȚ, İʌȓıȘȢ, IJȚȢ ıȣȞIJİIJĮȖµȑȞİȢ IJȠȣ ıȘµİȓȠȣ Įʌȩ IJȠ ȠʌȠȓȠ ȑȖȚȞİ Ș İȚıĮȖȦȖȒ. ȂİIJȐ IJȘȞ İȚıĮȖȦȖȒ, ĮțȠȜȠȣșİȓ ıȣȞȒșȦȢ µȓĮ ȡȠȒ Įʌȩ mouseMove ȖİȖȠȞȩIJĮ, țĮșȫȢ Ƞ įİȓțIJȘȢ IJȠȣ ʌȠȞIJȚțȚȠȪ ıȣȞİȤȓȗİȚ µȑıĮ ıIJȠ applet. public boolean mouseEnter(Event e, int x, int y) { theList.addItem("mouseEnter event at " + x + "," + y + ")"); return false; } mouseExit Ǿ µȑșȠįȠȢ mouseExit()ıȣµȕĮȓȞİȚ ȩIJĮȞ Ƞ įİȓțIJȘȢ IJȠȣ ʌȠȞIJȚțȚȠȪ İȟȑȡȤİIJĮȚ Įʌȩ IJȘȞ ʌİȡȚȠȤȒ IJȠȣ applet. ȁĮµȕȐȞİȚ, İʌȓıȘȢ, IJȚȢ ıȣȞIJİIJĮȖµȑȞİȢ IJȠȣ ıȘµİȓȠȣ Įʌȩ IJȠ ȠʌȠȓȠ ȑȖȚȞİ Ș ȑȟȠįȠȢ. public boolean mouseExit(Event e, int x, int y) { theList.addItem("mouseExit event at (" + x + "," + y + ")"); return false; } keyDown Ǿ µȑșȠįȠȢ KeyDown()ıȣµȕĮȓȞİȚ ȩIJĮȞ Ƞ ȤȡȒıIJȘȢ ʌȚȑȗİȚ țȐʌȠȚȠ ʌȜȒțIJȡȠ, țĮșȫȢ IJȠ applet IJȠȣ İȓȞĮȚ İȞİȡȖȩ. ȉȠ ĮțȑȡĮȚȠ ȩȡȚıµĮ IJȘȢ µİșȩįȠȣ įİȓȤȞİȚ IJȠ ıȣȖțİțȡȚµȑȞȠ ʌȜȒțIJȡȠ, ĮȞ IJȠ µİIJĮIJȡȑȥȠȣµİ ıİ ȤĮȡĮțIJȒȡĮ ʌĮȓȡȞȠȣµİ IJȠ ȖȡȐµµĮ ʌȠȣ ĮȞIJȚıIJȠȚȤİȓ ıIJȠ ʌȜȒțIJȡȠ. public boolean keyDown(Event e, int x) { theList.addItem("The " + (char) x + " key was pressed."); return false; } keyUp Ǿ µȑșȠįȠȢ KeyUp()ıȣµȕĮȓȞİȚ ȩIJĮȞ Ƞ ȤȡȒıIJȘȢ ĮijȒȞİȚ țȐʌȠȚȠ ʌȜȒțIJȡȠ ʌȠȣ İȓȤİ ʌĮIJȒıİȚ, țĮșȫȢ IJȠ applet IJȠȣ İȓȞĮȚ İȞİȡȖȩ. ȉȠ ĮțȑȡĮȚȠ ȩȡȚıµĮ IJȘȢ µİșȩįȠȣ įİȓȤȞİȚ IJȠ ıȣȖțİțȡȚµȑȞȠ ʌȜȒțIJȡȠ, ĮȞ IJȠ µİIJĮIJȡȑȥȠȣµİ ıİ ȤĮȡĮțIJȒȡĮ ʌĮȓȡȞȠȣµİ IJȠ ȖȡȐµµĮ ʌȠȣ ĮȞIJȚıIJȠȚȤİȓ ıIJȠ ʌȜȒțIJȡȠ. public boolean keyUp(Event e, int x) { theList.addItem("The " + (char) x + " key was released."); return false; }

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 37 -

3.6 īȡĮijȚțȐ 3.6.1 īȡĮµµĮIJȠıİȚȡȑȢ țĮȚ ȋȡȫµĮIJĮ īȚĮ ȞĮ µʌȠȡȑıȠȣµİ ȞĮ ݵijĮȞȓıȠȣµİ µȚĮ ȖȡĮµµĮIJȠıİȚȡȐ ıIJȘȞ Java, ʌȡȑʌİȚ ȞĮ ȖȞȦȡȓȗȠȣµİ IJĮ İȟȒȢ ıIJȠȚȤİȓĮ ȖȚ' ĮȣIJȒȞ: x x x

ȉȪʌȠȢ (Arial, Courier ț.Ȝ.ʌ.) ȈIJȣȜ (țĮȞȠȞȚțȐ, ȑȞIJȠȞĮ, ʌȜȐȖȚĮ – plain, bold, italic) ȂȑȖİșȠȢ ıİ ıIJȚȖµȑȢ (points)

īȚĮ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ȑȞĮ įȚțȩ µĮȢ ĮȞIJȚțİȓµİȞȠ ȖȡĮµµĮIJȠıİȚȡȐȢ, ȤȡȘıȚµȠʌȠȚȠȪµİ IJȘȞ țȜȐıȘ Font µİ IJȠȞ IJİȜİıIJȒ new țĮȚ ʌİȡȞȐµİ IJȡȓĮ ȠȡȓıµĮIJĮ, ȩʌȦȢ įȘȜȫșȘțĮȞ ʌĮȡĮʌȐȞȦ. ȂʌȠȡȠȪµİ ȞĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ IJȚȢ ıIJĮșİȡȑȢ Font.PLAIN, Font.BOLD, Font.ITALIC țĮȚ Font.BOLD+Font.ITALIC. Ȃİ IJȘȞ µȑșȠįȠ setFont() ȠȡȓȗȠȣµİ µȚĮ ȖȡĮµµĮIJȠıİȚȡȐ İȞȫ µİ IJȘȞ µȑșȠįȠ getFont() µʌȠȡȠȪµİ ȞĮ įȠȪµİ ʌȠȚĮ ȖȡĮµµĮIJȠıİȚȡȐ ȤȡȘıȚµȠʌȠȚİȓIJĮȚ İțİȓȞȘ IJȘ ıIJȚȖµȒ. ȉĮ ıIJȠȚȤİȓĮ IJȘȢ IJȡȑȤȠȣıĮȢ ȖȡĮµµĮIJȠıİȚȡȐȢ ȤȡȘıȚµȠʌȠȚȠȪȞIJĮȚ ȖȚĮ IJȘȞ ݵijȐȞȚıȘ IJȠȣ țİȚµȑȞȠȣ ıIJȘȞ ȠșȩȞȘ. ǹțȠȜȠȣșİȓ ȑȞĮ ʌĮȡȐįİȚȖµĮ: import java.applet.Applet; import java.awt.*; public class Fonts extends Applet { public void paint(Graphics g) { Font Font1 = new Font("Arial", Font.PLAIN, 20); Font Font2 = new Font("TimesRoman", Font.BOLD+Font.ITALIC, 40); g.setFont(Font1); g.drawString("īȡĮµµĮIJȠıİȚȡȐ Plain Times Roman 20 point", 10, 30); g.setFont(Font2); g.drawString("īȡĮµµĮIJȠıİȚȡȐ Bold+Italic Times Roman 40 point", 10, 80); } } ȂʌȠȡȠȪµİ ȞĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ įȪȠ IJȡȩʌȠȣȢ ȖȚĮ ȞĮ ȠȡȓıȠȣµİ IJȠ ȤȡȫµĮ ʌȠȣ șȑȜȠȣµİ ȞĮ ݵijĮȞȓıȠȣµİ ı' ȑȞĮ applet. ȅ ʌȡȫIJȠȢ ȤȡȘıȚµȠʌȠȚİȓ µȚĮ ıIJĮșİȡȒ IJȚµȒ IJȘȢ IJȐȟȘȢ Color țĮȚ Ƞ įİȪIJİȡȠȢ ȠȡȓȗİȚ ȞȑĮ ȤȡȫµĮIJĮ µİ ȕȐıȘ IJȚȢ RGB (Red, Green, Blue) IJȚµȑȢ IJȠȣȢ Įʌȩ 0-255. īȚĮ ʌĮȡȐįİȚȖµĮ ȖȚĮ ȞĮ İʌȚȜȑȟȠȣµİ ȑȞĮ µİıĮȓȠ ȖțȡȚ șĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ IJȘȞ color(127,127,127). īȚĮ IJȠ Ȝİȣțȩ șĮ İȓȞĮȚ color(255,255,255) İȞȫ ȖȚĮ IJȠ țȩțțȚȞȠ İȓȞĮȚ color(255,0,0) ț.Ƞ.ț. ȂʌȠȡȠȪµİ ȞĮ ȠȡȓıȠȣµİ IJȠ ȤȡȫµĮ IJȠȣ ijȩȞIJȠȣ IJȠȣ applet µİ IJȘȞ µȑșȠįȠ setBackground() țĮȚ IJȠ ȤȡȫµĮ IJȠȣ țİȚµȑȞȠȣ IJȠȣ applet µİ IJȘȞ µȑșȠįȠ setColor(). ǹțȠȜȠȣșİȓ ȑȞĮ ʌĮȡȐįİȚȖµĮ. import java.applet.Applet; import java.awt.*; public class Colors extends Applet { public void paint(Graphics g) { setBackground(Color.green); g.setColor(Color.blue); g.drawString("ȋȡȫµĮ ijȩȞIJȠȣ ʌȡȐıȚȞȠ", 10, 30); g.drawString("ȋȡȫµĮ țİȚµȑȞȠȣ µʌȜİ", 10, 50); Color mystery = new Color(100, 200, 50); g.setColor(mystery); g.drawString("ȋȡȫµĮ țİȚµȑȞȠȣ IJȣȤĮȓȠ", 10, 70); } } ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 38 -

3.6.2 ȋȡȒıȘ īȡĮijȚțȫȞ ȈIJȘȞ Java µʌȠȡȠȪµİ ȞĮ ıȤİįȚȐıȠȣµİ IJĮ İȟȒȢ ȖȡĮijȚțȐ: x x x x x x

īȡĮµµȑȢ ȅȡșȠȖȫȞȚĮ țĮȚ ȉİIJȡȐȖȦȞĮ ȀȪțȜȠȣȢ țĮȚ ǼȜȜİȓȥİȚȢ ȉȩȟĮ ȆȠȜȪȖȦȞĮ ǵȜĮ IJĮ ʌĮȡĮʌȐȞȦ ȞĮ İȓȞĮȚ ȖݵȚıµȑȞĮ µİ ȤȡȫµĮ Ȓ ȐįİȚĮ

īȚĮ ȞĮ ıȤİįȚȐıȠȣµİ ȑȞĮ ȖȡĮijȚțȩ ıIJȘȞ Java ȤȡȘıȚµȠʌȠȚȠȪµİ µȚĮ µȑșȠįȠ IJȘȢ țȜȐıȘȢ Graphics. īȚĮ ȞĮ ıȤİįȚȐıȠȣµİ µȚĮ ȖȡĮµµȒ ȤȡȘıȚµȠʌȠȚȠȪµİ IJȘȞ µȑșȠįȠ drawLine() ȦȢ İȟȒȢ: import java.applet.*; import java.awt.*; public class Line extends Applet { public void paint(Graphics g) { g.setColor(Color.red); g.drawLine(100, 150, 170, 200); } } ȈIJȠ ʌĮȡĮʌȐȞȦ applet ıȤİįȚȐȗİIJĮȚ µȚĮ ȖȡĮµµȒ µİ ȤȡȫµĮ țȩțțȚȞȠ Įʌȩ IJȠ ıȘµİȓȠ (100, 150) IJȠȣ applet µȑȤȡȚ IJȠ ıȘµİȓȠ (170, 200). īȚĮ ȞĮ ıȤİįȚȐıȠȣµİ ȑȞĮ ȠȡșȠȖȫȞȚȠ Ȓ IJİIJȡȐȖȦȞȠ ȑȤȠȣµİ ʌȠȜȜȑȢ İʌȚȜȠȖȑȢ : Ǿ µȑșȠįȠȢ drawRect() ȖȚĮ ĮʌȜȩ ȠȡșȠȖȫȞȚȠ, µȘ ȖݵȚıµȑȞȠ țĮȚ ȤȦȡȓȢ ıIJȡȠȖȖȣȜݵȑȞİȢ ȖȦȞȓİȢ: g.drawRect(100, 150, 200, 250); Ǿ ʌĮȡĮʌȐȞȦ İȞIJȠȜȒ ıȤİįȚȐȗİȚ ȑȞĮ ȠȡșȠȖȫȞȚȠ µİ ʌȐȞȦ ĮȡȚıIJİȡȐ țȠȡȣijȒ ıIJȠ ıȘµİȓȠ (100, 150), ʌȜȐIJȠȢ 200 țĮȚ ȪȥȠȢ 250 pixels. Ǿ µȑșȠįȠȢ fillRect() ȖȚĮ ȖݵȚıµȑȞȠ ȠȡșȠȖȫȞȚȠ: g.setColor(Color.blue); g.fillRect(100, 150, 200, 250); Ǿ ʌĮȡĮʌȐȞȦ İȞIJȠȜȒ ıȤİįȚȐȗİȚ ȑȞĮ ȠȡșȠȖȫȞȚȠ ȖݵȚıµȑȞȠ µİ µʌȜİ ȤȡȫµĮ, µİ ʌȐȞȦ ĮȡȚıIJİȡȐ țȠȡȣijȒ ıIJȠ ıȘµİȓȠ (100, 150), ʌȜȐIJȠȢ 200 țĮȚ ȪȥȠȢ 250 pixels. Ǿ µȑșȠįȠȢ draw3DRect() ȖȚĮ IJȡȚįȚȐıIJĮIJȠ (3D) ȠȡșȠȖȫȞȚȠ: g.draw3DRect(100, 150, 200, 250, true); Ǿ ʌĮȡĮʌȐȞȦ İȞIJȠȜȒ ıȤİįȚȐȗİȚ ȑȞĮ ȠȡșȠȖȫȞȚȠ µİ ʌȐȞȦ ĮȡȚıIJİȡȐ țȠȡȣijȒ ıIJȠ ıȘµİȓȠ (100, 150), ʌȜȐIJȠȢ 200 țĮȚ ȪȥȠȢ 250 pixels. Ǿ IJİȜİȣIJĮȓĮ ʌĮȡȐµİIJȡȠȢ İȓȞĮȚ IJȪʌȠȣ boolean (true Ȓ false) țĮșȠȡȓȗİȚ ĮȞ IJȠ ȠȡșȠȖȫȞȚȠ șĮ İȓȞĮȚ IJȡȚįȚȐıIJĮIJȠ Ȓ ȩȤȚ ĮȞIJȓıIJȠȚȤĮ. Ǿ µȑșȠįȠȢ drawRoundRect() ȖȚĮ ȠȡșȠȖȫȞȚȠ µİ ıIJȡȠȖȖȣȜݵȑȞİȢ ȖȦȞȓİȢ, İȖȖİȖȡĮµµȑȞȠ ıIJȠ țĮȞȠȞȚțȩ ȠȡșȠȖȫȞȚȠ: g.setColor(Color.green); g.drawRoundRect(100, 150, 200, 250, 15, 15); Ǿ µȑșȠįȠȢ fillRoundRect() ȖȚĮ ȖݵȚıµȑȞȠ ȠȡșȠȖȫȞȚȠ µİ ıIJȡȠȖȖȣȜݵȑȞİȢ ȖȦȞȓİȢ:

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 39 -

g.setColor(Color.yellow); g.fillRoundRect(100, 150, 200, 250, 15, 15); ȅȚ µȑșȠįȠȚ drawRoundRect() țĮȚ fillRoundRect() ȑȤȠȣȞ įȪȠ İʌȚʌȜȑȠȞ ʌĮȡĮµȑIJȡȠȣȢ, IJȚȢ įȪȠ IJİȜİȣIJĮȓİȢ, ʌȠȣ İȓȞĮȚ Ș ĮʌȩıIJĮıȘ Įʌȩ IJȘȞ ȖȦȞȓĮ IJȠȣ țĮȞȠȞȚțȠȪ ȠȡșȠȖȦȞȓȠȣ, ʌȠȣ șȑȜȠȣµİ ȞĮ ȟİțȚȞȐİȚ Ș țĮµʌȪȜȘ. īȚĮ ȞĮ ıȤİįȚȐıȠȣµİ µȚĮ ȑȜȜİȚȥȘ Ȓ ȑȞĮȞ țȪțȜȠ ȤȡȘıȚµȠʌȠȚȠȪµİ IJȘȞ µȑșȠįȠ drawOval() ȦȢ İȟȒȢ: g.setColor(Color.red); g.drawOval(100, 150, 20, 30); Ǿ ʌĮȡĮʌȐȞȦ İȞIJȠȜȒ ıȤİįȚȐȗİȚ µȚĮ ȑȜȜİȚȥȘ µİ țȩțțȚȞȠ ȤȡȫµĮ, İȖȖİȖȡĮµµȑȞȘ ıIJȠ ȠȡșȠȖȫȞȚȠ µİ ʌȐȞȦ ĮȡȚıIJİȡȐ țȠȡȣijȒ ıIJȠ ıȘµİȓȠ (100, 150), ʌȜȐIJȠȢ 20 țĮȚ ȪȥȠȢ 30 pixels. ǹȞ IJȠ ʌȜȐIJȠȢ țĮȚ IJȠ ȪȥȠȢ IJȠȣ ȠȡșȠȖȦȞȓȠȣ İȓȞĮȚ ȓıĮ IJȩIJİ ʌȡȩțİȚIJĮȚ, ʌȡȠijĮȞȫȢ, ȖȚĮ țȪțȜȠ. Ǿ µȑșȠįȠȢ fillOval() ȖݵȓȗİȚ IJȘȞ ȑȜȜİȚȥȘ µİ ȤȡȫµĮ : g.setColor(Color.yellow); g.fillOval(100, 150, 20, 30); īȚĮ ȞĮ ıȤİįȚȐıȠȣµİ ȑȞĮ IJȩȟȠ ȤȡȘıȚµȠʌȠȚȠȪµİ IJȘȞ µȑșȠįȠ drawArc() ȦȢ İȟȒȢ: g.setColor(Color.blue); g.drawArc(100, 150, 30, 20, 45, 180); Ǿ ʌĮȡĮʌȐȞȦ İȞIJȠȜȒ ıȤİįȚȐȗİȚ ȑȞĮ IJȩȟȠ ȑȜȜİȚȥȘȢ µİ µʌȜİ ȤȡȫµĮ, İȖȖİȖȡĮµµȑȞȠ ıIJȠ ȠȡșȠȖȫȞȚȠ ʌȠȣ ȠȡȓȗİIJĮȚ Įʌȩ IJȠȣȢ IJȑııİȡȚȢ ʌȡȫIJȠȣȢ ĮțİȡĮȓȠȣȢ. ȅȚ ȐȜȜȠȚ įȪȠ ĮțȑȡĮȚȠȚ ȠȡȓȗȠȣȞ IJȚȢ ȖȦȞȓİȢ İțțȓȞȘıȘȢ țĮȚ IJȑȜȠȣȢ ıİ µȠȓȡİȢ, µİ ijȠȡȐ ĮȞIJȓșİIJȘ ĮȣIJȒȢ IJȦȞ įİȚțIJȫȞ IJȠȣ ȡȠȜȠȖȚȠȪ. Ǿ µȑșȠįȠȢ fillArc() ȖݵȓȗİȚ IJȠ IJȩȟȠ µİ ȤȡȫµĮ: g.setColor(Color.green); g.fillArc(100, 150, 20, 20, 90, 180); īȚĮ ȞĮ ıȤİįȚȐıȠȣµİ ȑȞĮ ʌȠȜȪȖȦȞȠ, ʌȡȑʌİȚ ʌȡȫIJĮ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ȑȞĮȞ ʌȓȞĮțĮ (array) ĮțİȡĮȓȦȞ ʌȠȣ șĮ ʌİȡȚȑȤİȚ IJȚȢ x ıȣȞIJİIJĮȖµȑȞİȢ țĮȚ ȑȞĮȞ ȐȜȜȠȞ ʌȓȞĮțĮ ĮțİȡĮȓȦȞ ʌȠȣ șĮ ʌİȡȚȑȤİȚ IJȚȢ y ıȣȞIJİIJĮȖµȑȞİȢ IJȦȞ țȠȡȣijȫȞ IJȠȣ ʌȠȜȣȖȫȞȠȣ. ȋȡȘıȚµȠʌȠȚȠȪµİ IJȘȞ µȑșȠįȠ drawPolygon(), Ș ȠʌȠȓĮ ʌĮȓȡȞİȚ ıĮȞ ʌĮȡĮµȑIJȡȠȣȢ IJȠȣȢ įȪȠ ʌȓȞĮțİȢ µİ IJȚȢ ıȣȞIJİIJĮȖµȑȞİȢ țĮșȫȢ țĮȚ ȑȞĮȞ ĮțȑȡĮȚȠ ĮȡȚșµȩ ʌȠȣ ʌĮȡȚıIJȐȞİȚ IJȠȞ ĮȡȚșµȩ IJȦȞ țȠȡȣijȫȞ IJȠȣ ʌȠȜȣȖȫȞȠȣ. ȉȠ ʌĮȡĮțȐIJȦ ʌĮȡȐįİȚȖµĮ ıȤİįȚȐȗİȚ ȑȞĮ ʌȠȜȪȖȦȞȠ µİ 4 țȠȡȣijȑȢ țĮȚ ȤȡȫµĮ ȖȡĮµµȒȢ țȩțțȚȞȠ: import java.applet.*; import java.awt.*; public class Polygon extends Applet { public void paint(Graphics g) { int[] xPoints = {100, 150, 170, 120}; int[] yPoints = {50, 100, 160, 250}; int points = 4; g.setColor(Color.red); g.drawPolygon(xPoints, yPoints, points); } } Ǿ µȑșȠįȠȢ fillPolygon() ȖݵȓȗİȚ IJȠ ʌȠȜȪȖȦȞȠ µİ ȤȡȫµĮ.

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 40 -

ǼȚıĮȖȦȖȒ ǼȚțȩȞĮȢ ıİ applet ȅ ʌĮȡĮțȐIJȦ țȫįȚțĮȢ įİȓȤȞİȚ ʌȫȢ µʌȠȡȠȪµİ ȞĮ İȚıȐȖȠȣµİ µȓĮ İȚțȩȞĮ ıİ ȑȞĮ applet, ȤȡȘıȚµȠʌȠȚȫȞIJĮȢ IJȚȢ getImage țĮȚ drawImage. ȊʌȠșȑIJȠȣµİ ȩIJȚ Ș İȚțȩȞĮ ʌȠȣ İȚıȐȖȠȣµİ İȓȞĮȚ ĮʌȠșȘțİȣµȑȞȘ ıIJȠ ĮȡȤİȓȠ kotsiras.gif, ʌȠȣ ȕȡȓıțİIJĮȚ ıIJȠȞ ȓįȚȠ țĮIJȐȜȠȖȠ µİ IJȠ applet: import java.applet.*; import java.awt.*; public class ImagePaint extends Applet { Image MyImage; public void init() { MyImage = getImage(getCodeBase(), "kotsiras.gif"); } public void paint(Graphics g) { g.drawImage(MyImage, 0, 0, this); } } ȆĮȡȐįİȚȖµĮ: ȉȠ İʌȩµİȞȠ ʌĮȡȐįİȚȖµĮ İȓȞĮȚ ʌȚȠ įȪıțȠȜȠ ȞĮ ʌİȡȚȖȡĮijİȓ, Įʌȩ ȩ,IJȚ ȞĮ ȖȡĮijİȓ Ƞ țȫįȚțĮȢ. ǼțIJİȜİȓ ȑȞĮȞ ĮIJȑȡµȠȞĮ ȕȡȩȤȠ țĮȚ ݵijĮȞȓȗİȚ IJȣȤĮȓİȢ ȚʌIJȐµİȞİȢ ȖȡĮµµȑȢ. ȂİIJĮȖȜȦIJIJȓıIJİ IJȠȞ ĮțȩȜȠȣșȠ țȫįȚțĮ, İțIJİȜȑıIJİ IJȠ ʌȡȩȖȡĮµµĮ țĮȚ µİIJȐ µİȜİIJȒıIJİ IJȠȞ țȫįȚțĮ: import java.applet.Applet; import java.awt.*; public class FlyingLines extends Applet { int NUM_LINES = 25; int gDeltaTop=3, gDeltaBottom=3; int gDeltaLeft=2, gDeltaRight=6; int AppletWidth, AppletHeight; int gLines[][] = new int[NUM_LINES][4]; public void init() { AppletWidth = size().width; AppletHeight = size().height; } public void start() { gLines[0][0] = Randomize(AppletWidth); gLines[0][1] = Randomize(AppletHeight); gLines[0][2] = Randomize(AppletWidth); gLines[0][3] = Randomize(AppletHeight); for (int i=1; i < NUM_LINES; i++ ) { LineCopy(i, i-1); RecalcLine(i); } repaint(); } public void paint(Graphics g) { while (true) { for (int i=NUM_LINES - 1; i > 0; i--) { LineCopy(i, i-1); } ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 41 -

RecalcLine(0); g.setColor(Color.black); g.drawLine(gLines[0][0], gLines[0][1], gLines[0][2], gLines[0][3]); g.setColor(getBackground()); g.drawLine(gLines[NUM_LINES-1][0], gLines[NUM_LINES-1][1], gLines[NUM_LINES-1][2], gLines[NUM_LINES-1][3]); } } private void LineCopy (int to, int from) for (int i = 0; i < 4; i++) { gLines[to][i] = gLines[from][i]; } }

{

public int Randomize( int range ) { double rawResult; rawResult = Math.random(); return (int) (rawResult * range); } private void RecalcLine( int i ) { gLines[i][1] += gDeltaTop; if ((gLines[i][1] < 0) || (gLines[i][1] > AppletHeight)) { gDeltaTop *= -1; gLines[i][1] += 2*gDeltaTop; } gLines[i][3] += gDeltaBottom; if ( (gLines[i][3] < 0) || (gLines[i][3] > AppletHeight) ) { gDeltaBottom *= -1; gLines[i][3] += 2*gDeltaBottom; } gLines[i][0] += gDeltaLeft; if ( (gLines[i][0] < 0) || (gLines[i][0] > AppletWidth) ) { gDeltaLeft *= -1; gLines[i][0] += 2*gDeltaLeft; } gLines[i][2] += gDeltaRight; if ( (gLines[i][2] < 0) || (gLines[i][2] > AppletWidth) ) { gDeltaRight *= -1; gLines[i][2] += 2*gDeltaRight; } } }

3.7 ǻȚĮıȪȞįİıȘ µİ IJȠȞ ȋȡȒıIJȘ ȈIJȘȞ ʌĮȡȐȖȡĮijȠ ĮȣIJȒ șĮ įȠȪµİ ʌȫȢ µʌȠȡȠȪµİ µİ IJȘȞ Java ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ıİ ȑȞĮ applet, ıIJȠȚȤİȓĮ İʌȚțȠȚȞȦȞȓĮȢ µİ IJȠ ȤȡȒıIJȘ: ǼIJȚțȑIJİȢ țĮȚ ȆȜĮȓıȚĮ ȀİȚµȑȞȠȣ īȚĮ ȞĮ µʌȠȡȑıȠȣµİ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ȑȞĮ ıȣıIJĮIJȚțȩ, ȩʌȦȢ µȓĮ İIJȚțȑIJĮ (label) ı' ȑȞĮ ʌȡȩȖȡĮµµĮ IJȘȢ Java, įȘµȚȠȣȡȖȠȪµİ ʌȡȫIJĮ IJȠ ĮȞIJȚțİȓµİȞȠ țĮȚ µİIJȐ ȤȡȘıȚµȠʌȠȚȠȪµİ IJȘȞ ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 42 -

µȑșȠįȠ add() ȖȚĮ ȞĮ IJȠ ʌȡȠıșȑıȠȣµİ ı' ȑȞĮ ȣʌȐȡȤȠȞ ıȣıIJĮIJȚțȩ. ȂȚĮ İIJȚțȑIJĮ (Label) ݵijĮȞȓȗİȚ ȑȞĮ µȒȞȣµĮ (string) ʌȠȣ įİȞ µʌȠȡİȓ ȞĮ ĮȜȜĮȤșİȓ Įʌȩ IJȠȞ ȤȡȒıIJȘ, İȞȫ ȑȞĮ ʌȜĮȓıȚȠ țİȚµȑȞȠȣ (TextField) İȓȞĮȚ µȚĮ ʌİȡȚȠȤȒ ȩʌȠȣ Ƞ ȤȡȒıIJȘȢ µʌȠȡİȓ ȞĮ țĮIJĮȤȦȡȒıİȚ µȓĮ ȖȡĮµµȒ țİȚµȑȞȠȣ. ȂʌȠȡȠȪµİ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ İIJȚțȑIJİȢ țĮȚ ʌȜĮȓıȚĮ țİȚµȑȞȠȣ ı' ȑȞĮ applet IJȘȢ Java ȦȢ İȟȒȢ : import java.applet.*; import java.awt.*; public class LabelText extends Applet { Label emailLabel = new Label("ǻȚİȪșȣȞıȘ e-mail : "); TextField emailAddress = new TextField(30); public void init() { add(emailLabel); add(emailAddress); } } ȆȜȒțIJȡĮ ǼȞIJȠȜȒȢ DzȞĮ ıȣıIJĮIJȚțȩ Button İȓȞĮȚ ȑȞĮ ʌȜȒțIJȡȠ µİ įȣȞĮIJȩIJȘIJĮ țȜȚț țĮȚ µİ µȚĮ İIJȚțȑIJĮ (label, caption) ʌȠȣ ʌİȡȚȖȡȐijİȚ IJȚ șĮ ıȣµȕİȓ ĮȞ țȐȞȠȣµİ țȜȚț ıIJȠ ʌȜȒțIJȡȠ. īȚĮ ȞĮ ʌȡȠıșȑıȠȣµİ ȑȞĮ button ı' ȑȞĮ applet, ȖȡȐijȠȣµİ IJȠȞ İȟȒȢ țȫįȚțĮ : import java.applet.*; import java.awt.*; public class Button1 extends Applet { Button helloButton = new Button("Hello"); public void init() { add(helloButton); } } ȆȜĮȓıȚĮ ǼȜȑȖȤȠȣ țĮȚ ȆȜȒțIJȡĮ ǼʌȚȜȠȖȒȢ DzȞĮ ʌȜĮȓıȚȠ İȜȑȖȤȠȣ (checkbox) İȓȞĮȚ ȑȞĮ IJİIJȡȐȖȦȞȠ ıȣıIJĮIJȚțȩ ʌȠȣ µʌȠȡȠȪµİ ȞĮ İʌȚȜȑȟȠȣµİ ĮȞİȟȐȡIJȘIJĮ Įʌȩ ȐȜȜĮ ʌȜĮȓıȚĮ İȜȑȖȤȠȣ, İȞȫ ȑȞĮ ʌȜȒțIJȡȠ İʌȚȜȠȖȒȢ (radio button) İȓȞĮȚ ȑȞĮ țȣțȜȚțȩ ıȣıIJĮIJȚțȩ ȩʌȠȣ µʌȠȡȠȪµİ ȞĮ İʌȚȜȑȟȠȣµİ ȑȞĮ țĮȚ µȩȞȠ ȑȞĮ Įʌȩ µȚĮ ȠµȐįĮ ʌȜȒțIJȡȦȞ İʌȚȜȠȖȒȢ. Ǿ Java ȤĮȡĮțIJȘȡȓȗİȚ țĮȚ IJĮ ʌȜĮȓıȚĮ İȜȑȖȤȠȣ țĮȚ IJĮ ʌȜȒțIJȡĮ İʌȚȜȠȖȒȢ ıĮȞ CheckBox țĮȚ IJĮ įȚĮȤȦȡȓȗİȚ ĮȞ țĮIJȐ IJȘȞ ıIJȚȖµȒ IJȘȢ įȘµȚȠȣȡȖȓĮȢ IJȠȣȢ ĮȞȒțȠȣȞ Ȓ ȩȤȚ ıİ µȚĮ ȠµȐįĮ (CheckboxGroup). īȚĮ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ȑȞĮ ʌȜĮȓıȚȠ İȜȑȖȤȠȣ ı' ȑȞĮ applet ȖȡȐijȠȣµİ IJȠȞ İȟȒȢ țȫįȚțĮ : import java.applet.*; import java.awt.*; public class CheckB extends Applet { Checkbox emailMe = new Checkbox("ȈIJİȓȜIJİ e-mail", true); public void init() { add(emailMe); } } ȂʌȠȡȠȪµİ ȞĮ ʌȡȠıșȑıȠȣµİ įȪȠ ȠȡȓıµĮIJĮ țĮIJȐ IJȘȞ įȘµȚȠȣȡȖȓĮ İȞȩȢ ʌȜĮȚıȓȠȣ İȜȑȖȤȠȣ, ȩʌȠȣ IJȠ ʌȡȫIJȠ İȓȞĮȚ µȚĮ İʌİȟȘȖȘµĮIJȚțȒ ȖȡĮµµȒ țİȚµȑȞȠȣ ʌȠȣ șĮ ݵijĮȞȚıșİȓ įȓʌȜĮ ıIJȠ ʌȜĮȓıȚȠ İȜȑȖȤȠȣ țĮȚ IJȠ įİȪIJİȡȠ İȓȞĮȚ µȚĮ IJȚµȒ boolean ʌȠȣ įȚİȣțȡȚȞȓȗİȚ ĮȞ IJȠ ʌȜĮȓıȚȠ İȜȑȖȤȠȣ șĮ İȓȞĮȚ İʌȚȜİȖµȑȞȠ (true) Ȓ ȩȤȚ (false) ȩIJĮȞ İțIJİȜİıșİȓ Ș İijĮȡµȠȖȒ. ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 43 -

īȚĮ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ʌȜȒțIJȡĮ İʌȚȜȠȖȒȢ ı' ȑȞĮ applet ʌȡȑʌİȚ ʌȡȫIJĮ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ µȚĮ ȠµȐįĮ ʌȜĮȚıȓȦȞ İȜȑȖȤȠȣ µİ IJȠ ĮȞIJȚțİȓµİȞȠ CheckboxGroup țĮȚ µİIJȐ țĮIJȐ IJȘȞ įȘµȚȠȣȡȖȓĮ IJȦȞ ʌȜĮȚıȓȦȞ İȜȑȖȤȠȣ ȞĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ țĮȚ µȚĮ IJȡȓIJȘ ʌĮȡȐµİIJȡȠ ʌȠȣ ȞĮ įȘȜȫȞİȚ IJȘȞ ȠµȐįĮ ıIJȘȞ ȠʌȠȓĮ șĮ ĮȞȒțİȚ ĮȣIJȩ IJȠ ʌȜĮȓıȚȠ İȜȑȖȤȠȣ, ȐȡĮ ıIJȘȞ ȠȣıȓĮ įȘµȚȠȣȡȖȠȪµİ ȑȞĮ ʌȜȒțIJȡȠ İʌȚȜȠȖȒȢ. īȡȐijȠȣµİ IJȠȞ İȟȒȢ țȫįȚțĮ : import java.applet.*; import java.awt.*; public class CheckB1 extends Applet { CheckboxGroup cards = new CheckboxGroup(); Checkbox visacard = new Checkbox("Visa Card", true, cards); Checkbox mastercard = new Checkbox("Master Card", false, cards); Checkbox dinerscard = new Checkbox("Diners Card", false, cards); public void init() { add(visacard); add(mastercard); add(dinerscard); } } ǻȘµȚȠȣȡȖȒıĮµİ ȑȞĮ checkbox group µİ ȩȞȠµĮ cards țĮȚ ȩȜĮ IJĮ ʌȜĮȓıȚĮ İȜȑȖȤȠȣ (ıIJȘȞ ȠȣıȓĮ ʌȜȒțIJȡĮ İʌȚȜȠȖȒȢ) ʌȠȣ įȘµȚȠȣȡȖȒıĮµİ ʌȡȠıIJȑșȘțĮȞ ı' ĮȣIJȒ IJȘȞ ȠµȐįĮ (group). ȁȓıIJİȢ ǼʌȚȜȠȖȒȢ ȂȚĮ ȜȓıIJĮ İʌȚȜȠȖȒȢ (choice) İȓȞĮȚ µȚĮ ʌIJȣııȩµİȞȘ ȜȓıIJĮ İʌȚȜȠȖȫȞ Įʌȩ IJȚȢ ȠʌȠȓİȢ µȩȞȠ µȓĮ µʌȠȡİȓ ȞĮ İȓȞĮȚ İʌȚȜİȖµȑȞȘ. ǼȓȞĮȚ ȖȞȦıIJȒ țĮȚ ıĮȞ ʌIJȣııȩµİȞȠ Ȓ ıȪȞșİIJȠ ʌȜĮȓıȚȠ (combo box). īȚĮ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ µȚĮ ȜȓıIJĮ İʌȚȜȠȖȒȢ, įȘµȚȠȣȡȖȠȪµİ ʌȡȫIJĮ IJȠ ĮȞIJȚțİȓµİȞȠ țĮȚ µİIJȐ ʌȡȠıșȑIJȠȣµİ µȓĮ-µȓĮ IJȚȢ İʌȚȜȠȖȑȢ, ȦȢ İȟȒȢ : import java.applet.*; import java.awt.*; public class List extends Applet { Choice sport = new Choice(); public void init() { sport.add("ȂʌȐıțİIJ"); sport.add("ǺȩȜȜİȨ"); sport.add("ȆȠįȩıijĮȚȡȠ"); sport.add("ȀȠȜȪµȕȘıȘ"); add(sport); } } ǻȘµȚȠȣȡȖȒıĮµİ µȚĮ ȜȓıIJĮ İʌȚȜȠȖȒȢ µİ IJȑııİȡĮ ĮșȜȒµĮIJĮ. ȆİȡȚȠȤȑȢ ȀİȚµȑȞȠȣ ȂȚĮ ʌİȡȚȠȤȒ țİȚµȑȞȠȣ (TextArea) İȓȞĮȚ ȑȞĮ ʌİįȓȠ țİȚµȑȞȠȣ ȩʌȠȣ µʌȠȡȠȪµİ ȞĮ țĮIJĮȤȦȡȒıȠȣµİ ʌİȡȚııȩIJİȡİȢ Įʌȩ µȓĮ ȖȡĮµµȑȢ țİȚµȑȞȠȣ. Ȉİ µȚĮ ʌİȡȚȠȤȒ țİȚµȑȞȠȣ ʌȡȑʌİȚ ȞĮ țĮșȠȡȓıȠȣµİ IJȠ ʌȜȐIJȠȢ țĮȚ IJȠ ȪȥȠȢ IJȘȢ țĮȚ µʌȠȡȠȪµİ ȞĮ IJȠʌȠșİIJȒıȠȣµİ țĮȚ ȑȞĮ ĮȡȤȚțȩ țİȓµİȞȠ µĮȗȓ IJȘȞ įȒȜȦıȒ IJȘȢ. ȂʌȠȡȠȪµİ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ µȚĮ ʌİȡȚȠȤȒ țİȚµȑȞȠȣ ı' ȑȞĮ applet IJȘȢ Java ȦȢ İȟȒȢ : import java.applet.*; import java.awt.*; public class Txt extends Applet { TextArea comments = new TextArea("Hello World", 10, 20); public void init() { ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 44 -

}

add(comments);

} 3.7.1 ǹȜȜȘȜİʌȓįȡĮıȘ: ǼȓıȠįȠȢ µİ IJȠ ȆȠȞIJȓțȚ țĮȚ IJȠ ȆȜȘțIJȡȠȜȩȖȚȠ ȉȫȡĮ ȑȤȠȣµİ IJĮ İȡȖĮȜİȓĮ ȖȚĮ ȞĮ ȗȦȖȡĮijȓıȠȣµİ ʌȠȜȜȑȢ ʌȡĮȖµĮIJȚțȐ ȦȡĮȓİȢ țȚȞȒıİȚȢ țĮȚ ijȚȖȠȪȡİȢ ıIJȚȢ ıİȜȓįİȢ IJȠȣ web. ǹȣIJȩ µĮȢ IJȠʌȠșİIJİȓ ʌȐȞȦ Įʌȩ IJȠ µȑıȠ ıȤİįȚĮıIJȒ IJȦȞ ıİȜȓįȦȞ IJȠȣ web. ȉȠ ȐȜȜȠ µȚıȩ İȓȞĮȚ Ș ĮȜȜȘȜİʌȓįȡĮıȘ µİ IJȠ ȤȡȒıIJȘ. ȉĮ applet µʌȠȡȠȪȞ ȞĮ įİȤIJȠȪȞ İȓıȠįȠ Įʌȩ IJȠ ȤȡȒıIJȘ țĮȚ ȞĮ ĮȞIJĮʌȠțȡȚșȠȪȞ ı’ ĮȣIJȩȞ. ǼȓıȠįȠȢ µİ IJȠ ʌȠȞIJȓțȚ ȆĮȡĮțȐIJȦ ȑȤȠȣµİ ȑȞĮ ĮʌȜȩ applet ʌȠȣ µĮȢ İʌȚIJȡȑʌİȚ ȞĮ IJȡĮȕȐµİ ȖȡĮµµȑȢ µİ IJȠ ʌȠȞIJȓțȚ ʌȐȞȦ ıIJȠ applet. import java.applet.*; import java.awt.*; import java.util.Vector; public class JavaDoodle extends Applet { Vector points = new Vector(); public void paint(Graphics g) { int x1, y1, x2, y2; Point tempPoint; if (points.size() > 1) { tempPoint = (Point) points.elementAt(0); x1 = tempPoint.x; y1 = tempPoint.y; for (int i = 1; i < points.size(); i++) { tempPoint = (Point) points.elementAt(i); x2 = tempPoint.x; y2 = tempPoint.y; g.drawLine(x1, y1, x2, y2); x1 = x2; y1 = y2; } } } public boolean mouseDown(Event e, int x, int y) { points.addElement(new Point(x, y)); return true; } public boolean mouseDrag(Event e, int x, int y) { points.addElement(new Point(x, y)); repaint(); return true; } public boolean mouseUp(Event e, int x, int y) { points.addElement(new Point(x, y)); repaint(); return true; } } ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 45 -

ǼȓıȠįȠȢ µİ IJȠ ʌȜȘțIJȡȠȜȩȖȚȠ ȆĮȡĮțȐIJȦ ȑȤȠȣµİ ȑȞĮ ĮʌȜȩ applet ʌȠȣ ȤȡȘıȚµȠʌȠȚİȓ IJȘȞ µȑșȠįȠ KeyDown ȖȚĮ ȞĮ µĮȢ İʌȚIJȡȑȥİȚ ȞĮ ʌȜȘțIJȡȠȜȠȖȒıȠȣµİ țȐʌȠȚȠ țİȓµİȞȠ. import java.applet.*; import java.awt.Event; import java.awt.Graphics; public class typewriter extends Applet { int numcols = 80; int numrows = 25; int row = 0; int col = 0; char page[][] = new char[numrows][]; public void init() { for (int i = 0; i < numrows; i++) { page[i] = new char[numcols]; } for (int i = 0; i < numrows; i++) { for (int j = 0; j < numcols; j++) { page[i][j] = '\0'; } } } public boolean keyDown(Event e, int key) { char c = (char) key; switch (key) { case Event.HOME: row = 0; col = 0; break; case Event.END: row = numrows-1; col = numcols-1; break; case Event.UP: if (row > 0) row--; break; case Event.DOWN: if (row < numrows-1) row++; break; case Event.LEFT: if (col > 0) col--; else if (col == 0 && row > 0) { row--; col=numcols-1; } break; case Event.RIGHT: if (col < numcols-1) col++; else if (col == numcols-1 && row < numrows-1) { row++; col=0; } ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 46 -

break; default: if (c == '\n' || c == '\r') { row++; col = 0; } else if (row < numrows) { if (col >= numcols) { col = 0; row++; } page[row][col] = c; col++; } else { // row >= numrows col++; }

} repaint(); return true;

}

} public void paint(Graphics g) { for (int i=0; i < numrows; i++) { String tempString = new String(page[i]); g.drawString(tempString, 5, 15*(i+1)); } }

3.8 ȆȠȜȣİʌİȟİȡȖĮıȓĮ – ȃȘµĮIJȠʌȠȓȘıȘ ȅ ȩȡȠȢ ʌȠȜȣİʌİȟİȡȖĮıȓĮ (multitasking) ĮȞĮijȑȡİIJĮȚ ıIJȘȞ ȚțĮȞȩIJȘIJĮ İȞȩȢ ȣʌȠȜȠȖȚıIJȒ ȞĮ µʌȠȡİȓ ȞĮ İțIJİȜİȓ įȪȠ Ȓ ʌİȡȚııȩIJİȡİȢ İȡȖĮıȓİȢ (tasks) IJĮȣIJȩȤȡȠȞĮ. DzȞĮ Įʌȩ IJĮ ȤĮȡĮțIJȘȡȚıIJȚțȐ IJȘȢ Java İȓȞĮȚ Ș ȣʌȠıIJȒȡȚȟȘ IJȘȢ ʌȠȜȣİʌİȟİȡȖĮıȓĮȢ. Ǿ țĮșݵȓĮ Įʌ' ĮȣIJȑȢ IJȚȢ IJĮȣIJȩȤȡȠȞİȢ İȡȖĮıȓİȢ țĮȜİȓIJĮȚ ȞȒµĮ (thread) țĮȚ Ș ȩȜȘ įȚĮįȚțĮıȓĮ țĮȜİȓIJĮȚ ʌȠȜȣȞȘµĮIJȠʌȠȓȘıȘ (multithreading). ǹȞȐȜȠȖĮ µİ IJȠ ȜİȚIJȠȣȡȖȚțȩ ıȪıIJȘµĮ țĮȚ IJȠȞ ijȣȜȜȠµİIJȡȘIJȒ, ȓıȦȢ ȑȤİIJİ ʌĮȡĮIJȘȡȒıİȚ ȩIJȚ IJȠ ʌȡȩȖȡȐµµĮ FlyingLines (ʌȠȣ İȓįĮµİ ıIJȘȞ § 3.6.3, ȑȤİȚ IJȘȞ IJȐıȘ ȞĮ ‘’țȡݵȐİȚ’’ µİIJȐ Įʌȩ ĮȡțİIJȑȢ ȤȚȜȚȐįİȢ İʌĮȞĮȜȒȥİȚȢ İȞIJȠȜȫȞ. ȅ ȕȡȩȤȠȢ IJȘȢ ȗȦȖȡĮijȚțȒȢ ıIJȠ FlyingLines İȓȞĮȚ ȚįĮȞȚțȩȢ ȖȚĮ ȑȞĮ ȞȒµĮ, µȓĮ ȟİȤȦȡȚıIJȒ ȠµȐįĮ Įʌȩ ȜİȚIJȠȣȡȖȓİȢ, ʌȠȣ ȜĮµȕȐȞȠȣȞ ȤȫȡĮ IJĮȣIJȩȤȡȠȞĮ țĮȚ ĮȞİȟȐȡIJȘIJĮ Įʌȩ ȠIJȚįȒʌȠIJİ ȐȜȜȠ ȓıȦȢ ıȣµȕİȓ. ȈĮȞ ȑȞĮȢ ȖİȞȚțȩȢ țĮȞȩȞĮȢ ȩȜİȢ ȠȚ İȞIJĮIJȚțȑȢ İȡȖĮıȓİȢ IJȘȢ CPU ʌȡȑʌİȚ ȞĮ IJȠʌȠșİIJȠȪȞIJĮȚ ıIJĮ įȚțȐ IJȠȣȢ ȞȒµĮIJĮ. ȆĮȡĮțȐIJȦ ʌĮȡȠȣıȚȐȗİIJĮȚ µȚĮ ȞȘµĮIJȠʌȠȚȘµȑȞȘ ȑțįȠıȘ IJȠȣ FlyingLines: import java.applet.Applet; import java.awt.*; public class FlyingLines extends Applet implements Runnable { int NUM_LINES = 25; int gDeltaTop=3, gDeltaBottom=3; int gDeltaLeft=2, gDeltaRight=6; int AppletWidth, AppletHeight; int gLines[][] = new int[NUM_LINES][4];

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 47 -

public void init() { AppletWidth = size().width; AppletHeight = size().height; } public void start() { gLines[0][0] = Randomize(AppletWidth); gLines[0][1] = Randomize(AppletHeight); gLines[0][2] = Randomize(AppletWidth); gLines[0][3] = Randomize(AppletHeight); for (int i=1; i < NUM_LINES; i++ ) { LineCopy(i, i-1); RecalcLine(i); } repaint(); Thread t = new Thread(this); t.start(); } public void run () { Thread.currentThread().setPriority(Thread.MIN_PRIORITY); while (true) { for (int i=NUM_LINES - 1; i > 0; i--) { LineCopy(i, i-1); } RecalcLine(0); System.out.println(gLines[0][0] + ", " + gLines[0][1] + "," + gLines[0][2] + ", " + gLines[0][3]); repaint(); try { Thread.currentThread().sleep(10); } catch (Exception e) { } }

}

public void paint(Graphics g) { for (int i=0; i < NUM_LINES; i++) { g.drawLine(gLines[i][0], gLines[i][1], gLines[i][2], gLines[i][3]); } } private void LineCopy (int to, int from) for (int i = 0; i < 4; i++) { gLines[to][i] = gLines[from][i]; } } public int Randomize( int range ) { double rawResult; rawResult = Math.random(); return (int) (rawResult * range); }

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ

{


ȂĮșȒµĮIJĮ Java - 48 -

private void RecalcLine( int i ) { gLines[i][1] += gDeltaTop; if ((gLines[i][1] < 0) || (gLines[i][1] > AppletHeight)) { gDeltaTop *= -1; gLines[i][1] += 2*gDeltaTop; } gLines[i][3] += gDeltaBottom; if ( (gLines[i][3] < 0) || (gLines[i][3] > AppletHeight) ) { gDeltaBottom *= -1; gLines[i][3] += 2*gDeltaBottom; } gLines[i][0] += gDeltaLeft; if ( (gLines[i][0] < 0) || (gLines[i][0] > AppletWidth) ) { gDeltaLeft *= -1; gLines[i][0] += 2*gDeltaLeft; } gLines[i][2] += gDeltaRight; if ( (gLines[i][2] < 0) || (gLines[i][2] > AppletWidth) ) { gDeltaRight *= -1; gLines[i][2] += 2*gDeltaRight; } }

}

ȆĮȡĮIJȘȡȠȪµİ ȩIJȚ Ș ȞȘµĮIJȠʌȠȚȘµȑȞȘ ȑțįȠıȘ ȑȤİȚ İʌȚʌȡȩıșİIJĮ ıIJȘȞ İʌȚțİijĮȜȓįĮ IJȘȢ țȜȐıȘȢ IJȘȞ įȒȜȦıȘ implements Runnable.

3.9 ȀȜȐıİȚȢ, ǹȞIJȚțİȓµİȞĮ, ȂȑșȠįȠȚ țĮȚ ȀĮIJĮıțİȣĮıIJȑȢ ȅ ĮȞIJȚțİȚµİȞȠıIJȡİijȒȢ ʌȡȠȖȡĮµµĮIJȚıµȩȢ (Object Oriented Programming, İȞ ıȣȞIJȠµȓĮ OOP) ʌİȡȚȜĮµȕȐȞİȚ ȩȜĮ IJĮ ȤĮȡĮțIJȘȡȚıIJȚțȐ IJȠȣ įȠµȘµȑȞȠȣ ʌȡȠȖȡĮµµĮIJȚıµȠȪ țĮșȫȢ țĮȚ ȚıȤȣȡȠȪȢ IJȡȩʌȠȣȢ ȠȡȖȐȞȦıȘȢ ĮȜȖȠȡȓșµȦȞ țĮȚ įȠµȫȞ įİįȠµȑȞȦȞ. ȅȚ ȖȜȫııİȢ OOP ȑȤȠȣȞ IJȡȓĮ ȤĮȡĮțIJȘȡȚıIJȚțȐ: İȞșȣȜȐțȦıȘ, ʌȠȜȣµȠȡijȓĮ țĮȚ țȜȘȡȠȞȠµȚțȩIJȘIJĮ. ȀȜȐıİȚȢ țĮȚ ǹȞIJȚțİȓµİȞĮ ȉȠ ʌȡȦIJĮȡȤȚțȩ ȤĮȡĮțIJȘȡȚıIJȚțȩ IJȦȞ ȖȜȦııȫȞ OOP İȓȞĮȚ Ș țȜȐıȘ (class). Ǿ țȜȐıȘ İȓȞĮȚ µȚĮ įȠµȒ įİįȠµȑȞȦȞ ʌȠȣ µʌȠȡİȓ ȞĮ ıȣıȤİIJȚıIJİȓ µİ µİșȩįȠȣȢ ʌȠȣ İȞİȡȖȠȪȞ ʌȐȞȦ ıİ ȑȞĮ ĮȞIJȚțİȓµİȞȠ µİ IJȠ ĮȞIJȚțİȓµİȞȠ ĮȣIJȩ țĮș’ İĮȣIJȩ. ȈIJȚȢ ʌȡȚȞ-OOP ȖȜȫııİȢ, µȑșȠįȠȚ țĮȚ įİįȠµȑȞĮ ȒIJĮȞ ȟİȤȦȡȚıIJȐ. ȈIJȚȢ OOP ȖȜȫııİȢ ȩȜĮ ĮȣIJȐ İȓȞĮȚ µȑȡȘ µȚĮȢ țȜȐıȘȢ. ȅȚ ȖȜȫııİȢ ʌȡȠȖȡĮµµĮIJȚıµȠȪ ʌĮȡȑȤȠȣȞ ȠȡȚıµȑȞȠȣȢ ĮʌȜȠȪȢ IJȪʌȠȣȢ įİįȠµȑȞȦȞ ȩʌȦȢ int, float țĮȚ string. ǵµȦȢ, ʌȠȜȪ ıȣȤȞȐ IJĮ įİįȠµȑȞĮ įİȞ İȓȞĮȚ IJȩıȠ ĮʌȜȐ ȩʌȦȢ ints, floats Ȓ strings. ȅȚ țȜȐıİȚȢ İʌȚIJȡȑʌȠȣȞ ıIJȠȣȢ ʌȡȠȖȡĮµµĮIJȚıIJȑȢ ȞĮ ȠȡȓıȠȣȞ įȚțȠȪȢ IJȠȣȢ, ʌȚȠ ʌȠȜȪʌȜȠțȠȣȢ IJȪʌȠȣȢ įİįȠµȑȞȦȞ. īȚĮ ʌĮȡȐįİȚȖµĮ ĮȢ ȣʌȠșȑıȠȣµİ ȩIJȚ IJȠ ʌȡȩȖȡĮµµȐ ıȠȣ ȤȡİȚȐȗİIJĮȚ ȞĮ țȡĮIJȐİȚ µȚĮ ȕȐıȘ įİįȠµȑȞȦȞ İȞȩȢ site. īȚĮ țȐșİ site ȑȤİȚȢ ȑȞĮ ȩȞȠµĮ, ȑȞĮ URL țĮȚ µȚĮ ʌİȡȚȖȡĮijȒ. ȈIJȚȢ ʌĮȡĮįȠıȚĮțȑȢ ȖȜȫııİȢ ʌȡȠȖȡĮµµĮIJȚıµȠȪ șĮ ȑȤİȚ IJȡİȚȢ įȚĮijȠȡİIJȚțȑȢ µİIJĮȕȜȘIJȑȢ string ȖȚĮ țȐșİ site IJȠȣ WEB. Ȃİ µȚĮ țȜȐıȘ ıȣȞįȣȐȗİȚȢ ȩȜĮ ĮȣIJȐ ıİ ȑȞĮ ʌĮțȑIJȠ, ȩʌȦȢ ʌĮȡĮțȐIJȦ: class website { String name; String url; String description; } ǹȣIJȑȢ ȠȚ µİIJĮȕȜȘIJȑȢ (ȩȞȠµĮ, url țĮȚ ʌİȡȚȖȡĮijȒ) ȠȞȠµȐȗȠȞIJĮȚ µȑȜȘ IJȘȢ țȜȐıȘȢ. ȈȠȣ ȜȑȞİ IJȚ İȓȞĮȚ µȚĮ țȜȐıȘ țĮȚ ʌȠȚİȢ İȓȞĮȚ ȠȚ ȚįȚȩIJȘIJȑȢ IJȘȢ. ȈIJȘ ȕȐıȘ įİįȠµȑȞȦȞ IJȠȣ site IJȠȣ web șĮ ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 49 -

ȑȤȠȣµİ ʌȠȜȜȑȢ ȤȚȜȚȐįİȢ websites. ȀȐșİ ȟİȤȦȡȚıIJȩ web site İȓȞĮȚ ȑȞĮ ĮȞIJȚțİȓµİȞȠ. ȂȚĮ țȜȐıȘ ȠȡȓȗİȚ IJȚ İȓȞĮȚ ȑȞĮ ĮȞIJȚțİȓµİȞȠ, ĮȜȜȐ įİȞ İȓȞĮȚ ĮȣIJȩ țĮș’ İĮȣIJȩ ȑȞĮ ĮȞIJȚțİȓµİȞȠ. DzȞĮ ĮȞIJȚțİȓµİȞȠ İȓȞĮȚ ȑȞĮ ȚįȚĮȓIJİȡȠ ıIJȚȖµȚȩIJȣʌȠ IJȘȢ țȜȐıȘȢ. ǵµȦȢ, ȩIJĮȞ įȘµȚȠȣȡȖȠȪµİ ȑȞĮ ȞȑȠ ĮȞIJȚțİȓµİȞȠ Ȝȑµİ ȩIJȚ įȘµȚȠȣȡȖȠȪµİ ȑȞĮ ıIJȚȖµȚȩIJȣʌȠ IJȘȢ țȜȐıȘȢ. ȀȐșİ țȜȐıȘ ȣʌȐȡȤİȚ µȩȞȠ µȚĮ ijȠȡȐ ıİ ȑȞĮ ʌȡȩȖȡĮµµĮ, ĮȜȜȐ ȣʌȐȡȤȠȣȞ ʌȠȜȜȑȢ ȤȚȜȚȐįİȢ Įʌȩ ĮȞIJȚțİȓµİȞĮ ʌȠȣ İȓȞĮȚ ıIJȚȖµȚȩIJȣʌĮ țȜȐıİȦȢ. īȚĮ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ȑȞĮ ĮȞIJȚțİȓµİȞȠ ıIJȘ Java ȤȡȘıȚµȠʌȠȚȠȪµİ IJȘ ȜİȚIJȠȣȡȖȓĮ new. ȆĮȡĮțȐIJȦ ȕȜȑʌȠȣµİ ʌȦȢ șĮ įȘµȚȠȣȡȖȒıȠȣµİ IJȠ țĮȚȞȠȪȡȖȚȠ web site. website x = new website(); ȀĮșȫȢ ȑȤȠȣµİ ȑȞĮ website șȑȜȠȣµİ ȞĮ µȐșȠȣµİ țȐIJȚ ȖȚ’ ĮȣIJȩ. īȚĮ ȞĮ ʌȐȡȠȣµİ IJȚȢ µİIJĮȕȜȘIJȑȢ µȑȜȠȣȢ IJȠȣ website µʌȠȡȠȪµİ ȞĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ IJȠȞ IJİȜİıIJȒ ‘.’. ȉȠ website ȑȤİȚ IJȡİȚȢ µİIJĮȕȜȘIJȑȢ µȑȜȠȣȢ: ȩȞȠµĮ, url țĮȚ ʌİȡȚȖȡĮijȒ. DzIJıȚ IJȠ x ȑȤİȚ IJȡİȚȢ µİIJĮȕȜȘIJȑȢ µȑȜȠȣȢ IJȚȢ x.name, x.url, x.description. ȂʌȠȡȠȪµİ ȞĮ IJȠ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ ĮțȡȚȕȫȢ ȩʌȦȢ șĮ ȤȡȘıȚµȠʌȠȚȠȪıĮµİ ȠʌȠȚĮįȒʌȠIJİ ȐȜȜȘ µİIJĮȕȜȘIJȒ string. īȚĮ ʌĮȡȐįİȚȖµĮ: website x = new website(); x.name = "ȆĮȞİʌȚıIJȒµȚȠ ǹșȘȞȫȞ"; x.url = "http://www.uoa.gr"; x.description = "Really cool!"; System.out.println(x.name + " at " + x.url + " is " + x.description); ȂȑșȠįȠȚ ȅȚ IJȪʌȠȚ įİįȠµȑȞȦȞ įİȞ İȓȞĮȚ ʌȠȜȪ İȪȤȡȘıIJȠȚ ĮȞ įİȞ µʌȠȡİȓȢ ȞĮ țȐȞİȚȢ ʌȡȐȖµĮIJĮ µİ ĮȣIJȠȪȢ, īȚ’ ĮȣIJȩ IJȠ ıțȠʌȩ ȠȚ țȜȐıİȚȢ ȑȤȠȣȞ µİșȩįȠȣȢ (methods). ȉĮ µȑȜȘ ȜȑȞİ IJȚ İȓȞĮȚ µȚĮ țȜȐıȘ. ȅȚ µȑșȠįȠȚ ȜȑȞİ IJȚ țȐȞİȚ µȚĮ țȜȐıȘ. Ȇ.Ȥ. Ș țȜȐıȘ IJȠȣ website ȓıȦȢ ȑȤİȚ µȚĮ µȑșȠįȠ ȖȚĮ ȞĮ IJȣʌȫıİȚ IJĮ įİįȠµȑȞĮ IJȠȣ. ǼȐȞ İȓȞĮȚ ȑIJıȚ ĮȣIJȩ șĮ µȠȚȐȗİȚ ȩʌȦȢ ʌĮȡĮțȐIJȦ: class website { String name; String url; String description; print() { System.out.println(name + " at " + url + " is " + description); } } DzȟȦ Įʌȩ IJȘ µȑșȠįȠ website țĮȜȠȪµİ IJȘ µȑșȠįȠ print, ĮțȡȚȕȫȢ ȩʌȦȢ ĮȞĮijİȡȩµĮıIJĮȞ ıIJȚȢ µİIJĮȕȜȘIJȑȢ µȑȜȠȣȢ, ȤȡȘıȚµȠʌȠȚȫȞIJĮȢ IJȠ ȩȞȠµĮ IJȠȣ ıȣȖțİțȡȚµȑȞȠȣ ĮȞIJȚțİȚµȑȞȠȣ ʌȠȣ șȑȜȠȣµİ ȞĮ IJȣʌȫıȠȣµİ țĮȚ IJȠȞ IJİȜİıIJȒ ‘.’. website x = new website(); x.name = "ȆĮȞİʌȚıIJȒµȚȠ ǹșȘȞȫȞ"; x.url = "http://www.uoa.gr"; x.description = "Really cool!"; x.print(); ȆĮȡĮIJȒȡȘıİ ȩIJȚ µȑıĮ ıIJȘȞ țȜȐıȘ IJȠȣ website įİȞ ȤȡİȚȐȗİIJĮȚ ȞĮ ȤȡȘıȚµȠʌȠȚȠȪµİ x.name Ȓ x.url, name țĮȚ url İȓȞĮȚ ĮȡțİIJȐ. ǹȣIJȩ ȚıȤȪİȚ ȖȚĮIJȓ Ș µȑșȠįȠȢ print ʌȡȑʌİȚ ȞĮ țĮȜİȓIJĮȚ Įʌȩ ȑȞĮ ıȣȖțİțȡȚµȑȞȠ ıIJȚȖµȚȩIJȣʌȠ țȜȐıȘȢ IJȠȣ website. Ǿ µȑșȠįȠȢ print() ȑȤİȚ ȠȜȠțȜȘȡȦIJȚțȐ İȞșȣȜĮțȦșİȓ µȑıĮ ıIJȘȞ țȜȐıȘ IJȠȣ website. ǵȜİȢ ȠȚ µȑșȠįȠȚ ıIJȘ Java ʌȡȑʌİȚ ȞĮ ĮȞȒțȠȣȞ ıİ µȚĮ țȜȐıȘ.

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 50 -

ȀĮIJĮıțİȣĮıIJȑȢ Ǿ ʌȡȫIJȘ µȑșȠįȠȢ ʌȠȣ ȤȡİȚȐȗȠȞIJĮȚ ȠȚ ʌİȡȚııȩIJİȡİȢ țȜȐıİȚȢ İȓȞĮȚ Ƞ țĮIJĮıțİȣĮıIJȒȢ (Constructor). ȂȚĮ įȠµȒ įȘµȚȠȣȡȖİȓ ȑȞĮ ȞȑȠ ıIJȚȖµȚȩIJȣʌȠ IJȘȢ țȜȐıȘȢ. ǹȡȤȚțȠʌȠȚİȓ ȩȜİȢ IJȚȢ µİIJĮȕȜȘIJȑȢ țĮȚ İțIJİȜİȓ ȠʌȠȚĮįȒʌȠIJİ İȞȑȡȖİȚĮ ȤȡİȚȐȗİIJĮȚ ȖȚĮ ȞĮ ʌȡȠİIJȠȚµĮıIJİȓ Ș țȜȐıȘ țĮȚ ȞĮ ȤȡȘıȚµȠʌȠȚȘșİȓ. ȈIJȘ ȖȡĮµµȒ website x = new website(); Ș website( ) İȓȞĮȚ µȚĮ ıȣȞȐȡIJȘıȘ țĮIJĮıțİȣȒȢ. ǹȞ įİȞ ȣʌȐȡȤİȚ IJȑIJȠȚĮ ıȣȞȐȡIJȘıȘ Ș Java įȘµȚȠȣȡȖİȓ İȟ’ ȠȡȚıµȠȪ µȚĮ, ĮȜȜȐ İȓȞĮȚ țĮȜȪIJİȡȠ ȞĮ İȓıĮȚ ıȓȖȠȣȡȠȢ ȩIJȚ ȑȤİȚȢ ȠȡȓıİȚ IJȘ įȚțȒ ıȠȣ. ȅ țĮIJĮıțİȣĮıIJȒȢ ȖȡȐijİȚ µȚĮ public µȑșȠįȠ, Ș ȠʌȠȓĮ ȑȤİȚ IJȠ ȓįȚȠ ȩȞȠµĮ µİ IJȘȞ țȜȐıȘ. DzIJıȚ, Ș įȠµȒ IJȠȣ website µĮȢ țĮȜİȓIJĮȚ website(). Ǽįȫ İȓȞĮȚ µȚĮ ĮʌȜȒ website țȜȐıȘ µİ µȚĮ įȠµȒ ʌȠȣ ĮȡȤȚțȠʌȠȚİȓ ȩȜĮ IJĮ µȑȜȘ µİ µȘįİȞȚțȐ strings: class website { String name; String url; String description; public website() { name = ""; url = ""; description = ""; } } ǹțȩµĮ țĮȜȪIJİȡĮ ʌȡȑʌİȚ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ µȚĮ įȠµȒ ʌȠȣ ȞĮ įȑȤİIJĮȚ IJȡȓĮ strings ıĮȞ ȠȡȓıµĮIJĮ țĮȚ ȞĮ IJĮ ȤȡȘıȚµȠʌȠȚİȓ ȖȚĮ ȞĮ ĮȡȤȚțȠʌȠȚȒıİȚ IJȚȢ µİIJĮȕȜȘIJȑȢ µȑȜȠȣȢ ȦȢ İȟȒȢ: class website { String name; String url; String description; public website(String n, String u, String d) { name = n; url = u; description = d; } } șĮ IJȠ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ ȦȢ İȟȒȢ: website x = new website("ȆĮȞİʌȚıIJȒµȚȠ ǹșȘȞȫȞ","http://www.uoa.gr", "Really cool!"); x.print(); ǹȣIJȩ IJĮȚȡȚȐȗİȚ µİ IJȘȞ ʌȡȩșİıȒ µĮȢ ȞĮ țȡĮIJȐµİ IJȠȞ țȫįȚțĮ ıȤİIJȚțȩ µİ IJȘȞ țĮIJȐȜȜȘȜȘ ȜİȚIJȠȣȡȖȓĮ IJȘȢ țȜȐıȘ µȑıĮ ıİ µȚĮ IJȐȟȘ. ǵµȦȢ IJȚ ıȣµȕĮȓȞİȚ ȩIJĮȞ șȑȜȠȣµİ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ȑȞĮ website IJȠȣ ȠʌȠȓȠȣ µİȡȚțȑȢ ijȠȡȑȢ ȟȑȡȠȣµİ IJȠ url,IJȠ ȩȞȠµĮ țĮȚ IJȘȞ ʌİȡȚȖȡĮijȒ țĮȚ µİȡȚțȑȢ ijȠȡȑȢ įİȞ IJȠ ȟȑȡȠȣµİ; ȀĮȜȪIJİȡĮ ĮȢ IJĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ țĮȚ IJĮ įȣȠ: class website { String name; String url; String description; public website(String n, String u, String d) { name = n; url = u; description = d; } public website() { ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ȂĮșȒµĮIJĮ Java - 51 -

name = ""; url = ""; description = ""; } } ǹȣIJȩ țĮȜİȓIJĮȚ µȑșȠįȠȢ ȣʌİȡijȩȡIJȦıȘȢ Ȓ ʌȠȜȣµȠȡijȚıµȠȪ. ȅ ʌȠȜȣµȠȡijȚıµȩȢ İȓȞĮȚ ȑȞĮ ȤĮȡĮțIJȘȡȚıIJȚțȩ IJȦȞ ĮȞIJȚțİȚµİȞȠıIJȡİijȫȞ ȖȜȦııȫȞ ʌȠȣ ĮijȒȞȠȣȞ ȑȞĮ ȩȞȠµĮ ȞĮ ĮȞĮijȑȡİIJĮȚ ıİ įȚĮijȠȡİIJȚțȑȢ µİșȩįȠȣȢ,İȟĮȡIJȫµİȞȠ Įʌȩ IJȠ ʌİȡȚİȤȩµİȞȩ IJȠȣȢ. ȉȠ ıȘµĮȞIJȚțȩ ıIJȠ ʌİȡȚİȤȩµİȞȠ İȓȞĮȚ Ƞ IJȪʌȠȢ țĮȚ Ƞ ĮȡȚșµȩȢ IJȦȞ ȠȡȚıµȐIJȦȞ IJȘȢ µİșȩįȠȣ. Ȉ’ĮȣIJȒȞ IJȘȞ ʌİȡȓʌIJȦıȘ ȤȡȘıȚµȠʌȠȚȠȪµİ IJȘȞ ʌȡȫIJȘ ȑțįȠıȘ IJȘȢ µİșȩįȠȣ ĮȞ ȑȤȠȣµİ IJȡȓĮ ȠȡȓıµĮIJĮ țĮȚ IJȘȞ įİȪIJİȡȘ ȑțįȠıȘ ĮȞ įİȞ ȑȤȠȣµİ țĮșȩȜȠȣ ȠȡȓıµĮIJĮ. ǹȞ ȑȤİȚȢ ȑȞĮ, įȪȠ Ȓ IJȑııİȡĮ ȠȡȓıµĮIJĮ string ıIJȘ įȠµȒ, Ȓ ȠȡȓıµĮIJĮ ʌȠȣ įİȞ İȓȞĮȚ string, Ƞ µİIJĮȖȜȦIJIJȚıIJȒȢ įȘµȚȠȣȡȖİȓ ȑȞĮ ȜȐșȠȢ ȖȚĮIJȓ įİȞ ȑȤİȚ µȚĮ µȑșȠįȠ ʌȠȣ ȞĮ IJĮȚȡȚȐȗİȚ µİ IJȘ µȑșȠįȠ ʌȠȣ ȗȘIJȒșȘțİ. ȂȑșȠįȠȚ toStrings Ǿ µȑșȠįȠȢ print İȓȞĮȚ țȠȚȞȒ ıİ țȐʌȠȚİȢ ȖȜȫııİȢ, ĮȜȜȐ IJĮ ʌİȡȚııȩIJİȡĮ ʌȡȠȖȡȐµµĮIJĮ IJȘȢ Java IJȘȞ ȤİȚȡȓȗȠȞIJĮȚ įȚĮijȠȡİIJȚțȐ. ȂʌȠȡİȓȢ ȞĮ ȤȡȘıȚµȠʌȠȚȒıİȚȢ System.out.println() ȖȚĮ ȞĮ IJȣʌȫıİȚȢ țȐʌȠȚȠ ĮȞIJȚțİȓµİȞȠ. ǵµȦȢ ȖȚĮ țĮȜȐ ĮʌȠIJİȜȑıµĮIJĮ Ș țȜȐıȘ ıȠȣ ʌȡȑʌİȚ ȞĮ ȑȤİȚ µȚĮ µȑșȠįȠ toString(), ʌȠȣ ȞĮ µȠȡijȠʌȠȚİȓ IJĮ įİįȠµȑȞĮ IJȦȞ ĮȞIJȚțİȚµȑȞȦȞ µİ ȑȞĮ ȜȠȖȚțȩ IJȡȩʌȠ țĮȚ ȞĮ İʌȚıIJȡȑijİȚ ȑȞĮ string. ȆĮȡĮțȐIJȦ ȕȜȑʌȠȣµİ ʌȫȢ ȤȡȘıȚµȠʌȠȚİȓIJĮȚ ĮȣIJȩ ıIJȠ ʌĮȡȐįİȚȖµĮ IJȠȣ website: public class ClassTest { public static void main(String args[]) { website x = new website("ȆĮȞİʌȚıIJȒµȚȠ ǹșȘȞȫȞ", "http://www.uoa.gr", "Really cool!"); System.out.println(x); } } class website { String name; String url; String description; public website(String n, String u, String d) { name = n; url = u; description = d; } public website() { name = ""; url = ""; description = ""; } public String toString() { return (name + " at " + url + " is " + description); } }

ǹș. Ǽ. ȀȠȣIJıȠȞȚțȩȜĮȢ


ΜΑΘΗΜΑΤΑ JAVA