ΜΑΘΗΜΑΤΑ JAVA by Thanassis Koutsonikolas

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

ȂǹĬǾȂǹȉǹ JAVA

ƮƭƧƷƳ 2003

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

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

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

ǹʌȜȩĲȘĲĮ.

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

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

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

ǹıĳȐȜİȚĮ

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

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

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

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

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

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

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

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

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

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

µȚĮ

ĲİȜİȣĲĮȓĮ

ıȘµİȓȦıȘ.

ǹȞĲȓșİĲĮ

µİ

ĲȘȞ

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

printf

ĲȘȢ

µȑșȠįȠȢ

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

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

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

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

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

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

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

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

thread

"main"

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

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

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

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

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

ĲȘ

µİĲĮȕȜȘĲȒ

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

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

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

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

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

ȂĮșȒµĮĲĮ 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(); } } Ȃİ ĲȠȞ ʌĮȡĮʌȐȞȦ ĲȡȩʌȠ ȤİȚȡȚȗȩµĮıĲİ µȑȤȡȚ ĲȑııİȡĮ ȠȡȓıµĮĲĮ ȖȡĮµµȒȢ İȞĲȠȜȫȞ, ıĲȘȞ ʌĮȡĮțȐĲȦ İȞȩĲȘĲĮ șĮ įȠȪµİ ʌȫȢ ȞĮ ȤİȚȡȚȗȩµĮıĲİ ʌȐȞȦ Įʌȩ įȪȠ įȚıİțĮĲȠµµȪȡȚĮ ȠȡȓıµĮĲĮ ȖȡĮµµȒȢ İȞĲȠȜȫȞ µİ ĮʌȜȩ ĲȡȩʌȠ. ǹȈȀǾȈǾ ȄĮȞĮȖȡȐȥĲİ ȠȜȩțȜȘȡȠ ĲȠ ʌĮȡĮʌȐȞȦ ʌȡȩȖȡĮµµĮ ȤȡȘıȚµȠʌȠȚȫȞĲĮȢ µȓĮ µȩȞȠ İȞĲȠȜȒ İțĲȪʌȦıȘȢ ıİ țȐșİ µʌȜȠț (ȣʌȩįİȚȟȘ: ȤȡȘıȚµȠʌȠȚȒıĲİ ĲȠ +).

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

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

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

Ǿ İȞĲȠȜȒ for İțĲİȜİȓ ȑȞĮ ʌȡȠțĮșȠȡȚıµȑȞȠ ĮȡȚșµȩ İʌĮȞĮȜȒȥİȦȞ țĮȚ µİĲȐ ıĲĮµĮĲȐ. H while țĮȚ Ș do while, İʌĮȞĮȜĮµȕȐȞȠȣȞ ıȣȞİȤȫȢ ȑȞĮȞ ȕȡȩȤȠ µȑȤȡȚ µȚĮ ıȣȖțİțȡȚµȑȞȘ ıȣȞșȒțȘ ȞĮ ʌȐȥİȚ ȞĮ ȚıȤȪİȚ. īȚĮ ĲȘȞ ʌİȡȓʌĲȦıȘ ĲȠȣ ʌĮȡĮʌȐȞȦ ʌȡȠȖȡȐµµĮĲȠȢ, Hello4, șȑȜȠȣµİ ȞĮ ȖȡȐȥȠȣµİ ȑȞĮ ȕȡȩȤȠ ʌȠȣ șĮ ĲȣʌȫȞİȚ țĮșȑȞĮ Įʌȩ ĲĮ ȠȡȓıµĮĲĮ ȖȡĮµµȒȢ İȞĲȠȜȫȞ, ȟİțȚȞȫȞĲĮȢ Įʌȩ ĲȠ ʌȡȫĲȠ. ǻİȞ ȟȑȡȠȣµİ ʌȡȠȘȖȠȣµȑȞȦȢ ʌȩıĮ ȠȡȓıµĮĲĮ ȖȡĮµµȒȢ İȞĲȠȜȫȞ șĮ ȑȤȠȣµİ, ĮȜȜȐ µʌȠȡȠȪµİ ȞĮ ĲȠ µȐșȠȣµİ İȪțȠȜĮ, µİ ĲȘȞ ȤȡȒıȘ ĲȠȣ args.length. īȚ’ ĮȣĲȩ țĮȚ șĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ ĲȠȞ ȕȡȩȤȠ 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(); } } ȄİțȚȞȐµİ ĲȠȞ țȫįȚțĮ įȘȜȫȞȠȞĲĮȢ ĲȚȢ µİĲĮȕȜȘĲȑȢ µĮȢ. Ȉ’ ĮȣĲȒȞ ĲȘȞ ʌİȡȓʌĲȦıȘ ȑȤȠȣµİ µȓĮ µȩȞȠ µİĲĮȕȜȘĲȒ, ĲȘȞ ĮțȑȡĮȚĮ i. ȈĲȘ ıȣȞȑȤİȚĮ İµĳĮȞȓȗȠȣµİ ıĲȘȞ ȠșȩȞȘ ĲȠ "Hello" ȩʌȦȢ ʌȡȠȘȖȠȣµȑȞȦȢ. ǲʌİȚĲĮ ȤȡȘıȚµȠʌȠȚȠȪµİ ĲȠȞ ȕȡȩȤȠ for. ȅ ȕȡȩȤȠȢ ȟİțȚȞȐ ĮȡȤȚțȠʌȠȚȫȞĲĮȢ ĲȠȞ µİĲȡȘĲȒ i, įȓȞȠȞĲȐȢ ĲȠȣ ĲȘȞ ĲȚµȒ 0. AȣĲȩ ıȣµȕĮȓȞİȚ µȓĮ ĳȠȡȐ ıĲȘȞ ĮȡȤȒ ĲȠȣ ȕȡȩȤȠȣ. ǹțȠȜȠȣșİȓ Ș İȟȑĲĮıȘ ĲȘȢ ıȣȞșȒțȘȢ. Ȉ’ ĮȣĲȒȞ ĲȘȞ ʌİȡȓʌĲȦıȘ İȟİĲȐȗȠȣµİ ĮȞ Ĳo i İȓȞĮȚ µȚțȡȩĲİȡȠ Įʌȩ ĲȠȞ ĮȡȚșµȩ ĲȦȞ ȠȡȚıµȐĲȦȞ ȖȡĮµµȒȢ İȞĲȠȜȫȞ. ǵĲĮȞ ĲȠ i ȖȓȞİȚ ȓıȠ µİ ĲȠȞ ĮȡȚșµȩ ĮȣĲȩȞ, ȕȖĮȓȞȠȣµİ Įʌȩ ĲȠȞ ȕȡȩȤȠ țĮȚ ʌȘȖĮȓȞȠȣµİ ıĲȘȞ ʌȡȫĲȘ İȞĲȠȜȒ µİĲȐ ĲȠ țȜİȓıȚµȠ ĲȠȣ ȕȡȩȤȠȣ. ĬȣµȘșİȓĲİ ȩĲȚ ȟİțȚȞȒıĮµİ ȞĮ µİĲȡȐµİ Įʌȩ ĲȠ 0, ȩȤȚ Įʌȩ ĲȠ 1. ȉȑȜȠȢ, ȑȤȠȣµİ ĲȠ ʌȡȠıĮȣȟȘĲȚțȩ ȕȒµĮ i=i+1. ǹȣĲȩ İțĲİȜİȓĲĮȚ ıĲȠ ĲȑȜȠȢ țȐșİ İʌĮȞȐȜȘȥȘȢ ĲȠȣ ȕȡȩȤȠȣ. ȋȦȡȓȢ ĮȣĲȩ șĮ ʌĮȡĮµȑȞĮµİ ıĲȠȞ ȕȡȩȤȠ ȖȚĮ ʌȐȞĲĮ ĮĳȠȪ ĲȠ i șĮ ȒĲĮȞ µȩȞȚµĮ µȚțȡȩĲİȡȠ Įʌȩ ĲȠ args.length (İțĲȩȢ ĳȣıȚțȐ ĮȞ ĲȠ args.length ȒĲĮȞ µȚțȡȩĲİȡȠ Ȓ ȓıȠ µİ ĲȠ 0). ǹȈȀǾȈǾ ȉȚ ȖȓȞİĲĮȚ ĮȞ įİȞ įȫıȠȣµİ ıĲȠ ʌȡȩȖȡĮµµĮ Hello țĮȞȑȞĮ ȩȡȚıµĮ ȖȡĮµµȒȢ İȞĲȠȜȫȞ;

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

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

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

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

ȂȑȖȚıĲȘ ĲȚµȒ

-128 -32768 -2147483648 -9223372036854775808

127 32767 2147483647 9223372036854775807

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

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

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

ȅȚ ĮȡȚșµȠȓ țȚȞȘĲȒȢ ȣʌȠįȚĮıĲȠȜȒȢ µʌȠȡȠȪȞ ȞĮ ĮȞĮʌĮȡĮıĲȒıȠȣȞ µİȖĮȜȪĲİȡȠ ʌȜȒșȠȢ ĲȚµȫȞ Įʌ’ ȩĲȚ ȠȚ ĮțȑȡĮȚȠȚ. īȚĮ ʌĮȡȐįİȚȖµĮ, µʌȠȡİȓĲİ ȞĮ ȖȡȐȥİĲİ ʌȠȜȪ µİȖȐȜĮ ȞȠȪµİȡĮ, ȩʌȦȢ Ș ĲĮȤȪĲȘĲĮ ĲȠȣ ĳȦĲȩȢ (2.998Ǽ8 µȑĲȡĮ ĮȞȐ įİȣĲİȡȩȜİʌĲȠ) ĮȜȜȐ țĮȚ ʌȠȜȪ µȚțȡȐ, ȩʌȦȢ Ș ıĲĮșİȡȐ ĲȠȣ Plank, ȤȡȘıȚµȠʌȠȚȫȞĲĮȢ ĲȠȞ ȓįȚȠ ĮȡȚșµȩ ȥȘĳȓȦȞ. ǹʌȩ ĲȘȞ ȐȜȜȘ µİȡȚȐ ȤȐȞİĲĮȚ µȑȡȠȢ Įʌȩ ĲȘȞ ĮțȡȓȕİȚĮ, ʌȠȣ ʌȚșĮȞȩȞ ȩµȦȢ ȞĮ µȘȞ ȒĲĮȞ ĮʌĮȡĮȓĲȘĲȘ ȖȚĮ ĲȩıȠ µİȖȐȜĮ Ȓ ĲȩıȠ µȚțȡȐ ȞȠȪµİȡĮ. H Java ȣʌȠıĲȘȡȓȗİȚ įȪȠ ĲȪʌȠȣȢ ĮȡȚșµȫȞ țȚȞȘĲȒȢ ȣʌȠįȚĮıĲȠȜȒȢ: ĲȠȞ float țĮȚ ĲȠȞ double. Ǿ ȤȡȒıȘ ĮȡȚșµȫȞ țȚȞȘĲȒȢ ȣʌȠįȚĮıĲȠȜȒȢ įİȞ İȓȞĮȚ įȣıțȠȜȩĲİȡȘ Įʌȩ ĲȘ ȤȡȒıȘ ĮțİȡĮȓȦȞ. ȂʌȠȡȠȪµİ ȞĮ țȐȞȠȣµİ ĲȠ ʌȡȩȖȡĮµµȐ µĮȢ ʌȚȠ ĮțȡȚȕȑȢ µİĲĮĲȡȑʌȠȞĲĮȢ ȩȜİȢ ĲȚȢ int µİĲĮȕȜȘĲȑȢ ıİ double. //ǼțĲȪʌȦıȘ ʌȓȞĮțĮ Fahrenheit – Celsius µİ ʌİȡȚııȩĲİȡȘ ĮțȡȓȕİȚĮ 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; }

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

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

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

}

ĭȣıȚțȐ șĮ µʌȠȡȠȪıĮµİ ȞĮ ȖȡȐȥȠȣµİ ĲȠ ʌȡȩȖȡĮµµĮ µİĲĮĲȡȠʌȒȢ șİȡµȠțȡĮıȚȫȞ, ȤȡȘıȚµȠʌȠȚȫȞĲĮȢ ȕȡȩȤȠ for ıĲȘ șȑıȘ ĲȠȣ ȕȡȩȤȠȣ while. //ǼțĲȪʌȦıȘ ʌȓȞĮțĮ 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); }

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

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

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

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

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

ȊʌȐȡȤȠȣȞ İʌȓıȘȢ țĮȚ ȠȚ ĲİȜİıĲȑȢ *= țĮȚ /= ʌȠȣ ʌȠȜȜĮʌȜĮıȚȐȗȠȣȞ țĮȚ įȚĮȚȡȠȪȞ Įʌȩ ĲȘ įİȟȚȐ ʌȜİȣȡȐ ʌȡȚȞ ĲȘȞ ĮʌȩįȠıȘ. ȆĮȡĮțȐĲȦ ȑȤȠȣµİ ȑȞĮ ʌĮȡȐįİȚȖµĮ. ȆȡȚȞ ʌȠȜȜȐ ȤȡȩȞȚĮ, țȐʌȠȚȠȢ İĳİȪȡİ ĲȠ ʌĮȚȤȞȓįȚ ĲȠȣ ıțĮțȚȠȪ. ǹȣĲȩ ĲȠ ʌĮȚȤȞȓįȚ İȓȤİ İȞșȠȣıȚȐıİȚ ĲȩıȠ ʌȠȜȪ ĲȠ ǺĮıȚȜȚȐ ʌȠȣ ȒĲĮȞ įȚĮĲİșİȚµȑȞȠȢ ȞĮ ȤĮȡȓıİȚ ıĲȠȞ İĳİȣȡȑĲȘ ĲȠȣ ĲȠ µȚıȩ ĲȠȣ ȕĮıȓȜİȚȠ țĮȚ ĲȠ ȤȑȡȚ ĲȘȢ țȩȡȘȢ ĲȠȣ. ȅ İĳİȣȡȑĲȘȢ ʌȠȣ ȒĲĮȞ ʌȠȜȪ ȑȟȣʌȞȠȢ țĮȚ țĮșȩȜȠȣ ʌȜİȠȞȑțĲȘȢ įİȞ ȚțĮȞȠʌȠȚȒșȘțİ µİ ĲȠ µȚıȩ ȕĮıȓȜİȚȠ țĮȚ İȓʌİ ıĲȠ ǺĮıȚȜȚȐ: "ǺĮıȚȜȚȐ µȠȣ, İȓµĮȚ ȑȞĮȢ ĲĮʌİȚȞȩȢ ȐȞșȡȦʌȠȢ țĮȚ įİȞ ȟȑȡȦ ĲȚ ȞĮ țȐȞȦ ĲȠ µȚıȩ ıȠȣ ȕĮıȓȜİȚȠ. ǲȜĮ ȞĮ ȣʌȠȜȠȖȓıȠȣµİ ĲȠ įȫȡȠ µȠȣ ĮȜȜȚȫȢ. ǺȐȜİ ıĲȠ ʌȡȫĲȠ ĲİĲȡȐȖȦȞȠ ĲȠȣ ıțĮțȚȠȪ ȑȞĮ ıʌȩȡȠ ıȚĲȐȡȚ. ȂİĲȐ, ıĲȠ įİȪĲİȡȠ ĲİĲȡȐȖȦȞȠ įȪȠ ıʌȩȡȠȣȢ ıȚĲȐȡȚ, ıĲȠ ĲȡȓĲȠ ĲİĲȡȐȖȦȞȠ įȪȠ ĳȠȡȑȢ Įʌȩ įȪȠ ıʌȩȡȠȣȢ ț.Ȝ.ʌ. µȑȤȡȚ ȞĮ țĮȜȣĳșİȓ ȠȜȩțȜȘȡȠ ĲȠ ıțȐțȚ Įʌȩ ıʌȩȡȠȣȢ. ǵĲĮȞ ĲȠ ȐțȠȣıİ ĮȣĲȩ Ƞ ǺĮıȚȜȚȐȢ ȤȐȡȘțİ ʌȠȜȪ ʌȠȣ șĮ ȖȜȓĲȦȞİ µİ ĲȩıȠ ȜȓȖĮ ȑȟȠįĮ țĮȚ ıȣµĳȫȞȘıİ ĮµȑıȦȢ. ǽȒĲȘıİ ȞĮ ĲȠȣ ĳȑȡȠȣȞ µȚĮ ıĮțȠȪȜĮ ıȚĲȐȡȚ țĮȚ ȩĲĮȞ ĲȠȣ ĲȘȞ ȑĳİȡĮȞ ȐȡȤȚıİ ȞĮ ĲȠ ĲȠʌȠșİĲİȓ. ȈȪȞĲȠµĮ ĲȠ ıȚĲȐȡȚ ĲİȜİȓȦıİ țĮȚ įİȞ İȓȤİ țĮȜȪȥİȚ ȠȪĲİ ĲȠ µȚıȩ ıțȐțȚ. ǽȒĲȘıİ țĮȚ įİȪĲİȡȘ țĮȚ ĲȡȓĲȘ țĮȚ ȐȜȜİȢ ʌȠȜȜȑȢ ıĮțȠȪȜİȢ, µȑȤȡȚ ʌȠȣ ĮȞĮȖțȐıĲȘțİ ȞĮ ʌĮȡĮįİȤĲİȓ ĲȘȞ ȒĲĲĮ ĲȠȣ. ȆȩıȠ ıȚĲȐȡȚ ȤȡİȚĮȗȩĲĮȞ Ƞ ȕĮıȚȜȚȐȢ; ǹȢ ʌȡȠıʌĮșȒıȠȣµİ ȞĮ ȣʌȠȜȠȖȓıȠȣµİ. ĬȣµȘșİȓĲİ ȩĲȚ ĲȠ ıțȐțȚ ȑȤİȚ 64 ĲİĲȡȐȖȦȞĮ. 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); } } ȉȡȑȟĲİ ĲȠ ʌȡȩȖȡĮµµĮ. ȉȚ ʌĮȡĮĲȘȡİȓĲİ; ȂʌȠȡȠȪµİ ȞĮ ȕİȜĲȚȫıȠȣµİ İȜĮĳȡȫȢ ĲĮ ĮʌȠĲİȜȑıµĮĲĮ ĮȜȜȐȗȠȞĲĮȢ ĲȠȣȢ int µİ long. ǲȞĮȢ long İȓȞĮȚ ȑȞĮȢ ĮțȑȡĮȚȠȢ ĲȪʌȠȢ ʌȠȣ µʌȠȡİȓ ȞĮ İțĳȡȐıİȚ 9223372036854775807 ĮȡȚșµȠȪȢ. ǹțȩµĮ țȚ ȑȞĮȢ long ȩµȦȢ įİȞ µʌȠȡİȓ ȞĮ µİĲȡȒıİȚ ĲȠ ıȚĲȐȡȚ ʌȠȣ ȤȡİȚĮȗȩĲĮȞ Ƞ ȕĮıȚȜȚȐȢ. ǹȢ ʌȡȠıʌĮșȒıȠȣµİ ȞĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ ĲȫȡĮ ȑȞĮȞ double. ǲȞĮȢ double µʌȠȡİȓ ȞĮ țȡĮĲȒıİȚ ȑȞĮȞ ĮȡȚșµȩ µİȖȑșȠȣȢ 1.79769313486231570e+308. ǲĲıȚ İȓȞĮȚ ȚțĮȞȩȢ ȞĮ µİĲȡȒıİȚ ĲȠ ȤȡȑȠȢ ĲȠȣ ǺĮıȚȜȚȐ ʌȠȣ ĮȞȑȡȤİĲĮȚ ıİ 1.84467e+019 ıʌȩȡȠȣȢ Įʌȩ ıȚĲȐȡȚ.

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

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

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

ǹțȩµĮ țĮȚ ĲĮ ʌȚȠ ȕĮıȚțȐ įİįȠµȑȞĮ ȩʌȦȢ ȠȚ ĮțȑȡĮȚȠȚ, ıȣȤȞȐ İȓȞĮȚ ĮʌĮȡĮȓĲȘĲȠ ȞĮ İȞıȦµĮĲȦșȠȪȞ ıİ țȜȐıİȚȢ ʌȡȠĲȠȪ ȤȡȘıȚµȠʌȠȚȘșȠȪȞ ĮʌȠĲİȜİıµĮĲȚțȐ. ȀȜȐıȘ İȓȞĮȚ Ș șİµİȜȚȫįȘȢ µȠȞȐįĮ ĲȦȞ ʌȡȠȖȡĮµµȐĲȦȞ ĲȘȢ Java. īȚĮ ʌĮȡȐįİȚȖµĮ, ʌĮȡĮțȠȜȠȣșȒıĲİ ĲȠ ʌĮȡĮțȐĲȦ ʌȡȩȖȡĮµµĮ : 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!"); } } ȈȫıĲİ ĲȠȞ țȫįȚțĮ ıİ ȑȞĮ ĮȡȤİȓȠ ʌȠȣ șĮ ȠȞȠµȐıİĲİ hellogoodbye.java ıĲȠȞ țĮĲȐȜȠȖȠ İȡȖĮıȓĮȢ ıĮȢ (directory) țĮȚ µİĲĮȖȜȦĲĲȓıĲİ ĲȠ µİ ĲȠ javac hellogoodbye.java. ȈĲȘ ıȣȞȑȤİȚĮ įİȓĲİ ĲĮ ʌİȡȚİȤȩµİȞĮ ĲȠȣ țĮĲĮȜȩȖȠȣ. ĬĮ ʌĮȡĮĲȘȡȒıİĲİ ȩĲȚ Ƞ µİĲĮȖȜȦĲĲȚıĲȒȢ įȘµȚȠȪȡȖȘıİ įȪȠ ȟİȤȦȡȚıĲȐ ĮȡȤİȓĮ țȜȐıȘȢ, ĲȠ HelloWorld.class țĮȚ ĲȠ GoodbyeWorld.class. Ǿ įİȪĲİȡȘ țȜȐıȘ İȓȞĮȚ ȑȞĮ ĮȞİȟȐȡĲȘĲȠ ʌȡȩȖȡĮµµĮ. ȆȜȘțĲȡȠȜȠȖİȓıĲİ java GoodbyeWorld țĮȚ µİĲȐ java HelloWorld. ǹȣĲȐ ĲĮ ʌȡȠȖȡȐµµĮĲĮ ĲȡȑȤȠȣȞ țĮȚ İțĲİȜȠȪȞĲĮȚ ĮȞİȟȐȡĲȘĲĮ ĲȠ ȑȞĮ Įʌȩ ĲȠ ȐȜȜȠ ʌĮȡȩȜȠ ʌȠȣ ȣʌȐȡȤȠȣȞ ıĲȠ ȓįȚȠ ĮȡȤİȓȠ ʌȘȖĮȓȠȣ țȫįȚțĮ. ǺȑȕĮȚĮ įİȞ ȣʌȐȡȤİȚ țȐʌȠȚȠȢ ȜȩȖȠȢ ȞĮ șȑȜȠȣµİ įȪȠ įȚĮĳȠȡİĲȚțȐ ʌȡȠȖȡȐµµĮĲĮ ıĲȠ ȓįȚȠ ĮȡȤİȓȠ, ĮȜȜȐ ȑȤȠȣµİ ĲȘ įȣȞĮĲȩĲȘĲĮ ȞĮ ĲȠ ʌȡĮȖµĮĲȠʌȠȚȒıȠȣµİ. ǼȓȞĮȚ ʌȚȠ ʌȚșĮȞȩ ȞĮ șİȜȒıȠȣµİ ʌİȡȚııȩĲİȡİȢ Įʌȩ µȓĮ țȜȐıȘ ıĲȠ ȓįȚȠ ĮȡȤİȓȠ. ĬĮ ıȣȞĮȞĲȒıȠȣµİ ĮȡȤİȓȠ ʌȘȖĮȓȠȣ țȫįȚțĮ µİ ʌȠȜȜȑȢ țȜȐıİȚȢ țĮȚ µİșȩįȠȣȢ. ȈĲȘȞ ʌȡĮȖµĮĲȚțȩĲȘĲĮ ȣʌȐȡȤȠȣȞ İȞĲȠȜȑȢ ʌȠȣ µʌȠȡȠȪȞ ȞĮ İµĳĮȞȚıĲȠȪȞ ȑȟȦ Įʌȩ µȚĮ țȜȐıȘ. ȅȚ İȞĲȠȜȑȢ İȚıȩįȠȣ İµĳĮȞȓȗȠȞĲĮȚ ıĲȘȞ ĮȡȤȒ İȞȩȢ ĮȡȤİȓȠȣ ȑȟȦ Įʌȩ țȐșİ țȜȐıȘ. O µİĲĮȖȜȦĲĲȚıĲȒȢ ȩµȦȢ ĲȚȢ ĮȞĲȚțĮșȚıĲȐ µİ ĲĮ ʌİȡȚİȤȩµİȞĮ ĲȠȣ ĮȡȤİȓȠȣ ʌȠȣ ĮʌȠĲİȜİȓĲĮȚ Įʌȩ ʌİȡȚııȩĲİȡİȢ țȜȐıİȚȢ. ǻȚİʌĮĳȑȢ (Intefaces) ǵʌȦȢ İȓʌĮµİ, ȠȚ țȜȐıİȚȢ İȓȞĮȚ ʌȠȜȪ ȕĮıȚțȩ ıĲȠȚȤİȓȠ ĲȘȢ Java. ȆĮȡȩȜĮ ĮȣĲȐ ȣʌȐȡȤİȚ țȐĲȚ ıĲȠȞ țȫįȚțĮ ĲȘȢ Java ʌȠȣ įİȞ İȓȞĮȚ ȠȪĲİ țȜȐıȘ, ȠȪĲİ ĲµȒµĮ µȚĮȢ țȜȐıȘȢ. ǹȣĲȩ ȜȑȖİĲĮȚ įȚİʌĮĳȒ. ǻİȞ șĮ ʌȠȪµİ ʌȠȜȜȐ ȖȚĮ ĲȚȢ įȚİʌĮĳȑȢ µȚĮ țĮȚ ĮĳȠȡȠȪȞ ʌȚȠ İȟİȚįȚțİȣµȑȞȠ țİĳȐȜĮȚȠ. ǹʌȜȐ șĮ ıȘµİȚȫıȠȣµİ ȩĲȚ µȚĮ įȚİʌĮĳȒ ʌȡȠıįȚȠȡȓȗİȚ ĲȚȢ µİșȩįȠȣȢ ʌȠȣ İĳĮȡµȩȗİȚ µȓĮ țȜȐıȘ. Ȃİ ȐȜȜĮ ȜȩȖȚĮ įȘȜȫȞİȚ ĲȚ țȐȞȠȣȞ ıȣȖțİțȡȚµȑȞİȢ țȜȐıİȚȢ. ȂȚĮ įȚİʌĮĳȒ Įʌȩ µȩȞȘ ĲȘȢ įİȞ țȐȞİȚ ĲȓʌȠĲĮ. ǵȜȘ Ș įȡȐıȘ ĲȘȢ ʌȡĮȖµĮĲȠʌȠȚİȓĲĮȚ µȑıĮ ıĲȚȢ țȜȐıİȚȢ.

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

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

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

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

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

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

ȠȚ ĲȠʌȚțȑȢ µİĲĮȕȜȘĲȑȢ. ȉȑȜȠȢ ĲȠ ȣʌȩȜȠȚʌȠ ĲȘȢ µİșȩįȠȣ ʌİȡȚțȜİȓİĲĮȚ µȑıĮ ıİ ȐȖțȚıĲȡĮ ĲĮ ȠʌȠȓĮ ĲȠ țȐȞȠȣȞ ȑȞĮ ĮʌȜȩ µʌȜȠț. ȉȠ ĲµȒµĮ µȑıĮ ıĲĮ ȐȖțȚıĲȡĮ İȓȞĮȚ ȩʌȦȢ ȠȚ țȪȡȚİȢ µȑșȠįȠȚ. ȊʌȐȡȤȠȣȞ įȘȜȫıİȚȢ µİĲĮȕȜȘĲȫȞ, țȫįȚțĮȢ țĮȚ ĲȑȜȠȢ țȐĲȚ ȞȑȠ, µȓĮ įȒȜȦıȘ İʌȚıĲȡȠĳȒȢ, Ș ȠʌȠȓĮ ıĲȑȜȞİȚ µȚĮ ĲȚµȒ ʌȓıȦ ıĲȘȞ țĮȜȠȪıĮ µȑșȠįȠ. ȅ ĲȪʌȠȢ ĲȘȢ ĲȚµȒȢ ĮȣĲȒȢ ʌȡȑʌİȚ ȞĮ ıȣµĳȦȞİȓ µİ ĲȠȞ ĲȪʌȠ ʌȠȣ įȘȜȫșȘțİ ıĲȘ µȑșȠįȠ. ǹȞĮįȡȠµȚțȑȢ ȂȑșȠįȠȚ Ǿ Java ȣʌȠıĲȘȡȓȗİȚ ĲȚȢ ĮȞĮįȡȠµȚțȑȢ µİșȩįȠȣȢ. īȚĮ ʌĮȡȐįİȚȖµĮ, ĮȞ ȕȡȓıțİıĲİ ȒįȘ ıĲȘ µȑșȠįȠǹ() µʌȠȡİȓĲİ ȞĮ țĮȜȑıİĲİ ĲȘ µȑșȠįȠǹ(). ǵĲĮȞ ȖȡȐĳİĲİ ĮȞĮįȡȠµȚțȑȢ µİșȩįȠȣȢ ʌȡȑʌİȚ ȞĮ İȓıĲİ ʌȡȠıİțĲȚțȠȓ țĮȚ ȞĮ ıȣµʌİȡȚȜĮµȕȐȞİĲİ ıȣȞșȒțİȢ ĲİȡµĮĲȚıµȠȪ. ȆĮȡȩȜȠ ʌȠȣ Ș Java įİȞ șȑĲİȚ ȩȡȚĮ ȖȚĮ ĲȠ ȕȐșȠȢ µȚĮȢ İʌĮȞȐȜȘȥȘȢ İȓȞĮȚ ʌȚșĮȞȩȞ țȐĲȚ ĲȑĲȠȚȠ ȞĮ ȤȡȘıȚµȠʌȠȚȒıİȚ ȩȜȘ ĲȘ µȞȒµȘ ĲȠȣ ȣʌȠȜȠȖȚıĲȒ ıĮȢ. Ǿ ʌĮȡĮțȐĲȦ µȑșȠįȠȢ ȣʌȠȜȠȖȓȗİȚ µİ ĮȞĮįȡȠµȚțȩ ĲȡȩʌȠ ĲȠ ʌĮȡĮȖȠȞĲȚțȩ İȞȩȢ ĮțİȡĮȓȠȣ, ȤȡȘıȚµȠʌȠȚȫȞĲĮȢ ĲȠ ȖİȖȠȞȩȢ ȩĲȚ: 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) İȓȞĮȚ ȑȞĮȢ ĮʌȠĲİȜİıµĮĲȚțȩȢ ĲȡȩʌȠȢ ĮʌȠșȒțİȣıȘȢ ıȣȞȩȜȦȞ µİĲĮȕȜȘĲȫȞ. ǲȞĮȢ ʌȓȞĮțĮȢ İȓȞĮȚ ȑȞĮ ıȪȞȠȜȠ µİĲĮȕȜȘĲȫȞ ʌȠȣ µȠȚȡȐȗȠȞĲĮȚ ĲȠ ȓįȚȠ ȩȞȠµĮ țĮȚ ıȣȞĲȐııȠȞĲĮȚ µİ ĲȘ ıİȚȡȐ Įʌȩ ĲȠ 0 µȑȤȡȚ ĲȠ ʌȜȒșȠȢ ĲȦȞ µİĲĮȕȜȘĲȫȞ µİȚȦµȑȞȠ țĮĲȐ 1. ȅ ĮȡȚșµȩȢ ĲȦȞ µİĲĮȕȜȘĲȫȞ ʌȠȣ µʌȠȡİȓ ȞĮ ĮʌȠșȘțİȣĲİȓ ȠȞȠµȐȗİĲĮȚ įȚȐıĲĮıȘ ĲȠȣ ʌȓȞĮțĮ. ȀȐșİ µİĲĮȕȜȘĲȒ ȠȞȠµȐȗİĲĮȚ ıĲȠȚȤİȓȠ ĲȠȣ ʌȓȞĮțĮ. ǲȞĮȢ ʌȓȞĮțĮȢ µʌȠȡİȓ ȞĮ ʌĮȡĮıĲĮșİȓ ıĮȞ ıĲȒȜȘ įİįȠµȑȞȦȞ ȩʌȦȢ ʌȚȠ țȐĲȦ: I[0] I[1] I[2] I[3] I[4]

4 2 76 -90 6

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

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

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

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

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

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

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

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

ȅ ĲȡȩʌȠȢ ȖȚĮ ȞĮ ĮʌȠĳȪȖȠȣµİ ĲȠ ʌȡȫĲȠ ıȘµİȓȠ İȓȞĮȚ ĲȠ ʌĮȡȐįİȚȖµĮ ʌȠȣ ĮțȠȜȠȣșİȓ: float[] squares = new float[101]; for (int i=0, i < squares.length; i++) { squares[i] = i*i; } ȈȘµİȚȫıĲİ ȩĲȚ ĲȠ <= ȖȓȞİĲĮȚ <. ȈȣȞĲȠµİȪıİȚȢ ȆȚșĮȞȩȞ ȞĮ ĳĮȓȞİĲĮȚ įȪıțȠȜȘ ȣʌȩșİıȘ Ș įȒȜȦıȘ, Ƞ ȠȡȚıµȩȢ țĮȚ Ș ĮȡȤȚțȠʌȠȓȘıȘ İȞȩȢ ʌȓȞĮțĮ. ǵµȦȢ Ș Java ʌĮȡȑȤİȚ ʌȠȜȜȑȢ İȣțȠȜȓİȢ ȖȚĮ ĲȘ įȒȜȦıȘ, ĲȠȞ ȠȡȚıµȩ țĮȚ ĲȘȞ ĮȡȤȚțȠʌȠȓȘıȘ ʌȚȞȐțȦȞ. ȂʌȠȡȠȪµİ ȞĮ įȘȜȫıȠȣµİ țĮȚ ȞĮ ȠȡȓıȠȣµİ ȑȞĮȞ ʌȓȞĮțĮ ĲȘȞ ȓįȚĮ ıĲȚȖµȒ: int[] k = new int[3]; float[] yt = new float[7]; String[] names = new String[50]; ȂʌȠȡȠȪµİ ĮțȩµĮ ȞĮ įȘȜȫıȠȣµİ, ȞĮ ȠȡȓıȠȣµİ țĮȚ ȞĮ ĮȡȤȚțȠʌȠȚȒıȠȣµİ ȑȞĮȞ ʌȓȞĮțĮ ĲȘȞ ȓįȚĮ ıĲȚȖµȒ įȘµȚȠȣȡȖȫȞĲĮȢ µȚĮ ȜȓıĲĮ µİ ĲȚȢ ĮȡȤȚțȑȢ ĲȚµȑȢ µȑıĮ ıİ ĮȖțȪȜİȢ ȩʌȦȢ ʌȚȠ țȐĲȦ: int[] k = {1, 2, 3}; float[] yt = {0.0f, 1.2f, 3.4f, -9.87f, 65.4f, 0.0f, 567.9f}; ȆĮȡȐįİȚȖµĮ: ȉȠ ʌĮȡĮțȐĲȦ ʌȡȩȖȡĮµµĮ µİĲȡȐ ʌȩıİȢ ĳȠȡȑȢ İʌĮȞĮȜĮµȕȐȞȠȞĲĮȚ ĲĮ ȥȘĳȓĮ 0-9, ĮȞ țĮȜȑıȠȣµİ 1000000 ĳȠȡȑȢ ĲȘȞ ȖİȞȞȒĲȡȚĮ ĲȣȤĮȓȦȞ ĮȡȚșµȫȞ ĲȘȢ Java. ǹȞĮµȑȞȠȣµİ ȩĲȚ ĲĮ ȥȘĳȓĮ șĮ ʌȡȑʌİȚ ȞĮ İʌĮȞĮȜĮµȕȐȞȠȞĲĮȚ µİ ĲȘȞ ȓįȚĮ ʌİȡȓʌȠȣ ıȣȤȞȩĲȘĲĮ. ǹȣĲȩ șĮ ĲȠ įȠȪµİ įȘµȚȠȣȡȖȫȞĲĮȢ ȑȞĮȞ ʌȓȞĮțĮ Įʌȩ 10 ĮȡȚșµȠȪȢ long ʌȠȣ ȠȞȠµȐȗİĲĮȚ ndigit. ȈĲȠ µȘįİȞȚțȩ ıĲȠȚȤİȓȠ ĲȠȣ ndigit șĮ ĮʌȠșȘțİȪȠȣµİ ĲȠ ʌȜȒșȠȢ ĲȦȞ µȘįİȞȚțȫȞ, ıĲȠ ʌȡȫĲȠ ıĲȠȚȤİȓȠ ĲȠȣ ndigit șĮ ĮʌȠșȘțİȪȠȣµİ ĲȠ ʌȜȒșȠȢ ĲȦȞ ȐııȦȞ țĮȚ ȠȪĲȦ țĮșİȟȒȢ. 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; } ǹș. Ǽ. ȀȠȣĲıȠȞȚțȩȜĮȢ

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

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

}

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

} 2.12.2 ǻȚįȚȐıĲĮĲȠȚ ȆȓȞĮțİȢ ȅ ʌȚȠ ıȣȞȘșȚıµȑȞȠȢ ĲȪʌȠȢ ʌȠȜȣįȚȐıĲĮĲȠȣ ʌȓȞĮțĮ İȓȞĮȚ Ƞ įȚįȚȐıĲĮĲȠȢ. ǲȞĮȞ įȚįȚȐıĲĮĲȠ ʌȓȞĮțĮ µʌȠȡȠȪµİ ȞĮ ĲȠȞ ĳĮȞĲĮȗȩµĮıĲİ ȩʌȦȢ ʌĮȡĮțȐĲȦ: 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 ıĲȒȜİȢ, ʌȠȣ ĳȣıȚțȐ ȑȤİȚ ıȣȞȠȜȚțȐ 20 ıĲȠȚȤİȓĮ. ȆȡȑʌİȚ ȞĮ ȤȡȘıȚµȠʌȠȚȠȪµİ 2 įİȓțĲİȢ ȖȚĮ ȞĮ țĮșȠȡȓıȠȣµİ ĲȘ șȑıȘ İȞȩȢ ıĲȠȚȤİȓȠȣ ıİ ȑȞĮ įȚįȚȐıĲĮĲȠ ʌȓȞĮțĮ. ǹȣĲȠȓ ȠȚ įİȓțĲİȢ țĮșȠȡȓȗȠȣȞ ĲȘȞ ȖȡĮµµȒ țĮȚ ĲȘȞ ıĲȒȜȘ ʌȠȣ ȕȡȓıțİĲĮȚ ĲȠ ıĲȠȚȤİȓȠ. īȚĮ ʌĮȡȐįİȚȖµĮ ĮȞ Ƞ ʌĮȡĮʌȐȞȦ ʌȓȞĮțĮȢ ȜȑȖİĲĮȚ J ĲȩĲİ ĲȠ ıĲȠȚȤİȓȠ J[0][0] İȓȞĮȚ 0, ĲȠ J[0][1] İȓȞĮȚ 1, ĲȠ J[0][2] İȓȞĮȚ 2, ĲȠ J[0][3] İȓȞĮȚ 3, ĲȠ J[1][0] İȓȞĮȚ 1 ț.Ȝ.ʌ. ȅȚ įȚįȚȐıĲĮĲȠȚ ʌȓȞĮțİȢ įȘȜȫȞȠȞĲĮȚ, ȠȡȓȗȠȞĲĮȚ țĮȚ ĮȡȤȚțȠʌȠȚȠȪȞĲĮȚ ȩʌȦȢ țĮȚ ȠȚ µȠȞȠįȚȐıĲĮĲȠȚ ʌȓȞĮțİȢ. īȚ’ ĮȣĲȩ ʌȡȑʌİȚ ȞĮ țĮșȠȡȓȗȠȣµİ įȪȠ įȚĮıĲȐıİȚȢ ĮȞĲȓ ȖȚĮ µȓĮ țĮȚ ȖȚ’ ĮȣĲȩ ȤȡȘıȚµȠʌȠȚȠȪµİ įȪȠ ĳȦȜȚĮıµȑȞĮ for ȖȚĮ ȞĮ ȖİµȓıȠȣµİ ĲȠȞ ʌȓȞĮțĮ. ȈĲȠ ʌĮȡĮțȐĲȦ ʌĮȡȐįİȚȖµĮ Ƞ ʌȓȞĮțĮȢ Ȃ ȖİµȓȗİĲĮȚ ȦȢ İȟȒȢ: Ș ĲȚµȒ ĲȠȣ țȐșİ ıĲȠȚȤİȓȠȣ ĲȠȣ İȓȞĮȚ ȓıȘ µİ ĲȠ ȐșȡȠȚıµĮ ĲȦȞ įİȚțĲȫȞ ĲȘȢ ȖȡĮµµȒȢ țĮȚ ĲȘȢ ıĲȒȜȘȢ ĮȣĲȠȪ ĲȠȣ ıĲȠȚȤİȓȠȣ. 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; } } } ȈĲȠȣȢ įȚįȚȐıĲĮĲȠȣȢ ʌȓȞĮțİȢ ĲȠ ȜȐșȠȢ ArrayIndexOutOfBounds ıȣµȕĮȓȞİȚ ȩĲĮȞ ȣʌİȡȕĮȓȞȠȣµİ ĲȠ µȑȖȚıĲȠ įİȓțĲȘ ȖȡĮµµȒȢ Ȓ ıĲȒȜȘȢ.

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

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

2.12.3 ȆȠȜȣįȚȐıĲĮĲȠȚ ȆȓȞĮțİȢ Ǿ Java µĮȢ İʌȚĲȡȑʌİȚ ȞĮ ȑȤȠȣµİ ʌȓȞĮțİȢ ĲȡȚȫȞ, ĲİııȐȡȦȞ Ȓ țĮȚ ʌİȡȚııȩĲİȡȦȞ įȚĮıĲȐıİȦȞ. ǼȓȞĮȚ ʌȠȜȪ ʌȚșĮȞȩ ĮȞ ȤȡİȚȐȗİıĲİ ȑȞĮȞ ʌȓȞĮțĮ µİ ʌİȡȚııȩĲİȡİȢ Įʌȩ 3 įȚĮıĲȐıİȚȢ ȞĮ ȤȡȘıȚµȠʌȠȚȒıİĲİ ȜĮȞșĮıµȑȞȘ įȠµȒ įİįȠµȑȞȦȞ. ǹțȩµĮ țĮȚ ȠȚ ĲȡȚıįȚȐıĲĮĲȠȚ ʌȓȞĮțİȢ İȓȞĮȚ ıʌȐȞȚȠȚ ȑȟȦ Įʌȩ ĲȚȢ İʌȚıĲȘµȠȞȚțȑȢ țĮȚ µȘȤĮȞȚțȑȢ İĳĮȡµȠȖȑȢ. Ǿ ıȪȞĲĮȟȘ ȖȚĮ ĲȠȣȢ ĲȡȚıįȚȐıĲĮĲȠȣȢ ʌȓȞĮțİȢ İȓȞĮȚ µȚĮ İʌȑțĲĮıȘ ĮȣĲȒȢ ʌȠȣ ȤȡȘıȚµȠʌȠȚȒıĮµİ ıĲȠȣȢ įȚįȚȐıĲĮĲȠȣȢ. ǹțȠȜȠȣșİȓ ȑȞĮ ʌȡȩȖȡĮµµĮ ʌȠȣ įȘȜȫȞİȚ, ȠȡȓȗİȚ țĮȚ ĮȡȤȚțȠʌȠȚİȓ ȑȞĮȞ ĲȡȚıįȚȐıĲĮĲȠ ʌȓȞĮțĮ: 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 ǹȞĮȗȒĲȘıȘ ǼȓȞĮȚ ʌȠȜȪ ıȣȞȘșȚıµȑȞȠ ȞĮ ȥȐȤȞȠȣµİ ı’ ȑȞĮȞ ʌȓȞĮțĮ µȚĮ ıȣȖțİțȡȚµȑȞȘ ĲȚµȒ. ȂİȡȚțȑȢ ĳȠȡȑȢ ĮȣĲȒ Ș ĲȚµȒ İȓȞĮȚ ȖȞȦıĲȒ İț ĲȦȞ ʌȡȠĲȑȡȦȞ. ǱȜȜİȢ ĳȠȡȑȢ ĮȞĮȗȘĲȐµİ ĲȠ µȚțȡȩĲİȡȠ Ȓ ĲȠ µİȖĮȜȪĲİȡȠ ıĲȠȚȤİȓȠ. ǼțĲȩȢ Įʌȩ ĲȘȞ ʌİȡȓʌĲȦıȘ ʌȠȣ ȟȑȡȠȣµİ țȐĲȚ ȖȚĮ ĲȠ ʌİȡȚİȤȩµİȞȠ İȞȩȢ ʌȓȞĮțĮ, ıİ ȩȜİȢ ĲȚȢ ȐȜȜİȢ ʌİȡȚʌĲȫıİȚȢ Ƞ ĮȜȖȩȡȚșµȠȢ ĮȞĮȗȒĲȘıȘȢ İȞȩȢ ʌȓȞĮțĮ İȓȞĮȚ Ș ȖȡĮµµȚțȒ ĮȞĮȗȒĲȘıȘ. ȋȡȘıȚµȠʌȠȚȠȪµİ ȑȞĮȞ ȕȡȩȤȠ for țĮȚ İȜȑȖȤȠȣµİ țȐșİ ıĲȠȚȤİȓȠ ĲȠȣ ʌȓȞĮțĮ µȑȤȡȚ ȞĮ ȕȡȠȪµİ ĲȠ ıĲȠȚȤİȓȠ ʌȠȣ șȑȜȠȣµİ. ǹțȠȜȠȣșİȓ µȚĮ ĮʌȜȒ µȑșȠįȠȢ ʌȠȣ ĲȣʌȫȞİȚ ĲȠ µİȖĮȜȪĲİȡȠ țĮȚ ĲȠ µȚțȡȩĲİȡȠ ıĲȠȚȤİȓȠ İȞȩȢ ʌȓȞĮțĮ. 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 ȉĮȟȚȞȩµȘıȘ ǵȜȠȚ ȠȚ ĮȜȖȩȡȚșµȠȚ ĲĮȟȚȞȩµȘıȘȢ ȕĮıȓȗȠȞĲĮȚ ıİ įȪȠ șİµİȜȚȫįİȚȢ ȜİȚĲȠȣȡȖȓİȢ: ĲȘ ıȪȖțȡȚıȘ țĮȚ ĲȘȞ ĮȞĲȚµİĲȐșİıȘ (swapping). Ǿ ıȪȖțȡȚıȘ İȓȞĮȚ ĮʌȜȒ. Ǿ ĮȞĲȚµİĲȐșİıȘ İȓȞĮȚ ȜȓȖȠ ʌȚȠ ʌȠȜȪʌȜȠțȘ. ĬİȦȡİȓıĲİ ĲȠ ĮțȩȜȠȣșȠ ʌȡȩȕȜȘµĮ: șȑȜȠȣµİ ȞĮ ĮȞĲȚµİĲĮșȑıȠȣµİ ĲȚȢ ĲȚµȑȢ ĲȦȞ µİĲĮȕȜȘĲȫȞ a țĮȚ b. ȅȚ ʌȚȠ ʌȠȜȜȠȓ șĮ ʌȡȩĲİȚȞĮȞ µȚĮ ȜȪıȘ ıĮȞ ĲȘȞ ĮțȩȜȠȣșȘ: ǹș. Ǽ. ȀȠȣĲıȠȞȚțȩȜĮȢ

ȂĮșȒµĮĲĮ 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);

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

= = = =

1 2 2 2

ǻİȞ ʌİȡȚµȑȞĮµİ ȩµȦȢ ĮȣĲȩ! ȉȠ ʌȡȩȕȜȘµĮ İȓȞĮȚ ȩĲȚ ȤȐıĮµİ ĲȘȞ ĲȚµȒ 1 țĮșȫȢ ȕȐȜĮµİ ĲȘȞ ĲȚµȒ ĲȠȣ b ıĲȠ a. īȚĮ ȞĮ įȚȠȡșȦșİȓ ĮȣĲȩ ʌȡȑʌİȚ ȞĮ İȚıȐȖȠȣµİ µȚĮ ĲȡȓĲȘ µİĲĮȕȜȘĲȒ, ĲȘȞ temp, Ș ȠʌȠȓĮ șĮ țȡĮĲȐİȚ ĲȘȞ ĮȡȤȚțȒ ĲȚµȒ ĲȠȣ 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ȣĲȩȢ Ƞ țȫįȚțĮȢ ʌĮȡȐȖİȚ ĲȠ ĮʌȠĲȑȜİıµĮ ʌȠȣ ʌİȡȚµȑȞĮµİ. a b a b

= = = =

1 2 2 1

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

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

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

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

}

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

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

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

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

thread

"main"

ǹȣĲȩ ʌȠȣ ıȣȞȑȕĮȚȞİ ȒĲĮȞ ȩĲȚ Įʌȩ ĲȘ ıĲȚȖµȒ ʌȠȣ įİȞ įȓȞĮµİ ıĲȠ Ǿello țĮȞȑȞĮ ȩȡȚıµĮ ȖȡĮµµȒȢ İȞĲȠȜȫȞ, įİȞ ȣʌȒȡȤİ ĲȓʌȠĲĮ ıĲȠ args[0]. īȚ’ ĮȣĲȩ țĮȚ Ș Java ȑȕȖĮȗİ ĲȠ ʌĮȡĮʌȐȞȦ µȒȞȣµĮ ȜȐșȠȣȢ. ȆȡȠȘȖȠȣµȑȞȦȢ İȓȤĮµİ įȚȠȡșȫıİȚ ĮȣĲȩ ĲȠ ʌȡȩȕȜȘµĮ İȜȑȖȤȠȞĲĮȢ ĲȠ µȒțȠȢ ĲȠȣ ʌȓȞĮțĮ ʌȡȠĲȠȪ ʌȡȠıʌĮșȒıȠȣµİ ȞĮ ʌȡȠıʌİȜȐıȠȣµİ ĲȠ ʌȡȫĲȠ ĲȠȣ ıĲȠȚȤİȓȠ. Ǿ ȜȪıȘ ȒĲĮȞ țĮȜȒ ȖȚĮ µȚĮ ĮʌȜȒ ʌİȡȓʌĲȦıȘ. ǹȞ ȩµȦȢ ȑʌȡİʌİ ȞĮ İȜȑȖȤȠȣµİ ȖȚĮ țȐșİ ʌȚșĮȞȒ ȜĮȞșĮıµȑȞȘ ıȣȞșȒțȘ ıİ țȐșİ ȖȡĮµµȒ ĲȠȣ țȫįȚțĮ, ĲȩĲİ Ƞ țȫįȚțĮȢ șĮ İȓȤİ ʌİȡȚııȩĲİȡȠȣȢ İȜȑȖȤȠȣȢ ȜĮșȫȞ ʌĮȡȐ țĮșĮȣĲȫ țȫįȚțĮ. ǼʌȚʌȜȑȠȞ șĮ ȑʌȡİʌİ ȞĮ ĮȡȤȓıİĲİ ȞĮ İȜȑȖȤİĲİ ȖȚĮ ȜȐșȘ ıĲȚȢ ıȣȞșȒțİȢ ȜĮșȫȞ. ȅȚ İȟĮȚȡȑıİȚȢ "İțʌȑµʌȠȞĲĮȚ" Įʌȩ ĲȠ ıȪıĲȘµĮ İțĲȑȜİıȘȢ, ȩĲĮȞ ĮȣĲȩ įİȞ ȖȞȦȡȓȗİȚ ʌȫȢ ȞĮ ȤİȚȡȚıĲİȓ µȓĮ țĮĲȐıĲĮıȘ. ȂȓĮ ıȣȤȞȒ ʌİȡȓʌĲȦıȘ İȟĮȓȡİıȘȢ İȓȞĮȚ ȩĲĮȞ ʌȡȠıʌĮșȠȪµİ ȞĮ įȚĮȚȡȑıȠȣµİ µȓĮ ʌĮȡȐıĲĮıȘ µİ ĲȠ µȘįȑȞ. ȈĲȩȤȠȢ ĲȠȣ ȤİȚȡȚıµȠȪ ĲȦȞ İȟĮȚȡȑıİȦȞ İȓȞĮȚ ȞĮ ʌȡȠıįȚȠȡȓıȠȣµİ ĲȘȞ țĮȞȠȞȚțȒ ȡȠȒ ĲȠȣ ʌȡȠȖȡȐµµĮĲȠȢ ıİ ĲµȒµĮ ĲȠȣ țȫįȚțĮ, ȤȦȡȓȢ ȞĮ ĮȞȘıȣȤȠȪµİ ȖȚĮ ȩȜİȢ ĲȚȢ İȚįȚțȑȢ ʌİȡȚʌĲȫıİȚȢ. ǲʌİȚĲĮ, ı’ ȑȞĮ ȟİȤȦȡȚıĲȩ µʌȜȠț ĲȠȣ țȫįȚțĮ, șĮ țĮȜȪȥȠȣµİ ĲȚȢ ʌİȡȚʌĲȫıİȚȢ ĲȦȞ İȟĮȚȡȑıİȦȞ. ǲĲıȚ ʌĮȡȐȖȠȣµİ ʌİȡȚııȩĲİȡȠ İȣĮȞȐȖȞȦıĲȠ țȫįȚțĮ ĮĳȠȪ įİȞ ȤȡİȚȐȗİĲĮȚ ȞĮ įȚĮțȩʌĲȠȣµİ ĲȘ ȡȠȒ ĲȠȣ ĮȜȖȩȡȚșµȠȣ ȖȚĮ ȞĮ İȜȑȖȟȠȣµİ țĮȚ ȞĮ ĮȞĲĮʌȠțȡȚșȠȪµİ ıİ țȐșİ ʌİȡȓİȡȖȘ țĮĲȐıĲĮıȘ. ȉȠ ʌİȡȚȕȐȜȜȠȞ İțĲȑȜİıȘȢ İȓȞĮȚ ȣʌİȪșȣȞȠ ȖȚĮ ĲȘ µİĲĮțȓȞȘıȘ Įʌȩ ĲȘȞ țĮȞȠȞȚțȒ ȡȠȒ ĲȠȣ ʌȡȠȖȡȐµµĮĲȠȢ ıĲȠȣȢ ȤİȚȡȚıĲȑȢ İȟĮȚȡȑıİȦȞ, ȩĲĮȞ ʌȡȠțȪʌĲİȚ µȚĮ ĲȑĲȠȚĮ ıȣȞșȒțȘ. ȅ ȤİȚȡȚıµȩȢ ĲȦȞ İȟĮȚȡȑıİȦȞ, ȣȜȠʌȠȚİȓĲĮȚ µİ ĲȚȢ İȞĲȠȜȑȢ try țĮȚ catch. ȅȚ İȞĲȠȜȑȢ ĮȣĲȑȢ țĮșȠȡȓȗȠȣȞ ĲµȒµĮĲĮ ĲȠȣ țȫįȚțĮ ĲĮ ȠʌȠȓĮ ȣʌĮȖȠȡİȪȠȣȞ ʌȦȢ șĮ ȖȓȞİȚ Ƞ ȤİȚȡȚıµȩȢ µȚĮȢ İȟĮȓȡİıȘȢ. ȈĲȘȞ ȠȣıȓĮ, țĮșȠȡȓȗȠȣµİ ȑȞĮ ĲµȒµĮ țȫįȚțĮ ʌȠȣ șĮ ʌȡȠıʌĮșȒıİȚ (try) țĮȚ ıĲȘ ıȣȞȑȤİȚĮ șĮ ʌȚȐıİȚ (catch) țȐșİ İȟĮȓȡİıȘ ʌȠȣ șĮ ʌȡȠțȜȘșİȓ. ǹțȠȜȠȣșİȓ ȑȞĮ ʌĮȡȐįİȚȖµĮ ȤİȚȡȚıµȠȪ İȟĮȚȡȑıİȦȞ ȖȚĮ ĲȠ ʌĮȡĮʌȐȞȦ ʌȡȩȖȡĮµµĮ: // ȆȡȩȖȡĮµµĮ 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"); } } } ǵĲĮȞ įȘµȚȠȣȡȖİȓĲĮȚ µȓĮ İȟĮȓȡİıȘ, ĲȠ ıȪıĲȘµĮ İțĲȑȜİıȘȢ țȠȚĲȐȗİȚ ȖȚĮ İȞĲȠȜȑȢ catch ʌȠȣ µʌȠȡȠȪȞ ȞĮ ĲȘȞ ȤİȚȡȚıĲȠȪȞ. KȐʌȠȚİȢ İȟĮȚȡȑıİȚȢ İȓȞĮȚ įȣȞĮĲȩȞ ȞĮ ĲȚȢ ĮȞĲȚȜȘĳșȠȪµİ țĮȚ ȞĮ ĲȚȢ ȤİȚȡȚıĲȠȪµİ, İȞȫ țȐʌȠȚİȢ ȐȜȜİȢ İȓȞĮȚ ĲȩıȠ įȪıțȠȜİȢ ʌȠȣ ĲȠ ıȪıĲȘµĮ İțĲȑȜİıȘȢ ʌĮȡĮȚĲİȓĲĮȚ. Ǿ µİĲĮȕȜȘĲȒ e, ʌȠȣ ȣʌȐȡȤİȚ ıĲȠ catch, ʌİȡȚȑȤİȚ ĲȠ µȒȞȣµĮ ȜȐșȠȣȢ ʌȠȣ ıȣȞȑȕȘ țĮȚ µʌȠȡȠȪµİ ȞĮ ĲȠ ĲȣʌȫıȠȣµİ, ĮȞ șȑȜȠȣµİ, µİ ĲȘȞ ʌĮȡĮțȐĲȦ İȞĲȠȜȒ: System.out.println("Error: " + e);

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

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

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

ȞĮ

įȚĮȕȐıȦ

ĲȠ

ȩȞȠµȐ

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

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

} catch (Exception e) { return -1; } } īȡȐĳȠȞĲĮȢ ıİ ȑȞĮ ǹȡȤİȓȠ ȀİȚµȑȞȠȣ ȀȐʌȠȚİȢ ĳȠȡȑȢ ĮȞĲȓ ĲĮ įİįȠµȑȞĮ ȞĮ İțĲȣʌȫȞȠȞĲĮȚ ıĲȘ ȠșȩȞȘ, ȞĮ ĮʌȠșȘțİȪȠȞĲĮȚ ıİ ȑȞĮ ĮȡȤİȓȠ țİȚµȑȞȠȣ. īȚĮ ȞĮ ĲȠ țȐȞȠȣµİ ĮȣĲȩ ʌȡȑʌİȚ ȞĮ µȐșȠȣµİ ʌȫȢ ȞĮ ȖȡȐĳȠȣµİ įİįȠµȑȞĮ ı’ ȑȞĮ ĮȡȤİȓȠ. ǹȞĲȓ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ȑȞĮ țĮȚȞȠȪȡȚȠ ʌȡȩȖȡĮµµĮ șĮ ĲȡȠʌȠʌȠȚȒıȠȣµİ ĲȠ FahrȉȠCelsius, ʌȠȣ İȓįĮµİ ıĲȘȞ § 2.8. // īȡȐȥȚµȠ ĲȠȣ ʌȓȞĮțĮ Fahrenheit-Celsius ıİ ĮȡȤİȓȠ import java.io.*; class FahrToCelsius { public static void main (String args[]) { double fahr, celsius; double lower, upper, step; lower = 0.0; // țȐĲȦ ȩȡȚȠ ĲȠȣ ʌȓȞĮțĮ șİȡµȠțȡĮıȚȫȞ upper = 300.0; // ʌȐȞȦ ȩȡȚȠ ĲȠȣ ʌȓȞĮțĮ șİȡµȠțȡĮıȚȫȞ 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 ĮʌĮȡĮȓĲȘĲİȢ ıȣȞșȒțİȢ ȖȚĮ ȞĮ ȖȡȐȥȠȣµİ µȠȡĳȠʌȠȚȘµȑȞȘ ȑȟȠįȠ ıİ ȑȞĮ ĮȡȤİȓȠ: 1. ǹȞȠȓȟĲİ ȑȞĮ FileOutputStream ȤȡȘıȚµȠʌȠȚȫȞĲĮȢ µȓĮ ȖȡĮµµȒ ȩʌȦȢ ʌĮȡĮțȐĲȦ: FileOutputStream fout =

new FileOutputStream("test.out");

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

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

ǻȚĮȕȐȗȠȞĲĮȢ Įʌȩ ȑȞĮ ǹȡȤİȓȠ ȀİȚµȑȞȠȣ ȉȫȡĮ ʌȠȣ ȟȑȡȠȣµİ ʌȫȢ ȞĮ ȖȡȐȥȠȣµİ ȑȞĮ ĮȡȤİȓȠ țİȚµȑȞȠȣ ĮȢ ʌȡȠıʌĮșȒıȠȣµİ ȞĮ įȚĮȕȐıȠȣµİ ȑȞĮ. ȅ ʌĮȡĮțȐĲȦ țȫįȚțĮȢ ʌȡȠıȠµȠȚȐȗİȚ ĲȘȞ İȞĲȠȜȒ Type ĲȠȣ DOS. ǻȑȤİĲĮȚ µȚĮ ıİȚȡȐ Įʌȩ ȠȞȩµĮĲĮ ĮȡȤİȓȦȞ ıĲȘ ȖȡĮµµȒ İȞĲȠȜȫȞ țĮȚ µİĲȐ ĲȣʌȫȞİȚ ĲĮ ʌİȡȚİȤȩµİȞĮ ĲȦȞ ĮȡȤİȓȦȞ ĮȣĲȫȞ ıĲȘȞ ȠșȩȞȘ. // ʌȡȠıȠµȠȚȐȗİȚ ĲȘȞ İȞĲȠȜȒ Type ĲȠȣ DOS import java.io.*; class cat { public static void main (String args[]) { String thisLine; // īȚĮ ȩȜĮ ĲĮ ȠȡȓıµĮĲĮ ĲȘȢ ȖȡĮµµȒȢ İȞĲȠȜȫȞ for (int i=0; i < args.length; i++) { // ǱȞȠȚȖµĮ ĲȠȣ ĮȡȤİȓȠȣ ȖȚĮ įȚȐȕĮıµĮ try { FileInputStream fin = new FileInputStream(args[i]); // µİĲĮĲȡȠʌȒ ĲȠȣ 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) ȅȚ µȚțȡȠİĳĮȡµȠȖȑȢ (applets), İȓȞĮȚ ʌȡȠȖȡȐµµĮĲĮ ʌȠȣ ȖȡȐĳȠȞĲĮȚ ıİ Java țĮȚ İȞıȦµĮĲȩȞȠȞĲĮȚ ıİ ȚıĲȠıİȜȓįİȢ. īȚĮ ĲȘȞ țȦįȚțȠʌȠȓȘıȒ ĲȠȣ, ȤȡȘıȚµȠʌȠȚİȓĲĮȚ ʌȡȠȖȡĮµµĮĲȚıµȩȢ țĮșȠįȘȖȠȪµİȞȠȢ Įʌȩ ȖİȖȠȞȩĲĮ (event driven). Ȉ’ ĮȣĲȩȞ ĲȠȞ ĲȪʌȠ ʌȡȠȖȡĮµµĮĲȚıµȠȪ, Ș ȜȠȖȚțȒ ĲȠȣ ʌȡȠȖȡȐµµĮĲȠȢ įİȞ ȡȑİȚ Įʌȩ ĲȘȞ țȠȡȣĳȒ ıĲȘ ȕȐıȘ ĲȠȣ ʌȡȠȖȡȐµµĮĲȠȢ ȩʌȦȢ ıĲȠȣȢ ʌȚȠ įȚĮįȚțĮıĲȚțȠȪȢ țȫįȚțİȢ. ȉȠ ȜİȚĲȠȣȡȖȚțȩ ıȪıĲȘµĮ ıȣȜȜȑȖİȚ ĲĮ ȖİȖȠȞȩĲĮ (ȑȞĮ ȖİȖȠȞȩȢ µʌȠȡİȓ ʌ.Ȥ. ȞĮ İȓȞĮȚ ĲȠ ʌȐĲȘµĮ ĲȠȣ ʌȠȞĲȚțȚȠȪ ıȑȞĮ ıȘµİȓȠ ĲȘȢ ȠșȩȞȘȢ) țĮȚ ĲȠ ʌȡȩȖȡĮµµĮ ĮȞĲĮʌȠțȡȓȞİĲĮȚ ı’ ĮȣĲȐ. ȀȐșİ ʌȡȩȖȡĮµµĮ ȑȤİȚ ȑȞĮ ȕȡȩȤȠ ȖİȖȠȞȩĲȦȞ (event loop). ǹȣĲȩȢ İȓȞĮȚ ȑȞĮȢ ȕȡȩȤȠȢ while ʌȠȣ įȠȣȜİȪİȚ ĮıĲĮµȐĲȘĲĮ. Ȉİ țȐșİ ʌȑȡĮıµĮ µȑıĮ Įʌȩ ĲȠ ȕȡȩȤȠ, Ș İĳĮȡµȠȖȒ ĮȞĮțĲȐ ĲȠ İʌȩµİȞȠ ȖİȖȠȞȩȢ Įʌȩ ĲȘ ıİȚȡȐ ȖİȖȠȞȩĲȦȞ țĮȚ ĮȞĲĮʌȠțȡȓȞİĲĮȚ ĮȞȐȜȠȖĮ. ǹș. Ǽ. ȀȠȣĲıȠȞȚțȩȜĮȢ

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

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

3.1 Ǿ ȆȡȫĲȘ ȂȚțȡȠİĳĮȡµȠȖȒ (Applet) Ǿ ʌĮȡĮțȐĲȦ µȚțȡȠİĳĮȡµȠȖȒ, İȓȞĮȚ ĮȞĲȓıĲȠȚȤȘ ĲȠȣ ʌȡȠȖȡȐµµĮĲȠȢ HelloWorld, ʌȠȣ İȓįĮµİ ıĲȘȞ § 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); } } ȆȜȘțĲȡȠȜȠȖȒıĲİ ĲȠȞ țȫįȚțĮ țĮȚ ıȫıĲİ ĲȠ ı’ ȑȞĮ ĮȡȤİȓȠ µİ ȩȞȠµĮ HelloWorldApplet.java. ȂİĲĮȖȜȦĲĲȓıĲİ ĲȠ ʌȡȩȖȡĮµµĮ ʌȜȘțĲȡȠȜȠȖȫȞĲĮȢ: javac HelloWorldApplet.java ıĲȘȞ ȖȡĮµµȒ İȞĲȠȜȫȞ ĲȠȣ DOS. ǹȞ ȩȜĮ ʌȐȞİ țĮȜȐ șĮ įȘµȚȠȣȡȖȘșİȓ ȑȞĮ ĮȡȤİȓȠ µİ ĲȠ ȩȞȠµĮ HelloWorldApplet.class. ȉȫȡĮ ʌȡȑʌİȚ ȞĮ įȘµȚȠȣȡȖȒıİĲİ ȑȞĮ ĮȡȤİȓȠ HTML ʌȠȣ șĮ ıȣµʌİȡȚȜĮµȕȐȞİȚ ĲȘȞ µȚțȡȠİĳĮȡµȠȖȒ ıĮȢ. ǹțȠȜȠȣșİȓ ĲȠ ĮʌȜȩ ĮȡȤİȓȠ HTML. <HTML> <HEAD> <TITLE> Hello World </TITLE> </HEAD> <BODY> ǹȣĲȩ İȓȞĮȚ ĲȠ ʌȡȫĲȠ µȠȣ applet:<P> <APPLET CODE="HelloWorldApplet.class" WIDTH=200 HEIGHT=200> </APPLET> </BODY> </HTML> ȈȫıĲİ ĮȣĲȩ ĲȠ ĮȡȤİȓȠ ȦȢ HelloWorldApplet.html ıĲȠȞ ȓįȚȠ țĮĲȐȜȠȖȠ ʌȠȣ ȣʌȐȡȤİȚ țĮȚ ĲȠ HelloWorldApplet.class. ȈĲȘ ıȣȞȑȤİȚĮ ĮȞȠȓȟĲİ ĲȠȞ ĳȣȜȜȠµİĲȡȘĲȒ țĮȚ ĳȠȡĲȫıĲİ ĲȠ ĮȡȤİȓȠ HTML. ĬĮ ʌȡȑʌİȚ ȞĮ įİȓĲİ țȐĲȚ ıĮȞ ĲȠ ĮțȩȜȠȣșȠ: ǹȣĲȩ İȓȞĮȚ ĲȠ ʌȡȫĲȠ µȠȣ applet: Hello World! ǼȟİĲȐȗȠȞĲĮȢ ĲȠ applet HelloWorldApplet ȉȠ HelloWorldApplet, ıİ ıȤȑıȘ µİ ĲȠ ʌȡȩȖȡȐµµĮ HelloWorld, ʌȠȣ İȓįĮµİ ıĲȘȞ § 2.1, ȑȤİȚ țȐʌȠȚİȢ įȚĮĳȠȡȑȢ. ȄİțȚȞȫȞĲĮȢ Įʌȩ ʌȐȞȦ ʌȡȠȢ ĲĮ țȐĲȦ, ĲȠ ʌȡȫĲȠ ʌȡȐȖµĮ ʌȠȣ ʌȡȠıȑȤȠȣµİ İȓȞĮȚ ȠȚ įȪȠ ȖȡĮµµȑȢ: import java.applet.Applet; import java.awt.Graphics; Ǿ įȒȜȦıȘ import ıĲȘ Java İȓȞĮȚ ʌĮȡȩµȠȚĮ µİ ĲȘ įȒȜȦıȘ #include ıĲȘȞ C Ȓ ıĲȘȞ C++. ǼȚıȐȖİȚ ĲȚȢ țȜȐıİȚȢ ʌȠȣ ʌİȡȚȑȤȠȞĲĮȚ ı’ ȑȞĮ ʌĮțȑĲȠ țȐʌȠȣ ĮȜȜȠȪ. ǲȞĮ ʌĮțȑĲȠ İȓȞĮȚ ȑȞĮ ıȪȞȠȜȠ Įʌȩ ıȤİĲȚȗȩµİȞİȢ țȜȐıİȚȢ. Ȉ’ ĮȣĲȒȞ ĲȘȞ ʌİȡȓʌĲȦıȘ ȗȘĲȐµİ ʌȡȩıȕĮıȘ ıĲȚȢ țȜȐıİȚȢ ʌȠȣ ıȣµʌİȡȚȜĮµȕȐȞȠȞĲĮȚ ıĲȠ java.applet.Applet țĮȚ java.awt.Graphics. Ǿ İʌȩµİȞȘ įȚĮĳȠȡȐ ʌȠȣ ʌĮȡĮĲȘȡȠȪµİ İȓȞĮȚ Ƞ ȠȡȚıµȩȢ ĲȘȢ țȜȐıȘȢ: public class HelloWorldApplet extends Applet Ǿ ȜȑȟȘ țȜİȚįȓ extends ȣʌȠȞȠİȓ ȩĲȚ ĮȣĲȒ Ș țȜȐıȘ İȓȞĮȚ µȚĮ ȣʌȠțȜȐıȘ ĲȘȢ țȜȐıȘȢ Applet. ǳ ǹș. Ǽ. ȀȠȣĲıȠȞȚțȩȜĮȢ

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3.4 ȆȑȡĮıµĮ ȆĮȡĮµȑĲȡȦȞ ıĲȚȢ ȂȚțȡȠİĳĮȡµȠȖȑȢ Ǿ ʌİȡȚȠȤȒ ĮȞȐµİıĮ ıĲȠ ȐȞȠȚȖµĮ țĮȚ ĲȠ țȜİȓıȚµȠ ĲȘȢ İĲȚțȑĲĮȢ <APPLET> ȤȡȘıȚµȠʌȠȚİȓĲĮȚ, İʌȓıȘȢ, ȖȚĮ ȞĮ ʌİȡĮıĲȠȪȞ ʌĮȡȐµİĲȡȠȚ ıĲĮ applets. ǹȣĲȩ İʌȚĲȣȖȤȐȞİĲĮȚ µİ ĲȘ ȤȡȒıȘ ĲȘȢ İĲȚțȑĲĮȢ PARAM ĲȘȢ HTML țĮȚ ĲȘȢ µİșȩįȠȣ getParameter. īȚĮ ȞĮ ĲȠ įİȓȟȠȣµİ ĮȣĲȩ șĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ ĲȠ HelloWorldApplet ıİ µȚĮ ȖİȞȚțȐ ıȤİįȚĮıµȑȞȘ İĳĮȡµȠȖȒ. īȚĮ ȞĮ ĲȠ țȐȞȠȣµİ ĮȣĲȩ șĮ ʌİȡȐıȠȣµİ ıĲȠ applet, ȦȢ ʌĮȡȐµİĲȡȠ, ĲȠ ĮȜĳĮȡȚșµȘĲȚțȩ ʌȠȣ șĮ ĲȣʌȫȞİĲĮȚ. 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 ĮȡȤİȓȠ ʌȠȣ șĮ ʌİȡȚȜĮµȕȐȞİȚ ĲȠ applet, ȦȢ İȟȒȢ: <HTML> <HEAD> <TITLE> Draw String </TITLE> </HEAD> <BODY> ǹȣĲȩ İȓȞĮȚ ĲȠ applet:<P> <APPLET code="DrawStringApplet.class" width=200 height=200> <PARAM name="String" value="Good morning, there!"> </APPLET> </BODY> </HTML> ĭȣıȚțȐ İȓµĮıĲİ İȜİȪșİȡȠȚ ȞĮ ĮȜȜȐȟȠȣµİ ĲȠ ‘Good morning, there!’ µİ ȑȞĮ ĮȜĳĮȡȚșµȘĲȚțȩ ĲȘȢ İʌȚȜȠȖȒȢ µĮȢ. ȈȘµİȚȫıĲİ ȩĲȚ ĮȣĲȩ µĮȢ İʌȚĲȡȑʌİȚ ȞĮ ĮȜȜȐȟȠȣµİ ĲȘȞ ȑȟȠįȠ ĲȠȣ applet ȤȦȡȓȢ ȞĮ ǹș. Ǽ. ȀȠȣĲıȠȞȚțȩȜĮȢ

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

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

3.5 īİȖȠȞȩĲĮ (events) țĮȚ ȂȚțȡȠİĳĮȡµȠȖȑȢ ȉȠ ĮțȩȜȠȣșȠ applet İȓȞĮȚ ıȤİįȚĮıµȑȞȠ ȖȚĮ ȞĮ ıĮȢ įȫıİȚ țȐʌȠȚĮ ĮȓıșȘıȘ ȖȚĮ ĲȠ ĲȚ İȓȞĮȚ ʌȡȠȖȡĮµµĮĲȚıµȩȢ țĮșȠįȘȖȠȪµİȞȠȢ Įʌȩ ȖİȖȠȞȩĲĮ țĮȚ ʌȠȚĮ İȓȞĮȚ ĲĮ įȚȐĳȠȡĮ ȖİȖȠȞȩĲĮ ʌȠȣ ʌȚșĮȞȩȞ șĮ ıȣȞĮȞĲȒıİĲİ. ǵĲĮȞ ıȣµȕĮȓȞİȚ ȑȞĮ ȖİȖȠȞȩȢ ĲȠ applet ĮȞĲĮʌȠțȡȓȞİĲĮȚ ʌȡȠıĮȡĲȫȞĲĮȢ ĲȠ ȩȞȠµĮ ĲȠȣ ȖİȖȠȞȩĲȠȢ ıİ µȓĮ ȜȓıĲĮ. ȂȚĮ ȜȓıĲĮ (List) İȓȞĮȚ µȚĮ țȣȜȚȩµİȞȘ ıİȚȡȐ Įʌȩ ĮȜĳĮȡȚșµȘĲȚțȐ ʌȠȣ ȠȡȓȗİĲĮȚ ıĲȠ java.awt.List. ĬĮ įȘµȚȠȣȡȖȒıȠȣµİ µȚĮ țĮȚȞȠȪȡȖȚĮ ȜȓıĲĮ, ĮțȡȚȕȫȢ ȩʌȦȢ įȘµȚȠȣȡȖȠȪµİ ȑȞĮ ĮȞĲȚțİȓµİȞȠ. ȅ ıȣȖțİțȡȚµȑȞȠȢ țĮĲĮıțİȣĮıĲȒȢ (constructor) ʌȠȣ ȤȡȘıȚµȠʌȠȚȠȪµİ, įȑȤİĲĮȚ ȦȢ ʌĮȡȐµİĲȡȠ ȑȞĮȞ ĮțȑȡĮȚȠ (int), ʌȠȣ İțĳȡȐȗİȚ ĲȠ ʌȜȒșȠȢ ĲȦȞ ȠȡĮĲȫȞ ȖȡĮµµȫȞ ĲȘȢ ȜȓıĲĮȢ țĮȚ ȑȞĮ boolean, ĲȠ ȠʌȠȓȠ İțĳȡȐȗİȚ ĲȠ ĮȞ İʌȚĲȡȑʌȠȞĲĮȚ Ȓ ȩȤȚ ʌȠȜȜĮʌȜȑȢ İʌȚȜȠȖȑȢ. ĬĮ įȘµȚȠȣȡȖȒıȠȣµİ ĲȘȞ ȜȓıĲĮ µİ 25 ȠȡĮĲȑȢ ȖȡĮµµȑȢ țĮȚ ȤȦȡȓȢ ʌȠȜȜĮʌȜȑȢ İʌȚȜȠȖȑȢ. List theList; theList = new List(25, false); ĬĮ ʌȡȠıșȑĲȠȣµİ ĮȜĳĮȡȚșµȘĲȚțȐ ıĲȘȞ ȜȓıĲĮ ȤȡȘıȚµȠʌȠȚȫȞĲĮȢ ĲȘȞ µȑșȠįȠ addItem Įʌȩ ĲȠ List. theList.addItem("This is a list item"); ȉȑȜȠȢ ȤȡİȚȐȗİĲĮȚ ȞĮ ʌȡȠıșȑıȠȣµİ ĮȣĲȒȞ ĲȘȞ ȜȓıĲĮ ıĲȠ applet µĮȢ. ǹȣĲȩ ĲȠ țȐȞȠȣµİ µİ ĲȘ ȖȡĮµµȒ: add(theList); ıĲȘȞ µȑșȠįȠ 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"); } ǹș. Ǽ. ȀȠȣĲıȠȞȚțȩȜĮȢ

ȂĮșȒµĮĲĮ 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; }

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

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

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

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

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

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

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

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

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

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

īȚĮ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ȑȞĮ įȚțȩ µĮȢ ĮȞĲȚțİȓµİȞȠ ȖȡĮµµĮĲȠıİȚȡȐȢ, ȤȡȘıȚµȠʌȠȚȠȪµİ ĲȘȞ țȜȐıȘ Font µİ ĲȠȞ ĲİȜİıĲȒ new țĮȚ ʌİȡȞȐµİ ĲȡȓĮ ȠȡȓıµĮĲĮ, ȩʌȦȢ įȘȜȫșȘțĮȞ ʌĮȡĮʌȐȞȦ. ȂʌȠȡȠȪµİ ȞĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ ĲȚȢ ıĲĮșİȡȑȢ Font.PLAIN, Font.BOLD, Font.ITALIC țĮȚ Font.BOLD+Font.ITALIC. Ȃİ ĲȘȞ µȑșȠįȠ setFont() ȠȡȓȗȠȣµİ µȚĮ ȖȡĮµµĮĲȠıİȚȡȐ İȞȫ µİ ĲȘȞ µȑșȠįȠ getFont() µʌȠȡȠȪµİ ȞĮ įȠȪµİ ʌȠȚĮ ȖȡĮµµĮĲȠıİȚȡȐ ȤȡȘıȚµȠʌȠȚİȓĲĮȚ İțİȓȞȘ ĲȘ ıĲȚȖµȒ. ȉĮ ıĲȠȚȤİȓĮ ĲȘȢ ĲȡȑȤȠȣıĮȢ ȖȡĮµµĮĲȠıİȚȡȐȢ ȤȡȘıȚµȠʌȠȚȠȪȞĲĮȚ ȖȚĮ ĲȘȞ İµĳȐȞȚıȘ ĲȠȣ țİȚµȑȞȠȣ ıĲȘȞ ȠșȩȞȘ. ǹțȠȜȠȣșİȓ ȑȞĮ ʌĮȡȐįİȚȖµĮ: 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("īȡĮµµĮĲȠıİȚȡȐ Plain Times Roman 20 point", 10, 30); g.setFont(Font2); g.drawString("īȡĮµµĮĲȠıİȚȡȐ Bold+Italic Times Roman 40 point", 10, 80); } } ȂʌȠȡȠȪµİ ȞĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ įȪȠ ĲȡȩʌȠȣȢ ȖȚĮ ȞĮ ȠȡȓıȠȣµİ ĲȠ ȤȡȫµĮ ʌȠȣ șȑȜȠȣµİ ȞĮ İµĳĮȞȓıȠȣµİ ı' ȑȞĮ applet. ȅ ʌȡȫĲȠȢ ȤȡȘıȚµȠʌȠȚİȓ µȚĮ ıĲĮșİȡȒ ĲȚµȒ ĲȘȢ ĲȐȟȘȢ Color țĮȚ Ƞ įİȪĲİȡȠȢ ȠȡȓȗİȚ ȞȑĮ ȤȡȫµĮĲĮ µİ ȕȐıȘ ĲȚȢ RGB (Red, Green, Blue) ĲȚµȑȢ ĲȠȣȢ Įʌȩ 0-255. īȚĮ ʌĮȡȐįİȚȖµĮ ȖȚĮ ȞĮ İʌȚȜȑȟȠȣµİ ȑȞĮ µİıĮȓȠ ȖțȡȚ șĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ ĲȘȞ color(127,127,127). īȚĮ ĲȠ Ȝİȣțȩ șĮ İȓȞĮȚ color(255,255,255) İȞȫ ȖȚĮ ĲȠ țȩțțȚȞȠ İȓȞĮȚ color(255,0,0) ț.Ƞ.ț. ȂʌȠȡȠȪµİ ȞĮ ȠȡȓıȠȣµİ ĲȠ ȤȡȫµĮ ĲȠȣ ĳȩȞĲȠȣ ĲȠȣ applet µİ ĲȘȞ µȑșȠįȠ setBackground() țĮȚ ĲȠ ȤȡȫµĮ ĲȠȣ țİȚµȑȞȠȣ ĲȠȣ applet µİ ĲȘȞ µȑșȠįȠ 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("ȋȡȫµĮ ĳȩȞĲȠȣ ʌȡȐıȚȞȠ", 10, 30); g.drawString("ȋȡȫµĮ țİȚµȑȞȠȣ µʌȜİ", 10, 50); Color mystery = new Color(100, 200, 50); g.setColor(mystery); g.drawString("ȋȡȫµĮ țİȚµȑȞȠȣ ĲȣȤĮȓȠ", 10, 70); } } ǹș. Ǽ. ȀȠȣĲıȠȞȚțȩȜĮȢ

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

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

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

īȚĮ ȞĮ ıȤİįȚȐıȠȣµİ ȑȞĮ ȖȡĮĳȚțȩ ıĲȘȞ Java ȤȡȘıȚµȠʌȠȚȠȪµİ µȚĮ µȑșȠįȠ ĲȘȢ țȜȐıȘȢ Graphics. īȚĮ ȞĮ ıȤİįȚȐıȠȣµİ µȚĮ ȖȡĮµµȒ ȤȡȘıȚµȠʌȠȚȠȪµİ ĲȘȞ µȑșȠįȠ 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); } } ȈĲȠ ʌĮȡĮʌȐȞȦ applet ıȤİįȚȐȗİĲĮȚ µȚĮ ȖȡĮµµȒ µİ ȤȡȫµĮ țȩțțȚȞȠ Įʌȩ ĲȠ ıȘµİȓȠ (100, 150) ĲȠȣ applet µȑȤȡȚ ĲȠ ıȘµİȓȠ (170, 200). īȚĮ ȞĮ ıȤİįȚȐıȠȣµİ ȑȞĮ ȠȡșȠȖȫȞȚȠ Ȓ ĲİĲȡȐȖȦȞȠ ȑȤȠȣµİ ʌȠȜȜȑȢ İʌȚȜȠȖȑȢ : Ǿ µȑșȠįȠȢ drawRect() ȖȚĮ ĮʌȜȩ ȠȡșȠȖȫȞȚȠ, µȘ ȖİµȚıµȑȞȠ țĮȚ ȤȦȡȓȢ ıĲȡȠȖȖȣȜİµȑȞİȢ ȖȦȞȓİȢ: g.drawRect(100, 150, 200, 250); Ǿ ʌĮȡĮʌȐȞȦ İȞĲȠȜȒ ıȤİįȚȐȗİȚ ȑȞĮ ȠȡșȠȖȫȞȚȠ µİ ʌȐȞȦ ĮȡȚıĲİȡȐ țȠȡȣĳȒ ıĲȠ ıȘµİȓȠ (100, 150), ʌȜȐĲȠȢ 200 țĮȚ ȪȥȠȢ 250 pixels. Ǿ µȑșȠįȠȢ fillRect() ȖȚĮ ȖİµȚıµȑȞȠ ȠȡșȠȖȫȞȚȠ: g.setColor(Color.blue); g.fillRect(100, 150, 200, 250); Ǿ ʌĮȡĮʌȐȞȦ İȞĲȠȜȒ ıȤİįȚȐȗİȚ ȑȞĮ ȠȡșȠȖȫȞȚȠ ȖİµȚıµȑȞȠ µİ µʌȜİ ȤȡȫµĮ, µİ ʌȐȞȦ ĮȡȚıĲİȡȐ țȠȡȣĳȒ ıĲȠ ıȘµİȓȠ (100, 150), ʌȜȐĲȠȢ 200 țĮȚ ȪȥȠȢ 250 pixels. Ǿ µȑșȠįȠȢ draw3DRect() ȖȚĮ ĲȡȚįȚȐıĲĮĲȠ (3D) ȠȡșȠȖȫȞȚȠ: g.draw3DRect(100, 150, 200, 250, true); Ǿ ʌĮȡĮʌȐȞȦ İȞĲȠȜȒ ıȤİįȚȐȗİȚ ȑȞĮ ȠȡșȠȖȫȞȚȠ µİ ʌȐȞȦ ĮȡȚıĲİȡȐ țȠȡȣĳȒ ıĲȠ ıȘµİȓȠ (100, 150), ʌȜȐĲȠȢ 200 țĮȚ ȪȥȠȢ 250 pixels. Ǿ ĲİȜİȣĲĮȓĮ ʌĮȡȐµİĲȡȠȢ İȓȞĮȚ ĲȪʌȠȣ boolean (true Ȓ false) țĮșȠȡȓȗİȚ ĮȞ ĲȠ ȠȡșȠȖȫȞȚȠ șĮ İȓȞĮȚ ĲȡȚįȚȐıĲĮĲȠ Ȓ ȩȤȚ ĮȞĲȓıĲȠȚȤĮ. Ǿ µȑșȠįȠȢ drawRoundRect() ȖȚĮ ȠȡșȠȖȫȞȚȠ µİ ıĲȡȠȖȖȣȜİµȑȞİȢ ȖȦȞȓİȢ, İȖȖİȖȡĮµµȑȞȠ ıĲȠ țĮȞȠȞȚțȩ ȠȡșȠȖȫȞȚȠ: g.setColor(Color.green); g.drawRoundRect(100, 150, 200, 250, 15, 15); Ǿ µȑșȠįȠȢ fillRoundRect() ȖȚĮ ȖİµȚıµȑȞȠ ȠȡșȠȖȫȞȚȠ µİ ıĲȡȠȖȖȣȜİµȑȞİȢ ȖȦȞȓİȢ:

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

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

g.setColor(Color.yellow); g.fillRoundRect(100, 150, 200, 250, 15, 15); ȅȚ µȑșȠįȠȚ drawRoundRect() țĮȚ fillRoundRect() ȑȤȠȣȞ įȪȠ İʌȚʌȜȑȠȞ ʌĮȡĮµȑĲȡȠȣȢ, ĲȚȢ įȪȠ ĲİȜİȣĲĮȓİȢ, ʌȠȣ İȓȞĮȚ Ș ĮʌȩıĲĮıȘ Įʌȩ ĲȘȞ ȖȦȞȓĮ ĲȠȣ țĮȞȠȞȚțȠȪ ȠȡșȠȖȦȞȓȠȣ, ʌȠȣ șȑȜȠȣµİ ȞĮ ȟİțȚȞȐİȚ Ș țĮµʌȪȜȘ. īȚĮ ȞĮ ıȤİįȚȐıȠȣµİ µȚĮ ȑȜȜİȚȥȘ Ȓ ȑȞĮȞ țȪțȜȠ ȤȡȘıȚµȠʌȠȚȠȪµİ ĲȘȞ µȑșȠįȠ drawOval() ȦȢ İȟȒȢ: g.setColor(Color.red); g.drawOval(100, 150, 20, 30); Ǿ ʌĮȡĮʌȐȞȦ İȞĲȠȜȒ ıȤİįȚȐȗİȚ µȚĮ ȑȜȜİȚȥȘ µİ țȩțțȚȞȠ ȤȡȫµĮ, İȖȖİȖȡĮµµȑȞȘ ıĲȠ ȠȡșȠȖȫȞȚȠ µİ ʌȐȞȦ ĮȡȚıĲİȡȐ țȠȡȣĳȒ ıĲȠ ıȘµİȓȠ (100, 150), ʌȜȐĲȠȢ 20 țĮȚ ȪȥȠȢ 30 pixels. ǹȞ ĲȠ ʌȜȐĲȠȢ țĮȚ ĲȠ ȪȥȠȢ ĲȠȣ ȠȡșȠȖȦȞȓȠȣ İȓȞĮȚ ȓıĮ ĲȩĲİ ʌȡȩțİȚĲĮȚ, ʌȡȠĳĮȞȫȢ, ȖȚĮ țȪțȜȠ. Ǿ µȑșȠįȠȢ fillOval() ȖİµȓȗİȚ ĲȘȞ ȑȜȜİȚȥȘ µİ ȤȡȫµĮ : g.setColor(Color.yellow); g.fillOval(100, 150, 20, 30); īȚĮ ȞĮ ıȤİįȚȐıȠȣµİ ȑȞĮ ĲȩȟȠ ȤȡȘıȚµȠʌȠȚȠȪµİ ĲȘȞ µȑșȠįȠ drawArc() ȦȢ İȟȒȢ: g.setColor(Color.blue); g.drawArc(100, 150, 30, 20, 45, 180); Ǿ ʌĮȡĮʌȐȞȦ İȞĲȠȜȒ ıȤİįȚȐȗİȚ ȑȞĮ ĲȩȟȠ ȑȜȜİȚȥȘȢ µİ µʌȜİ ȤȡȫµĮ, İȖȖİȖȡĮµµȑȞȠ ıĲȠ ȠȡșȠȖȫȞȚȠ ʌȠȣ ȠȡȓȗİĲĮȚ Įʌȩ ĲȠȣȢ ĲȑııİȡȚȢ ʌȡȫĲȠȣȢ ĮțİȡĮȓȠȣȢ. ȅȚ ȐȜȜȠȚ įȪȠ ĮțȑȡĮȚȠȚ ȠȡȓȗȠȣȞ ĲȚȢ ȖȦȞȓİȢ İțțȓȞȘıȘȢ țĮȚ ĲȑȜȠȣȢ ıİ µȠȓȡİȢ, µİ ĳȠȡȐ ĮȞĲȓșİĲȘ ĮȣĲȒȢ ĲȦȞ įİȚțĲȫȞ ĲȠȣ ȡȠȜȠȖȚȠȪ. Ǿ µȑșȠįȠȢ fillArc() ȖİµȓȗİȚ ĲȠ ĲȩȟȠ µİ ȤȡȫµĮ: g.setColor(Color.green); g.fillArc(100, 150, 20, 20, 90, 180); īȚĮ ȞĮ ıȤİįȚȐıȠȣµİ ȑȞĮ ʌȠȜȪȖȦȞȠ, ʌȡȑʌİȚ ʌȡȫĲĮ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ȑȞĮȞ ʌȓȞĮțĮ (array) ĮțİȡĮȓȦȞ ʌȠȣ șĮ ʌİȡȚȑȤİȚ ĲȚȢ x ıȣȞĲİĲĮȖµȑȞİȢ țĮȚ ȑȞĮȞ ȐȜȜȠȞ ʌȓȞĮțĮ ĮțİȡĮȓȦȞ ʌȠȣ șĮ ʌİȡȚȑȤİȚ ĲȚȢ y ıȣȞĲİĲĮȖµȑȞİȢ ĲȦȞ țȠȡȣĳȫȞ ĲȠȣ ʌȠȜȣȖȫȞȠȣ. ȋȡȘıȚµȠʌȠȚȠȪµİ ĲȘȞ µȑșȠįȠ drawPolygon(), Ș ȠʌȠȓĮ ʌĮȓȡȞİȚ ıĮȞ ʌĮȡĮµȑĲȡȠȣȢ ĲȠȣȢ įȪȠ ʌȓȞĮțİȢ µİ ĲȚȢ ıȣȞĲİĲĮȖµȑȞİȢ țĮșȫȢ țĮȚ ȑȞĮȞ ĮțȑȡĮȚȠ ĮȡȚșµȩ ʌȠȣ ʌĮȡȚıĲȐȞİȚ ĲȠȞ ĮȡȚșµȩ ĲȦȞ țȠȡȣĳȫȞ ĲȠȣ ʌȠȜȣȖȫȞȠȣ. ȉȠ ʌĮȡĮțȐĲȦ ʌĮȡȐįİȚȖµĮ ıȤİįȚȐȗİȚ ȑȞĮ ʌȠȜȪȖȦȞȠ µİ 4 țȠȡȣĳȑȢ țĮȚ ȤȡȫµĮ ȖȡĮµµȒȢ țȩțțȚȞȠ: 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() ȖİµȓȗİȚ ĲȠ ʌȠȜȪȖȦȞȠ µİ ȤȡȫµĮ.

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

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

ǼȚıĮȖȦȖȒ ǼȚțȩȞĮȢ ıİ applet ȅ ʌĮȡĮțȐĲȦ țȫįȚțĮȢ įİȓȤȞİȚ ʌȫȢ µʌȠȡȠȪµİ ȞĮ İȚıȐȖȠȣµİ µȓĮ İȚțȩȞĮ ıİ ȑȞĮ applet, ȤȡȘıȚµȠʌȠȚȫȞĲĮȢ ĲȚȢ getImage țĮȚ drawImage. ȊʌȠșȑĲȠȣµİ ȩĲȚ Ș İȚțȩȞĮ ʌȠȣ İȚıȐȖȠȣµİ İȓȞĮȚ ĮʌȠșȘțİȣµȑȞȘ ıĲȠ ĮȡȤİȓȠ kotsiras.gif, ʌȠȣ ȕȡȓıțİĲĮȚ ıĲȠȞ ȓįȚȠ țĮĲȐȜȠȖȠ µİ ĲȠ 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); } } ȆĮȡȐįİȚȖµĮ: ȉȠ İʌȩµİȞȠ ʌĮȡȐįİȚȖµĮ İȓȞĮȚ ʌȚȠ įȪıțȠȜȠ ȞĮ ʌİȡȚȖȡĮĳİȓ, Įʌȩ ȩ,ĲȚ ȞĮ ȖȡĮĳİȓ Ƞ țȫįȚțĮȢ. ǼțĲİȜİȓ ȑȞĮȞ ĮĲȑȡµȠȞĮ ȕȡȩȤȠ țĮȚ İµĳĮȞȓȗİȚ ĲȣȤĮȓİȢ ȚʌĲȐµİȞİȢ ȖȡĮµµȑȢ. ȂİĲĮȖȜȦĲĲȓıĲİ ĲȠȞ ĮțȩȜȠȣșȠ țȫįȚțĮ, İțĲİȜȑıĲİ ĲȠ ʌȡȩȖȡĮµµĮ țĮȚ µİĲȐ µİȜİĲȒıĲİ ĲȠȞ țȫįȚțĮ: 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); } ǹș. Ǽ. ȀȠȣĲıȠȞȚțȩȜĮȢ

ȂĮșȒµĮĲĮ 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 ǻȚĮıȪȞįİıȘ µİ ĲȠȞ ȋȡȒıĲȘ ȈĲȘȞ ʌĮȡȐȖȡĮĳȠ ĮȣĲȒ șĮ įȠȪµİ ʌȫȢ µʌȠȡȠȪµİ µİ ĲȘȞ Java ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ıİ ȑȞĮ applet, ıĲȠȚȤİȓĮ İʌȚțȠȚȞȦȞȓĮȢ µİ ĲȠ ȤȡȒıĲȘ: ǼĲȚțȑĲİȢ țĮȚ ȆȜĮȓıȚĮ ȀİȚµȑȞȠȣ īȚĮ ȞĮ µʌȠȡȑıȠȣµİ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ȑȞĮ ıȣıĲĮĲȚțȩ, ȩʌȦȢ µȓĮ İĲȚțȑĲĮ (label) ı' ȑȞĮ ʌȡȩȖȡĮµµĮ ĲȘȢ Java, įȘµȚȠȣȡȖȠȪµİ ʌȡȫĲĮ ĲȠ ĮȞĲȚțİȓµİȞȠ țĮȚ µİĲȐ ȤȡȘıȚµȠʌȠȚȠȪµİ ĲȘȞ ǹș. Ǽ. ȀȠȣĲıȠȞȚțȩȜĮȢ

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

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

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

īȚĮ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ ʌȜȒțĲȡĮ İʌȚȜȠȖȒȢ ı' ȑȞĮ applet ʌȡȑʌİȚ ʌȡȫĲĮ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ µȚĮ ȠµȐįĮ ʌȜĮȚıȓȦȞ İȜȑȖȤȠȣ µİ ĲȠ ĮȞĲȚțİȓµİȞȠ CheckboxGroup țĮȚ µİĲȐ țĮĲȐ ĲȘȞ įȘµȚȠȣȡȖȓĮ ĲȦȞ ʌȜĮȚıȓȦȞ İȜȑȖȤȠȣ ȞĮ ȤȡȘıȚµȠʌȠȚȒıȠȣµİ țĮȚ µȚĮ ĲȡȓĲȘ ʌĮȡȐµİĲȡȠ ʌȠȣ ȞĮ įȘȜȫȞİȚ ĲȘȞ ȠµȐįĮ ıĲȘȞ ȠʌȠȓĮ șĮ ĮȞȒțİȚ ĮȣĲȩ ĲȠ ʌȜĮȓıȚȠ İȜȑȖȤȠȣ, ȐȡĮ ıĲȘȞ ȠȣıȓĮ įȘµȚȠȣȡȖȠȪµİ ȑȞĮ ʌȜȒțĲȡȠ İʌȚȜȠȖȒȢ. īȡȐĳȠȣµİ ĲȠȞ İȟȒȢ țȫįȚțĮ : 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 țĮȚ ȩȜĮ ĲĮ ʌȜĮȓıȚĮ İȜȑȖȤȠȣ (ıĲȘȞ ȠȣıȓĮ ʌȜȒțĲȡĮ İʌȚȜȠȖȒȢ) ʌȠȣ įȘµȚȠȣȡȖȒıĮµİ ʌȡȠıĲȑșȘțĮȞ ı' ĮȣĲȒ ĲȘȞ ȠµȐįĮ (group). ȁȓıĲİȢ ǼʌȚȜȠȖȒȢ ȂȚĮ ȜȓıĲĮ İʌȚȜȠȖȒȢ (choice) İȓȞĮȚ µȚĮ ʌĲȣııȩµİȞȘ ȜȓıĲĮ İʌȚȜȠȖȫȞ Įʌȩ ĲȚȢ ȠʌȠȓİȢ µȩȞȠ µȓĮ µʌȠȡİȓ ȞĮ İȓȞĮȚ İʌȚȜİȖµȑȞȘ. ǼȓȞĮȚ ȖȞȦıĲȒ țĮȚ ıĮȞ ʌĲȣııȩµİȞȠ Ȓ ıȪȞșİĲȠ ʌȜĮȓıȚȠ (combo box). īȚĮ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ µȚĮ ȜȓıĲĮ İʌȚȜȠȖȒȢ, įȘµȚȠȣȡȖȠȪµİ ʌȡȫĲĮ ĲȠ ĮȞĲȚțİȓµİȞȠ țĮȚ µİĲȐ ʌȡȠıșȑĲȠȣµİ µȓĮ-µȓĮ ĲȚȢ İʌȚȜȠȖȑȢ, ȦȢ İȟȒȢ : import java.applet.*; import java.awt.*; public class List extends Applet { Choice sport = new Choice(); public void init() { sport.add("ȂʌȐıțİĲ"); sport.add("ǺȩȜȜİȨ"); sport.add("ȆȠįȩıĳĮȚȡȠ"); sport.add("ȀȠȜȪµȕȘıȘ"); add(sport); } } ǻȘµȚȠȣȡȖȒıĮµİ µȚĮ ȜȓıĲĮ İʌȚȜȠȖȒȢ µİ ĲȑııİȡĮ ĮșȜȒµĮĲĮ. ȆİȡȚȠȤȑȢ ȀİȚµȑȞȠȣ ȂȚĮ ʌİȡȚȠȤȒ țİȚµȑȞȠȣ (TextArea) İȓȞĮȚ ȑȞĮ ʌİįȓȠ țİȚµȑȞȠȣ ȩʌȠȣ µʌȠȡȠȪµİ ȞĮ țĮĲĮȤȦȡȒıȠȣµİ ʌİȡȚııȩĲİȡİȢ Įʌȩ µȓĮ ȖȡĮµµȑȢ țİȚµȑȞȠȣ. Ȉİ µȚĮ ʌİȡȚȠȤȒ țİȚµȑȞȠȣ ʌȡȑʌİȚ ȞĮ țĮșȠȡȓıȠȣµİ ĲȠ ʌȜȐĲȠȢ țĮȚ ĲȠ ȪȥȠȢ ĲȘȢ țĮȚ µʌȠȡȠȪµİ ȞĮ ĲȠʌȠșİĲȒıȠȣµİ țĮȚ ȑȞĮ ĮȡȤȚțȩ țİȓµİȞȠ µĮȗȓ ĲȘȞ įȒȜȦıȒ ĲȘȢ. ȂʌȠȡȠȪµİ ȞĮ įȘµȚȠȣȡȖȒıȠȣµİ µȚĮ ʌİȡȚȠȤȒ țİȚµȑȞȠȣ ı' ȑȞĮ applet ĲȘȢ Java ȦȢ İȟȒȢ : import java.applet.*; import java.awt.*; public class Txt extends Applet { TextArea comments = new TextArea("Hello World", 10, 20); public void init() { ǹș. Ǽ. ȀȠȣĲıȠȞȚțȩȜĮȢ

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

}

add(comments);

} 3.7.1 ǹȜȜȘȜİʌȓįȡĮıȘ: ǼȓıȠįȠȢ µİ ĲȠ ȆȠȞĲȓțȚ țĮȚ ĲȠ ȆȜȘțĲȡȠȜȩȖȚȠ ȉȫȡĮ ȑȤȠȣµİ ĲĮ İȡȖĮȜİȓĮ ȖȚĮ ȞĮ ȗȦȖȡĮĳȓıȠȣµİ ʌȠȜȜȑȢ ʌȡĮȖµĮĲȚțȐ ȦȡĮȓİȢ țȚȞȒıİȚȢ țĮȚ ĳȚȖȠȪȡİȢ ıĲȚȢ ıİȜȓįİȢ ĲȠȣ web. ǹȣĲȩ µĮȢ ĲȠʌȠșİĲİȓ ʌȐȞȦ Įʌȩ ĲȠ µȑıȠ ıȤİįȚĮıĲȒ ĲȦȞ ıİȜȓįȦȞ ĲȠȣ web. ȉȠ ȐȜȜȠ µȚıȩ İȓȞĮȚ Ș ĮȜȜȘȜİʌȓįȡĮıȘ µİ ĲȠ ȤȡȒıĲȘ. ȉĮ applet µʌȠȡȠȪȞ ȞĮ įİȤĲȠȪȞ İȓıȠįȠ Įʌȩ ĲȠ ȤȡȒıĲȘ țĮȚ ȞĮ ĮȞĲĮʌȠțȡȚșȠȪȞ ı’ ĮȣĲȩȞ. ǼȓıȠįȠȢ µİ ĲȠ ʌȠȞĲȓțȚ ȆĮȡĮțȐĲȦ ȑȤȠȣµİ ȑȞĮ ĮʌȜȩ applet ʌȠȣ µĮȢ İʌȚĲȡȑʌİȚ ȞĮ ĲȡĮȕȐµİ ȖȡĮµµȑȢ µİ ĲȠ ʌȠȞĲȓțȚ ʌȐȞȦ ıĲȠ 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; } } ǹș. Ǽ. ȀȠȣĲıȠȞȚțȩȜĮȢ

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

ǼȓıȠįȠȢ µİ ĲȠ ʌȜȘțĲȡȠȜȩȖȚȠ ȆĮȡĮțȐĲȦ ȑȤȠȣµİ ȑȞĮ ĮʌȜȩ applet ʌȠȣ ȤȡȘıȚµȠʌȠȚİȓ ĲȘȞ µȑșȠįȠ KeyDown ȖȚĮ ȞĮ µĮȢ İʌȚĲȡȑȥİȚ ȞĮ ʌȜȘțĲȡȠȜȠȖȒıȠȣµİ țȐʌȠȚȠ țİȓµİȞȠ. 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; } ǹș. Ǽ. ȀȠȣĲıȠȞȚțȩȜĮȢ

ȂĮșȒµĮĲĮ 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 ȆȠȜȣİʌİȟİȡȖĮıȓĮ – ȃȘµĮĲȠʌȠȓȘıȘ ȅ ȩȡȠȢ ʌȠȜȣİʌİȟİȡȖĮıȓĮ (multitasking) ĮȞĮĳȑȡİĲĮȚ ıĲȘȞ ȚțĮȞȩĲȘĲĮ İȞȩȢ ȣʌȠȜȠȖȚıĲȒ ȞĮ µʌȠȡİȓ ȞĮ İțĲİȜİȓ įȪȠ Ȓ ʌİȡȚııȩĲİȡİȢ İȡȖĮıȓİȢ (tasks) ĲĮȣĲȩȤȡȠȞĮ. ǲȞĮ Įʌȩ ĲĮ ȤĮȡĮțĲȘȡȚıĲȚțȐ ĲȘȢ Java İȓȞĮȚ Ș ȣʌȠıĲȒȡȚȟȘ ĲȘȢ ʌȠȜȣİʌİȟİȡȖĮıȓĮȢ. Ǿ țĮșİµȓĮ Įʌ' ĮȣĲȑȢ ĲȚȢ ĲĮȣĲȩȤȡȠȞİȢ İȡȖĮıȓİȢ țĮȜİȓĲĮȚ ȞȒµĮ (thread) țĮȚ Ș ȩȜȘ įȚĮįȚțĮıȓĮ țĮȜİȓĲĮȚ ʌȠȜȣȞȘµĮĲȠʌȠȓȘıȘ (multithreading). ǹȞȐȜȠȖĮ µİ ĲȠ ȜİȚĲȠȣȡȖȚțȩ ıȪıĲȘµĮ țĮȚ ĲȠȞ ĳȣȜȜȠµİĲȡȘĲȒ, ȓıȦȢ ȑȤİĲİ ʌĮȡĮĲȘȡȒıİȚ ȩĲȚ ĲȠ ʌȡȩȖȡȐµµĮ FlyingLines (ʌȠȣ İȓįĮµİ ıĲȘȞ § 3.6.3, ȑȤİȚ ĲȘȞ ĲȐıȘ ȞĮ ‘’țȡİµȐİȚ’’ µİĲȐ Įʌȩ ĮȡțİĲȑȢ ȤȚȜȚȐįİȢ İʌĮȞĮȜȒȥİȚȢ İȞĲȠȜȫȞ. ȅ ȕȡȩȤȠȢ ĲȘȢ ȗȦȖȡĮĳȚțȒȢ ıĲȠ FlyingLines İȓȞĮȚ ȚįĮȞȚțȩȢ ȖȚĮ ȑȞĮ ȞȒµĮ, µȓĮ ȟİȤȦȡȚıĲȒ ȠµȐįĮ Įʌȩ ȜİȚĲȠȣȡȖȓİȢ, ʌȠȣ ȜĮµȕȐȞȠȣȞ ȤȫȡĮ ĲĮȣĲȩȤȡȠȞĮ țĮȚ ĮȞİȟȐȡĲȘĲĮ Įʌȩ ȠĲȚįȒʌȠĲİ ȐȜȜȠ ȓıȦȢ ıȣµȕİȓ. ȈĮȞ ȑȞĮȢ ȖİȞȚțȩȢ țĮȞȩȞĮȢ ȩȜİȢ ȠȚ İȞĲĮĲȚțȑȢ İȡȖĮıȓİȢ ĲȘȢ CPU ʌȡȑʌİȚ ȞĮ ĲȠʌȠșİĲȠȪȞĲĮȚ ıĲĮ įȚțȐ ĲȠȣȢ ȞȒµĮĲĮ. ȆĮȡĮțȐĲȦ ʌĮȡȠȣıȚȐȗİĲĮȚ µȚĮ ȞȘµĮĲȠʌȠȚȘµȑȞȘ ȑțįȠıȘ ĲȠȣ 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];

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

ȂĮșȒµĮĲĮ 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); }

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

{

ȂĮșȒµĮĲĮ 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; } }

}

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

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

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

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

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

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

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

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

name = ""; url = ""; description = ""; } } ǹȣĲȩ țĮȜİȓĲĮȚ µȑșȠįȠȢ ȣʌİȡĳȩȡĲȦıȘȢ Ȓ ʌȠȜȣµȠȡĳȚıµȠȪ. ȅ ʌȠȜȣµȠȡĳȚıµȩȢ İȓȞĮȚ ȑȞĮ ȤĮȡĮțĲȘȡȚıĲȚțȩ ĲȦȞ ĮȞĲȚțİȚµİȞȠıĲȡİĳȫȞ ȖȜȦııȫȞ ʌȠȣ ĮĳȒȞȠȣȞ ȑȞĮ ȩȞȠµĮ ȞĮ ĮȞĮĳȑȡİĲĮȚ ıİ įȚĮĳȠȡİĲȚțȑȢ µİșȩįȠȣȢ,İȟĮȡĲȫµİȞȠ Įʌȩ ĲȠ ʌİȡȚİȤȩµİȞȩ ĲȠȣȢ. ȉȠ ıȘµĮȞĲȚțȩ ıĲȠ ʌİȡȚİȤȩµİȞȠ İȓȞĮȚ Ƞ ĲȪʌȠȢ țĮȚ Ƞ ĮȡȚșµȩȢ ĲȦȞ ȠȡȚıµȐĲȦȞ ĲȘȢ µİșȩįȠȣ. Ȉ’ĮȣĲȒȞ ĲȘȞ ʌİȡȓʌĲȦıȘ ȤȡȘıȚµȠʌȠȚȠȪµİ ĲȘȞ ʌȡȫĲȘ ȑțįȠıȘ ĲȘȢ µİșȩįȠȣ ĮȞ ȑȤȠȣµİ ĲȡȓĮ ȠȡȓıµĮĲĮ țĮȚ ĲȘȞ įİȪĲİȡȘ ȑțįȠıȘ ĮȞ įİȞ ȑȤȠȣµİ țĮșȩȜȠȣ ȠȡȓıµĮĲĮ. ǹȞ ȑȤİȚȢ ȑȞĮ, įȪȠ Ȓ ĲȑııİȡĮ ȠȡȓıµĮĲĮ string ıĲȘ įȠµȒ, Ȓ ȠȡȓıµĮĲĮ ʌȠȣ įİȞ İȓȞĮȚ string, Ƞ µİĲĮȖȜȦĲĲȚıĲȒȢ įȘµȚȠȣȡȖİȓ ȑȞĮ ȜȐșȠȢ ȖȚĮĲȓ įİȞ ȑȤİȚ µȚĮ µȑșȠįȠ ʌȠȣ ȞĮ ĲĮȚȡȚȐȗİȚ µİ ĲȘ µȑșȠįȠ ʌȠȣ ȗȘĲȒșȘțİ. ȂȑșȠįȠȚ toStrings Ǿ µȑșȠįȠȢ print İȓȞĮȚ țȠȚȞȒ ıİ țȐʌȠȚİȢ ȖȜȫııİȢ, ĮȜȜȐ ĲĮ ʌİȡȚııȩĲİȡĮ ʌȡȠȖȡȐµµĮĲĮ ĲȘȢ Java ĲȘȞ ȤİȚȡȓȗȠȞĲĮȚ įȚĮĳȠȡİĲȚțȐ. ȂʌȠȡİȓȢ ȞĮ ȤȡȘıȚµȠʌȠȚȒıİȚȢ System.out.println() ȖȚĮ ȞĮ ĲȣʌȫıİȚȢ țȐʌȠȚȠ ĮȞĲȚțİȓµİȞȠ. ǵµȦȢ ȖȚĮ țĮȜȐ ĮʌȠĲİȜȑıµĮĲĮ Ș țȜȐıȘ ıȠȣ ʌȡȑʌİȚ ȞĮ ȑȤİȚ µȚĮ µȑșȠįȠ toString(), ʌȠȣ ȞĮ µȠȡĳȠʌȠȚİȓ ĲĮ įİįȠµȑȞĮ ĲȦȞ ĮȞĲȚțİȚµȑȞȦȞ µİ ȑȞĮ ȜȠȖȚțȩ ĲȡȩʌȠ țĮȚ ȞĮ İʌȚıĲȡȑĳİȚ ȑȞĮ string. ȆĮȡĮțȐĲȦ ȕȜȑʌȠȣµİ ʌȫȢ ȤȡȘıȚµȠʌȠȚİȓĲĮȚ ĮȣĲȩ ıĲȠ ʌĮȡȐįİȚȖµĮ ĲȠȣ website: public class ClassTest { public static void main(String args[]) { website x = new website("ȆĮȞİʌȚıĲȒµȚȠ ǹșȘȞȫȞ", "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); } }

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