‫ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬

‫‪Kotlin‬‬

‫أﺣﻤﺪ اﻟﺠﻌﻴﺪ‬
 ‫اﻟﻤﺤﺘﻮﻳﺎت‬

‫اﻟﻤﺤﺘﻮﻳﺎت ‪2 .....................................................................................................................................................‬‬

‫ﺑﻴﺌﺔ اﻟﻌﻤﻞ ‪ERROR! BOOKMARK NOT DEFINED. ...........................................‬‬

‫ﺗﺜﺒﻴﺖ ‪9 ........................................................................................................................................... JAVA 8‬‬

‫ﺗﺜﺒﻴﺖ‪9 ...................................................................................................................................................... IDE‬‬
‫اﺳﺘﺨﺪام‪10 ..................................................................................................................................... vs code‬‬
‫ﻣﻮﺟﻪ اﻷواﻣﺮ ‪13 ...............................................................................................................................................‬‬
‫ﺗﮭﯿﺌﺔ ‪ ECLIPSE‬ﻟﺒﺮﻣﺠﺔ ‪14 ............................................................................ KOTLIN‬‬
‫ﺗﺜﺒﻴﺖ اﻻدوات ‪14 ............................................................................................................................................‬‬
‫ﻣﺸﺮوع‪16 .......................................................................................................................................... Kotlin‬‬
‫اﻫﻼ ً ﺑﺎﻟﻌﺎﻟﻢ ‪17 ..................................................................................................................................................‬‬
‫ﻟﻐﺔ ‪18 ..................................................................................................... KOTLIN‬‬
‫أوﻻ ‪ :‬ﻣﻘﺪﻣﺔ ‪18 .................................................................................................................................................‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﺟﺎﻓﺎ ‪ Java‬أم ﻛﻮﺗﻠﻦ‪18 .......................................................................................................... Kotlin‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬ﻣﺰا ﻳﺎ ﻟﻐﺔ ﻛﻮﺗﻠﻦ‪19 ................................................................................................................. Kotlin‬‬

‫اﻟﻤﻘﺪﻣﺔ‪20 .....................................................................................................................‬‬
‫اﻟﻤﺘﻐﯿﺮات ‪21 ........................................................................................................‬‬
‫أوﻻ ‪ :‬ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات‪21 ............................................................................................................................‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬أﻧﻮاع اﻟﻤﺘﻐﻴﺮات ‪23 ..............................................................................................................................‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬ﺗﺤﻮﻳﻞ اﻟﻤﺘﻐﻴﺮات ‪24 ...........................................................................................................................‬‬
‫راﺑﻌﺎ ً ‪ :‬ﺑﺮﻧﺎﻣﺞ "‪25 ................................................................................................................. "hello world‬‬
‫ادﺧﺎل اﻟﺒﯿﺎﻧﺎت ‪26 ...................................................................................................‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪2‬‬

‫أوﻻ ‪ :‬داﻟﺔ ‪27 .................................................................................................................................. readLine‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬اﻟﺘﺤﻮﻳﻞ‪27 .............................................................................................................................................‬‬
‫اﻟﺘﻌﻠﯿﻘﺎت ‪29 .........................................................................................................‬‬
‫اﻟﻌﻤﻠﯿﺎت اﻟﺮﯾﺎﺿﯿﺔ ‪31 ..............................................................................................‬‬
‫أوﻻ ‪ :‬اﻟﺮﻣﻮز اﻟﺮﻳﺎﺿﻴﺔ ‪31 .................................................................................................................................‬‬
‫ﺛﺎﻧﻴﺎ ‪32 ........................................................................................................ Decrement & Increment :‬‬
‫اﻟﻌﻤﻠﯿﺎت اﻟﻤﻨﻄﻘﯿﺔ ‪33 ..............................................................................................‬‬
‫أوﻻ ‪ :‬اﻟﺮﻣﻮز اﻟﻤﻨﻄﻘﻴﺔ ‪34 ................................................................................................................................‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬اﻟﺒﻮاﺑﺎت اﻟﻤﻨﻄﻘﻴﺔ "اﻟﻤﻘﺎرﻧﺔ" ‪35 .......................................................................................................‬‬
‫اﻟﺴﻼﺳﻞ اﻟﻨﺼﯿﺔ ‪38 ................................................................................................‬‬
‫اﻟﻤﺼﻔﻮﻓﺎت ‪42 ......................................................................................................‬‬
‫أوﻻ ‪ :‬ﺗﻌﺮﻳﻒ اﻟﻤﺼﻔﻮﻓﺔ ‪42 ............................................................................................................................‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬إدﺧﺎل ﻗﻴﻢ ﻟﻠﻤﺼﻔﻮﻓﺔ ‪43 ...................................................................................................................‬‬
‫ﺛﺎﻟﺜﺎ ‪ :‬ﻃﺒﺎﻋﺔ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ‪45 ...............................................................................................................‬‬
‫راﺑﻌﺎ ‪ :‬اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺼﻔﻮﻓﺎت ‪47 .............................................................................................................‬‬
‫اﻟﻨﻄﺎق ‪49 ............................................................................................................‬‬
‫أوﻻ ‪ :‬اﻟﻨﻄﺎق‪49 .................................................................................................................................................‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬اﻟﻘﻔﺰة أو ‪51 ................................................................................................................................. step‬‬
‫ﺛﺎﻟﺜﺎ ‪ :‬اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻨﻄﺎق ‪51 ........................................................................................................................‬‬
‫‪54 ...................................................................................... VISIBILITY MODIFIERS‬‬
‫أوﻻ ‪ :‬رؤﻳﺔ اﻟﻤﺘﻐﻴﺮات‪54 .................................................................................................................................‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬أﻫﻤﻴﺔ رؤﻳﺔ اﻟﻤﺘﻐﻴﺮات ‪55 ...................................................................................................................‬‬
‫‪55 ..................................................................................... ESCAPE SEQUENCE‬‬
‫أوﻻ ‪ :‬ﻣﺎﻫﻲ اﻻﺧﺘﺼﺎرات أو اﻷواﻣﺮ اﻟﺴﺮﻳﻌﺔ ‪55 ........................................... ESCAPE SEQUENCE‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬اﻟﺮﻣﻮز وﻣﻌﺎﻧﻴﻬﺎ ‪55 ...............................................................................................................................‬‬
‫‪58 ..................................................................................................... UNICODE‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪3‬‬

‫)‪62 ....................................................................... REGEX (REGULAR EXPRESSION‬‬
‫أوﻻ ‪ :‬اﻟﺘﻌﺒﻴﺮات اﻟﻘﻴﺎﺳﻴﺔ‪62 ..........................................................................................................................‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬ﻃﺮﻳﻘﺔ اﻟﺘﻌﺒﻴﺮ ﻋﻦ اﻟﺘﻌﺒﻴﺮات اﻟﻘﻴﺎﺳﻴﺔ ‪63 ......................................................................................‬‬
‫ﺛﺎﻟﺜﺎ‪ :‬ﻣﺜﺎل‪66 ................................................................................................................................................. :‬‬
‫راﺑﻌﺎ ‪ :‬اﻟﺪوال اﻟﻤﺴﺘﺨﺪﻣﺔ ﻣﻊ اﻟﺘﻌﺒﻴﺮات اﻟﻘﻴﺎﺳﻴﺔ ‪68 ...........................................................................‬‬

‫ﺑﻨﻰ اﻟﺘﺤﻜﻢ ‪74 ..............................................................................................................‬‬

‫‪74 ...................................................................................................... FOR LOOP‬‬
‫أوﻻ ‪ :‬اﻟﺠﻤﻠﺔ ‪74 ............................................................................................................................... for loop‬‬
‫ﺛﺎﻧﻴﺎ ‪ nested for :‬واﻟﻤﻘﺼﻮد ﻫﻨﺎ اﻟﺤﻠﻘﺎت اﻟﻤﺘﺪاﺧﻠﺔ ‪76 .....................................................................‬‬
‫‪78 ......................................................................................... WHILE & DO WHILE‬‬
‫اﻟﺠﻤﻠﺔ‪78 ............................................................................................................................................... while‬‬
‫‪79 ............................................................................................................................................nested while‬‬
‫اﻟﺠﻤﻠﺔ‪79 ...................................................................................................................................... do…while‬‬
‫‪81 ............................................................................................................WHEN‬‬
‫اﻟﺠﻤﻠﺔ اﻟﺸﺮطﯿﺔ‪84 .................................................................................................‬‬
‫اﻟﺠﻤﻠﺔ‪84 ....................................................................................................................................................... if‬‬
‫‪85 ........................................................................................................................................................ if ..else‬‬
‫‪86 .................................................................................................................................................... if ..else if‬‬
‫‪ If‬اﻟﻤﺘﺪاﺧﻠﺔ ‪87 ...............................................................................................................................................‬‬
‫اﻟﺘﻌﺒﻴﺮات ﻣﻊ ‪88 ........................................................................................................................................ if‬‬

‫اﻟﺪوال ‪90 .......................................................................................................................‬‬

‫اﻟﺪوال ‪90 .............................................................................................................‬‬
‫أوﻻ ‪ :‬ﻃﺮﻳﻘﺔ ﻛﺘﺎﺑﺘﻬﺎ ‪90 ....................................................................................................................................‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬أﻧﻮاع اﻟﺪوال ‪90 ......................................................................................................................................‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪4‬‬

‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻻﺳﺘﺪﻋﺎء‪92 ..........................................................................................................................................‬‬
‫‪94 ..................................................................................... EXTENSION FUNCTION‬‬
‫‪96 ......................................................................................... LAMBDA FUNCTION‬‬
‫‪98 ..................................................................................... HIGH LEVEL FUNCTION‬‬
‫ﻣﻔﮭﻮم ‪100 ................................................................................. JUMP & RETURN‬‬

‫ﺑﺮﻣﺠﺔ ﻛﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ‪101 ..............................................................................................‬‬

‫أوﻻ ‪ :‬اﻟﺒﺮﻣﺠﺔ ﻛﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ‪102 ...................................................................................................................‬‬

‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﻣﻘﺪﻣﺔ ﻋﻦ‪102 ............................................................................................... Classes & Object‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻟﻔﺮق ﺑﻴﻦ‪103 ................................................................................................. Classes & Object‬‬
‫‪104 .............................................................................................. CLASSES OOP‬‬
‫أوﻻ ً ‪ :‬ﻃﺮﻳﻘﺔ إﻧﺸﺎء اﻟﺼﻨﻒ‪104 ......................................................................................................... class‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﻃﺮﻳﻘﺔ إﻧﺸﺎء ﻛﺎﺋﻦ‪106 ........................................................................................................ Object‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻟﻮﺻﻮل إﻟﻰ اﻟﻤﺘﻐﻴﺮات اﻟﺨﺎﺻﺔ ﺑﺎﻟـ ‪106 ..............................................................................Class‬‬
‫راﺑﻌﺎ ً ‪ :‬اﻟﻮﺻﻮل إﻟﻰ اﻟﺪوال اﻟﺨﺎﺻﺔ ﺑﺎﻟـ ‪108 .................................................................................... Class‬‬
‫ﺧﺎﻣﺴﺎ ً ‪ :‬ﺗﻤﺮﻳﺮ اﻟﻮﺳﺎﺋﻂ ﻓﻲ‪108 ....................................................................................................... Class‬‬
‫ﺳﺎدﺳﺎ ً ‪ :‬ﻛﻠﻤﺔ‪110 ................................................................................................................................ this‬‬
‫ﺳﺎﺑﻌﺎ ً ‪ :‬داﻟﺔ اﻟﺒﻨﺎء ‪111 .........................................................................................................constructor‬‬
‫ﺗﻨﻮﻳﻪ ‪113 ..........................................................................................................................................................‬‬
‫‪114 ................................................................................................ INHERITANCE‬‬
‫أوﻻ ‪ :‬ﻣﻔﺎﻫﻴﻢ ﻣﺘﻌﻠﻘﺔ ﺑﺎﻟﻮراﺛﺔ ‪115 ...............................................................................................................‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬اﻟﻮراﺛﺔ ﻓﻲ اﻟﺒﺮﻣﺠﺔ ‪116 ........................................................................................................................‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻮﺳﺎﺋﻂ اﻟﻤﻤﺮرة ﻟﻠﺘﺼﻨﻴﻒ ‪118 ................................................................................‬‬
‫راﺑﻌﺎ ‪ :‬اﻟﻔﺮق ﺑﻴﻦ ‪ this‬و‪121 .......................................................................................................... super‬‬
‫‪121 ................................................................................................... INTERFACE‬‬
‫أوﻻ ً ‪ :‬ﺗﻤﻬﻴﺪ ‪121 ...............................................................................................................................................‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪5‬‬

‫ﺛﺎﻧﻴﺎ ً ‪ :‬اﻟﺘﻌﺮﻳﻒ ﻋﻦ‪122 ............................................................................................................. interface‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻹﻋﻼن ﻓﻲ ‪122 ................................................................................................................. interface‬‬
‫راﺑﻌﺎ ً ‪ :‬اﺳﺘﺨﺪام‪123 ................................................................................................................... interface‬‬
‫ﺧﺎﻣﺴﺎ ً ‪ :‬ﻣﺜﺎل‪127 .................................................................................................................... interface‬‬
‫‪129 .................................................................................................... ABSTRACT‬‬
‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم اﻟـ‪129 ....................................................................................................................... abstract‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬اﺳﺘﺨﺪام اﻟـ‪129 ................................................................................................................. abstract‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻧﺸﺎء ﺗﺼﻨﻴﻒ‪129 ........................................................................................................... abstract‬‬
‫راﺑﻌﺎ ً ‪ :‬ﻣﺜﺎل ‪130 ..............................................................................................................................................‬‬
‫ﺧﺎﻣﺴﺎ ً ‪ :‬ﻣﺒﺪأ اﻟﻮراﺛﺔ اﻟﻤﺘﻌﺪدة ‪133 ..................................................................... multi inheritance‬‬
‫‪134 .................................................................................................... OVERRIDE‬‬
‫أوﻻً ‪ :‬ﻣﻔﮭوم‪134 ............................................................................................................................ Override‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﻛﻠﻤﺔ‪136 ...................................................................................................................................... final‬‬
‫‪137 ...................................................................................................OVERLOAD‬‬
‫‪139 ..................................................................................... COMPANION OBJECT‬‬
‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم‪139 ....................................................................................................... companion object‬‬
‫ﺛﺎﻧﻴﺎ ِ ‪ :‬ﻃﺮﻳﻘﺔ ﻛﺘﺎﺑﺘﻪ ‪139 .................................................................................................................................‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬ﻣﺜﺎل ‪139 ...............................................................................................................................................‬‬
‫راﺑﻌﺎ ً ‪ :‬ﻣﺘﻐﻴﺮ ﻳﺴﺘﻘﺒﻞ‪141 .................................................................................... companion object‬‬
‫ﺧﺎﻣﺴﺎ ً ‪ :‬ﻣﻌﻠﻮﻣﺎت ﺣﻮل‪143 ................................................................................ companion object‬‬
‫اﻟﺘﺼﻨﯿﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ ‪145 ................................................................ NASTED CLASSES‬‬
‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ ‪145 ......................................................................................................‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﻃﺮﻳﻘﺔ ﺗﻌﺮﻳﻒ اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ ‪145 ......................................................................................‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬أﻫﻤﻴﺔ اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ ‪146 .....................................................................................................‬‬
‫راﺑﻌﺎ ً ‪ :‬ﻣﺼﻄﻠﺤﺎت ﻣﻬﻤﺔ ﻓﻲ اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ ‪146 .........................................................................‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪6‬‬

‫ﺧﺎﻣﺴﺎ ً ‪ :‬اﻧﺸﺎء ﻛﺎﺋﻦ ﻣﻦ‪146 ................................................................................................ inner class‬‬
‫ﺳﺎدﺳﺎ ً ‪ :‬ﻣﺜﺎل‪147 ..........................................................................................................................................‬‬
‫‪148 ............................................................................................... ENUM CLASS‬‬
‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم‪148 ..................................................................................................................... Enum class‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬اﺳﺘﺨﺪاﻣﻬﺎ‪148 ........................................................................................................... Enum class‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬ﺗﻌﺮﻳﻒ‪148 .................................................................................................................. Enum class‬‬
‫‪149 .................................................................................................. DATA CLASS‬‬
‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم‪149 ........................................................................................................................ data class‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﻃﺮﻳﻘﺔ‪150 ...................................................................................................................... data class‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬ﻣﺜﺎل ﻻﺳﺘﺨﺪام‪150 ................................................................................................................. class‬‬
‫راﺑﻌﺎ ً ‪ :‬اﺿﺎﻓﺔ ‪ data‬ﻗﺒﻞ ﺗﻌﺮﻳﻒ‪151 ............................................................................................... class‬‬
‫‪152 ........................................................................................... POLYMORPHISM‬‬
‫أوﻻ ً ‪ :‬ﻣﺒﺪأ‪152 .................................................................................................................. Polymorphism‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﺷﺮوط‪152 ............................................................................................................ Polymorphism‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬أﻣﺜﻠﺔ ﻣﺘﻨﻮﻋﺔ ﻟﻤﻔﻬﻮم‪153 ...................................................................................Polymorphism‬‬
‫اﻻﺳﺘﺜﻨﺎءات ‪159 ................................................................................. EXCEPTION-‬‬
‫أوﻻ ‪ :‬ﻣﺎ ﻫﻲ اﻻﺳﺘﺜﻨﺎءات ‪159 .......................................................................................................................‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬ﺗﻜﻮﻳﻦ اﻻﺳﺘﺜﻨﺎءات‪159 ......................................................................................................................‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬ﻣﺜﺎل ‪161 ...............................................................................................................................................‬‬
‫‪161 ....................................................................................... MULTI-THREADING‬‬
‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم ‪161 ................................................................................................................ multi-thread‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﻋﻤﻞ‪162 .................................................................................................................... multi-thread‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻟﺪوال اﻟﺘﻲ ﺗﻌﻤﻞ ﻣﻊ‪164 ................................................................................................. thread‬‬
‫‪167 ............................................................................................................ ANY‬‬
‫أوﻻ ً ‪ :‬ﻣﺎ ﻫﻮ ‪167 ........................................................................................................................... class any‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪7‬‬

 ‫ﺗﻘﺪﻳﻢ‬

‫ﻟﻐﺔ ‪ Kotlin‬اﺣﺪى اﻟﻠﻐﺎت اﻟﺘﻲ ﻻﻗﺖ رواﺟﺎ ً ﻓﻲ اﻟﺴـﻨﺘﻴﻦ اﻟﻤﺎﺿـﻴﺔ وزادت ﺷـﻌﺒﻴﺘﻬﺎ ﺑﻌﺪ دﻋﻤﻬﺎ اﻻﻧﺪروﻳﺪ‬
‫ﺑﺸﻜﻞ رﺳﻤﻲ ﻓﻲ اﻧﺪروﻳﺪ اﺳﺘﺪﻳﻮ ﻟﺒﺮﻣﺠﺔ ﺗﻄﺒﻴﻘﺎت اﻻﻧﺪروﻳﺪ ‪..‬‬

‫ﻟﻐﺔ ‪ Kotlin‬ﻗﺎدرة ﻋﻠﻰ ﺑﺮﻣﺠﺔ ﺗﻄﺒﻴﻘﺎت اﻟﻮﻳﺐ واﻟ ـ ــــــــــ ـ‪ IOS‬ﺑﺸـ ــ ـﻜﻞ ﻃﺒﻴﻌﻲ ﺑﺎﺳـ ــ ـﺘﺨﺪام أدوات‬
‫ﻟﻠﺘﻄﻮﻳﺮ ﻣﺪﻋﻮﻣﺔ ﻣﺒﺎﺷﺮة ﻣﻦ اﻟﺸﺮﻛﺔ اﻟﻤﻄﻮرة ﻟـ‪Kotlin‬‬

‫ﻜﺘﻴـﺐ ا ﻳﺠـﺎز ﻟﻐـﺔ ‪ Kotlin‬ﺑﺸـ ــــــ ـﻜـﻞ ﻋـﺎم ﻟﻴﺘﻤﻜﻦ اﻟﻤﺴـ ــــــ ـﺘﺨـﺪم اﻟﻤﺒﺘـﺪئ ﻓﻲ‬
‫ﺣـﺎوﻟـﺖ ﻓﻲ ﻫـﺬا اﻟ ُ‬
‫اﻟﺒﺮﻣﺠﺔ ﻣﻦ ﻣﻌﺮﻓﺔ ﺟﻤﻴﻊ ﺟﻮاﻧﺐ اﻟﻠﻐﺔ‪.‬‬

‫وﻓﻲ اﻟﻨﻬـﺎﻳـﺔ اﺣﻤـﺪ ﷲ ﻋﻠﻰ اﻧﻬـﺎء ﻫـﺬا اﻟﻌﻤـﻞ وارﺟﻮا ان ﻳﻜﻮن ﻧـﺎﻓﻌـﺎ ً ﻻﺛﺮاء اﻟﻤﺤﺘﻮى اﻟﻌﺮﺑﻲ ﻓﻲ‬
‫ﻣﺠﺎل اﻟﺒﺮﻣﺠﺔ‪.‬‬

‫اﺣﻤﺪ اﻟﺠﻌﻴﺪ‬
‫ﻣﻌﻠﻢ ﺣﺎﺳﺐ آﻟﻲ – وزارة اﻟﺘﺮ ﺑﻴﺔ واﻟﺘﻌﻠﻴﻢ‬
‫ا ﻟﺴﻌﻮدﻳﺔ‬
‫ﺗﻮاﺻﻞ‪aljo3aid@gmail.com :‬‬
‫‪966504511433.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪8‬‬

 ‫ﺑﻴﺌﺔ اﻟﻌﻤﻞ‬
‫ﻟﻠﺒـﺪء ﻓﻲ اﻟـﺪروس ﻧﺤﺘـﺎج اﻟﻰ ﺗﻬﻴﺌـﺔ ﺑﻴﺌـﺔ ﺗﺸـ ــــــ ـﻐﻴـﻞ ﻟﻠﻌﻤـﻞ ﻋﻠﻲ اﻟﺒﺮﻣﺠـﺔ و ‪Compiler‬‬
‫ﻟﻠﻐﺔ ‪ .Kotlin‬ﻧﺤﺘﺎج ﻟﻠﻘﻴﺎم ﺑﺒﻌﺾ اﻟﺨﻄﻮات ﻟﻨﺠﻌﻞ ﺟﻬﺎزك ﺟﺎﻫﺰ ﻟﻠﺒﺮﻣﺠﺔ‪.‬‬

‫ﺗﺜﺒﻴﺖ ‪JAVA 8‬‬

‫‪ Kotlin‬ﺗﻌﻤﻞ ﻋﻠﻰ ‪ JVM‬وﻟﻬﺬا اﻟﺴـ ــــ ـﺒﺐ ﻧﺤﺘﺎج اﻟﻰ ﺗﺜﺒﻴﺖ ‪ JDK 8‬ﻋﻠﻰ ﺟﻬﺎزك‪ .‬اذﻫﺐ‬
‫اﻟﻰ اﻟﻤﻮﻗﻊ اﻟﺮﺳ ـﻤﻲ ﻟ ـ ــــــــ ـﺎورا ﻛﻞ وﻗﻢ ﺑﺘﺤﻤﻴﻞ وﺗﺜﺒﻴﺖ ‪ JDK 8‬او اﺣﺪث‪ .‬اذا ﻛﻨﺖ ﻗﺪ ﺟﻬﺰت‬
‫ﺑﻴﺌﺔ ﻟﺒﺮﻣﺠﺔ ‪ JAVA‬ﻓﺒﻄﺒﻴﻌﺔ اﻟﺤﺎل ﻻ ﺗﺤﺘﺎج اﻟﻰ ﺗﺜﺒﻴﺖ ‪ JDK‬وﻟﻜﻦ ﻳﺠﺐ ان ﺗﺘﺎﻛﺪ ﻣﻦ رﻗﻢ‬
‫اﻻﺻـ ـــ ـﺪار ﻟﺪﻳﻚ ﺑﺎﺳـ ـــ ـﺘﺨﺪام اﻻﻣﺮ ‪ java -version‬ﻓﻲ ﻣﻮﺟﺔ اﻻواﻣﺮ ﻟﻠﻮﻧﺪوز او اﻟﻄﺮﻓﻴﺔ ﻟﻼﺟﻬﺰ‬
‫ﻳﻮﻧﻜﺲ وﻣﺎك‪.‬‬

‫ﺗﺜﺒﻴﺖ ‪IDE‬‬

‫ﻳﻮﺟﺪ اﻟﻜﺜﻴﺮ ﻣﻦ ﺑﺮاﻣﺞ ‪ IDE‬ﻋﻠﻲ ﺷـ ـﺒﻜﺔ اﻻﻧﺘﺮﻧﺖ وﻟﻜﻦ اﻟﺸـ ـﻬﻴﺮ ﻣﻨﻬﺎ ر ﺑﻤﺎ ﻳﻜﻮن ﻣﻌﺪود‬
‫ﻋﻠﻰ اﻻﺻﺎﺑﻊ ﻟﺬﻟﻚ ﺳﺄ ﻛﺘﺐ ﻟﻚ اﻻﺷﻬﺮ ﻣﻨﻬﺎ وﺗﺴﺘﻄﻴﻊ اﺧﺘﻴﺎر ﻣﺎﻳﻨﺎﺳﺒﻚ واﺳﺘﺨﺪاﻣﺔ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪9‬‬

 ‫اﺳﺘﺨﺪام ‪vs code‬‬

‫ﺣﻘﻴﻘﺔ ﻓﻲ اﻟﺒﺪا ﻳﺎت اﻧﺼ ـﺢ ﺑﺎﺳ ـﺘﺨﺪام ﻣﺤﺮرات ﺷ ـﻔﺮات ﺑﺴ ـﻴﻄﺔ ﻻﺗﺪﻋﻢ اﻻﻛﻤﺎل اﻟﺘﻠﻘﺎﺋﻲ‬
‫ﻟﻴﺲ ﻟﻠﻨﻌﻘﻴـﺪ وﻟﻜﻦ ﻟﺠﻌـﻞ ﻳـﺪك ﻣﻤـﺎرﺳـ ــــــ ـﻪ ﻟﻠﻜﺘـﺎﺑـﺔ اﻟﺴـ ــــــ ـﺮ ﻳﻌـﺔ وا ﻳﻀـ ــــــ ـﺎ ً ﻟﻠﻔﻬﻢ اﻟﺠﻴـﺪ دون‬
‫اﺳﺘﺨﺪام ﺑﺮاﻣﺞ اﻻﻛﻤﺎل اﻟﺘﻠﻘﺎﺋﻲ‪.‬‬

‫ﻣﻦ اﻓﻀـ ـﻞ ﻣﺤﺮرات اﻻﻛﻮاد اﻟﺘﻲ اﺳـ ـﺘﺨﺪﻣﺘﻬﺎ ﻣﺆﺧﺮا ً وﻫﻮ ‪ vs code‬ﻣﺤﺮر ﺑﺴـ ـﻴﻂ وﻟﻜﻦ‬
‫ﻛﻤﻴـﺔ اﻻﺿـ ـــــــ ـﺎﻓـﺎت اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﻤﺘﺠﺮ اﻟﺨـﺎص ﻓﻴـﻪ ﺗﺠﻌـﻞ ﻣﻨـﻪ ﻣﻨـﺎﻓﺲ ﺷـ ــــــ ـﺮس ﻟﻠﺒﺮاﻣﺞ‬
‫اﻟﻜﺒﻴﺮة واﻟﻤﺘﺨﺼﺼﻪ‪.‬‬

‫‪ v‬ﺗﺤﻤﻴﻞ اﻟﺒﺮﻧﺎﻣﺞ‬

‫‪ v‬اﺿﺎﻓﺔ ‪Kotlin‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪10‬‬

‫اﺿـ ـﺎﻓﺔ ﺗﻘﻮم ﺑﺪﻋﻢ ‪ Syntax highlighter‬ﻓﻲ ﻟﻐﺔ ‪ kotlin‬ﺣﺼـ ـﻠﺖ اﻻﺿـ ـﺎﻓﺔ ﻋﻠﻰ ‪ 30‬اﻟﻒ‬
‫ﺗﺤﻤﻴﻞ ﺗﻘﺮ ﻳﺒﺎ ً وﻣﺪﻋﻮﻣﺔ ﺑﺸ ـﻜﻞ ﻛﺒﻴﺮ ﻣﻦ اﻟﻤﻄﻮر ﻋﻠﻰ ﺻ ـﻔﺤﺔ ‪ github‬اﻟﺨﺎﺻ ـﺔ ﺣﻴﺚ ﺗﺘﻴﺢ‬
‫ﻟﻚ ﺗﺸﻐﻴﻞ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﻣﻦ اي ﺻﻔﺤﺔ ﻣﻔﺘﻮﺣﺔ ﻣﺒﺎﺷﺮة‪.‬‬

‫اﻻﺿـ ـــ ـﺎﻓﺔ ﺑﺪورﻫﺎ ﺳـ ـــ ـﺘﻘﻮم ﺑﺘﺤﺪﻳﺪ اﻟﻤﺘﻐﻴﺮات ﺑﺎﻟﻮان ﻣﺨﺘﻠﻔﺔ وﺗﺮﺗﻴﺐ اﻟﺸـ ـــ ـﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‬
‫ﺑﺸﻜﻞ ﺟﺬاب وﺟﻤﻴﻞ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪11‬‬

 ‫‪ v‬إﺿ ﺎﻓ ﺔ ﺳ ﻤ ﺔ ﻟﻴﻠﻴﺔ‬

‫ﻣــﺎﻳﻬﻢ اﻟﻤﺒﺮﻣﺠﻴﻦ ان ﻳﻜﻮن اﻟﻤﺤﺮر ﻣﺮ ﻳﺢ ﻟﻠﻌﻴﻦ ﻓﻨﻌﻠﻢ ﺟﻤﻴﻌـ ـﺎ ً اﻋﺘﻜـ ـﺎﻓﻨـ ـﺎ ﻋﻠﻰ اﺟﻬﺰة‬
‫اﻟﺤﺴـﺎب ﻻوﻗﺎت ﻃﻮ ﻳﻠﺔ وﻟﻜﻦ ﻫﺬا اﻟﺸـﻲ ﻣﺘﻌﺐ ﻟﻠﻌﻴﻦ ﻓﻲ ﺣﺎﻟﺔ ﻛﺎﻧﺖ اﻟﺸـﺎﺷـﺔ ﺗﺸـﻊ ﺑﺎﻟﻠﻮن‬
‫اﻻﺑﻴﺾ وﻟﺬﻟﻚ ﺳـ ـﻨﺤﺘﺎج اﻟﻰ اﺿـ ـﺎﻓﺔ ﺳـ ـﻤﺎت ﻟﻴﻠﻴﺔ ﻟﻠﺒﺮﻧﺎﻣﺞ وﺳـ ـﺎﻗﻮم ﺑﺎﺿـ ـﺎﻓﺔ اﻟﺴـ ـﻤﺔ اﻟﺘﻲ‬
‫اﺳﺘﺨﺪﻣﻬﺎ ‪ .‬اﺳﻢ اﻟﺴﻤﺔ‪Atom One Dark Theme .‬‬

‫‪ v‬اﺿﺎﻓﺔ ا ﻳﻘﻮﻧﺎت ﺗﻮﺿﻴﺤﻴﺔ‬

‫ﻧﻌﻠﻢ ﺟﻤﻴﻌﺎ ً ان اي ﻟﻐﺔ ﺑﺮﻣﺠﺔ ﻳﻜﻮن ﻟﻬﺎ ا ﻳﻘﻮﻧﺔ ﺗﻮﺿــﻴﺤﻴﺔ وﺳــﻨﻘﻮم ﺑﺎﺿــﺎﻓﺘﻬﺎ ﻟﻠﺒﺮﻧﺎﻣﺞ‬
‫وذﻟﻚ ﻻﻋﻄﺎء اﻟﺒﺮﻧﺎﻣﺞ ﺷـ ــ ـﻜﻞ ﺟﻤﻴﻞ وﻣﺮﺗﺐ ‪ .‬اﻻﺿـ ــ ـﺎﻓﺔ ﺗﺨﻄﺖ اﻟﻤﻠﻴﻮن ﺗﺤﻤﻴﻞ ﻟﺸـ ــ ـﻌﺒﻴﺘﻬﺎ‬
‫وﺟﺬاﺑﻴﺘﻬﺎ ودﻋﻤﻬﺎ اﻟﻤﺴﺘﻤﺮ ﻣﻦ اﻟﻤﺒﺮﻣﺞ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪12‬‬

 ‫ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﺷﻜﺎل اﻻﻳﻘﻮﻧﺎت اﻟﺨﺎﺻﺔ ﺑﻠﻐﺎت اﻟﺒﺮﻣﺠﺔ‬

‫اﻵن اﺻﺒﺢ ﻟﺪﻳﻚ ﻣﺤﺮر أ ﻛﻮاد ﻗﻮي وﻣﻨﺎﻓﺲ ﻛﺒﻴﺮ‪.‬‬

‫ﻣﻮﺟﻪ اﻷواﻣﺮ‬

‫ـــــــــــ ـ ‪Kotlin‬‬ ‫اﻻن ﻧﺤﺘﺎج ﻟﺘﺤﻤﻴﻞ اﺿـ ـــ ـﺎﻓﺎت ﻟﻠﻨﻈﺎم ﻟﻌﻤﻞ ‪ compiler‬ﻟﻠﺸـ ـــ ـﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﻟ ـ‬
‫ﺑﺎﺳﺘﺨﺪام ﻣﻮﺟﻪ اﻻواﻣﺮ ﻻن اﻻﺿﺎﻓﺔ ﺗﻌﺘﻤﺪ ﻋﻠﻴﻪ ﺑﺸﻜﻞ اﺳﺎﺳﻲ‪.‬‬

‫ﻗﻢ ﺑﺘﺤﻤﻴﻞ اﺧﺮ اﺻﺪار ﻣﻦ ﻫﻨﺎ وﺳﻴﻘﻮم ﺑﺎﻟﺘﺜﺒﻴﺖ ﺑﺸﻜﻞ ﺗﻠﻘﺎﺋﻲ‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪13‬‬

 ‫اﻻن ﻳﻤﻜﻨﻚ اﻻﻧﺘﻘﺎل ﻟﻠﺪروس وﻣﺘﺎﺑﻌﺘﻬﺎ‬

‫ﺗﻬﻴﺌﺔ ‪ Eclipse‬ﻟﺒﺮﻣﺠﺔ ‪Kotlin‬‬

‫ﻳﻌﺘﺒﺮ ‪ Eclipse‬ﻣﻦ أﻗﻮى ‪ IDE‬اﻟﻤﺠﺎﻧﻴﺔ ﻓﻲ اﻟﺒﺮﻣﺠﺔ ﻻﺣﺘﻮاﺋﻪ ﻋﻠﻲ ﻣﺘﺠﺮ وإﺿـ ـــ ـﺎﻓﺎت ﻛﺜﻴﺮة‬
‫ﺗﺪﻋﻢ اﻟﻌﺪﻳﺪ ﻣﻦ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ واﻟﺪﻋﻢ اﻟﻜﺒﻴﺮ ﻣﻦ اﻟﻤﻄﻮر ﻳﻦ‪.‬‬

‫ﻧﺤﺘﺎج اﺿﺎﻓﺔ ﺑﻌﺾ اﻻدوات ﻟﻠﺒﺮﻧﺎﻣﺞ ﺣﺘﻰ ﻧﺴﺘﻄﻴﻊ اﺳﺘﺨﺪاﻣﺔ ﻓﻲ ﺑﺮﻣﺠﺔ ‪.Kotlin‬‬

‫ﺗﺜﺒﻴﺖ اﻻدوات‬

‫اﻓﺘﺢ ﺑﺮﻧـﺎﻣﺞ ‪ Eclipse‬واذﻫـﺐ اﻟﻰ ﺧﻴـﺎر ”‪ “Eclipse Market Place‬ﺳـ ــــــ ـﺘﻈﻬﺮ ﻟـﻚ ﻧـﺎﻓـﺬه‬
‫ﻣﺸﺎﺑﻬﻪ ﻟﻤﺎ ﻓﻲ اﻻﺳﻔﻞ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪14‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪15‬‬
‫ﻓﻲ ﻣﺮ ﺑﻊ اﻟﺒﺤﺚ ا ﻛﺘﺐ ‪ kotlin‬وﺳﺘﻈﻬﺮ ﻟﻚ ﻧﺘﻴﺠﺔ ﻣﺸﺎﺑﻬﺔ ﻟﻤﺎ ﻓﻲ اﻟﺼﻮرة ﻗﻢ ﺑﺘﺜﺒﻴﺘﻬﺎ ﻓﻲ‬
‫اﻟﻐﺎﻟﺐ ﺳـ ـﺘﺤﺘﺎج اﻻﻧﺘﻈﺎر ﻟﺒﻌﺾ اﻟﻮﻗﺖ ﻟﺘﺤﻤﻴﻞ وذﻟﻚ ﻳﻌﺘﻤﺪ ﻋﻠﻰ ﺳـ ـﺮﻋﺔ اﻻﻧﺘﺮﻧﺖ ﻟﺪﻳﻚ ‪.‬‬
‫ﻓﻲ اﻟﻐﺎﻟﺐ ﺑﻌﺪ اﻟﺘﺤﺪﻳﺚ ﺳﺘﺤﺘﺎج اﻟﻰ اﻋﺎدة ﺗﺸﻐﻴﻞ‪Eclipse .‬‬

‫ﻣﺸﺮوع ‪Kotlin‬‬

‫اﻵن ﺑﻌﺪ اﻋﺎدة اﻟﺘﺸـﻐﻴﻞ ﺳـﺘﺴـﻄﻴﻊ اﺳـﺘﺨﺪام ‪ Eclipse‬ﻓﻲ ﺑﺮﻣﺠﺔ ﻣﺸـﺎر ﻳﻊ ‪ Kotlin .‬ﻣﻦ‬
‫ﻗﺎﺋﻤﺔ ‪ File -> New -> Others‬ﺑﻌﺪ ذﻟﻚ ﻗﻢ ﺑﺎﺧﺘﻴﺎر ”‪ “Kotlin project‬ﻣﻦ اﻟﻘﺎﺋﻤﺔ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪16‬‬

‫ﺳـ ـــ ـﻴﻨﺸـ ـــ ـﺊ ﻟﺪﻳﻚ ﻣﺸـ ـــ ـﺮوع ‪ Kotlin‬ﺟﺪﻳﺪ وﺳـ ـــ ـﺘﺠﺪ ﻣﻠﻒ ‪ Kotlin‬داﺧﻞ ﻣﺠﻠﺪ ‪ src .‬ﻋﻨﺪ‬
‫اﻟﻀﻐﻂ ﺑﺰر اﻟﻤﺎوس اﻻﻳﻤﻴﻦ ﻋﻠﻰ ﻣﺠﻠﺪ ‪ src‬ﺳﺘﺠﺪ اﻟﻜﺜﻴﺮ ﻣﻦ اﻟﺨﻴﺎرات ﺗﺨﺺ‪ Kotlin‬ﻻﻧﺸﺎء‬
‫ﻓﺼﺎﺋﻞ وا ﻳﻀﺎ ً ‪ interface‬اﻟﺦ‪...‬‬

‫ﺳﺘﺠﺪ ﻟﺪﻳﻚ ﺻﻮرة ﻣﺸﺎﺑﻬﻪ ﻟﻤﺎ ﻓﻲ اﻻﺳﻔﻞ‪.‬‬

‫اﻫﻼ ً ﺑﺎﻟﻌﺎﻟﻢ‬

‫ﻃﺎﻟﻤـﺎ رأ ﻳﺘﻬـﺎ ﻓﻲ ﺟﻤﻴﻊ ﻟﻐـﺎت‬

‫ﻋﻨـﺪ ﻓﺘﺢ ﻣﻠﻒ ‪ Hello.kt‬ﺳـ ــــــ ـﺘﺠـﺪ ﺷـ ــــــ ـﻔﺮة ﺑﺮﻣﺠﻴـﺔ اﻟﺘﻲ ﻻ ـ‬
‫اﻟﺒﺮﻣﺠﺔ‪“Hello World” .‬‬

‫{ )>‪fun main(args: Array<String‬‬

‫)"!‪println("Hello, World‬‬
‫}‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪17‬‬

‫ﻋﻨﺪ ﺗﺸﻐﻴﻞ اﻟﻤﺸﺮوع ﺳﺘﻈﻬﺮ ﻟﻚ رﺳﺎﻟﺔ ﻓﻲ ‪ console output‬وﺳﺘﻜﻮن اﻟﻨﺘﻴﺠﺔ ﻃﺒﺎﻋﺔ‬
‫رﺳﺎﻟﺔ "اﻫﻼ ﺑﺎﻟﻌﺎﻟﻢ"‪.‬‬

‫ﻟﻐﺔ ‪Kotlin‬‬

‫أوﻻ ‪ :‬ﻣﻘﺪﻣﺔ‬

‫ُﺗﻌـﺪ ‪ Kotlin‬ﻟﻐـﺔ ﺑﺮﻣﺠﻴـﺔ ﻛـﺎﺋﻨﻴـﺔ اﻟﺘﻮﺟـﻪ ﺗﻌﻤـﻞ ﻋﻠﻰ ‪ JVM‬وﻣﺘﻮاﻓﻘـﺔ ﻣﻊ ﺣﺰﻣـﺔ ‪JDK‬‬
‫ﺑﺸــﻜﻞ ﻛﺎﻣﻞ‪ ،‬ﺗﻢ اﻃﻼق وﺗﻄﻮ ﻳﺮ ﻫﺬه اﻟﻠﻐﺔ ﻋﺎم ‪٢٠١١‬م ﻣﻦ ﻗﺒﻞ ﺷــﺮﻛﺔ ‪ JetBrains‬اﻟﺸـ ـﺮﻛﺔ‬
‫اﻟﻤﻄﻮرة ﻷﻛﺒﺮ وأﺷـ ـــ ـﻬﺮ ﻣﺠﻤﻮﻋﺔ ‪ IDE‬ﻣﺴـ ـــ ـﺘﺨﺪﻣﻪ ﺣﻮل اﻟﻌﺎﻟﻢ ﻣﻊ ﻣﺨﺘﻠﻒ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ‪،‬‬
‫وﺗﻌﺘﺒﺮ ﻟﻐﺔ ﻣﻔﺘﻮﺣﺔ اﻟﻤﺼـ ـﺪر ‪ .‬وﻟﻘﺪ ‪ Google‬ﺧﻼل ﻓﻌﺎﻟﻴﺎت ﻣﺆﺗﻤﺮ ‪ I/O‬ﻟﻠﻌﺎم ‪2017‬م ﺑﺪء‬
‫اﻟﺪﻋﻢ ﻟﻬﺬه اﻟﻠﻐﺔ وﺳـﻴﺘﻢ ﺗﻀـﻤﻴﻨﻬﺎ ﻓﻲ ﻧﺴـﺨﺔ ‪ Android Studio 3.0‬اﻟﺠﺪﻳﺪة ﺑﺪون اﻟﺤﺎﺟﺔ‬
‫ﻹﻋﺪادات اﻟﺘﺜﺒﻴﺖ اﻹﺿﺎﻓﻴﺔ‪.‬‬

‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﺟﺎﻓﺎ ‪ Java‬أم ﻛﻮﺗﻠﻦ ‪Kotlin‬‬

‫ﺑـﺎﻟﻄﺒﻊ وﺟﻮد ﻛﻮﺗﻠﻦ ﻻ ﻳﻠﻐﻲ أﻫﻤﻴـﺔ اﻟﺠـﺎﻓـﺎ ووﺟﻮدﻫـﺎ واﺧﺘﻴـﺎرك ﻟﻠﺠـﺎﻓـﺎ أم ﻟﻠﻜﻮﺗﻠﻦ ﻳﻌﻮد‬
‫ﻟﻚ وﻟﻄﺒﻴﻌﺔ ﻋﻤﻠﻚ وﻟﻠﻔﺮ ﻳﻖ اﻟﺬي ﺗﻌﻤﻞ ﻣﻌﻪ ‪ ،‬أﻣﺎ ﺑﺎﻟﻤﺠﻤﻞ ﻓﺘﻌﺘﺒﺮ ﻛﻮﺗﻠﻦ ﻟﻐﺔ اﻧﺴـ ـــ ـﻴﺎﺑﻴﺔ‬
‫وﺳـﻬﻠﺔ اﻟﻔﻬﻢ وﺗﻮﻓﺮ اﻟﻮﻗﺖ واﻟﺠﻬﺪ ﻓﻤﻄﻮري اﻟﻠﻐﺔ ﺣﺮﺻـﻮ ﻋﻠﻰ ﺗﻼﻓﻲ اﻷﺧﻄﺎء وﺣﻞ ﻣﺸـﺎﻛﻞ‬
‫اﻟﺘﺮﻣﻴﺰ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪18‬‬

 ‫ﺛﺎﻟﺜﺎ ً ‪ :‬ﻣﺰا ﻳﺎ ﻟﻐﺔ ﻛﻮﺗﻠﻦ ‪Kotlin‬‬

‫• ﻟﻐﺔ ﻣﻔﺘﻮﺣﺔ اﻟﻤﺼﺪر‪.‬‬

‫• ﺗﻮﻓﻴﺮ اﻟﻮﻗﺖ واﻟﺠﻬﺪ‪.‬‬
‫• ﻣﺘﻮاﻓﻘﺔ ﻣﻊ ‪. android studio‬‬
‫• أﺧﻄﺎء أﻗﻞ وﺗﺘﻤﻴﺰ ﺑﻘﻀﺎﺋﻬﺎ ﻋﻠﻰ ﻣﺸﻜﻠﺔ ‪. NullPointerException‬‬
‫• ﺗﺘﻤﻴﺰ ﺑﺎﻻﻧﺴﻴﺎﺑﻴﺔ‪.‬‬
‫• أ ﻛﺜﺮ أﻣﺎن‪.‬‬
‫• ﻣﺘﻌﺪدة اﻻﺳﺘﺨﺪاﻣﺎت ﻓﻴﻤﻜﻨﻚ ﻣﻦ ﺧﻼﻟﻬﺎ ﺗﻄﻮﻳﺮ ﻣﻮاﻗﻊ اﻻﻧﺘﺮﻧﺖ ‪ ،‬اﻟﺴﻴﺮﻓﺮات ‪،‬‬
‫ﺳﻄﺢ اﻟﻤﻜﺘﺐ إﻟﺦ ‪.. .‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪19‬‬

 ‫اﻟﻤﻘﺪﻣﺔ‬

‫ﺳـ ــــ ـﺄﻗﺪم ﻓﻲ ﻫﺬه اﻟﺠﺰﺋﻴﺔ ﻣﻘﺪﻣﺔ ﻋﻦ ﺟﻤﻴﻊ اﻟﻌﻨﺎﺻـ ــــ ـﺮ اﻟﺘﻲ ﺗﺤﺘﺎﺟﻬﺎ ﻟﻔﻬﻢ ﺗﺮﻛﻴﺒﺔ ﺑﺮﻣﺠﺔ‬
‫ﻟﻐـﺔ ‪ Kotlin‬ﺑـﺪا ﻳـًﺔ ﻣﻦ اﻟﻤﺘﻐﻴﺮات وﻣﺮورا ً ﻋﻠﻰ اﻟﺨﻮارزﻣﻴـﺎت اﻟﺨـﺎﺻـ ـــــــ ـﺔ ﺑﻬـﺎ اﻟـﺪوارة واﻻﺧﺘﻴـﺎر‬
‫واﻻﺣﺘﻤﺎﻻت‪.‬‬

‫ﺑﺎذن ﷲ ﺳـ ــ ـﻴﻜﻮن ﻫﻨﺎك ﺗﻔﺎﺻـ ــ ـﻴﻞ ﻣﺬﻛﻮرة وﻣﻤﻴﺰات ﺧﺎﺻـ ــ ـﺔ ﺑﻠﻐﺔ ‪ Kotlin‬اﻟﺘﻲ ﺗﺠﻌﻠﻬﺎ‬
‫ﺑﺪﻳﻞ ﺟﻴﺪ ﻟﻠﻐﺔ ‪ JAVA‬وا ﻳﻀـ ــ ـﺎ ً ﻓﻲ وﻗﺖ ﻻﺣﻖ ﺳـ ــ ـﻨﺘﻌﻠﻢ ﻛﻴﻒ ﻧﺴـ ــ ـﺘﺨﺪﻣﻬﺎ ﻣﻊ ‪JavaScript‬‬
‫وا ﻳﻀـ ــــــ ـﺎ ً ﻓﻲ ﺑﺮﻣﺠـﺔ ﺗﻄﺒﻴﻘـﺎت اﻻﻧـﺪروﻳـﺪ و اﻻﻳﻔﻮن‪ .‬اﻧـﺖ اﻻن ﻋﻠﻰ ﺑﻌـﺪ ﺧﻄﻮات ﺑﺴـ ــــــ ـﻴﻄـﺔ ﻣﻦ‬
‫ﻫﺎ وﺗﺠﻌـﻠﻚ‬
‫ﺣﺎﻓﺰ ـﻟﻚ ﻟﻼﻃﻼع ﻋﻠﻰ ﺗـﻔﺎﺻـ ــــــ ــﻴﻞ ﻟﻢ اذﻛﺮ ـ‬
‫اﻟـﺒﺪا ـﻳﺔ وـﺑﺈذن ﷲ ﺳـ ــــــ ـﺘﻜﻮن اـﻟﺪروس ـ‬
‫ﺗﺘﻮﺳﻊ ﻓﻲ ﺗﻌﻠﻢ اﻟﻠﻐﺔ وﻓﻖ اﺣﺘﻴﺎﺟﺎﺗﻚ‪.‬‬

‫• اﻟﻤﺘﻐﻴﺮات‬
‫• ادﺧﺎل اﻟﺒﻴﺎﻧﺎت‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪20‬‬

 ‫• اﻟﺘﻌﻠﻴﻘﺎت‬
‫• اﻟﻌﻤﻠﻴﺎت اﻟﺮ ﻳﺎﺿﻴﺔ‬
‫• اﻟﻌﻤﻠﻴﺎت اﻟﻤﻨﻄﻘﻴﺔ‬
‫• اﻟﺴﻼﺳﻞ اﻟﻨﺼﻴﺔ‬
‫• اﻟﻤﺼﻔﻮﻓﺎت‬
‫• اﻟﻨﻄﺎق‬
‫• ‪Visibility Modifiers‬‬
‫• ‪ESCAPE SEQUENCE‬‬
‫• ‪UNICODE‬‬
‫• )‪REGEX (Regular Expression‬‬

‫اﻟﻤﺘﻐﻴﺮات‬

‫ﻋﻨﺪ ﺗﻌﻠﻢ أي ﻟﻐﺔ ﻓﻼﺑﺪ ﻣﻦ اﻟﺘﻄﺮق ﻷﺳـ ـﺎﺳـ ـﻴﺎﺗﻬﺎ وﻣﻦ ﺿـ ـﻤﻦ ﻫﺬه اﻷﺳـ ـﺎﺳـ ـﻴﺎت اﻟﻤﻬﻤﺔ‬
‫ﻫﻲ ﻛﺘﺎﺑﺔ اﻟﻤﺘﻐﻴﺮات ﺑﻄﺮ ﻳﻘﺔ ﺻـ ــ ـﺤﻴﺤﺔ وﺳـ ــ ـﻨﺘﻌﺮف ﻓﻲ ﻫﺬا اﻟﺪرس ﻋﻠﻰ ﺗﻌﺮ ﻳﻒ اﻟﻤﺘﻐﻴﺮات‪،‬‬
‫واﻟﺜﻮاﺑﺖ‪ ،‬وﺷﺮوط اﻟﺘﺴﻤﻴﺔ ‪ ،‬ﺟﻤﻠﺔ اﻟﻄﺒﺎﻋﺔ واﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‪.‬‬

‫اﻟﻤﺘﻐﻴﺮات ﻫﻲ ﻋﺒـﺎرة ﻋﻦ ﻗﻴﻤـﺔ ﻗـﺎﺑﻠـﺔ ﻟﻠﺘﻐﻴﻴﺮ اﺛﻨـﺎء ﻛﺘـﺎﺑـﺔ اﻟﺒﺮﻧـﺎﻣﺞ‪ ،‬ﻟﺘﻌﺮ ﻳﻒ اﻟﻤﺘﻐﻴﺮات‬
‫ﻓﻲ ﻟﻐﺔ ‪ kotlin‬ﻧﺴﺘﺨﺪام ﻛﻠﻤﺔ ‪ ،var‬وﺳﻨﺮى اﻷن أﺷﻜﺎل ﻣﺨﺘﻠﻔﺔ ﻟﻠﺘﻌﺮ ﻳﻒ ﺑﺎﻟﻤﺘﻐﻴﺮات‪.‬‬

‫أوﻻ ‪ :‬ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪21‬‬

 ‫‪ v‬اﺳ ﻨ ﺎد اﻟﻘ ﻴ ﻤ ﺔ‬

‫ﻳﻤﻜﻨﻚ اﻟﺘﻌﺮ ﻳﻒ ﺑﺎﻟﻤﺘﻐﻴﺮ ﻋﻦ ﻃﺮ ﻳﻖ ﺗﻌﺮ ﻳﻔﻪ واﺳﻨﺎد اﻟﻘﻴﻤﺔ ﻟﻪ ﻣﺒﺎﺷﺮة ‪.‬‬

‫”‪var myName=”Ahmed‬‬
‫‪var myAge=27‬‬

‫ﻓﻲ اﻟﻤﺜﺎل أﻋﻼه ﻟﻢ ﻧﺬﻛﺮ اﻟﻨﻮع وﻟﻜﻦ اﺳـ ـﻨﺪﻧﺎ اﻟﻘﻴﻤﺔ ﻛﻴﻒ ﻳﺴـ ـﺘﻄﻴﻊ اﻟﺒﺮﻧﺎﻣﺞ ﻣﻌﺮﻓﺔ ﻧﻮع‬
‫اﻟﻤﺘﻐﻴﺮ؟ ﺑﻮاﺳﻄﺔ ‪ compiler‬اﻟﺬي ﻳﻘﻮم ﺑﻤﻌﺮﻓﺔ اﻟﻨﻮع ﻣﻦ ﺧﻼل اﻟﻘﻴﻤﺔ اﻟﻤﺴﻨﺪة ﻟﻪ‪.‬‬

‫اذا ﻗﻤﺖ ﺑﺎﺳ ـﻨﺎد ﻗﻴﻤﺔ ﻟﻠﻤﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ‪ Int‬ﻣﺜﻼ ً ﻓﺎﻧﻚ ﻟﻦ ﺗﺴ ـﺘﻄﻴﻊ ﺗﻐﻴﻴﺮﻫﺎ اﻟﻰ اي ﻧﻮع‬
‫آﺧﺮ‪.‬‬

‫‪var age = 12‬‬

‫‪age = "12 years old" // Error: type mismatch‬‬

‫‪ v‬ﺗﻌﺮﻳﻒ ﺑﺎﻟﻤﺘﻐﻴﺮ واﻟﺘﻌﺮﻳﻒ ﺑﻨﻮﻋﻪ واﺳﻨﺎد اﻟﻘﻴﻤﺔ ﻣﺒﺎﺷﺮة‬

‫ﻳﻤﻜﻨﻚ اﻟﺘﻌﺮ ﻳﻒ ﺑﺎﻟﻤﺘﻐﻴﺮ واﻟﺘﻌﺮ ﻳﻒ ﺑﻨﻮﻋﻪ ﻣﻊ ﻣﺮاﻋﺎة ﻛﺘﺎﺑﺔ أول ﺣﺮف ﻣﻦ ﻧﻮﻋﻪ ﺑﺤﺮف‬
‫ﻛﺒﻴﺮ‪.‬‬

‫”‪var myName : String =”Ahmed‬‬

‫‪var myAge:Int=27‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪22‬‬

 ‫‪ v‬ﺗﻌ ﺮ ﻳﻒ ﺑﺎﻟﻤ ﺘﻐ ﻴﺮ و اﻟﺘ ﻌ ﺮ ﻳﻒ ﺑﻨﻮ ﻋ ﻪ و اﺳ ﻨﺎد اﻟﻘ ﻴ ﻤ ﺔ ﻻ ﺣ ﻘ ﺎ ً‬

‫ﻳﻤﻜﻨﻚ اﻟﺘﻌﺮ ﻳﻒ ﺑﺎﻟﻤﺘﻐﻴﺮ واﻟﺘﻌﺮ ﻳﻒ ﺑﻨﻮﻋﻪ ﻣﻊ ﻣﺮاﻋﺎة ﻛﺘﺎﺑﺔ أول ﺣﺮف ﻣﻦ ﻧﻮﻋﻪ ﺑﺤﺮف‬
‫ﻛﺒﻴﺮ ﻓﻲ ﺳﻄﺮ وﻳﻤﻜﻨﻨﺎ اﺳﻨﺎد اﻟﻘﻴﻤﺔ ﺧﻼل اﺳﻄﺮ اﻟﺒﺮﻧﺎﻣﺞ أو ﻓﻲ اﻟﺴﻄﺮ اﻟﺬي ﻳﻠﻴﻪ‪.‬‬

‫‪var myName : String‬‬

‫”‪myName=”Ahmed‬‬

‫ﻐـﻴﺮات ـﻓﻲ ـﻟﻐـ ــ ـﺔ ‪ kotlin‬أـﻧﻬـ ــ ـﺎ ﻻ ـﺗﺒـ ــ ـﺪأ ﺑـ ــ ـﺄي ـ‬

‫ﺣﺮف ـﻣﻦ اـﻟﺮـﻣﻮز‬ ‫ﻤـﺘ ـ‬
‫ﻌﺮ ـﻳﻒ اـﻟ ـ‬
‫ﻋﻨـ ــ ـﺪ ـﺗ ـ‬
‫ﻋﻰ ـ‬
‫ـﻳﺮا ـ‬
‫اﻟﻤﺨﺼﺼﺔ ﺑﺎﺳﺘﺜﻨﺎء )ـ( ﻣﺎ ﺗﻌﺮف ﺑﺎﻟﺸﺮﻃﺔ اﻟﺘﺤﺘﻴﺔ أو ‪.underscore‬‬

‫ﺛﺎﻧﻴﺎ ً ‪ :‬أﻧﻮاع اﻟﻤﺘﻐﻴﺮات‬

‫اﻟﻌﺪد اﻟﺼﺤﻴﺢ‬ ‫‪Int‬‬

‫ﻋﺪد ﺻﺤﻴﺢ ﻗﺼﻴﺮ‬ ‫‪Short‬‬
‫ﻋﺪد ﺻﺤﻴﺢ ﻃﻮ ﻳﻞ‬ ‫‪Long‬‬
‫ﻗﻴﻤﺔ ﻋﺸﺮ ﻳﺔ ﺑﺴﻴﻄﺔ‬ ‫‪Float‬‬
‫ﻗﻴﻤﺔ ﻋﺸﺮ ﻳﺔ أ ﻛﺜﺮ دﻗﺔ وﺗﺤﺪﻳﺪ‬ ‫‪Double‬‬
‫ﺣﺮف‬ ‫‪Char‬‬
‫ﺳﻠﺴﻠﺔ ﻧﺼﻴﺔ‬ ‫‪String‬‬
‫ﻣﺘﻐﻴﺮ ﻣﻨﻄﻘﻲ‬ ‫‪Bolean‬‬
‫ﻟـﻠـﺘـﻔـﺮ ﻳـﻖ ﺑـﻴـﻦ ‪ Double‬و ‪ Float‬ﻫـﻮ ﻋـﻨـ ــ ـﺪﻣـ ــ ـﺎ ﻧـﺮ ﻳـ ــ ـﺪ ﺗـﻌـﺮ ﻳـﻒ ﻣـﺘـﻐـﻴـﺮ ﻋﺸـ ـــــــ ـﺮي ﻣـﻦ‬
‫ﻧﻮع ‪ Float‬ﻧﻀﻊ ﻓﻲ ﻧﻬﺎﻳﺘﻪ ﺣﺮف ‪.f‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪23‬‬

 ‫ﻣﻊ ﻣﻼﺣﻈـ ـ ـﺔ ان اﻟﻤﺘﻐﻴﺮ ‪ double‬ﻳﺘﻜﻮن ﻣﻦ ‪ bit64‬ﺑﻌﻜﺲ ‪ float‬اﻟـ ـ ـﺬي ﻳﺘﻜﻮن ﻣﻦ‬
‫‪ bit32‬ﻓﻘﻂ‬

‫‪var cost:Double=12.9001111‬‬
‫‪var cost = 14.1655f‬‬

‫‪ v‬اﻟﺜ ﻮ اﺑﺖ‬

‫ﺗﻨﻄﺒﻖ ﻋﻠﻴﻪ ﻧﻔﺲ ﻣﻮاﺻـ ـــــ ـﻔﺎت اﻟﻤﺘﻐﻴﺮات ﺑﺎﺳـ ـــــ ـﺘﺜﻨﺎء أﻧﻪ ﻗﻴﻤﺔ ﻏﻴﺮ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻌﺪﻳﻞ أﺛﻨﺎء‬
‫اﻟﺒﺮﻧﺎﻣﺞ وﻟﺘﻌﺮ ﻳﻒ اﻟﺜﺎﺑﺖ ﻧﺴـ ـــ ـﺘﺨﺪم ﻛﻠﻤﺔ ‪ ، val‬ﻳﻤﻜﻨﻨﺎ اﻻﺳـ ـــ ـﺘﻔﺎدة ﻣﻨﻪ ﻓﻲ ﺗﻌﺮ ﻳﻒ اﻟﻘﻮاﻧﻴﻦ‬
‫اﻟﺮ ﻳـﺎﺿـ ــــــ ـﻴـﺔ أو ﻟﻮ ﻛـﺎن ﻫﻨـﺎﻟـﻚ رﻗﻢ وﻇﻴﻔﻲ ﻓﻬﻮ ﺛـﺎﺑـﺖ ﺑـﺎﻟﻄﺒﻊ ﻻ ﻳﻤﻜﻦ ﺗﻐﻴﻴﺮه آو رﻗﻢ اﻟﻬﻮﻳـﺔ‬
‫اﻟﻮﻃﻨﻲ‪.‬‬

‫‪val id:Int=601121‬‬
‫‪id = 1234 // Error‬‬

‫ﺛﺎﻟﺜﺎ ً ‪ :‬ﺗﺤﻮﻳﻞ اﻟﻤﺘﻐﻴﺮات‬

‫ر ﺑﻤﺎ ﻛﺘﺒﺖ ﻣﺘﻐﻴﺮ واردت ﺗﺤﻮﻳﻞ اﻟﻰ اي ﻧﻮع آﺧﺮ ﻓﺎﻧﻚ ﻟﻦ ﺗﺴـﺘﻄﻴﻊ ذﻟﻚ ﺑﺴـﺒﺐ اﻧﻚ ﻗﺪ‬
‫ﺣـﺪدت ﻧﻮع اﻟﻤﺘﻐﻴﺮ او ان ‪ Compiler‬ﻗـﺪ ﻗـﺎم ﺑﺘﺤـﺪﻳـﺪ ﻧﻮع اﻟﻤﺘﻐﻴﺮ اذا ﻛـﺎن اﺳـ ــــــ ـﻨـﺎد اﻟﻘﻴﻤـﺔ‬
‫ﺑﺸ ـﻜﻞ ﻣﺒﺎﺷ ـﺮ‪ .‬ﺗﺤﻮﻳﻞ اﻟﻤﺘﻐﻴﺮات اﺑﺴ ـﻂ ﻣﻤﺎ ﺗﺘﺨﻴﻞ ﻟﻦ ﺗﺤﺘﺎج اﻟﻰ ا ﻛﺜﺮ ﻣﻦ ﺳ ـﻄﺮ او ذا ﻛﺮة‬
‫ﻛﺒﻴﺮه ﻟﺤﻔﻆ اﻟﻄﺮ ﻳﻘﺔ‪ .‬ﺗﺎﺑﻊ اﻟﺸﻔﺮة اﻟﻘﺎدﻣﺔ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪24‬‬

val number1: Int = 55
val number2: Long = number1.toLong()

.‫)( وﺑﺸﻜﻞ ﺳﻠﺲ وﺑﺴﻴﻂ‬toLong ‫ ﺑﺎﺳﺘﺨﺪام داﻟﺔ‬Long ‫ اﻟﻰ‬Int ‫ﻻﺣﻆ ﻗﻤﻨﺎ ﺑﺘﺤﻮﻳﻞ‬

: ‫ﻗﺎﺋﻤﺔ ﺑﺠﻤﻴﻊ دوال اﻟﺘﺤﻮﻳﻞ‬

toByte()

toShort()

toInt()

toLong()

toFloat()

toDouble()

toChar()

Boolean !‫ﻻﺣﻆ ﻻ ﻳﻮﺟﺪ ﺗﻐﻴﻴﺮ ﻟﻠﻤﺘﻐﻴﺮ‬

"hello world" ‫ ﺑﺮﻧﺎﻣﺞ‬: ً ‫راﺑﻌﺎ‬

fun main(args : Array<String>)

{

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 25 ‫اﻟﺼﻔﺤﺔ‬

 ‫)"‪println("hello world‬‬
‫}‬

‫ﻧﺮى ﻫﻨﺎ اﻟﻔﺮق اﻟﻮاﺿـ ـــــ ـﺢ ﺑﻴﻨﻬﺎ وﺑﻴﻦ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﻣﻦ ﺣﻴﺚ اﻻﺧﺘﺼـ ـــــ ـﺎر اﻟﺸـ ـــــ ـﺪﻳﺪ ﻓﻲ ﻛﺘﺎﺑﺔ‬
‫اﻟﺪاﻟﺔ واﻟﻮاﺿﺢ ﻓﻲ ﻛﺘﺎﺑﺔ ﺟﻤﻠﺔ اﻟﻄﺒﺎﻋﺔ أ ﻳﻀﺎ‪.‬‬

‫ﺟﻤﻠـﺔ اﻟﻄﺒـﺎﻋـﺔ ﺗﻜﺘـﺐ ﺑﻄﺮ ﻳﻘﺘﻴﻦ اﻣـﺎ ‪ print‬او ‪ println‬اﻟﻔﺮق اﻟﻮﺣﻴـﺪ ﺑﻴﻨﻬﻤـﺎ ان اﻷﺧﻴﺮة‬
‫ﺗﺴﻤﺢ ﺑﺘﺮك ﺳﻄﺮ اﺳﻔﻞ اﻟﺠﻤﻠﺔ اﻟﻤﻄﺒﻮﻋﺔ‪.‬‬

‫‪ v‬ﻣ ﺜﺎل‬

‫)>‪fun main(args : Array<String‬‬

‫{‬
‫;‪var id:Int=105541‬‬
‫;"‪var carName:String="Corolla‬‬
‫;‪var price:Double= 1593.32‬‬
‫)"‪println("this car is : $carName and its price :$price‬‬
‫}‬

‫ﻓﻲ ﺟﻤﻠـﺔ اﻟﻄﺒـﺎﻋـﺔ ﻫـﺬه أردﻧـﺎ ﻛﺘـﺎﺑـﺔ ﺟﻤﻠـﺔ وﻣﻦ ﺛﻢ اﻟﻤﺘﻐﻴﺮ اﻟـﺬي ﻳﺤﻤـﻞ ﻗﻴﻤﺘﻬـﺎ وﻓﺼـ ــــــ ـﻠﻨـﺎ‬
‫ﺑﻴﻨﻬﻤﺎ ﺑﻌﻼﻣﺔ ‪ ، +‬ﻫﻨﺎﻟﻚ أ ﻳﻀﺎ ً ﻃﺮ ﻳﻘﺔ أﺧﺮى ﺳﻨﺘﻌﺮف ﻋﻠﻴﻬﺎ وﻫﻲ ‪:‬‬

‫)"‪println("this car is :$carName and its price: $price‬‬

‫اد ﺧ ﺎل اﻟﺒﻴﺎﻧﺎت‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪26‬‬

 ‫ﺳﺘﻘﺒﺎل اﻟﺒﻴﺎﻧﺎت ﻣﻦ اﻟﻤ ـ‬
‫ﺴﺘﺨﺪم وﻛﻴﻔﻴﺔ اﻟﺘﺤﻮﻳﻞ‬ ‫ﻓﻲ ﻫﺬا اﻟﺪرس ـ‬
‫ﺳﻨﺘﻌﺮف ﻋﻠﻰ ﻃﺮ ﻳﻘﺔ ا ـ‬
‫ﺑﻴﻦ اﻟﻤﺘﻐﻴﺮات ‪.‬‬

‫أوﻻ ‪ :‬داﻟﺔ ‪readLine‬‬

‫ﻧﺴـ ــــــ ـﺘﺨـﺪم ﻫـﺬه اﻟـﺪاﻟـﺔ ﻋﻨـﺪﻣـﺎ ﻧﺮ ﻳـﺪ اﺳـ ــــــ ـﺘﻘﺒـﺎل ﻗﻴﻤـﺔ ﻣﻦ اﻟﻤﺴـ ــــــ ـﺘﺨـﺪم ‪ ،‬ﻣﺜﻼ ﻃﻠﺒـﺖ ﻣﻦ‬
‫اﻟﻤﺴـﺘﺨﺪم أن ﻳﺪﺧﻞ اﺳـﻤﻪ و ﻋﻤﺮه واﻟﻤﺮﺣﻠﺔ اﻟﺪراﺳـﻴﺔ ﻓﻬﻨﺎ ﻧﻘﻮم ﺑﺎﺳـﺘﺨﺪام ﻫﺬه اﻟﺪاﻟﺔ ﻛﻤﺎ‬
‫ﺳﻨﺮى‪.‬‬

‫)"‪println("please enter your name‬‬

‫!!)(‪var yourName:String= readLine‬‬
‫)" ‪println("Hello $yourName‬‬

‫ﻓﻲ اﻟﻤﺜﺎل أﻋﻼه ﻃﻠﺒﻨﺎ ﻣﻦ اﻟﻤﺴﺘﺨﺪم أن ﻳﺪﺧﻞ اﺳﻤﻪ ﻣﻦ ﺧﻼل ﺟﻤﻠﺔ اﻟﻄﺒﺎﻋﺔ ‪ ،‬وﻣﻦ ﺛﻢ‬
‫ﻋﺮﻓﻨﺎ ﻣﺘﻐﻴﺮ وﺣﺪدﻧﺎ ﻧﻮﻋﻪ وﻗﻤﻨﺎ ﺑﺈﺳﻨﺎد اﻟﺪاﻟﺔ اﻟﺘﻲ ﺗﻘﻮم ﺑﺎﺳﺘﻘﺒﺎل ﻫﺬه اﻟﻘﻴﻤﺔ‪.‬‬

‫ﺗﻌﻨﻲ ﻗﻢ ﺑﻘﺮاءة ﻣﺎ ﺳﻮف ﻳﺪﺧﻠﻪ اﻟﻤﺴﺘﺨﺪم‪.‬‬

‫ﺛﺎﻧﻴﺎ ‪ :‬اﻟﺘﺤﻮﻳﻞ‬

‫‪ readLine‬ﻫﺬه اﻟﺪاﻟﺔ ﺗﺴـ ـــ ـﺘﻘﺒﻞ ﻗﻴﻤﺔ ﻓﻘﻂ ﻧﺼـ ـــ ـﻴﺔ أي ﻣﻦ ﻧﻮع ‪ ،String‬وﻟﻜﻦ ﻓﻠﻨﻔﺮض‬
‫أﻧﻨﺎ أردﻧﺎ ﻣﻦ اﻟﻤﺴﺘﺨﺪم إدﺧﺎل ﻋﻤﺮه واﻟﻌﻤﺮ ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ﺻﺤﻴﺢ‪ ،‬ﻣﺎ اﻟﻌﻤﻞ إذا ؟‬

‫اﻟﺤﻞ ﺑﺴﻴﻂ ﺟﺪا ً ﻛﺎﻟﺘﺎﻟﻲ ‪:‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪27‬‬

 ‫)"‪println("please enter your age‬‬
‫)(‪var yourAge:Int= readLine()!!.toInt‬‬
‫)(‪yourAge.toInt‬‬

‫ﻋﺮﻓﻨﺎ ﻣﺘﻐﻴﺮ اﻟﻌﻤﺮ ﻣﻦ ﻧﻮع ﻋﺪد ﺻـ ـــــ ـﺤﻴﺢ وﻣﻦ ﺛﻢ ﻗﻤﻨﺎ ﺑﺈﺳـ ـــــ ـﻨﺎد اﻟﺪاﻟﺔ ﻟﺘﻘﻮم ﺑﻘﺮاءة ﻣﺎ‬
‫ﻳﺪﺧﻠﻪ اﻟﻤﺴﺘﺨﺪم وﻣﻦ ﺛﻢ ﻗﻤﻨﺎ ﺑﺎﻟﺨﻄﻮة اﻟﺠﺪﻳﺪة اﻟﺘﺎﻟﻴﺔ وﻫﻲ اﻟﺘﺤﻮﻳﻞ ‪:‬‬

‫)(‪.toInt‬‬

‫ﻫـﺬا اﻟﺴـ ــــــ ـﻄﺮ ﻳﻌﻨﻲ أن ﻧﻘﻮم ﺑﺘﺤﻮﻳـﻞ اﻟﻌﻤﺮ ﻣﻦ ﻣﺘﻐﻴﺮ ﻧﺼـ ــــــ ـﻲ إﻟﻰ ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ﻋـﺪد‬
‫ﺻﺤﻴﺢ وذﻟﻚ ﻷن داﻟﺔ‬

‫ﺗﻘﺮأ اﻟﻨﺺ ﻋﻠﻰ أﻧﻪ ﺳﻠﺴﻠﺔ ﻧﺼﻴﺔ ‪.readline‬‬

‫ﻟﻮ أردﻧﺎ اﻟﺘﺤﻮﻳﻞ إﻟﻰ ﻣﺘﻐﻴﺮ ﻧﻮﻋﻪ ﻋﺪد ﻋﺸﺮي‪:‬‬

‫)(‪Age.toFloat‬‬

‫ﻫﻨﺎ ﻟﻮ أردﻧﺎ اﻟﺘﺤﻮﻳﻞ إﻟﻰ ﻣﺘﻐﻴﺮ ﻧﻮﻋﻪ ﻋﺪد ﻋﺸﺮي ﻣﺰدوج ‪:‬‬

‫)(‪Age.toDouble‬‬

‫ﻻ ﻳﻘﺘﺼﺮ اﻟﺘﺤﻮﻳﻞ ﻋﻠﻴﻬﻢ ﻓﻴﻤﻜﻨﻨﺎ اﻟﺘﺤﻮﻳﻞ إﻟﻰ أي ﻧﻮع‪ ،‬ﺑﺎﺳﺘﺜﻨﺎء ‪:‬‬

‫ﻋﺪد ﺻـ ــــــ ـﺤﻴﺢ ﻻ ﻳﻤﻜﻦ ﺗﺤﻮﻳـﻠﻪ إﻟﻰ ﻣﻨﻄﻘﻲ وذـﻟﻚ ﻷن اﻟﻤﻨﻄﻘﻲ ﻳﺤ ـ‬

‫ﻤﻞ‬ ‫اﻟﻤﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ـ‬
‫ﻗﻴﻤﺔ ﺻﺢ أو ﺧﻄﺎء‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪28‬‬

 ‫ ﻣ ﺜﺎل‬v

fun main(args : Array<String>){

println("please enter length for rectangle :")

var n1:Int=readLine()!!.toInt()
println("please enter width for rectangle:")
var n2:Int=readLine()!!.toInt()
var distance = n1*n2
var circumference=2*(n1+n2)
println("The distance = $distance and the circumference =
$circumference")

‫ ﻧﺎﺗﺞ اﻟﺘ ﻨ ﻔ ﻴ ﺬ‬v

please enter length for rectangle :

7
please enter width for rectangle:
4
The distance = 28 and the circumference = 22

‫اﻟﺘﻌ ﻠﻴﻘ ﺎت‬

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 29 ‫اﻟﺼﻔﺤﺔ‬

‫ﻻ ﻳﺨﻔﻰ ﻋﻠﻴﻨ ـﺎ أن ﻛﺘ ـﺎﺑ ـﺔ اﻟﺘﻌﻠﻴﻘ ـﺎت ﻣﻔﻴ ـﺪة ﺟ ـﺪا ً ﻟﻠﻤﺒﺮﻣﺠﻴﻦ ﻓﻬﻲ ﺗﻌﻤ ـﻞ ﻋﻠﻰ ﺗﻌﺮ ﻳﻒ‬
‫ﻌﺔ اﻟﺒﺮﻣﺠـﻴﺔ ﻛـﻔﺎـﺋﺪﺗـﻬﺎ أو ـﻣﺎ اﻟﻐﺮض ﻣﻨـﻬﺎ ﻓﻲ ﺣﻴﻦ أـﻧﻪ ﻧﺴـ ــــــ ـﻲ ـﻣﺎ اﻟـﻬﺪف اـﻟﺬي ﻣﻦ أﺟـﻠﻪ‬
‫اﻟﻘﻄ ـ‬
‫ﻛﺘﺒﻬﺎ ‪ ،‬وﻫﻲ ﻻ ﺗﺆﺛﺮ ﻓﻲ ﻋﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻛﻤﺎ ﻧﻌﻠﻢ ﻓﻼ ﻳﺘﻢ ﺗﻨﻔﻴﺬﻫﺎ ﻣﻦ اﻷﺳـﺎس ﻷن اﻟﺒﺮﻧﺎﻣﺞ ﻻ‬
‫ﻳﺴﺘﻄﻴﻊ ﻗﺮأﺗﻬﺎ ‪.‬‬

‫وﻟﻠﺘﻌﻠﻴﻘـﺎت ﻧﻮﻋـﺎن اﻣـﺎ ان ﺗﻜﻮن ﺳـ ــــــ ـﻄﺮ ﻳـﺔ أي ﺗﻌﻠﻴﻖ ﻓﻲ ﺳـ ــــــ ـﻄﺮ واح ﻓﻘﻂ أو ﻣﺘﻌـﺪدة‬
‫اﻷﺳﻄﺮ‪ ،‬ﻣﺜﺎل‪:‬‬

‫‪ v‬ﻣ ﺘﻌ ﺪ د ة اﻷ ﺳ ﻄ ﺮ‬

‫*‪/‬‬
‫‪* calculate distance and‬‬
‫‪* circumference for rectangle‬‬
‫‪*/‬‬
‫‪var length:Int=5‬‬
‫‪var width:Int=7‬‬
‫‪var distance=length * width‬‬
‫)‪println(distance‬‬
‫)‪var circumference= 2*(length+width‬‬
‫)‪println(circumference‬‬

‫‪ v‬ﺳ ﻄ ﺮ ﻳﺔ‬

‫‪var num1=5 //value num1‬‬

‫)‪println(num1‬‬
‫‪num1--‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪30‬‬

 ‫)‪println(num1‬‬

‫اﻟﻌ ﻤ ﻠﻴﺎت اﻟﺮ ﻳﺎﺿ ﻴﺔ‬

‫ﺳـ ـﻨﺘﻄﺮق إﻟﻰ اﻟﻌﻤﻠﻴﺎت اﻟﺮ ﻳﺎﺿـ ـﻴﺔ اﻟﺘﻲ ﺗﻠﻌﺐ دور ﻣﻬﻢ وﻛﺒﻴﺮ ﻓﻲ اﻟﺒﺮﻣﺠﺔ ‪ ،‬ﺳـ ـﻮف ﻧﻘﻮم‬
‫ﺑﺸـ ــ ـﺮح اﻟﻌﻤﻠﻴﺎت ‪ ،‬رﻣﻮزﻫﺎ ‪ ،‬ﻃﺮق ﻣﺨﺘﺼـ ــ ـﺮة ﻹﺟﺮاء اﻟﻌﻤﻠﻴﺎت وأ ﻳﻀـ ــ ـﺎ ً ﺳـ ــ ـﻨﺘﻌﻠﻢ ﻛﻴﻔﻴﺔ ﻛﺘﺎﺑﺔ‬
‫اﻟﺘﻌﻠﻴﻘﺎت‪.‬‬

‫أوﻻ ‪ :‬اﻟﺮﻣﻮز اﻟﺮﻳﺎﺿﻴﺔ‬

‫ﻓﻲ اﻟﺒﺪا ﻳﺔ ﻧﺤﺐ أن ﻧﻘﻮم ﺑﺘﻌﺮ ﻳﻒ اﻟﻌﻤﻠﻴﺎت اﻷﺳـ ــ ـﺎﺳـ ــ ـﻴﺔ وﻫﻲ ‪ :‬اﻟﺠﻤﻊ‪ ،‬اﻟﻄﺮح‪ ،‬اﻟﻀـ ــ ـﺮب‪،‬‬
‫اﻟﻘﺴﻤﺔ وﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ‪.‬‬

‫اﻟﻌﻤﻠﻴﺔ‬ ‫اﻟﺮﻣﺰ‬
‫اﻟﺠﻤﻊ‬ ‫‪+‬‬
‫اﻟﻄﺮح‬ ‫–‬
‫اﻟﻀﺮب‬ ‫*‬
‫اﻟﻘﺴﻤﺔ‬ ‫‪/‬‬
‫ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ‬ ‫‪٪‬‬
‫ﻓﻲ اﻟﻌﻤﻠﻴﺎت اﻟﺮ ﻳﺎﺿـﻴﺔ ﻳﺮاﻋﻰ ﻋﻨﺪ ﺗﻨﻔﻴﺬﻫﺎ إذا ﻛﺎﻧﺖ ﺗﺘ ـ‬
‫ﻀﻤﻦ اﻷﻗﻮاس‪ ،‬وﻋﻤﻠﻴﺔ اﻟﻀـﺮب‪/‬‬
‫اﻟﻘﺴﻤﺔ‪ ،‬واﻟﺠﻤﻊ‪ /‬اﻟﻄﺮح اﻟﺘﺎﻟﻲ‪:‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪31‬‬

 ‫ﻧﺒﺪأ ﺑﺘﻨﻔﻴﺬ ﻣﺎ ﺑﻴﻦ اﻷﻗﻮاس وﻣﻦ ﺛﻢ ﻋﻤﻠﻴﺔ اﻟﻀﺮب‪ /‬اﻟﻘﺴﻤﺔ وﻣﻦ ﺛﻢ اﻟﺠﻤﻊ‪ /‬اﻟﻄﺮح‪.‬‬

‫ﻫﺬا ﻣﺜﺎل ﻳﺤﺴـﺐ ﻟﻨﺎ ﻣﺴـﺎﺣﺔ اﻟﻤﺴـﺘﻄﻴﻞ وﻣﺤﻴﻄﻪ‪ ،‬ﻧﺠﺪ أن اﻟﻤﺴـﺎﺣﺔ ﻫﻲ ﻣﺠﺮد ﻋﻤﻠﻴﺔ‬
‫ﺿـ ـــ ـﺮب ﻋﺎدﻳﺔ ‪ ،‬وﺑﺎﻟﻨﺴـ ـــ ـﺒﺔ ﻟﻠﻤﺤﻴﻂ ﻓﻬﻮ ﻳﻌﻄﻲ أوﻟﻮﻳﺔ اﻟﺘﻨﻔﻴﺬ إﻟﻰ اﻷﻗﻮاس وﻣﻦ ﺛﻢ ﻳﻀـ ـــ ـﺮب‬
‫اﻟﻨﺎﺗﺞ ﻓﻲ ‪.٢‬‬

‫‪var length:Int=5‬‬
‫‪var width:Int=7‬‬
‫‪var distance=length * width‬‬
‫)‪println(distance‬‬
‫)‪var circumference= 2*(length+width‬‬
‫)‪println(circumference‬‬

‫ﻤﺔ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ واردﻧﺎ اﺟﺮاء ﻋﻤﻠﻴﺔ اﻟﻀـ ــــــ ـﺮب‬

‫ﻤﻞ ﻗﻴ ـ‬
‫ﻫـﻨﺎ ﻗﻤـﻨﺎ ﺑﺎﺧﺘﺼـ ــــــ ـﺎر ﻓـﻠﺪي ﻣﺘﻐﻴﺮ ﻳﺤ ـ‬
‫ﻋﻠﻴﻪ ﻓﻘﻤﻨﺎ ﺑﻜﺘﺎﺑﺔ ‪ num *=3‬ﺑﺪﻻ ﻣﻦ ﻛﺘﺎﺑﺔ‪num=num*3 .‬‬

‫ﺳﻢ اﻟﻤﺘﻐﻴﺮ وﻣﻦ ﺛﻢ رﻣﺰ اﻟﻌﻤﻠﻴﺔ‬

‫ﺴﻤﺔ ﻧﻘﻮم ﺑﻜﺘﺎﺑﺔ ا ـ‬
‫ﻛﺬﻟﻚ اﻷﻣﺮ ﻟﻮ أردﻧﺎ اﺟﺮاء ﻃﺮح او ﻗ ـ‬
‫ﻋﻼﻣﺔ اﻟﻤﺴﺎواة وﻣﻦ ﺛﻢ اﻟﻌﺪد اﻟﺬي ﻧﺮﻏﺐ ﺑﺈﺟﺮاء اﻟﻌﻤﻠﻴﺔ ﻋﻠﻴﻪ‪.‬‬

‫‪var num=9‬‬
‫)‪println(num‬‬
‫‪num *=3‬‬
‫)‪println(num‬‬

‫ﺛﺎﻧﻴﺎ ‪Decrement & Increment :‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪32‬‬

‫ﻟﻨﻔﺮض أن ﻟﺪي ﻣﺘﻐﻴﺮ وأر ﻳﺪ ز ﻳﺎدﺗﻪ ﺑﻌﺪد واﺣﺪ ﻓﻘﻂ ﺳـ ـﻮف ﻧﻘﻮم ﺑﻌﻤﻠﻴﺔ ﺑﺴـ ـﻴﻄﺔ ﺟﺪا ً‬
‫وﻫﻲ ﺗﻌﺮف ﺑﺎﻟﺰ ﻳﺎدة أو‪.Increment‬‬

‫‪var num1=5‬‬
‫)‪println(num1‬‬
‫‪num1++‬‬
‫)‪println(num1‬‬

‫ﻫﻨﺎ ﻗﻤﻨﺎ ﺑﺎﻹﺧﺘﺼﺎر ﻓﺒﺪﻻ ﻣﻦ ﻛﺘﺎﺑﺔ ‪:‬‬

‫‪num=num+1‬‬

‫ﻗﻤﻨﺎ ﺑﻜﺘﺎﺑﺔ ‪:‬‬

‫‪num1++‬‬

‫ﻟﻮ أردﻧﺎ ﻃﺮح ﻋﺪد واﺣﺪ ﻣﻦ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﺳـ ـــــ ـﻮف ﻧﻘﻮم ﺑﻌﻤﻠﻴﺔ اﻟﻨﻘﺼـ ـــــ ـﺎن أو ﻣﺎ ﺗﻌﺮف‬
‫ﺑـ ‪Decrement‬‬

‫‪var num1=5‬‬
‫)‪println(num1‬‬
‫‪num1--‬‬
‫)‪println(num1‬‬

‫اﻟﻌ ﻤ ﻠﻴﺎت اﻟﻤ ﻨﻄ ﻘ ﻴﺔ‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪33‬‬

‫ﺳـ ــــــ ـﻨﺘﻄﺮق إﻟﻰ اﻟﻌﻤﻠﻴـﺎت اﻟﻤﻨﻄﻘﻴـﺔ اﻟﺘﻲ ﻫﻲ أ ﻳﻀـ ـــــــ ـﺎ ﺑـﺪورﻫـﺎ ﺗﻠﻌـﺐ دور ﻣﻬﻢ وﻛﺒﻴﺮ ﻓﻲ‬
‫اﻟﺒﺮﻣﺠﺔ‪ ،‬ﺳـ ـــ ـﻮف ﻧﻘﻮم ﺑﺸـ ـــ ـﺮح اﻟﻌﻤﻠﻴﺎت‪ ،‬رﻣﻮزﻫﺎ‪ ،‬ﻃﺮق ﻣﺨﺘﺼـ ـــ ـﺮة ﻹﺟﺮاء اﻟﻌﻤﻠﻴﺎت وأ ﻳﻀـ ـــ ـﺎ ً‬
‫ﺳﻨﺘﻌﻠﻢ ﻛﻴﻔﻴﺔ ﻛﺘﺎﺑﺔ اﻟﺘﻌﻠﻴﻘﺎت‪.‬‬

‫أوﻻ ‪ :‬اﻟﺮﻣﻮز اﻟﻤﻨﻄﻘﻴﺔ‬

‫ﻓﻲ اﻟﺒـﺪا ﻳـﺔ ﻧﺤـﺐ أن ﻧﻘﻮم ﺑﺘﻌﺮ ﻳﻒ اﻟﻌﻤﻠﻴـﺎت اﻷﺳـ ـــــــ ـﺎﺳـ ــــــ ـﻴـﺔ وﻫﻲ‪ :‬اﺻـ ــــــ ـﻐﺮ‪ ،‬ا ﻛﺒﺮ‪ ،‬اﻟﻨﻔﻲ‪،‬‬
‫اﻟﻤﺴﺎواة‪.‬‬

‫اﻟﻌﻤﻠﻴﺔ‬ ‫اﻟﺮﻣﺰ‬
‫اﺻﻐﺮ‬ ‫<‬
‫ا ﻛﺒﺮ‬ ‫>‬
‫اﺻﻐﺮ ﻣﻦ او ﻳﺴﺎوي‬ ‫>=‬
‫ا ﻛﺒﺮ ﻣﻦ او ﻳﺴﺎوي‬ ‫<=‬
‫ﻳﺴﺎوي‬ ‫==‬
‫ﻋﻼﻣﺔ اﻟﻨﻔﻲ‬ ‫!‬
‫ﻻ ﻳﺴﺎوي‬ ‫=!‬

‫‪ v‬أﻣ ﺜ ﻠﺔ‬

‫§ ﻫﻨـﺎ ﻧﻄﻠـﺐ اﻟﺘﺤﻘﻖ ﺑﻴﻦ اﻟﻘﻴﻤﺘﻴﻦ ‪ number1‬و ‪ number2‬واﻟﻨـﺎﺗﺞ اﻟﻌـﺎﺋـﺪ ﻟﻨـﺎ‬

‫ﻫﻮ ﻣﻨﻄﻘﻲ ‪.true / false‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪34‬‬

 ‫‪var number1:Int=13‬‬
‫‪var number2:Int=20‬‬
‫)‪println(number1<number2‬‬

‫ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‪:‬‬

‫‪true‬‬

‫§ ﻋﺮﻓﻨــﺎ ﻣﺘﻐﻴﺮ ﻣﻨﻄﻘﻲ ﻳﺤﻤــﻞ ﻗﻴﻤــﺔ ‪ false‬وﻟﻜﻦ ﻧﻼﺣﻆ وﻗــﺖ اﻟﻄﺒــﺎﻋــﺔ ﻧﻔﻴﻨــﺎ‬
‫اﻟﻘﻴﻤﺔ أي اﻧﻪ ﺳﻴﻄﺒﻊ اﻟﻌﻜﺲ‪.‬‬
‫‪var isReal:Boolean=false‬‬
‫)‪println ("Ahmed loves Kotlin :"+ !isReal‬‬

‫ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‪:‬‬

‫‪Ahmed loves Kotlin :true‬‬

‫ﺛﺎﻧﻴﺎ ‪ :‬اﻟﺒﻮاﺑﺎت اﻟﻤﻨﻄﻘﻴﺔ "اﻟﻤﻘﺎرﻧﺔ"‬

‫اﻟﺒﻮاﺑﺎت اﻟﻤﻨﻄﻘﻴﺔ ﻓﻲ اﻟﺒﺮﻣﺠﺔ ﻫﻲ‪. AND , OR ,NOT :‬‬

‫‪ v‬ﺑﻮاﺑﺔ ‪AND‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪35‬‬

‫ﻟﻮ ﻛ ـﺎن ﻟ ـﺪي ﻗﻴﻤ ـﺔ ار ﻳ ـﺪ اﻟﺘﺤﻘﻖ ﻣﻨﻬ ـﺎ وﻟ ـﺪي ﻗﻴﻤ ـﺔ أﺧﺮى وأر ﻳ ـﺪ اﻟﺘﺤﻘﻖ ﻣﻨﻬ ـﺎ أ ﻳﻀـ ـــــــ ـﺎ‬
‫ﻌﺎ ﻣﺘﺤﻘﻖ‬ ‫ﺠﺐ ان ﻳﻜﻮن ـﻧﺎﺗﺠﻬ ـ‬
‫ﻤﺎ ﺟﻤﻴ ـ‬ ‫ﻌﻞ ذـﻟﻚ ﻋﻦ ﻃﺮ ﻳﻖ ﺑﻮاـﺑﺔ ‪ AND‬وﻟﻜﻦ ﻳ ـ‬
‫‪،‬ﻧﺴـ ــــــ ـﺘﻄﻴﻊ ﻓ ـ‬
‫أي اﻧﻪ ﻻ ﻳﻜﻮن اﻟﺸﺮط اﻷول ﺻﺤﻴﺤﺎ واﻷﺧﺮ ﺧﻄﺎء‪.‬‬

‫ﻟﺬﻟﻚ ﻧﺴـ ــــــ ـﺘﺨﺪﻣﻬﺎ ﻛﺜﻴﺮا ﻓﻲ اﻟﺘﺤﻘﻖ ﻣﻦ اﺳـ ــــــ ـﻢ اﻟﻤﺴـ ــــــ ـﺘﺨﺪم وﻛﻠﻤﺔ اﻟﻤﺮور ﻋﻨﺪﻣﺎ ﻳﻘﻮم‬
‫اﻟﻤﺴـ ـــ ـﺘﺨﺪم ﻣﻦ ادﺧﺎل اﻟﻤﻌﺮف اﻟﺨﺎص ﺑﻪ وﻛﻠﻤﺔ اﻟﻤﺮور اﻟﺨﺎﺻـ ـــ ـﺔ أ ﻳﻀـ ـــ ـﺎ ﺑﻪ وﻛﺎﻧﺘﺎ ﻛﻠﺘﺎﻫﻤﺎ‬
‫ﺻـ ــــــ ـﺤﻴﺤﺘـﺎن ﺣﻴﻨﻬـﺎ ﻳﻜﻮن اﻟﻨـﺎﺗﺞ ﻟـﺪﻳﻨـﺎ ‪ true‬ﺑـﺪاﺧـﻞ اﻟﺒﺮﻧـﺎﻣﺞ وﻧـﺎﺗﺞ اﻟﺘﻨﻔﻴـﺬ ﻫﻮ اﻟـﺪﺧﻮل إﻟﻰ‬
‫اﻟﺒﺮﻧﺎﻣﺞ وﻟﻜﻦ ﻓﻲ ﺣﺎل اﻧﻪ ادﺧﻞ اﻟﻤﻌﺮف اﻟﺨﺎص ﺑﻪ ﺑﺸـ ـﻜﻞ ﺻـ ـﺤﻴﺢ واﺧﻄﺎء ﻓﻲ ﻛﺘﺎﺑﺔ ﻛﻠﻤﺔ‬
‫اﻟﻤﺮور ﻓـﺎﻟﻨـﺎﺗﺞ ﺑـﺎﻟـﺪاﺧـﻞ ﺳـ ــــــ ـﻴﻜﻮن ﺧﻄـﺎء وﻧـﺎﺗﺞ اﻟﺘﻨﻔﻴـﺬ اﻟـﺬي ﻧﺮاه ﻟﻦ ﻳﺴـ ــــــ ـﻤﺢ ﻟﻲ ﺑـﺪﺧﻮل‬
‫اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬

‫ﺗﻤﺜﻞ ﺑﺮﻣﺠﻴﺎ ً ﺑﻬﺬا اﻟﺮﻣﺰ )&&(‪.‬‬

‫وﻓﻲ اﻟﻤﺜﺎل ﻧﺠﺪ أﻧﻪ ﻟﺪي ﻗﻴﻤﺘﻴﻦ ار ﻳﺪ اﻟﺘﺤﻘﻖ ﻣﻨﻬﻤﺎ ﻛﻠﻬﻤﺎ ﺑﺄﻧﻬﻤﺎ ﻳﻌﻴﺪان ﻟﻲ ‪.true‬‬

‫‪var number1:Int = 7‬‬

‫‪var number2:Int = 4‬‬
‫)‪println(number1 < 10 && number2 < 5‬‬

‫‪output : true‬‬

‫‪ v‬ﺑﻮاﺑﺔ ‪OR‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪36‬‬

‫ﻫـﺬه اﻟﺒﻮاﺑـﺔ ﺗﺨـﺎﻟﻒ ‪ AND‬ﻓﻲ اﻧﻬـﺎ اذا ﻛـﺎن اﺣـﺪ اﻟﺸـ ــــــ ـﺮﻃﻴﻦ ﺻـ ــــــ ـﺤﻴﺢ ﻓﻬﻲ ﺗﻌﻴـﺪ ﻗﻴﻤـﺔ‬
‫ﺻﺤﻴﺤﺔ ‪ true‬أي اﻧﻬﺎ ﻻ ﺗﺸﺘﺮط ان ﻳﻜﻮن ﻛﻼﻫﻤﺎ ﺻﺤﻴﺤﻴﻦ‪.‬‬

‫ﺗﻤﺜﻞ ﺑﺮﻣﺠﻴﺎ ً ﺑﻬﺬا اﻟﺮﻣﺰ )||(‪.‬‬

‫اذا ﻛـﺎن اﺣـﺪﻫﻤـﺎ ﺻـ ــــــ ـﺤﻴﺢ ﻋﻠﻰ اﻷﻗـﻞ ﻓﻬﻲ ﺗﻌﻴـﺪ ‪ true‬اذا ﻻ ﺗﺸـ ــــــ ـﺘﺮط ان ﻳﻜﻮن ﻛﻼﻫﻤـﺎ‬
‫ﺻﺤﻴﺢ ﻛﻤﺎ ﻓﻲ ‪.AND‬‬

‫‪var number1:Int = 7‬‬

‫‪var number2:Int = 4‬‬
‫)‪println(number1 < 10 || number2 > 5‬‬

‫‪output : true‬‬

‫‪ v‬ﺑﻮاﺑﺔ ‪NOT‬‬

‫ﺗﻘﻮم ﺑﻨﻔﻲ اﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ ﻛﻤﺎ ﺷﺮﺣﻨﺎه ﻓﻲ اﻟﻤﺜﺎل اﻋﻼه‪.‬‬

‫‪ v‬ﺟﺪول ﻣﻘﺎرﻧﺔ‬

‫ﺑﻮاﺑﺔ ‪OR‬‬ ‫ﺑﻮاﺑﺔ ‪AND‬‬

‫ﺗﻤﺜﻞ ﺑﺮﻣﺠﻴﺎ ً ﺑﻬﺬا اﻟﺮﻣﺰ )||(‪.‬‬ ‫ﻞ ﺑﺮﻣﺠﻴﺎ ً ﺑﻬﺬا اﻟﺮﻣﺰ )&&(‪.‬‬
‫ﻟﻤﺜـ ــ ـﺎل ﻧﺠـ ــ ـﺪ أﻧـ ــ ـﻪ ﻟـ ــ ـﺪي ﻗﻴﻤﺘﻴﻦ ار ﻳـ ــ ـﺪ‬
‫ﻘﻖ ﻣﻨﻬﻤﺎ ﻛﻠﻬﻤﺎ ﺑﺄﻧﻬﻤﺎ ﻳﻌﻴﺪان ﻟﻲ ‪.true‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪37‬‬

 ‫اذا ﻛ ـﺎن اﺣ ـﺪﻫﻤ ـﺎ ﺻـ ــــــ ـﺤﻴﺢ ﻋﻠﻰ اﻷﻗ ـﻞ ﻓﻬﻲ‬ ‫‪5 > number2 && 10 > numb‬‬
‫ﺗﻌﻴـ ـﺪ‪ true‬اذا ﻻ ﺗﺸـ ــــــ ـﺘﺮط ان ﻳﻜﻮن ﻛﻼﻫﻤـ ـﺎ‬
‫ﺻﺤﻴﺢ ﻛﻤﺎ ﻓﻲ ‪.AND‬‬
‫‪var number1:Int = 7‬‬ ‫‪var number1:Int = 7‬‬
‫‪var number2:Int = 4‬‬ ‫‪var number2:Int = 4‬‬
‫)‪println(number1 < 10 || number2 > 5‬‬ ‫< ‪println(number1 < 10 && number2‬‬
‫ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬ ‫اﻟﺘﻨﻔﻴﺬ‬
‫‪true‬‬ ‫‪true‬‬

‫اﻟﺴ ﻼ ﺳ ﻞ اﻟﻨﺼ ﻴﺔ‬

‫ﻻ ﻳﺨﻔﻰ ﻋﻠﻴﻨﺎ أن اﻟﺴـ ـﻼﺳـ ـﻞ اﻟﻨﺼـ ـﻴﺔ ﻫﻴﺎ ﻣﻦ أﻫﻢ اﻟﻤﺪﺧﻼت واﻟﻤﺨﺮﺟﺎت أ ﻳﻀـ ـﺎ ً ﻓﻲ أي‬
‫ﻟﻐﺔ ﻧﺘﻌﻠﻤﻬﺎ‪ ،‬ﻛﻴﻒ ﻧﺴـ ـﺘﻄﻴﻊ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﺑﺎﻟﺤﺬف‪ ،‬اﻹﺿـ ـﺎﻓﺔ‪ ،‬اﺧﺘﺒﺎرﻫﺎ وﺣﺘﻰ اﻟﺘﻌﺎﻣﻞ ﻣﻊ‬
‫اﻷﺣﺮف وﺳﻮف ﻧﺘﻄﺮق ﻟﻬﺬا اﻟﺤﺪث ﻓﻲ درﺳﻨﺎ اﻟﻴﻮم‪.‬‬

‫ﺳﻨﺬﻛﺮ ﻓﻲ اﻟﺒﺪا ﻳﺔ ﻣﺜﺎل ﺑﺴﻴﻂ ﺗﻌﺮ ﻳﻔﻲ ﻟﻠﺴﻼﺳﻞ اﻟﻨﺼﻴﺔ‪:‬‬

‫"‪var name:String="Ahmed‬‬
‫)‪println(name‬‬

‫ﻓﻲ ﻫﺬا اﻟﻤﺜﺎل اﻟﺒﺴـ ــ ـﻴﻂ ﻗﻤﻨﺎ ﺑﻄﺒﺎﻋﺔ اﻻﺳـ ــ ـﻢ اﺣﻤﺪ‪ ،‬اﻷن ﺳـ ــ ـﻨﺴـ ــ ـﺘﻌﺮض أﻫﻢ اﻟﺪوال اﻟﺘﻲ‬
‫ﺗﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺴﻼﺳﻞ اﻟﻨﺼﻴﺔ ﻣﺴﺘﺨﺪﻣﻴﻦ اﻟﻤﺜﺎل اﻟﺤﺎﻟﻲ‪:‬‬

‫‪length v‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪38‬‬

 ‫ﻋﻨﺪﻣﺎ ﻧﺮ ﻳﺪ ﻣﻌﺮﻓﺔ ﻃﻮل اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ‪.‬‬

‫"‪var name:String="Ahmed‬‬
‫)‪println(name.length‬‬

‫‪plus v‬‬

‫ﻋﻨﺪﻣﺎ ﻧﺮ ﻳﺪ إﺿﺎﻓﺔ ﺳﻠﺴﻠﺔ ﻧﺼﻴﺔ ﻟﻠﺴﻠﺴﻠﺔ اﻟﺴﺎﺑﻘﺔ‪.‬‬

‫"‪var name:String="Ahmed‬‬
‫))"‪println(name.plus(" aljuaid‬‬

‫‪get v‬‬

‫ﻋﻨﺪﻣﺎ ﻧﺮ ﻳﺪ اﺳﺘﺮﺟﺎع اﻟﻘﻴﻤﺔ اﻟﺘﻲ ﻳﺸﻴﺮ إﻟﻴﻬﺎ اﻟﻌﻨﻮان أو اﻟﻤﺆﺷﺮ ]‪.[index‬‬

‫"‪var name:String="Ahmed‬‬
‫))‪println(name.get(3‬‬

‫‪equals v‬‬

‫اﻟﻘﻴﻤﺔ اﻟﻌﺎﺋﺪة ﻣﻦ اﻟﺪاﻟﺔ ﻫﻴﺎ ﻣﻨﻄﻘﻴﺔ ﻓﻬﻲ ﺗﺴ ـﺘﺨﺪم ﻟﻠﺘﺤﻘﻖ ﻣﻦ ﺗﻄﺎﺑﻖ اﻟﻘﻴﻢ وﺳ ـﻮف‬
‫ﻧﺮى ذﻟﻚ ﺑﺎﻟﻤﺜﺎل‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪39‬‬

var name:String="Ahmed"
println(name.equals("Khaled"))

hashCode v

.‫وﻫﻲ ﻟﺠﻠﺐ اﻟﺘﺮﻣﻴﺰ اﻟﺨﺎص ﺑﺎﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ‬

var name:String="Ahmed"
println(name.hashCode())

replaceFirst v

.‫ﺗﻘﻮم ﺑﺎﺳﺘﺒﺪال اول ﺣﺮف ﻣﻦ اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ ﻓﻘﻂ‬

var name:String="Ahmed"
println(name.replaceFirst("A","G"))

reversed v

.‫ﺗﻘﻮم ﺑﻌﻜﺲ اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ‬

var name:String="Ahmed"
println(name.reversed())

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 40 ‫اﻟﺼﻔﺤﺔ‬

 ‫‪toLowerCase v‬‬

‫ﺗﻘﻮم ﺑﺘﺤﻮﻳﻞ ﺣﺮوف اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ إﻟﻰ ﺣﺮوف ﺻﻐﻴﺮة‪.‬‬

‫"‪var name:String="Ahmed‬‬
‫))(‪println(name.toLowerCase‬‬

‫‪toUpperCase v‬‬

‫ﺗﻘﻮم ﺑﺘﺤﻮﻳﻞ ﺣﺮوف اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ إﻟﻰ ﺣﺮوف ﻛﺒﻴﺮة‪.‬‬

‫"‪var name:String="Ahmed‬‬
‫))(‪println(name.toUpperCase‬‬

‫‪removeRange v‬‬

‫ﻟﻮ ﻃﺮأ ﻓﻲ ﺑﺎﻟﻚ ﺣﺬف ﺣﺮف ﻣﻦ اﻟﺴـ ـﻠﺴـ ـﻠﺔ اﻟﻨﺼـ ـﻴﺔ أو ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺤﺮوف اﻟﻤﺘﺼـ ـﻠﺔ‬
‫ﻓﻜﻞ ﻣﺎ ﻳﺘﻮﺟﺐ ﻋﻠﻴﻚ ﻓﻌﻠﻪ ﻫﻮ ﺗﺤﺪﻳﺪ اﻟﻌﻨﻮان اﻟﺬي ﺳـ ـــ ـﺘﺒﺪأ ﺑﻪ ]‪ [index‬واﻟﺬي ﺳـ ـــ ـﺘﻨﺘﻬﻲ‬
‫ﻋﻨﺪه‪.‬‬

‫"‪var name:String="Ahmed‬‬
‫))‪println(name.removeRange(2,4‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪41‬‬

 ‫”‪var name:String=“Ahmed‬‬ ‫ﻓـﻠـﻨـﻔـﺮض ﻣـﺜـﻼ أﻧـ ــ ـﻚ اردت ان ﺗـﻘـﺘـﻄـﻊ ﺟـﺰًء ﻣـﻦ‬
‫))‪println(name.take(3‬‬
‫ـﻠﺴـ ـــــ ـﻠﺔ اﻟﻨﺼـ ـــــ ـﻴﺔ وﺗﻘﻮم ﺑﺤﺬﻓﻬﺎ ﻛﻞ ﻣﺎ ﻋﻠﻴﻚ ﻫﻮ‬
‫ﺪ اﻟﻌﻨﻮان اﻟﺬي ﺗﺮ ﻳﺪ ﺑﺪء اﻗﺘﻄﺎع اﻟﺴﻠﺴﻠﺔ ﻣﻨﻪ‪.‬‬
‫”‪var name:String=“Ahmed‬‬ ‫‪ f‬ﺗﻌﻮد ﺑﺄول ﺣﺮف ﻣﻦ اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ‪.‬‬
‫))(‪println(name.first‬‬
‫”‪var name:String=“Ahmed‬‬ ‫ﺗﻌﻮد ﺑﺄول ﺣﺮف ﻣﻦ اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ‪.‬‬
‫))(‪println(name.last‬‬
‫”‪var name:String=“Ahmed‬‬ ‫ﺤﺬف ﺣﺮف ﻣﻦ اﻟﺴـ ــــــ ـﻠﺴـ ــــــ ــﻠﺔ‬
‫ﻫﺬه اـﻟﺪاـﻟﺔ ﺗﻘﻮم ﺑ ـ‬
‫‪ d‬ـ‬
‫))‪println(name.drop(1‬‬
‫ﻴﺔ ﻋﻦ ﻃﺮ ﻳﻖ ﺗﺤﺪﻳﺪ ﻋﻨﻮاﻧﻬﺎ‪.‬‬

‫اﻟﻤ ﺼ ﻔ ﻮ ﻓ ﺎت‬

‫اﻟﻤﺼـﻔﻮﻓﺎت ﺗﻌﺘﺒﺮ اﻟﺤﻞ اﻟﺴـﺤﺮي إذا ﻛﻨﺖ ﺗﺮ ﻳﺪ ادﺧﺎل او ﻃﺒﺎﻋﺔ ﺑﻴﺎﻧﺎت ﻛﺜﻴﺮة ‪ ،‬ﻓﺮﺋﻴﺲ‬
‫اﻟﻘﺴـ ـــﻢ ﻳﺴـ ـــﺘﻄﻴﻊ ﺣﺼـ ـــﺮ ﺑﻴﺎﻧﺎت ﻣﻦ ﻫﻢ ﻓﻲ ﻗﺴـ ـــﻤﻪ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻋﻦ ﻃﺮ ﻳﻖ اﻟﻤﺼـ ـــﻔﻮﻓﺔ ‪،‬‬
‫ﻛﺬﻟﻚ اﻟﻤﻌﻠﻢ ﻳﺴﺘﻄﻊ ﻃﺒﺎﻋﺔ ﺑﻴﺎﻧﺎت اﻋﺪاد ﻛﺒﻴﺮة ﻣﻦ ﻃﻠﺒﺘﻪ ﻓﻘﻂ ﺑﻀﻐﻄﺔ اﻟﺰر ‪ ،‬واﻟﻤﺼﻔﻮﻓﺔ‬
‫ﺳﻮف ﻧﺘﻌﺮف ﻋﻠﻰ ﻃﺮ ﻳﻘﺔ ﺗﻌﺮ ﻳﻔﻬﺎ وﺗﻌﺒﺌﺘﻬﺎ‬
‫ﻣﻌﺮوف أﻧﻬﺎ ﻣﺠﻤﻮﻋﺔ ﺑﻴﺎﻧﺎت ﻣﻦ ﻧﻔﺲ اﻟﻨﻮع ‪ .‬ـ‬
‫وﻃﺒﺎﻋﺘﻬﺎ‪:‬‬

‫أوﻻ ‪ :‬ﺗﻌﺮﻳﻒ اﻟﻤﺼﻔﻮﻓﺔ‬

‫}‪var myArray=Array<Int>(5){0‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪42‬‬

‫ﻓﻲ اﻟﺒﺪا ﻳﺔ ﻧﻌﺮف اﻟﻤﺘﻐﻴﺮ وﻣﻦ ﺛﻢ ﺑﻌﺪ ﻋﻼﻣﺔ = ﻧﺤﺪد أن ﻧﻮع اﻟﻤﺘﻐﻴﺮ ﻣﺼـ ـﻔﻮﻓﺔ وﻣﻦ ﺛﻢ‬
‫ﻧﺤﺪد ﻧﻮﻋﻬﺎ >‪ <Int‬أﻧﻬﺎ ﻣﻦ ﻧﻮع ﻋﺪد ﺻ ـﺤﻴﺢ )‪(5‬ﺗﺸ ـﻴﺮ إﻟﻰ ﻃﻮل اﻟﻤﺼ ـﻔﻮﻓﺔ أي أﻧﻬﺎ ﺗﺤﻮي‬
‫ﺑﺪاﺧﻠﻬﺎ ‪ ٥‬ﻋﻨﺎﺻﺮ‪ ،‬وﻓﻲ اﻟﻨﻬﺎﻳﺔ }‪ {0‬ﻧﺤﺪد أن اﻟﻤﺆﺷﺮ أو ‪ index‬ﻳﺒﺪأ ﻣﻦ اﻟﺼﻔﺮ‪.‬‬

‫ﺛﺎﻧﻴﺎ ‪ :‬إدﺧﺎل ﻗﻴﻢ ﻟﻠﻤﺼﻔﻮﻓﺔ‬

‫ﺣﺴﻨﺎ ً اﻷن ﻋﺮﻓﻨﺎ ﻫﺬه اﻟﻤﺼﻔﻮﻓﺔ أر ﻳﺪ إدﺧﺎل ﻗﻴﻢ ﺑﺪاﺧﻠﻬﺎ أي ﺗﻌﺒﺌﺘﻬﺎ ‪ ،‬ﻧﺴﺘﻄﻴﻊ ﺗﻌﺒﺌﺘﻬﺎ‬
‫ﺑﻬﺬه اﻟﻄﺮ ﻳﻘﺔ‬

‫‪myArray[0]=12‬‬

‫وﻟﻜﻦ ﻫﺬه اﻟﻄﺮ ﻳﻘﺔ ﺳـ ـﺘﻜﻮن ﻣﺮﻫﻘﺔ ﻟﻮ ﻛﺎﻧﺖ اﻟﻤﺼـ ـﻔﻮﻓﺔ ﻟﺪي ﻃﻮ ﻳﻠﺔ أي ﺗﺤﻤﻞ ﻋﻨﺎﺻـ ـﺮ‬
‫ﻛﺜﻴﺮة‪ ،‬واﻟﺤﻞ اﻟﺴﺤﺮي ﻛﺎﻟﻌﺎدة ﻫﻮ اﺳﺘﺨﺪام اﻟﺪوارة أو ‪ ، loop‬ﻓﻘﻤﻨﺎ ﺑﺎﺳﺘﺨﺪام ‪: for loop‬‬

‫ﻃﺒﻌـﺎ ً ﻫـﺬا اﻟﻤﺜـﺎل اﻟـﺬي ﺳـ ــــــ ـﻮف ﻧﻄﺮﺣـﻪ ﻫﻮ ﻟﻮ أﻧﻨـﺎ أردﻧـﺎ ﻃﺒـﺎﻋـﺔ اﻷرﻗـﺎم ﻣﻦ ‪ ٤-٠‬ﺑـﺎﻟﺘﺮﺗﻴـﺐ‬
‫ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ‪:‬‬

‫)‪for(i in 0..5‬‬
‫{‬
‫‪myArray[i]=i‬‬
‫)]‪println(myArray[i‬‬
‫}‬

‫أوﻻ ً ‪:‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪43‬‬

 ‫)‪for(i in 0..5‬‬

‫اﻟﺤﻠﻘﺔ اﻟﺘﻲ ﻟﺪي ﻋﺪد ﻋﻨﺎﺻﺮﻫﺎ ﺳﺘﺔ ‪ ،‬ﻣﻦ ‪ ٠‬إﻟﻰ ‪.٥‬‬

‫ﺛﺎﻧﻴﺎ ً ‪:‬‬

‫‪ i myArray[i]=i‬ﺗﻌﺒﺮ ﻋﻦ إذا ﻛﺎﻧﺖ اﻟﺤﻠﻘﺔ ﺗﺒﺪأ ﻣﻦ ‪ ٠‬ﻓﺄﺟﻌﻞ أ ﻳﻀ ـﺎ ﻗﻴﻤﺔ اﻟﻌﻨﺼ ـﺮ = ‪، ٠‬‬

‫وﻫﻜﺬا‪:‬‬

‫‪myArray[0]=0‬‬
‫‪myArray[1]=1‬‬
‫…‬

‫ﺛﺎﻟﺜﺎ ً ‪:‬‬

‫وﻫﻲ اﻟﺨﻄﻮة اﻷﺧﻴﺮة ﺑﻌﺪ اﻟﺘﻌﺒﺌﺔ وﻫﻲ ﻃﺒﺎﻋﺔ اﻟﻌﻨﺎﺻﺮ‪.‬‬

‫ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ ‪:‬‬

‫‪0‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬

‫ﺣﺴﻨﺎ ً وﻟﻜﻦ ﻟﻮ أردﻧﺎ ﻣﻦ اﻟﻤﺴﺘﺨﺪم ﺗﻌﺒﺌﺔ ﻫﺬه اﻟﻤﺼﻔﻮﻓﺔ ؟ اﻟﺤﻞ ﺑﺴﻴﻂ ﺟﺪا ً ‪:‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪44‬‬

 ‫)"‪println("Enter Number for ARRAY‬‬

‫{ )‪for (i in 0..4‬‬
‫)(‪myArray[i] = readLine()!!.toInt‬‬
‫}‬

‫)(‪myArray[i] = readLine()!!.toInt‬‬

‫ﻫﺬا ﻳﻌﻨﻲ أﻧﻪ ﺑﻜﻞ ﻋﻨﺼ ـﺮ ﻣﻦ ‪ ٤ – ٠‬ﻗﻢ ﺑﻄﻠﺐ اﻟﻤﺴ ـﺘﺨﺪم أن ﻳﺪﺧﻞ رﻗﻢ وﻟﻤﺎذا ﻣﻦ ‪-٠‬‬
‫‪ ٤‬وذﻟﻚ ﻷن ﻣﺼﻔﻮﻓﺘﻨﺎ ﻋﺪد ﻋﻨﺎﺻﺮﻫﺎ ‪.٥‬‬

‫ﺛﺎﻟﺜﺎ ‪ :‬ﻃﺒﺎﻋﺔ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ‬

‫ﺣﺴـ ـﻨﺎ ﻫﻜﺬا ﺗﻢ أﻣﺮ اﻹدﺧﺎل‪ ،‬ﺗﺒﻘﻰ ﻟﻨﺎ أﻣﺮ وﻫﻮ ﻟﻮ أردﻧﺎ ﻃﺒﺎﻋﺔ ﻫﺬه اﻟﻌﻨﺎﺻـ ـﺮ اﻟﺘﻲ أدﺧﻠﻬﺎ‬
‫؟ ﻧﺴﺘﻄﻴﻊ اﻟﻄﺒﺎﻋﺔ إﻣﺎ ﺑﺎﻟـ ‪: while or for‬‬

‫‪//printed by for‬‬
‫)"‪println("printed by for‬‬
‫{)‪for(i in myArray‬‬
‫)‪println(i‬‬
‫}‬

‫‪//printed by while‬‬
‫)"‪println("printed by while‬‬
‫‪var i=0‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪45‬‬

 while (i<myArray.size){
println(myArray[i])
i++
}

: ‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
Enter Number for ARRAY
5
4
3
2
1
printed by for
5
4
3
2
1
printed by while
5
4
3
2
1

: ‫ ﺗﻜﻮن اﻟﺸﻔﺮة ﺑﻬﺬا اﻟﺸﻜﻞ‬for ‫ ﻟﻠﻤﺼﻔﻮﻓﻪ ﺑﺎﺳﺘﺨﺪام‬index ‫§ ﻟﻮ اردﻧﺎ ﻃﺒﺎﻋﺔ‬

for ((index, value) in myArray.withIndex()) {
println("the element at $index is $value")

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 46 ‫اﻟﺼﻔﺤﺔ‬

 ‫}‬

‫§ ﻣﺼﻔﻮﻓﺔ ﻧﺼﻴﺔ ‪:‬‬

‫}""{)‪var student=Array<String>(6‬‬
‫)"‪println("Enter name your student :‬‬
‫{)‪for(i in 0..5‬‬
‫!!)(‪student[i]=readLine‬‬
‫}‬

‫{)‪for(i in 0..4‬‬
‫)]‪println(student[i‬‬
‫}‬

‫ﻫـﻨﺎ ﻋﺮﻓـﻨﺎ ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ﺳـ ــــــ ـﻠﺴـ ــــــ ـﻠﺔ ﻧﺼـ ــــــ ـﻴﺔ ﻷﺳـ ــــــ ـﻤﺎء اﻟﻄﻼب ﻣﻊ ﻣﺮاﻋﺎة } “”{ اﻟﻘﻴﻤﺔ‬
‫اﻻﻓﺘﺮاﺿ ـﻴﺔ ﻫﻨﺎ ﻻ ﻧﺴ ـﺘﻄﻴﻊ ﻛﺘﺎﺑﺘﻬﺎ ‪ ٠‬أو أي ارﻗﻢ وذﻟﻚ ﻷن اﻟﻤﺼ ـﻔﻮﻓﺔ ﻧﺼ ـﻴﺔ ﻓﻨﻘﻮم ﺑﻮﺿ ـﻊ‬
‫ﻋﻼﻣﺘﻲ اﻟﺘﻨﺼـ ــــــ ـﻴﺺ وﻧ ـﺪﻋﻬ ـﺎ ﻓ ـﺎرﻏ ـﺔ ‪ ،‬ﻛﻤ ـﺎ ﺗﺮون ﻫﻮ ﻧﻔﺲ اﻷﻣﺮ اﺣﺘﺠﻨ ـﺎ إﻟﻰ دوارﺗ ـﺎن اﻷوﻟﻰ‬
‫ﻹدﺧﺎل اﻷﺳﻤﺎء ﻣﻦ اﻟﻤﺴﺘﺨﺪم واﻷﺧﺮى ﻟﻄﺒﺎﻋﺔ ﺑﻴﺎﻧﺎت ﻫﺬه اﻟﻤﺼﻔﻮﻓﺔ‪.‬‬

‫راﺑﻌﺎ ‪ :‬اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺼﻔﻮﻓﺎت‬

‫ﺑﺎﻟﻄﺒﻊ اذا ﻛﺎن ﻟﺪي ﻣﺼـ ـــ ـﻔﻮﻓﺔ وﻫﻲ ﺗﺠﻤﻊ ﻛﺒﻴﺮ ﻟﻠﺒﻴﺎﻧﺎت ﻓﺴـ ـــ ـﻨﺤﺘﺎج إﻟﻰ دوال ﺳـ ـــ ـﺮ ﻳﻌﺔ‬
‫وﺟـﺎﻫﺰة ﻟﻠﺘﻌـﺎﻣـﻞ ﻣﻊ ﻫـﺬه اﻟﻤﺼـ ــــــ ـﻔﻮﻓـﺔ‪ ،‬ﻓﻲ اﻟﺠـﺪول ادﻧـﺎه اﺷـ ــــــ ـﻬﺮ اﻟـﺪوال اﻟﻤﺴـ ــــــ ـﺘﺨـﺪﻣـﺔ‬
‫ﻟﻠﻤﺼﻔﻮﻓﺔ‪:‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪47‬‬

‫اﻻﺛﻨﺎن ﻟﻬﻢ ﻧﻔﺲ اﻻﺳـ ـــﺘﺨﺪام وﻫﻮ ﻣﻌﺮﻓﺔ ﻋﺪد ﻋﻨﺎﺻـ ـــﺮ اﻟﻤﺼـ ـــﻔﻮﻓﺔ‬ ‫‪count – size‬‬
‫ﻓﻨﻘﻮم ﺑﻜﺘﺎﺑﺔ‪:‬‬
‫)‪println(myArray.size‬‬
‫ﻟﺠﻠـ ــ ـﺐ ﻋﻨﺼـ ــــــ ـﺮ ﻓﻲ اﻟﻤﺼـ ــــــ ـﻔﻮﻓـ ــ ـﺔ ﻧﻘﻮم ﺑـ ــ ـﺎﺳـ ــــــ ـﺘﺨـ ــ ـﺪام ‪ get‬وﻧﻤﺮر‬ ‫‪get‬‬
‫ﻟﻬﺎ ‪ index‬اﻟﻌﻨﺼﺮ‪:‬‬
‫))‪println(myArray.get(index‬‬
‫اﺳـ ــــــ ـﺘﺒﺪال ﻗﻴﻤﺔ ﻋﻨﺼـ ــــــ ـﺮ ﻓﻲ اﻟﻤﺼـ ــــــ ـﻔﻮﻓﺔ ﺑﻘﻴﻤﺔ ﺟﺪﻳﺪة ﺳـ ــــــ ـﻨﻘﻮم‬ ‫‪set‬‬
‫ﺑﺎﺳﺘﺨﺪام ‪ set‬وﻧﻤﺮر ﻟﻬﺎ ‪ index‬اﻟﻌﻨﺼﺮ واﻟﻘﻴﻤﺔ اﻟﺠﺪﻳﺪة‪ ،‬ﻫﻜﺬا‪:‬‬
‫))‪println(myArray.set(index,new value‬‬
‫وﻫﻲ ﻟﻠﺘﺤﻘﻖ ﻣﻦ ﻗﻴﻤﺔ اﻟﻌﻨﺼﺮ أي ان ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ اﻟﻌﺎﺋﺪ ﺳﻴﻜﻮن‬ ‫‪equals‬‬
‫ﻣﻨﻄﻘﻲ اﻣﺎ ‪:true or false‬‬
‫))‪println(myArray.equals(value‬‬
‫ﻟﺘﺮﺗﻴﺐ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ‪:‬‬ ‫‪sort‬‬
‫))(‪println(myArray.sort‬‬
‫ﻹﻳﺠﺎد ا ﻛﺒﺮ ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ‪:‬‬ ‫‪max‬‬
‫))(‪println(myArray.max‬‬
‫ﻹﻳﺠﺎد اﺻﻐﺮ ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ‪:‬‬ ‫‪min‬‬
‫))(‪println(myArray.min‬‬
‫ﻟﺠﻠﺐ اﺧﺮ ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ‪:‬‬ ‫‪last‬‬
‫))(‪println(myArray.last‬‬
‫ﻟﺠﻠﺐ اول ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ‪:‬‬ ‫‪first‬‬
‫))(‪println(myArray.first‬‬
‫ﻓﻠﺘﺮة اﻟﻌﻨﺎﺻﺮ او اﻟﺒﺤﺚ داﺧﻞ اﻟﻤﺼﻔﻮﻓﺔ‪:‬‬ ‫‪filter‬‬
‫} ‪val search = myArray.filter { x -> x <= 3‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪48‬‬

 ‫ﻫﻨﺎ ﺳـ ــــ ـﻴﻘﻮم ﺑﻄﺒﺎﻋﺔ اﻟﻌﻨﺎﺻـ ــــ ـﺮ داﺧﻞ اﻟﻤﺼـ ــــ ـﻔﻮﻓﺔ ذات اﻟﻘﻴﻢ ‪ 3‬او‬
‫اﻗﻞ‪.‬‬
‫ﻟﻌﺮض اﻟﺘﺮﻣﻴﺰ اﻟﺨﺎص ﺑﺎﻟﻤﺼﻔﻮﻓﺔ‪:‬‬ ‫‪hashcode‬‬
‫))(‪println(myArray.hashCode‬‬
‫ﺗﻘﻮم ﺑﻌﻜﺲ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ‪:‬‬ ‫‪reserved‬‬
‫))(‪println(myArray.reversed‬‬

‫اﻟﻨﻄ ﺎق‬

‫اﻟﺤﺪود او اﻟﻨﻄﺎق ﻣﻦ اﻟﻤﺴـ ـــــ ـﻤﻰ ﻧﻌﻠﻢ او ﻧﻔﻬﻢ ان ﻟﻬﺎ ﻗﻴﻤﺔ ﺑﺪا ﻳﺔ وﻗﻴﻤﺔ ﻧﻬﺎﻳﺔ ﻣﺤﺪودة‬
‫وﺑﺪاﺧﻠﻬﺎ ارﻗﺎم او ﺣﺮوف اﻟﺦ‪.‬‬

‫أوﻻ ‪ :‬اﻟﻨﻄﺎق‬

‫ﻌﺔ ﺑﻴﻦ ‪ ١‬إﻟﻰ ‪ ١٠‬أو اﻷﺣﺮف ﻣﻦ أ إﻟﻰ ي ‪ ،‬أي اـﻧﻪ ﻣﺠﻤﻮ ـ‬

‫ﻋﺔ ﻗﻴﻢ‬ ‫ﻳﻌﺒﺮ ﻋﻦ اﻷرـﻗﺎم ﻣﺜﻼ اﻟﻮاﻗ ـ‬
‫ﻣﺘﺴـ ــــــ ـﻠﺴـ ــــــ ـﻠـﺔ ﻟﻬـﺎ ﻗﻴﻤـﺔ ﺑـﺪا ﻳـﺔ وﻟﻬـﺎ ﻧﻬـﺎﻳـﺔ ‪ ،‬ﻓﻲ ﺗﻌﺒﻴﺮاﺗﻨـﺎ اﻟﺒﺮﻣﺠﻴـﺔ ﻧﺤﺘـﺎﺟﻬـﺎ ﻓﻬﻲ ﺗﻮﻓﺮ اﻟﻮﻗـﺖ‬
‫وﺗﻌﺘﺒﺮ ﺗﻌﺒﻴﺮ ﻣﻤﺘﺎز وﺳﺮ ﻳﻊ‪.‬‬

‫‪ v‬أﻣ ﺜ ﻠﺔ‬

‫ﻟﻄﺒﺎﻋﺔ اﻷرﻗﺎم اﻟﺰوﺟﻴﺔ ﻣﻦ ‪ ١‬إﻟﻰ ‪: ٢٠‬‬

‫‪var evenNumbers=1..20‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪49‬‬

for(i in evenNumbers){
if(i%2==0)
{
println(i)
}
}

output : 2 4 6 8 10 ..20

:‫اﻟﺒﺤﺚ ﻋﻦ ﻗﻴﻤﺔ ﻣﺎ إذا ﻛﺎﻧﺖ ﻣﻮﺟﻮدة ﻓﻲ ﻫﺬا اﻟﻨﻄﺎق ام ﻻ‬

var evenNumbers = 1..20

var i = 30
if (i in evenNumbers) {
println("the value in the range")
} else {
println("not found")
}

not found

:‫ﺗﻄﺒﻴﻖ ﻧﻔﺲ اﻟﻤﺜﺎل ﻋﻠﻰ اﻟﺴﻼﺳﻞ اﻟﻨﺼﻴﺔ‬

var word:String="Hello , My name is Ahmed"

var letter:Char='b'
if(letter in word){
println("the value in the word")

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 50 ‫اﻟﺼﻔﺤﺔ‬

 ‫{ ‪} else‬‬
‫)"‪println("not found‬‬
‫}‬

‫‪not found‬‬

‫ﺛﺎﻧﻴﺎ ‪ :‬اﻟﻘﻔﺰة أو ‪step‬‬

‫اﻟﻘﻔﺰة ﻫﻮ ﺑﻤﻌﻨﻰ ﻳﻜﻮن ﻟﺪي ﻧﻄﺎق وﻟﻜﻦ ار ﻳﺪ ﻋﻨﺎﺻـﺮ ﻣﻌﻴﻨﺔ ﺗﺒﻌﺪ ﻋﻦ ﺑﻌﻀـﻬﺎ ﺑﻤﺴـﺎﻓﺔ‬
‫ﺛـﺎﺑﺘـﻪ‪ ،‬ﺑﻤﻌﻨﻰ أﺧﺮ ﻧﻌﻠﻢ أن اﻷرﻗـﺎم اﻟﺰوﺟﻴـﺔ ﺗﺒﻌـﺪ ﻋﻦ ﺑﻌﻀـ ــــــ ـﻬـﺎ رﻗﻤﻴﻦ ﻓﻌﻨـﺪﻣـﺎ اﻋﻤـﻞ ﻗﻔﺰ ﻓﻲ‬
‫اﻟﻨﻄﺎق اﺳﺘﻄﻴﻊ اﻟﻮﺻﻮل إﻟﻴﻪ‪.‬‬

‫‪var numbers= 2..20‬‬

‫{)‪for(i in numbers step 2‬‬
‫)‪println(i‬‬
‫}‬

‫‪output : 2 4 6 8 10 ..20‬‬

‫ﺛﺎﻟﺜﺎ ‪ :‬اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻨﻄﺎق‬

‫‪downTo v‬‬

‫ﻟﻄﺒﺎﻋﺔ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﺗﻨﺎزﻟﻴﺎ‪ ،‬ﻣﺜﺎل‪:‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪51‬‬

 ‫{)‪for (i in 10 downTo 0‬‬
‫)‪println(i‬‬
‫}‬

‫‪until v‬‬

‫ﻟﻄﺒﺎﻋﺔ اﻟﻌﻨﺎﺻﺮ ﺗﺼﺎﻋﺪﻳﺎ‪ ،‬ﻣﺜﺎل‪:‬‬

‫{)‪for (i in 1 until 10‬‬

‫)‪println(i‬‬
‫}‬

‫ﻫﻨـﺎ ﻳﺒـﺪأ ﻳﻄﺒﻊ ﻣﻦ رﻗﻢ ‪ ١‬وﻳﺘﻮﻗﻒ ﻋﻨـﺪ ‪ ، ٩‬وذﻟـﻚ ﻷن ‪ until‬ﺗﻌﻨﻲ ﺣﺘﻰ أي ﻛـﺂﻧﻨـﺎ ﻧﻘﻮل‬
‫ﺣﺘﻰ ﺗﺮى ‪ ١٠‬ﻓﺘﻮﻗﻒ ﻟﻮ أردﻧﺎ ﻃﺒﺎﻋﺔ اﻟﺮﻗﻢ ‪ ١٠‬ﻓﺴﻨﺠﻌﻞ اﻟﺮﻗﻢ ﻳﻨﺘﻬﻲ ﻋﻨﺪ ‪١١‬‬

‫داﻟ ـﺔ ﺟ ـﺎﻫﺰة ﻟﻮ اردﻧ ـﺎ اﻟﺒﺤ ـﺚ ﺑ ـﺪاﺧ ـﻞ اﻟﻨﻄ ـﺎق و واﻟﻘﻴﻤ ـﺔ اﻟﻌ ـﺎﺋ ـﺪة ﻣﻦ‬ ‫‪contains‬‬
‫اﻟﺒﺤﺚ ﻣﻨﻄﻘﻴﺔ‪ ،‬ﻣﺜﺎل‪:‬‬
‫"‪var letter="A".."Z‬‬
‫))"‪println(letter.contains("D‬‬
‫داﻟﺔ ﻟﻠﺘﺤﻘﻖ ﻫﻞ اﻟﻨﻄﺎق ﺧﺎﻟﻲ ام ﻻ واﻟﻘﻴﻤﺔ اﻟﻌﺎﺋﺪة ﻣﻨﻄﻘﻴﺔ‪ ،‬ﻣﺜﺎل‪:‬‬ ‫‪isEmpty‬‬
‫"‪var letter="A".."Z‬‬
‫))(‪println(letter.isEmpty‬‬
‫ﺗﻘﻮم ﺑﻄﺒﺎﻋﺔ اﻟﻌﻨﺼﺮ اﻟﺬي ﻳﺒﺪأ ﻓﻴﻪ اﻟﻨﻄﺎق "ﻧﻘﻂ؛ اﻟﺒﺪا ﻳﺔ"‪ ،‬ﻣﺜﺎل‪:‬‬ ‫‪start‬‬
‫‪var letter="A".."Z‬‬
‫)‪println(letter.start‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪52‬‬

 ‫ﻃﺒﺎﻋﺔ اﺧﺮ ﻋﻨﺼﺮ ﻳﻨﺘﻬﻲ ﻋﻨﺪه اﻟﻨﻄﺎق "ﻧﻘﻂ؛ اﻟﻨﻬﺎﻳﺔ"‪ ،‬ﻣﺜﺎل‪:‬‬ ‫‪endInclusive‬‬
‫"‪var letter="A".."Z‬‬
‫)‪println(letter.endInclusive‬‬
‫اﻟﺘﺮﻣﻴﺰ اﻟﺨﺎص ﺑﺎﻟﻨﻄﺎق ﻧﻔﺴﻪ‪ ،‬ﻣﺜﺎل‪:‬‬ ‫‪hashCode‬‬
‫"‪var letter="A".."Z‬‬
‫))(‪println(letter.hashCode‬‬
‫ﻟﻠﺘﺤﻘﻖ ﻣﻦ ﻣﻄﺎﺑﻘﺔ اﻟﻘﻴﻢ‪ ،‬ﻣﺜﺎل‪:‬‬ ‫‪equals‬‬
‫"‪var letter="A".."Z‬‬
‫"‪var newLetter="A".."Z‬‬
‫))‪println(letter.equals(newLetter‬‬
‫ﻫﻨـ ـﺎ ﻋﺮﻓﻨـ ـﺎ ﻣﺘﻐﻴﺮ اﺧﺮ ﻟـ ـﻪ ﻧﻔﺲ اﻟﻨﻄـ ـﺎق ‪ ،‬وﻗﻤﻨـ ـﺎ ﺑـ ـﺎﻻﺧﺘﺒـ ـﺎر ﻫـ ـﻞ ﻫﻢ‬
‫ﻣﺘﺴﺎوﻳﺎن ام ﻻ‪.‬‬
‫ﻟﻄﺒﺎﻋﺔ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﺗﻨﺎزﻟﻴﺎ‪ ،‬ﻣﺜﺎل‪:‬‬ ‫‪downTo‬‬
‫{)‪for (i in 10 downTo 0‬‬
‫)‪println(i‬‬
‫}‬
‫ﻟﻄﺒﺎﻋﺔ اﻟﻌﻨﺎﺻﺮ ﺗﺼﺎﻋﺪﻳﺎ‪ ،‬ﻣﺜﺎل‪:‬‬ ‫‪until‬‬
‫{)‪for (i in 1 until 10‬‬
‫)‪println(i‬‬
‫}‬
‫ﻫﻨـ ـﺎ ﻳﺒـ ـﺪأ ﻳﻄﺒﻊ ﻣﻦ رﻗﻢ ‪ ١‬وﻳﺘﻮﻗﻒ ﻋﻨـ ـﺪ ‪ ، ٩‬وذﻟـ ـﻚ ﻷن ‪ until‬ﺗﻌﻨﻲ‬
‫ﺣﺘﻰ أي ﻛـﺂﻧﻨـﺎ ﻧﻘﻮل ﺣﺘﻰ ﺗﺮى ‪ ١٠‬ﻓﺘﻮﻗﻒ ﻟﻮ أردﻧـﺎ ﻃﺒـﺎﻋـﺔ اﻟﺮﻗﻢ ‪١٠‬‬
‫ﻓﺴﻨﺠﻌﻞ اﻟﺮﻗﻢ ﻳﻨﺘﻬﻲ ﻋﻨﺪ ‪١١‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪53‬‬

 ‫‪Visibility Modifiers‬‬

‫أوﻻ ‪ :‬رؤﻳﺔ اﻟﻤﺘﻐﻴﺮات‬

‫ﻳﻘﺼـ ــــــ ـﺪ ﺑﺮؤﻳﺔ اﻟﻤﺘﻐﻴﺮات وﻫﻲ ﻣﺠﺎل رؤ ﻳﺘﻬﺎ ﻓﻲ اﻟﻤﺸـ ــــــ ـﺮوع وﻟﻜﻲ ﻧﻌﺮﻓﻬﺎ ﻻﺑﺪ أن ﻧﻌﺮف‬
‫أﻧﻮاع اﻟﻘﻴﻮد ﻋﻠﻰ اﻟﻤﺘﻐﻴﺮات‪:‬‬

‫اﻟ ـﺪوال واﻟﻤﺘﻐﻴﺮات اﻟ ـﺬي ﻧﻘﻮم ﺑﺘﻌﺮ ﻳﻔﻬ ـﺎ داﺋﻤ ـﺎ ﻫﻲ ﺑ ـﺎﻷﺳـ ــــــــ ـﺎس‬ ‫‪Publi‬‬
‫‪public‬أي أﻧﻪ ﻋﻨﺪﻣﺎ ﻧﻘﻮم ﺑﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪var num1:Int=0‬‬
‫ﺳـ ــــــ ـﻮاء ﻗﻤﻨــﺎ ﺑﻮﺿـ ــــــ ـﻊ اﻟﻜﻠﻤــﺔ أم ﻟﻢ ﻧﻀـ ــــــ ـﻌﻬــﺎ ﻫﻲ ﺗﻠﻘــﺎﺋﻴــﺎ ﻫﻜــﺬا‬
‫ﺗﻌﺘﺒﺮ‪ public .‬ﺣـﺪود رؤﻳـﺔ اﻟﻤﺘﻐﻴﺮات اﻟﻤﻌﺮﻓـﺔ ﺑﻬـﺬه اﻟﻄﺮ ﻳﻘـﺔ ﺗﻜﻮن‬
‫ﻣﺮﺋﻴﺔ ﻋﻠﻰ ﻣﺴﺘﻮى اﻟﻤﺸﺮوع ﻛﺎﻣﻞ‬
‫ﺣـﺪود رؤﻳـﺔ اﻟﻤﺘﻐﻴﺮات واﻟـﺪوال اﻟﻤﻌﺮﻓـﺔ ﺑﻬـﺬه اﻟﻄﺮ ﻳﻘـﺔ ﺗﻜﻮن ﻓﻘﻂ‬ ‫‪internal‬‬
‫ﻓﻲ ‪ module‬اﻟﺤﺎﻟﻲ‪:‬‬
‫‪internal var num2:Int=0‬‬
‫اﻟـﻤـﺘـﻐـﻴـﺮات واﻟـ ــ ـﺪوال اﻟـﺘـﻲ ﺗـﻌـﺮف ﺑـﻬـ ــ ـﺬا اﻟـﻨـﻮع ﻻ ﻳـﻤـﻜـﻦ رؤ ﻳـﺘـﻬـ ــ ـﺎ إﻻ‬ ‫‪Protected‬‬
‫ﺑﺎﻟﺘﺼﻨﻴﻔﺎت اﻟﻮارﺛﺔ‪:‬‬
‫‪protected var num3:Int=0‬‬
‫ﻻ ﻳﻤﻜﻦ رؤﻳﺘﻪ إﻻ ﺑﺪاﺧﻞ اﻟﺘﺼﻨﻴﻒ اﻟﺬي ﺗﻢ ﺗﻌﺮ ﻳﻔﻪ ﻓﻴﻪ ﻓﻘﻂ‬ ‫‪private‬‬
‫‪private var num4 :Int =0‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪54‬‬

 ‫ﺛﺎﻧﻴﺎ ‪ :‬أﻫﻤﻴﺔ رؤﻳﺔ اﻟﻤﺘﻐﻴﺮات‬

‫وﺿـ ـﻊ ﻗﻴﻮد ﻋﻠﻰ اﻟﻤﺘﻐﻴﺮات ﺗﺠﻌﻞ اﻟﻮﺻـ ـﻮل إﻟﻰ ﻫﺬه اﻟﻤﺘﻐﻴﺮات ﺳـ ـﻬﻞ ‪ ،‬ﻓﻤﺜﻼ ﻟﻮ أردت‬
‫أن أﻋﺮف ﻣﺠﻤﻮﻋﺔ ﻣﺘﻐﻴﺮات وأر ﻳﺪ ﻓﻘﻂ أن أﺻـ ــــــ ﻞ إﻟﻰ ﻣﺘﻐﻴﺮ واﺣﺪ ﻓﻲ اﻟﻤﺸـ ــــــ ﺮوع ﻛﻜﻞ ﻫﻨﺎ‬
‫ﻧﺴﺘﻄﻴﻊ وﺿﻌﻪ ﻋﺎم ﻟﻨﺘﻤﻜﻦ ﻣﻦ رؤ ﻳﺘﻪ ﻓﻲ ﻛﺎﻓﺔ أﺟﺰاء اﻟﻤﺸﺮوع ‪ ،‬وﺑﻘﻴﺔ اﻟﻤﺘﻐﻴﺮات ﻧﺴﺘﻄﻴﻊ‬
‫ﺗﻌﺮ ﻳﻔﻪ ﻋﻠﻰ ﺣﺴـﺐ اﺳـﺘﺨﺪاﻣﻬﺎ ﻫﻞ ﻓﻘﻂ ﺳـﺄ ﻛﺘﻔﻲ ﺑﺄن ﻳﻜﻮن اﻟﻤﺘﻐﻴﺮ ﻓﻲ اﻟﺘﺼـﻨﻴﻒ اﻟﻮارث‬
‫أو ﻓﻲ ‪ module‬اﻟﺤﺎﻟﻲ‪.‬‬

‫‪ESCAPE SEQUENCE‬‬

‫أوﻻ ‪ :‬ﻣﺎﻫﻲ اﻻﺧﺘﺼﺎرات أو اﻷواﻣﺮ اﻟﺴﺮﻳﻌﺔ‬

‫‪ESCAPE SEQUENCE‬‬

‫ﻫﻲ رﻣﻮز ﺗﺴـ ــــ ـﺎﻋﺪﻧﺎ اﺛﻨﺎء ﻛﺘﺎﺑﺔ اﻷواﻣﺮ اﻟﺒﺮﻣﺠﻴﺔ ﻋﻠﻰ أداء أﻣﺮ ﻣﻌﻴﻦ‪ ،‬ﻣﺜﻞ‪ :‬ﻧﺰول ﺳـ ــــ ـﻄﺮ‪،‬‬
‫ﺗﺮك ﻣﺴﺎﻓﺔ ﻣﻌﻴﻨﺔ‪ ،‬اﻟﺒﺪء ﻣﻦ أول اﻟﺴﻄﺮ …إﻟﺦ‪.‬‬

‫ﺛﺎﻧﻴﺎ ‪ :‬اﻟﺮﻣﻮز وﻣﻌﺎﻧﻴﻬﺎ‬

‫‪ v‬اﻟﺮ ﻣ ﺰ ‪\ n‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪55‬‬

 ‫ﻳﺸﻴﺮ إﻟﻰ ﻧﺰول ﺳﻄﺮ ﻋﻨﺪ ﻋﻤﻠﻴﺔ اﻟﻄﺒﺎﻋﺔ وﻫﻜﺬا ﻳﻜﺘﺐ‪:‬‬

‫)"‪print("Hello World\n‬‬

‫‪ v‬اﻟﺮ ﻣ ﺰ ‪\ t‬‬

‫ﻟﻄﺒﺎﻋﺔ ﻣﺴﺎﺣﺔ ﺑﻴﻦ اﻟﻜﻠﻤﺎت ﻋﻨﺪ ﻋﻤﻠﻴﺔ اﻟﻄﺒﺎﻋﺔ وﻫﻜﺬا ﻳﻜﺘﺐ‪:‬‬

‫)"‪println("hello ,\t we learn Kotlin programming‬‬

‫‪ v‬اﻟﺮ ﻣ ﺰ ‪\ b‬‬

‫ﻣﺴﺢ أﺧﺮ ﺣﺮف ﻣﻦ اﻟﻜﻠﻤﺔ اﻟﻤﻮﺿﻮع ﻋﻨﺪﻫﺎ اﻟﺮﻣﺰ ‪ ،‬وﻫﻜﺬا ﻳﻜﺘﺐ‪:‬‬

‫)" ‪println("hello ,we learn Kotlin programming\b‬‬

‫‪ v‬اﻟﺮ ﻣ ﺰ ‪\ r‬‬

‫ﺗﻘﻮم ﺑﻤﺴـﺢ اﻟﺴـﻄﺮ ﻛﺎﻣﻼ ﻟﻮ وﺿـﻌﺖ اﺧﺮ اﻷﻣﺮ ‪ ،‬وﻟﻮ ﻛﺎن ﻓﻲ اﻣﺮ ﻃﺒﺎﻋﺔ ﻣﺜﻼ ووﺿـﻌﺘﻪ ﻓﻲ‬
‫اﻟﻤﻨﺘﺼـﻒ ﻳﻤﺴـﺢ ﻣﺎ ﻗﺒﻠﻪ ‪ ،‬ﻧﺴـﺘﻄﻴﻊ اﻻﺳـﺘﻔﺎدة ﻣﻦ ﻫﺬا اﻷﻣﺮ ﻓﻲ ﻋﻤﻠﻴﺔ ﺗﺤﺘﺎج إﻟﻰ اﻟﻌﺪ ﻣﺜﻼ‬
‫ﻟﻮ اردﻧـﺎ ﻗﻴـﺎس ﻧﺴـ ــــــ ـﺒـﺔ ﺗﺤﻤﻴـﻞ ﺑﺮﻧـﺎﻣﺞ ﻣﻌﻴﻦ أﻻ ﻳﻈﻬﺮ ﻟﻨـﺎ ﻓﻲ اﻟﺒـﺪا ﻳـﺔ ‪… ٪٤٠، ٪١٩ ، ٪١٥‬إﻟﺦ‬
‫وﻫﻜﺬا ﻧﻤﺴﺢ اﻟﻌﺪد وﻧﻀﻊ ﻋﺪد ﺟﺪﻳﺪ ﻟﻠﺘﻘﺪم‪:‬‬

‫{)‪for(x in 1..800‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪56‬‬

 ‫{)‪for ( i in 1..500‬‬
‫)‪print("\r"+i‬‬
‫}}‬

‫‪ v‬اﻟﺮ ﻣ ﺰ ' \‬

‫ﻣﺨﺼﺺ ﻟﻄﺒﺎﻋﺔ ﻋﻼﻣﺔ ‘ ﻟﻮ أردﻧﺎ ﻃﺒﺎﻋﺘﻬﺎ ﻓﻲ اﻟﻨﺺ ‪ ،‬ﻣﺜﺎل‪:‬‬

‫)" ‪println("hello ,we learn \'Kotlin\' programming‬‬

‫‪ v‬اﻟﺮ ﻣ ﺰ " \‬

‫ﻣﺨﺼﺺ ﻟﻄﺒﺎﻋﺔ ﻋﻼﻣﺔ ” ﻟﻮ أردﻧﺎ ﻃﺒﺎﻋﺘﻬﺎ ﻓﻲ اﻟﻨﺺ ‪ ،‬ﻣﺜﺎل‪:‬‬

‫)" ‪println("hello ,we learn \"Kotlin\" programming‬‬

‫‪ v‬اﻟﺮ ﻣ ﺰ ‪\ $‬‬

‫ﻣﺨﺼﺺ ﻟﻄﺒﺎﻋﺔ ﻋﻼﻣﺔ ‪ $‬ﻟﻮ أردﻧﺎ ﻃﺒﺎﻋﺘﻬﺎ ﻓﻲ اﻟﻨﺺ ‪ ،‬ﻣﺜﺎل‪:‬‬

‫)" ‪println("Dollar \$ is the currency for United State‬‬

‫‪ v‬اﻟﺮ ﻣ ﺰ \ \‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪57‬‬

 ‫ﻣﺨﺼﺺ ﻟﻄﺒﺎﻋﺔ ﻋﻼﻣﺔ \ ﻟﻮ أردﻧﺎ ﻃﺒﺎﻋﺘﻬﺎ ﻓﻲ اﻟﻨﺺ ‪ ،‬ﻣﺜﺎل‪:‬‬

‫)"‪println("hello \\ welcome‬‬

‫‪UNICODE‬‬

‫ﺗﺘﻨﻮع اﻟﺮﻣﻮز واﻟﺤﺮوف اﻟﻤﺴـﺘﺨﺪﻣﺔ ﻣﻦ ﺑﻠﺪ ﻷﺧﺮ واﻟﻴﻮﻧﻴﻜﻮد ﻫﻮ ﻋﺒﺎرة ﻋﻦ ﺷـﻔﺮة ﺧﺎﺻـﺔ‬
‫ﻟﺤﺮوف ورﻣﻮز ﻣﺨﺼﺼﺔ ﻛﻤﺎ ﻫﻮ ﻣﻮﺿﺢ ﻓﻲ اﻟﺼﻮرة اﻟﺘﺎﻟﻴﺔ‪:‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪58‬‬

‫ﻫﺬه اﻟﺮﻣﻮز اﻟﻤﺨﺼـﺼـﺔ ﻳﻤﻜﻨﻚ اﻟﻮﺻـﻮل إﻟﻴﻬﺎ ﻣﻦ ﺧﻼل اﻟﻤﻮﻗﻊ‪ UNICODE‬وﻟﺠﻠﺐ ال‬
‫‪Unicode‬اﻟﺨﺎص ﺑﻬﺎ ﻧﻘﻮم ﺑﺎﻟﺘﺎﻟﻲ‪:‬‬

‫ﺑﻤﺠﺮد اﻟﻮﻗﻮف ﻋﻠﻰ اﻟﺮﻣﺰ واﻟﻀﻐﻂ ﻇﻬﺮ ﻟﻨﺎ ﻣﺮ ﺑﻊ اﺧﺘﺼﺎر ﻓﻴﻪ اﻟﻤﻌﻠﻮﻣﺎت اﻟﺘﻲ ﻧﺤﺘﺎﺟﻬﺎ‬
‫وﻧﻼﺣﻆ رﻣﺰ ‪ Unicode‬ﻇﻬﺮ ﻟﻨﺎ‪.‬‬

‫ﻟﻜﺘﺎﺑﺔ اﻟﺮﻣﺰ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ واﻻﺳﺘﻔﺎدة ﻣﻨﻪ ﻧﻜﺘﺐ ﻫﻜﺬا\‪:u2101‬‬

‫ﻻﺑﺪ ﻣﻦ رﻣﺰ ‪ \u‬ﻓﻲ اﻟﺒﺪا ﻳﺔ وﻣﻦ ﺛﻢ اﻟﺮﻗﻢ اﻟﺨﺎص ﺑﺎﻟﺮﻣﺰ‪ ،‬ﻣﺜﺎل‪:‬‬

‫{)>‪fun main(args:Array<String‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪59‬‬

 var c='\u2101'
println(c)
}

:‫وﻫﻨﺎ ﻗﻤﻨﺎ ﺑﻌﻤﻠﻴﺔ ﻃﺒﺎﻋﺔ ﻟﻠﺮﻣﻮز اﻟﻮاﻗﻌﺔ ﺑﻴﻦ ﻣﺪى ﻣﻌﻴﻦ‬

fun main(args:Array<String>){
var e1='\u0200'
var e2='\u0218'

for ( i in '\u0200' .. '\u0218')

{
println(i)
}

: ‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
Ȁ
ȁ
Ȃ
ȃ
Ȅ
ȅ
Ȇ
ȇ
Ȉ
ȉ

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 60 ‫اﻟﺼﻔﺤﺔ‬

Ȋ
ȋ
Ȍ
ȍ
Ȏ
ȏ
Ȑ
ȑ
Ȓ
ȓ
Ȕ
ȕ
Ȗ
ȗ
Ș

:‫ اﻟﺨﺎص ﺑﺤﺮف أو رﻣﺰ ﻣﻌﻴﻦ‬Unicode ‫ ﻟﺠﻠﺐ‬v

:‫ ﻣﺜﺎل‬،‫ اﻟﺨﺎص ﺑﻪ‬Unicode ‫ﻟﻮ أردت ﻛﻤﺴﺘﺨﺪم أن ﺗﻘﻮم ﺑﺈدﺧﺎل ﺣﺮف ﻣﻌﻴﻦ ﻟﻤﻌﺮﻓﺔ‬

fun main(args:Array<String>){
println("enter any character :")
var ch:Char = readLine()!!.single()
println("unicode of this character is : ${ch.toInt()}")
}

var ch:Char = readLine()!!.single()

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 61 ‫اﻟﺼﻔﺤﺔ‬

‫ إذا ﻟﺘﺤﻮﻳﻞ اﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ‬،toChar ‫اﻟﺤﺮف ﻫﻮ اﻟﻮﺣﻴﺪ اﻟﺬي ﻻ ﺗﺴـ ـــــ ـﺘﻄﻴﻊ ﻛﺘﺎﺑﺘﻪ ﻫﻜﺬا‬
.single ‫إﻟﻰ ﺣﺮف ﻧﻘﻮم ﺑﺎﺳﺘﺨﺪام‬

${toInt()}

.Unicode ‫ﻋﻦ ﻃﺮ ﻳﻖ ﻫﺬا اﻷﻣﺮ ﺳﻴﻈﻬﺮ ﻟﻨﺎ‬

Unicode ‫ ﻟﺠﻠﺐ اﻟﺤﺮف أو رﻣﺰ ﻣﻌﻴﻦ ﻋﻦ ﻃﺮﻳﻖ إدﺧﺎل‬v

fun main(args:Array<String>){

println("enter the unicode :")

var uniNum:Int= readLine()!!.toInt()
println("unicode of this character is : ${uniNum.toChar()}")

REGEX (Regular Expression)

‫ اﻟﺘﻌﺒﻴﺮات اﻟﻘﻴﺎﺳﻴﺔ‬: ‫أوﻻ‬

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 62 ‫اﻟﺼﻔﺤﺔ‬

‫اﻟﺘﻌﺒﻴﺮات اﻟﻘﻴﺎﺳـﻴﺔ ﻣﻔﻴﺪة ﺑﺸـﻜﻞ ﻛﺒﻴﺮ ﺧﺼـﻮﺻـﺎ ﻟﻮ أردت أن ﻳﺪﺧﻞ اﻟﻤﺴـﺘﺨﺪم ﺑﻴﺎﻧﺎت‬
‫وﻟﻜﻦ ﺑﻘﻴﻮد ﻣﻌﻴﻨـﺔ ‪ ،‬ﻣﺜﻼ اﻟﺒﺮ ﻳـﺪ اﻹﻟﻜﺘﺮوﻧﻲ ﺗﺮ ﻳـﺪه أن ﻳﻘﻮم ﺑـﺈدﺧـﺎﻟـﻪ ﺑﺼـ ــــــ ـﻴﻐﺘـﻪ اﻟﺼـ ــــــ ـﺤﻴﺤـﺔ‬
‫ﻛﺎﻟﺘﺎﻟﻲ ‪:‬‬

‫‪Ahmed1431@gmail.com‬‬

‫ﺛﺎﻧﻴﺎ ‪ :‬ﻃﺮﻳﻘﺔ اﻟﺘﻌﺒﻴﺮ ﻋﻦ اﻟﺘﻌﺒﻴﺮات اﻟﻘﻴﺎﺳﻴﺔ‬

‫ﻻﺑﺪ ﻣﻦ اﻟﺘﻌﺮف ﻋﻠﻰ اﻟﺮﻣﻮز اﻟﻤﺴﺘﺨﺪﻣﺔ ﻟﻠﺘﻌﺒﻴﺮ ﻋﻦ اﻟﺮﻣﻮز اﻟﻘﻴﺎﺳﻴﺔ‪:‬‬

‫§ \‪d‬‬

‫ﻣﺨﺼـ ــــــ ـﺺ ﻹدﺧـﺎل رﻗﻢ ﻣﻦ ‪ ٩-٠‬ﻓﻘﻂ أي ﻟﻮ ﻗﻤـﺖ ﺑـﺈدﺧـﺎل أي ﺣﺮف او رﻣﺰ ﺳـ ــــــ ـﺘﻜﻮن‬
‫اﻟﻨﺘﻴﺠﺔ ‪.false‬‬

‫§ \‪w‬‬

‫ﻹدﺧﺎل أي ﻣﻦ اﻟﻘﻴﻢ اﻟﺘﺎﻟﻴﺔ ‪ : a-z ,A-Z ,0-9‬اﻟﺤﺮوف ﺳـﻮاء ﻛﺎﻧﺖ ﻛﺒﻴﺮة أو ﺻـﻐﻴﺮة وأي‬
‫رﻗﻢ ﻣﻦ ‪.٩-٠‬‬

‫§ \‪s‬‬

‫ﻟﻄﺒﺎﻋﺔ ﻣﺴﺎﻓﺔ‪.‬‬

‫§ ][‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪63‬‬

‫ﻟﻠﺘﻨﺴـ ـﻴﻖ ﺑﻤﻌﻨﻰ ﻟﻮ أردت أن ﺗﻄﻠﺐ ﻣﻦ اﻟﻤﺴـ ـﺘﺨﺪم إدﺧﺎل ﺣﺮوف ﻣﻦ ‪ a-z‬وﻧﻼﺣﻆ أﻧﻨﺎ‬
‫ﻃﻠﺒﻨﺎ ﺣﺮوف ﺻﻐﻴﺮة ﻧﻘﻮم ﺑﻮﺿﻌﻬﺎ ﺑﻴﻦ ﻫﺬه اﻷﻗﻮاس اﻟﻤﺮ ﺑﻌﺔ ﻫﻜﺬا]‪: [a-z‬‬

‫§ }{‬

‫ﻧﺴﺘﺨﺪﻣﻬﺎ ﻟﺘﺤﺪﻳﺪ ﻋﺪد اﻟﺨﺎﻧﺎت اﻟﻤﺪﺧﻠﺔ ﻓﻤﺜﻼ ﺑﻌﺪ ﻃﻠﺒﻚ ﻣﻦ اﻟﻤﺴﺘﺨﺪم ادﺧﺎل اﺳﻤﻪ‬
‫ﺳـ ــــ ـﻨﻘﻮم ﺑﺘﺤﺪﻳﺪ ﻋﺪد اﻟﺤﺮوف اﻟﻤﺪﺧﻠﺔ ﺑﺤﻴﺚ أن اﺳـ ــــ ـﻤﻪ ﻻ ﻳﺘﺠﺎوز ‪ ٢٠‬ﺣﺮف وﻻ ﻳﻘﻞ ﻋﻦ ‪٥‬‬
‫ﻣﺜﻼ ﻫﻜﺬا‪:‬‬

‫}‪[a-z]{5,20‬‬

‫§ \*‬

‫ﻟﻮ أردت أن ﻳﻘﻮم اﻟﻤﺴـ ــــ ـﺘﺨﺪم ﺑﺈدﺧﺎل ﺧﺎﻧﺎت ﻛﺜﻴﺮة وﻓﻲ ﺣﺎل أ ﻳﻀـ ــــ ـﺎ ﺗﺮﻛﺖ ﻟﻪ ﺧﻴﺎر ﺑﺄن ﻻ‬
‫ﻳﻘﻮم ﺑﺎﻹدﺧﺎل أ ﻳﻀﺎ‪ .‬ﻣﺜﻼ‪:‬‬

‫*‪\w‬‬

‫§ \‪+‬‬

‫ﻟﻮ أردت أن ﻳﻘﻮم اﻟﻤﺴـ ــــــ ـﺘﺨـﺪم ﺑـﺈدﺧـﺎل ﺧـﺎﻧـﺎت ﻛﺜﻴﺮة أو ﻋﻠﻰ اﻷﻗـﻞ ﻻﺑـﺪ ﻣﻦ إدﺧـﺎل ﺧـﺎﻧـﺔ‬
‫ﺨﺎـﻧﺎت ﻛﺜﻴﺮة أو ﻋﻠﻰ اﻷـﻗﻞ‬
‫ﻤﻞء اﻟﻔﺮاغ ﺑ ـ‬
‫ﺠﺎل ﻟﺘﺮـﻛﻪ ـﻓﺎﺿـ ــــــ ـﻲ إـﻣﺎ إن ﺗﻘﻮم ﺑ ـ‬
‫ﺣﺪة ﺑﻤﻌﻨﻰ ﻻ ﻣ ـ‬
‫وا ـ‬
‫أدﺧﻞ ﺧﺎﻧﺔ‪ .‬ﻣﺜﻼ‪:‬‬

‫‪\w+‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪64‬‬

 ‫§ \?‬

‫ﻳﺪع اﻟﻤﺠﺎل ﻟﻠﻤﺴﺘﺨﺪم إﻣﺎ أن ﻻ ﻳﺪﺧﻞ أﺑﺪا أو ﻳﺪﺧﻞ ﺧﺎﻧﺔ واﺣﺪة ﻓﻘﻂ ‪ ،‬ﻣﺜﻼ‪:‬‬

‫?‪\w‬‬

‫§ )(‬

‫ﻟﺘﺠﻤﻴﻊ اﻟﺘﻨﺴﻴﻖ اﻟﺬي ﺗﺨﻄﻂ ﻟﻪ ‪ ،‬ﻣﺜﻼ‪:‬‬

‫)"}‪("\\d{4‬‬

‫ﻧﻼﺣﻆ أﻧﻨﺎ وﺿﻌﻨﺎ ﻗﻮﺳﻴﻦ داﺋﺮ ﻳﻴﻦ وﻣﻦ ﺛﻢ ﻋﻼﻣﺔ اﻟﺘﻨﺼﻴﺺ‪.‬‬

‫§ |‬

‫ﻟﻨﻔﺮض أﻧﻚ ﻃﻠﺒﺖ ﻣﻦ اﻟﻤﺴـ ــ ـﺘﺨﺪم إدﺧﺎل ﺑﻴﺎن ﻣﻌﻴﻦ وﻳﺤﺘﻤﻞ إدﺧﺎﻟﻪ أ ﻛﺜﺮ ﻣﻦ ﺷـ ــ ـﻜﻞ‬
‫)ﺗﻨﺴـ ــــــ ـﻴﻖ( ﻓﻨﺴـ ــــــ ـﺘﺨـﺪم ﻫـﺬه اﻟﻌﻼﻣـﺔ ﻟﻠﺘﺨﻴﻴﺮ ﺑﻤﻌﻨﻰ ﻟﻮ أدﺧـﻞ اﻟﺘﻨﺴـ ــــــ ـﻴﻖ اﻟـﺬي ﻋﺮﻓﻨـﺎه أو‬
‫اﻟﺘﻨﺴﻴﻖ اﻷﺧﺮ ﻓﻬﻮ ﺻﺤﻴﺢ‪ ،‬ﻣﺜﻼ‪:‬‬

‫ﺧﺎـﻟﻪ ﺑﻄﺮ ﻳﻘﺘﻴﻦ إـﻣﺎ‬

‫ﺧﺎل رﻗﻢ اﻟـﻬﺎﺗﻒ اﻟﻨـﻘﺎل ـﻓﺄـﻧﺖ ﺗﺘﻮﻗﻊ إد ـ‬
‫ﺨﺪم إد ـ‬
‫ﻟﻮ ﻃﻠـﺒﺖ ﻣﻦ اﻟﻤﺴـ ــــــ ـﺘ ـ‬
‫أن ﻳﻘﻮم ﺑـﺈدﺧـﺎل ‪ ١٠‬ارﻗـﺎم ﻛﻤـﺎ ﻫﻮ ﻣﻌﺘـﺎد أو إﻣـﺎ ﻋﻦ ﻃﺮ ﻳﻖ وﺿـ ــــــ ـﻊ ﻣﻔﺘـﺎح اﻟـﺪوﻟـﺔ وﻣﻦ ﺛﻢ ‪٩‬‬
‫ارﻗﺎم ﻫﻜﺬا‪:‬‬

‫)"}‪var exp = Regex("\\d{10‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪65‬‬

 ‫)"}‪var exp1 = Regex("\\+966\\d{9‬‬

‫وﻋﻨﺪ اﻻﺧﺘﻴﺎر ﺳﻨﻘﻮم ﻫﻜﺬا‪:‬‬

‫‪exp |exp1‬‬

‫§ ﻟﻠﻮﺻﻮل إﻟﻰ اﻟﺮﻣﻮز ﻛـ )& ‪ ، * ،‬؟ ‪… ، . ، !، @ ، # ،‬إﻟﺦ(‬

‫?\‬
‫‪\$‬‬
‫&\‬
‫*\‬

‫§ ‪. Dout‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻠﺘﺠﺎﻫﻞ ﻓﻤﺜﻼ ﺗﺮ ﻳﺪ ﺗﺠﺎﻫﻞ ﺧﺎﻧﺔ أو أ ﻛﺜﺮ ﻓﻲ اﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ‪ ،‬ﻣﺜﻼ‪:‬‬

‫}‪\\d..\\d{4‬‬

‫ﻧﻼﺣﻆ ﻃﻠﺒﻨـﺎ أﻧـﻪ ﻳـﺪﺧـﻞ ﻓﻲ اﻟﺒـﺪا ﻳـﺔ رﻗﻢ ﺛﻢ ‪ .‬ﻟﺘﺠـﺎﻫـﻞ ﺧـﺎﻧـﺔ و ‪ .‬ﻣﺮة أﺧﺮى ﻟﺘﺠـﺎﻫـﻞ ﺧـﺎﻧـﺔ‬
‫ﺛﺎﻧﻴﺔ وﻣﻦ ﺛﻢ رﻗﻢ‪.‬‬

‫ﺛﺎﻟﺜﺎ‪ :‬ﻣﺜﺎل‪:‬‬

‫{)>‪fun main(args:Array<String‬‬

‫)"‪println("Hello , please complete this form :\n Enter your name :‬‬
‫)"}‪val nameEx = Regex("\\w{3,10}\\s\\w{3,15‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪66‬‬

 val name = readLine()!!.toString()
if(nameEx.matches(name)){
println(" Enter your phone number :")
val phoneEx = Regex("\\+966\\d{9}")
val phone = readLine()!!.toString()
if(phoneEx.matches(phone)){
println(" Enter your Email :")
val emailEx = Regex("(^[a-zA-Z0-9_.+-]{2,25}+@[a-zA-Z0-9-
]{5,12}+\\.[a-zA-Z0-9-.]{2,3})")
val email = readLine()!!.toString()
if(emailEx.matches(email)){
println("thank you")
}
else {
println("please enter correct email")
}
}
else {
println("please enter correct phone name begining with +966
")
}
}
else {
println("please enter correct name")
}
}

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
Hello , please complete this form :
Enter your name :

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 67 ‫اﻟﺼﻔﺤﺔ‬

ahmed aljuaid
Enter your phone number :
+966123456789
Enter your Email :
ahmed12.ahmed@gmail.com
thank you

‫ اﻟﺪوال اﻟﻤﺴﺘﺨﺪﻣﺔ ﻣﻊ اﻟﺘﻌﺒﻴﺮات اﻟﻘﻴﺎﺳﻴﺔ‬: ‫راﺑﻌﺎ‬

Find v

.[matchedResult – null] ‫اﻟﻘﻴﻤﺔ اﻟﻌﺎﺋﺪة‬

‫ﺗﺘﺤﻘﻖ ﻫﺬه اﻟﺪاﻟﺔ ﻣﻦ ﺗﻄﺎﺑﻖ اﻟﻨﺺ اﻟﻤﺪﺧﻞ ﻣﻊ اﻟﺘﻨﺴـ ـــــ ـﻴﻖ اﻟﻤﺨﺼـ ـــــ ـﺺ ﻟﻪ ﻃﺎﻟﻤﺎ ﻛﺎن‬
.null ‫ وﻋﻨﺪ ﻋﺪم اﻟﺘﻄﺎﺑﻖ ﻳﻌﻮد ﺑـ‬،‫ﻣﺘﻄﺎﺑﻖ ﻳﻌﻮد ﺑﺎﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ‬

‫§ ﻣﺜﺎل‬
println("enter your phone number:")
var phone = readLine()!!.toString()

val phoneEx :String? = Regex("\\+966\\d{9}") // like : +966561234567

.find(phone)?.value
println(phoneEx)

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 68 ‫اﻟﺼﻔﺤﺔ‬

 ‫ادﺧﻠﻨﺎ ﻗﻴﻤﺔ ﻏﻴﺮ ﻣﻄﺎﺑﻘﺔ ﻟﻠﺘﻨﺴﻴﻖ ﻓﻨﻼﺣﻆ اﻧﻪ ﺳﻴﻄﺒﻊ ‪.null‬‬

‫‪findAll v‬‬

‫اﻟﻘﻴﻤﺔ اﻟﻌﺎﺋﺪة ‪ :‬ﺗﻌﻮد ﺑﺠﻤﻴﻊ اﻟﻘﻴﻢ اﻟﻤﺘﻄﺎﺑﻘﺔ ﻣﻊ اﻟﺘﻨﺴﻴﻖ اﻟﻤﻄﻠﻮب‪ .‬ﻣﺜﻼ‪:‬‬

‫= ‪val matchedResults = Regex(pattern = """\d+""").findAll(input‬‬

‫)"‪"1as232v4‬‬

‫{ )‪for (i in matchedResults‬‬
‫)" " ‪print(i.value +‬‬
‫}‬

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬

‫اﻟﺘﻨﺴـ ـــ ـﻴﻖ اﻟﻤﻄﻠﻮب ﻓﻲ اﻟﻤﺜﺎل ﻫﻮ رﻗﻢ ﻓﻘﻂ ﻓﻨﻘﻮم ﺑﻌﻤﻞ ﺣﻠﻘﺔ ﺗﻌﻮد ﺑﺎﻷرﻗﺎم اﻟﻤﻮﺟﻮدة‬
‫ﻓﻲ اﻟﻨﺺ ﻣﻊ ﻃﺒﺎﻋﺔ ﻣﺴﺎﻓﺔ‪:‬‬

‫‪1 232 4‬‬

‫ﻧﻼﺣﻆ أﻧﻪ ﻃﺒﻊ رﻗﻢ ‪ ١‬وﻣﻦ ﺛﻢ ﻣﺴـ ـــﺎﻓﺔ وﻣﻦ ﺛﻢ ﻃﺒﻊ اﻷرﻗﺎم ‪ ٢٣٢‬ﻣﺘﺘﺎﻟﻴﺔ ﺑﺪون ﻣﺴـ ـــﺎﺣﺔ‬
‫ﻷﻧﻬﺎ ﻓﻲ اﻟﻨﺺ أﺗﺖ ﻣﻊ ﺑﻌﻀـ ـــ ـﻬﺎ ﻟﻢ ﻳﻔﺼـ ـــ ـﻠﻬﺎ ﺣﺮف أو رﻣﺰ وﻣﻦ ﺛﻢ ﻣﺴـ ـــ ـﺎﺣﺔ وﻫﻜﺬا ﻳﺴـ ـــ ـﺘﻤﺮ‬
‫ﻋﻤﻠﻬﺎ‪.‬‬

‫‪matchEntire v‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪69‬‬

 ‫اﻟﻘﻴﻤﺔ اﻟﻌﺎﺋﺪة‪.[matchedResult – null] :‬‬

‫ﻟﻠﺘﺤﻘﻖ ﻣﻦ اﻟﻘﻴﻤـﺔ اﻟﻤـﺪﺧﻠـﺔ ﻋﻨـﺪ اﻟﺘﻄـﺎﺑﻖ ﻣﻊ اﻟﺘﻨﺴـ ــــــ ـﻴﻖ اﻟﻤﺨﺼـ ــــــ ـﺺ ﻟـﻪ ﻃـﺎﻟﻤـﺎ ﻛـﺎن‬
‫ﻣﺘﻄﺎﺑﻖ ﻳﻌﻮد ﺑﺎﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ ‪ ،‬وﻋﻨﺪ ﻋﺪم اﻟﺘﻄﺎﺑﻖ ﻳﻌﻮد ﺑ ـ ـــــــ ـ ‪ ،null‬ﻣﻊ اﻟﺘﻨﻮﻳﻪ أن اﻟﻤﺴـﺎﻓﺔ‬
‫ﺗﺤﺘﺴﺐ ﻛﺤﺮف ﻓﻌﻨﺪ إٍذ ﺗﻌﻮد ﺑـ ‪ null‬ﻟﻮ ﻛﺎن اﻟﺘﻨﺴﻴﻖ اﻟﻤﻄﻠﻮب رﻗﻢ ﻓﻘﻂ‪.‬‬

‫)"‪println("enter your age:‬‬

‫‪val age= Regex("\\d+").matchEntire("25")?.value‬‬

‫)‪println(age‬‬

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬

‫ﻋﻨﺪ اﻟﺘﻄﺎﺑﻖ ﻃﺒﻊ اﻟﻌﻤﺮ وﻋﻨﺪ اﻻﺧﺘﻼف ﻳﻌﻮد‪null .‬‬

‫‪enter your age:‬‬

‫‪25‬‬

‫‪matches v‬‬

‫اﻟﻘﻴﻤﺔ اﻟﻌﺎﺋﺪة‪.[true – false] :‬‬

‫ﻟﻠﺘﺤﻘﻖ ﻣﻦ ﺗﻄـﺎﺑﻖ اﻟﻘﻴﻤـﺔ اﻟﻤـﺪﺧﻠـﺔ ﻛـﺎﻣﻠـﺔ ﻣﻊ اﻟﺘﻨﺴـ ــــــ ـﻴﻖ اﻟﻤﺨﺼـ ــــــ ـﺺ ﻟـﻪ ﻃـﺎﻟﻤـﺎ ﻛـﺎن‬
‫ﻣﺘﻄﺎﺑﻖ ﻳﻌﻮد ﺑـ ‪ ، true‬وﻋﻨﺪ ﻋﺪم اﻟﺘﻄﺎﺑﻖ ﻳﻌﻮد ﺑـ ‪.false‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪70‬‬

 ‫§ ﻣﺜﺎل‬
‫)"""‪val regex = Regex(pattern = """\d+‬‬
‫))"‪println(regex.matches(input = "50 dollars‬‬

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
‫‪false‬‬

‫‪containsMatchIn v‬‬

‫اﻟﻘﻴﻤﺔ اﻟﻌﺎﺋﺪة‪.[true – false] :‬‬

‫إذا ﻛﺎن ﺟﺰء ﻣﻦ اﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ ﻣﺘﻄﺎﺑﻘﺔ ﻣﻊ اﻟﺘﻨﺴ ـﻴﻖ اﻟﻤﺨﺼ ـﺺ ﻟﻪ ﻳﻌﻮد ﺑ ـ ــــــــ ـ ‪،true‬‬
‫وﻋﻨﺪ ﻋﺪم اﻟﺘﻄﺎﺑﻖ ﻳﻌﻮد ﺑ ـ ــــــــــ ـ ‪ ،false‬وﻫﻲ ﻋﻜﺲ اﻟﺪاﻟﺔ ‪ matchEntire‬اﻟﺘﻲ ﺗﻌﺪ أن اﻟﻘﻴﻤﺔ‬
‫ﻏﻴﺮ ﻣﺘﻄﺎﺑﻘﺔ‪.‬‬

‫§ ﻣﺜﺎل‬
‫)"‪var age =Regex("""\d+""").containsMatchIn("25 years‬‬
‫)‪println(age‬‬

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
‫‪true‬‬

‫ﻧﻼﺣﻆ أﻧﻪ ﻋﺎد ﺑـ ‪ true‬وذﻟﻚ ﻷن اﻟﻮﻇﻴﻔﺔ اﻟﺮﺋﻴﺴﻴﺔ ﻟﻴﺴﺖ ﺗﻄﺎﺑﻖ ﺟﻤﻴﻊ اﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ‬
‫إﻧﻤﺎ ﻳﺘﺤﻘﻖ ﻫﻞ أدﺧﻠﺖ رﻗﻢ ﻛﻤﺎ ﻫﻮ ﻣﻄﻠﻮب ﻓﻲ اﻟﺘﻨﺴﻴﻖ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪71‬‬

 ‫‪split v‬‬

‫اﻟﻘﻴﻤﺔ اﻟﻌﺎﺋﺪة ‪ :‬ﺗﻌﻴﺪ ﻟﻨﺎ ﻗﺎﺋﻤﺔ ﺗﺨﻠﻮ ﻣﻦ اﻟﺘﻨﺴﻴﻖ اﻟﺬي أﻧﺖ ﺣﺪدﺗﻪ‪ .‬ﻣﺜﺎل‪:‬‬

‫)"‪println("enter your age:‬‬

‫)(‪var testSplit = readLine()!!.toString‬‬
‫)‪val a = Regex("[a-zA-Z]").split(testSplit‬‬
‫)‪println(a‬‬

‫ﻃﻠﺒﻨـﺎ ﻣﻨـﻪ أن ﻳﻌﻮد ﺑﺠﻤﻴﻊ ﻣـﺎ ﺗﻘﻮم ﺑـﺈدﺧـﺎﻟـﻪ ﺑـﺎﺳـ ــــــ ـﺘﺜﻨـﺎء )”]‪ Regex(“[a-zA-Z‬ﺟﻤﻴﻊ‬
‫اﻟﺤﺮوف ﻻ ﺗﻌﻮد‪.‬‬

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
‫‪enter your age:‬‬
‫‪28‬‬
‫]‪[28‬‬

‫‪replace v‬‬

‫ﺳﺘﺒﺪال ﻣﺎ ﺗﻢ ﺗﺤﺪﻳﺪه ﻓﻲ اﻟﺘﻨ ـ‬

‫ﺴﻴﻖ ﻣﻦ ﺣﺮف او رﻗﻢ‬ ‫ﺼﻴﺔ ﻣﻊ ا ـ‬
‫اﻟﻘﻴﻤﺔ اﻟﻌﺎﺋﺪة‪ :‬اﻟﻘﻴﻤﺔ اﻟﻨ ـ‬
‫او رﻣﺰ ﺑﻘﻴﻤﺔ أﺧﺮى‪ .‬ﻣﺜﺎل‪:‬‬

‫)"‪val testReplace = Regex("""\d+""").replace("ab12cd34ef", "x‬‬

‫)‪println(testReplace‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪72‬‬

‫ﻧـ ــ ـﻼﺣـ ــ ـﻆ أن )”””‪ Regex(“””\d+‬ﺣـ ــ ـﺪدﻧـ ــ ـﺎ أﻧـ ــ ـﻨـ ــ ـﺎ ﻧـ ــ ـﺮ ﻳـ ــ ـﺪ اﺳـ ــــــــــ ـﺘـ ــ ـﺒـ ــ ـﺪال ﻛـ ــ ـﻞ رﻗـ ــ ـﻢ ﻓـ ــ ـﻲ‬
‫اﻟﻨﺺ )”‪ replace(“ab12cd34ef”,“x‬ﺣـﺪدﻧـﺎ وﻣﻦ ﺛﻢ ﺣـﺪدﻧـﺎ اﻟﺤﺮف اﻟ ـﺬي ﻧﺮ ﻳـﺪه أن ﻳﺤـﻞ‬
‫ﻣﻜﺎن اﻟﺮﻗﻢ اﻟﺬي ﻧﺮ ﻳﺪ ﺗﺒﺪﻳﻠﻪ‪.‬‬

‫إذا ﺗﻘﻮم ﺑﺎﺳﺘﺒﺪال ﻗﻴﻤﺔ ﻣﻌﻴﻨﺔ ﻓﻲ اﻟﻨﺺ ﺑﻘﻴﻤﺔ أﺧﺮى ﻋﻦ ﻃﺮ ﻳﻖ ﺗﺤﺪﻳﺪﻫﺎ ﻓﻲ اﻟﺘﻨﺴﻴﻖ‪.‬‬

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
‫‪abxcdxef‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪73‬‬

 ‫ﺑﻨﻰ اﻟﺘﺤﻜﻢ‬

‫‪For Loop‬‬

‫ﻓﻠﻨﻔﺘﺮض أﻧﻨـﺎ أردﻧـﺎ ﻛﺘـﺎﺑـﺔ ﺟﻤﻴﻊ اﻷرﻗـﺎم اﻟﻮاﻗﻌـﺔ ﻣﻦ ‪ ١٠-١‬ﻓﻲ ﺑﺮﻧـﺎﻣﺠﻨـﺎ‪ ،‬ﻫـﻞ ﻫـﺬا ﻣﻤﻜﻦ؟‬
‫ﻧﻌﻢ‪ ،‬ﻣﻤﻜﻦ ﺣﺴـ ــــــ ـﻨـﺎ ً وﻟﻮ اردﻧـﺎ ﻛﺘـﺎﺑـﺔ اﻷرﻗـﺎم ﻣﻦ ‪ ،٢٠ -١‬ﻫـﻞ ﻫـﺬا ﻣﻤﻜﻦ؟ ﺳـ ــــــ ـﻮف ﻧﻘﻮل ﻧﻌﻢ‬
‫وﻟﻜﻦ ﻟﻨﻔﻜﺮ ﻗﻠﻴﻼ ً ﺑﺄرﻗﺎم ا ﻛﺒﺮ ﻣﺜﻼ ً ﻣﻦ ‪ ١٠٠ – ١‬ﺳـ ــــ ـﻮف ﺗﺠﺎوب وﺑﺴـ ــــ ـﺮﻋﺔ إﻧﻪ أﻣﺮ ﻣﺮﻫﻖ أن‬
‫ا ﻛﺘﺐ ﻛﻞ اﻷﻋﺪاد ﺑﺪاﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ﺣﺴـ ـــــ ـﻨﺎ ً ﻣﺜﺎل أﺧﺮ ﻟﻮ وﺿـ ـــــ ـﻌﺖ ﺷـ ـــــ ـﺮط أردﻧﺎ ﺗﻜﺮار ﻇﻬﻮر‬
‫رﺳـ ــ ـﺎﻟﺔ ﻣﻌﻴﻨﺔ ﻣﺎدام ﻫﺬا اﻟﺸـ ــ ـﺮط ﺻـ ــ ـﺤﻴﺢ‪ ،‬ﻫﻨﺎ ﺗﻈﻬﺮ ﻓﺎﺋﺪة ﺣﻠﻘﺎت اﻟﺘﻜﺮار اﻟﺘﻲ ﺗﻘﻮم ﺑﺘﻜﺮار‬
‫ﻤﺎ ﻓﻲ ﻣـﺜﺎل اﻷرـﻗﺎم اـﻟﺬي ذﻛﺮـﻧﺎه أردـﻧﺎ ﻃـﺒﺎ ـ‬
‫ﻋﺔ‬ ‫ﻌﺖ ـﻟﻪ ﺷـ ــــــ ـﺮط أو ﻛ ـ‬ ‫اﻷﻣﺮ اﻟﺒﺮﻣﺠﻲ ﻓﻲ ـ‬
‫ﺣﺎل وﺿـ ــــــ ـ ـ‬
‫ﻣﺠﻤﻮﻋﺔ اﻷرﻗﺎم‪.‬‬

‫أﻧﻮاع اﻟﺤﻠﻘﺎت اﻟﺘﻜﺮار ﻳﺔ‪((for loop – while – do..while :‬‬

‫أوﻻ ‪ :‬اﻟﺠﻤﻠﺔ ‪for loop‬‬

‫ﻧﺴﺘﺨﺪﻣﻬﺎ ﻋﻨﺪﻣﺎ ﻳﻜﻮن ﻟﺪي ﻋﺪد ﻣﻌﻠﻮم ﻟﻠﺘﻜﺮار اﻟﺬي أر ﻳﺪه‪.‬‬

‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ‪:‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪74‬‬

 ‫{ )‪for (item in collection‬‬
‫‪// body of loop‬‬
‫}‬

‫ﻫﻨ ـﺎ أردﻧ ـﺎ ﻃﺒ ـﺎﻋ ـﺔ اﻷﻋ ـﺪاد ﻣﻦ ‪ ١٠-١‬أي أن اﻟﻨﻄ ـﺎق ﻋﻨ ـﺪي ﻣﻌﻠﻮم ﻓﻘﻂ ‪ ١٠‬ارﻗ ـﺎم ار ﻳ ـﺪ‬
‫ﻃﺒـﺎﻋﺘﻬـﺎ ﻣﻊ ﻣﺮاﻋـﺎة ان اﻟﻨﻘﻄﺘﻴﻦ ﺑﻴﻦ اﻟﻌـﺪدﻳﻦ ﻣﻬﻤﻴﻦ ﻷﻧﻨـﺎ ﻧﺮ ﻳـﺪ اﻷﻋـﺪاد اﻟﺘﻲ ﺗﻘﻊ ﻓﻲ ﻫـﺬا‬
‫اﻟﻨﻄﺎق‪.‬‬

‫)‪for ( i in 1..10‬‬
‫{‬
‫)‪println(i‬‬
‫}‬

‫ﺳﻢ ﺣﺮف ﺣﺮف أي‬

‫ﺳﻤﻪ وﻣﻦ ﺛﻢ ﻧﺮ ﻳﺪ ﻃﺒﺎﻋﺔ ﻫﺬا اﻻ ـ‬
‫ﺴﺘﺨﺪم أن ﻳﺪﺧﻞ ا ـ‬
‫ﻫﻨﺎ ﻧﺮ ﻳﺪ ﻣﻦ اﻟﻤ ـ‬
‫ﻓﻲ ﻛﻞ ﺳﻄﺮ ﺣﺮف‬

‫)"‪println("please enter your name :‬‬

‫!!)(‪var name:String= readLine‬‬
‫)‪for(i in name‬‬
‫{‬
‫)‪println(i‬‬
‫}‬

‫وﻧﺴـﺘﻄﻴﻊ ﺗﻄﺒﻴﻖ ﻣﺎ ﺗﻌﻠﻤﻨﺎه ﻓﻲ درس اﻟﺴـﻼﺳـﻞ اﻟﻨﺼـﻴﺔ وﻫﻮ اﺳـﺘﺨﺪام اﻟﺪوال اﻟﺨﺎﺻـﺔ‬
‫ﺑﻬﺎ‪.‬‬

‫)"‪println("please enter your name :‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪75‬‬

 ‫!!)(‪var name:String= readLine‬‬
‫))(‪for(i in name.reversed‬‬
‫{‬
‫)‪println(i‬‬
‫}‬

‫ﺛﺎﻧﻴﺎ ‪ nested for :‬واﻟﻤﻘﺼﻮد ﻫﻨﺎ اﻟﺤﻠﻘﺎت اﻟﻤﺘﺪاﺧﻠﺔ‬

‫ﻣﺜﻼ ﻟﻮ أردﻧﺎ ﻃﺒﺎﻋﺔ ﺟﺪول اﻟﻀ ـﺮب ﻣﻦ ‪ ٥-١‬ﺟﺪول ‪ ١‬وﺟﺪول ‪ ٢‬وﺟﺪول ‪ ٣‬وﻫﻜﺬا وﺻ ـﻮﻻ ً‬
‫ﻟ ـ ــــــــ ـ ‪ ، ٥‬وﻟﻜﻨﻨﺎ ﻻ ﻧﺮ ﻳﺪ ﻃﺒﺎﻋﺔ ﺟﺪول اﻟﻀ ـﺮب ﻛﺎﻣﻼ ﻣﻦ ‪ ١٠-١‬ﺳ ـﻮف ﻧﻜﺘﻔﻲ ﻣﻦ ‪، ٣-١‬ﺳ ـﻮف‬
‫ﻧﺴﺘﺨﺪم ﺣﻠﻘﺘﻴﻦ ﻣﺘﺪاﺧﻠﺘﻴﻦ ﻛﻤﺎ ﻓﻲ اﻟﻤﺜﺎل‪.‬‬

‫ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ i‬ﻓﻲ اﻟﺤﻠﻘﺔ اﻷوﻟﻰ ﺗﻌﺒﺮ ﻋﻦ ﻋﺪد ﺟﺪاول اﻟﻀـ ـــ ـﺮب اﻟﺬي ﻧﺮ ﻳﺪﻫﺎ ﻓﻨﺤﻦ ﻧﺮ ﻳﺪ‬
‫ﻣﻦ ﺟـﺪول ‪ ١‬إﻟﻰ ﺟـﺪول ‪ ، ٥‬وﻣﻦ ﺛﻢ ﻗﻤﻨـﺎ ﺑﻔﺘﺢ اﻷﻗﻮاس اﻟﻤﺮ ﺑﻌـﺔ وﻛﺘﺒـﺎن ﺑـﺪاﺧﻠﻬـﺎ اﻟﺤﻠﻘـﺔ‬
‫اﻟﺜـﺎﻧﻴـﺔ وﻫﻲ ﻣـﺎ ﺗﻌﺮف ﺑـﺎﻟﻤﺘـﺪاﺧﻠـﺔ ﻷﻧﻬـﺎ دﺧﻠـﺖ ﻋﻠﻰ اﻷوﻟﻰ ‪ ،‬ﻗﻴﻤـﺔ اﻟﻤﺘﻐﻴﺮ ‪ x‬ﺗﻌﺒﺮ ﻋﻦ أﻧﻨـﺎ‬
‫ﻧﺮ ﻳﺪ ﺑﺪء اﻟﻀﺮب ﻣﻦ رﻗﻢ ‪ ١‬واﻟﺘﻮﻗﻒ ﻋﻨﺪ ‪ ٣‬ﻻ ﻧﺮ ﻳﺪ ﻃﺒﺎﻋﺔ اﻟﺠﺪول ﻛﺎﻣﻞ‪.‬‬

‫{)‪for(i in 1..5‬‬
‫{ )‪for(x in 1..3‬‬
‫)‪println("$i * $x = " +i*x‬‬
‫}‬
‫)"‪println("--------------‬‬
‫}‬

‫‪ v‬ﺑﺮﻧﺎﻣﺞ اﺧﺘﺒﺎر اﻟﺮﻗﻢ زوﺟﻲ ام ﻓﺮدي‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪76‬‬

 for( i in 1..3) {
println("please enter number :")
var num: Int = readLine()!!.toInt()
if (num % 2 == 0)
{ println("number is even")}
else
{ println("number is odd")}
}

‫ ﻧﺎﺗﺞ اﻟﺘ ﻨ ﻔ ﻴ ﺬ‬v

please enter number:

number is even

please enter number:

21

number is odd

please enter number:

10

number is even

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 77 ‫اﻟﺼﻔﺤﺔ‬

 ‫‪while & do while‬‬

‫اﻟﺠﻤﻠﺔ ‪while‬‬

‫ﻳﺆدي اﻷﻣﺮ ‪ while‬اﻟﻰ ﺗﻨﻔﻴﺬ اﻟﺸـ ـــــ ـﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﻣﺮارا ً وﺗﻜﺮاًر ﻃﺎﻟﻤﺎ ان اﻟﺸـ ـــــ ـﺮط ﻣﺘﺤﻘﻖ‬
‫ﺑـ‪True‬‬

‫)‪while( condition‬‬
‫{‬
‫‪statements‬‬
‫‪.‬‬
‫‪.‬‬
‫‪counter‬‬
‫}‬

‫ﻫﻨﺎ اﻓﺘﺮﺿـﻨﺎ ان اﻟﻤﺘﻐﻴﺮ ﻗﻴﻤﺘﻪ ‪ ٢‬وﻣﻦ ﺛﻢ ﻗﻠﻨﺎ ﻃﺎﻟﻤﺎ أن ‪ i‬اﻗﻞ ﻣﻦ ‪ ١٠‬ﻗﻢ ﺑﻄﺒﺎﻋﺔ ﻗﻴﻤﺔ ‪،‬‬
‫ﺣﺴﻨﺎ وﻟﻜﻦ ﻣﺎذا ﺗﻌﻨﻲ ‪ i++‬ﻫﺬا ﻳﻌﻨﻲ أﻧﻨﺎ ﻧﺮ ﻳﺪ ز ﻳﺎدة اﻟﻌﺪد وﻣﻦ ﺛﻢ ﻧﺨﺘﺒﺮه ﻣﺮة أﺧﺮى ﺣﺘﻰ‬
‫ﻳﺼـ ـــ ـﻞ إﻟﻰ ‪ ٩‬ﻳﻘﻮم ﺑﻄﺒﺎﻋﺘﻪ وﻣﻦ ﺛﻢ ﻳﺘﻮﻗﻒ اﻟﺒﺮﻧﺎﻣﺞ ﻟﻤﺎذا؟ ﻷن اﻟﺸـ ـــ ـﺮط ﻳﺮ ﻳﺪ ﻃﺒﺎﻋﺔ اﻻﻋﺪاد‬
‫اﻟﺘﻲ ﺗﻘﻞ ﻋﻦ ‪ ١٠‬ﻓﻌﻨﺪﻣﺎ ﻧﺼـﻞ ﻟﻠﻌﺸـﺮة ﻟﻦ ﻳﺘﺤﻘﻖ اﻟﺸـﺮط أي ﻳﺼـﺒﺢ ﻏﻴﺮ ﺻـﺤﻴﺢ وﻣﻦ ﺛﻢ‬
‫ﻳﺘﻮﻗﻒ ‪ ،‬ﻟﻮ اﻧﻨﺎ ﻗﻠﻨﺎ اﻟﺸـ ـﺮط ﻫﻜﺬا ‪ i<=10‬ﻫﻨﺎ ﺳـ ـﻮف ﻳﺘﺤﻘﻖ ﻣﻦ ﻗﻴﻤﺔ ‪ ١٠‬وﻣﻦ ﺛﻢ ﻳﺘﻮﻗﻒ‬
‫وذﻟﻚ ﻷن ﻋﻼﻣﺔ اﻟﻤﺴﺎواة ﻣﺘﻮاﺟﺪة أي ﻫﻞ اﻟﺮﻗﻢ اﻗﻞ‬

‫ﻣﻦ ‪ ١٠‬او ﻳﺴﺎوﻳﻬﺎ اذا ﻛﺎن ﻧﻌﻢ ﻓﺎﻟﺸﺮط ﺻﺤﻴﺢ وإذا اﻟﻌﻜﺲ ﻓﺘﻮﻗﻒ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪78‬‬

 ‫‪var i=2‬‬
‫)‪while(i<10‬‬
‫{‬
‫)‪println(i‬‬
‫‪i++‬‬
‫}‬

‫‪nested while‬‬

‫ﺳﻮف‬
‫ﺴﻰ ﻛﺘﺎﺑﺔ اﻟﻌﺪاد ‪ x++,y++‬وﻋﻨﺪﻣﺎ ﻻ ﻧﻜﺘﺒﻬﺎ ﻛﻠﻴﻬﺎ او اﺣﺪﻫﻤﺎ ـ‬
‫اﻟﻤﻬﻢ ﻫﻮ ان ﻻ ﻧﻨ ـ‬
‫ﻳﻘﻮم ﺑﻄﺒﺎﻋﺔ ﻟﻠﻤﺎ ﻻﻧﻬﺎﻳﺔ ﻻن اﻟﺮﻗﻢ ﻟﻦ ﻳﺘﻐﻴﺮ وﺳﻴﻀﻞ ﺻﺤﻴﺢ وﻫﻲ ﻣﺎ ﺗﺴﻤﻰ ﺑـ ‪infinitive‬‬
‫‪.loop‬‬

‫‪var x =1‬‬
‫‪var y =1‬‬
‫)‪while(x<=5‬‬
‫{‬
‫)‪while(y<=3‬‬
‫{‬
‫)‪println("$x*$y="+x*y‬‬
‫‪y++‬‬
‫}‬
‫‪x++‬‬
‫}‬

‫اﻟﺠﻤﻠﺔ ‪do…while‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪79‬‬

‫ﻓﻲ ﻫﺬه اﻟﺤﻠﻘﺔ اﻷﻣﺮ ﻣﺨﺘﻠﻒ ﻗﻠﻴﻼ ً ﻫﻮ أﻧﻪ ﺣﺘﻰ ﻟﻮ اﻟﺸـ ـــــ ـﺮط ﻏﻴﺮ ﻣﺘﺤﻘﻖ ﻓﺴـ ـــــ ـﻮف ﻳﻘﻮم‬
‫ﺑﺘﻨﻔﻴﺬ اﻷﻣﺮ ﻟﻤﺮة واﺣﺪة ‪ ،‬ﻣﺜﺎل ﺗﻮﺿﻴﺤﻲ ﻋﻠﻰ ذﻟﻚ‪.‬‬

‫ﻫﻨـﺎ ﻓﻲ اﻟﺒـﺪا ﻳـﺔ ﻋﺮﻓﻨـﺎ اﻟﻤﺘﻐﻴﺮ ‪ x‬وﻗﻴﻤﺘـﻪ ‪ ، ٥‬اﻟﺒﺮﻧـﺎﻣﺞ ﺳـ ــــــ ـﻮف ﻳـﺪﺧـﻞ إﻟﻰ ‪ do‬ﻓﻲ اﻟﺒـﺪا ﻳـﺔ‬
‫وﻳﻨﻔﺬ ﻣﺎ ﺑﺪاﺧﻠﻬﺎ وﻫﻲ ﻃﺒﺎﻋﺔ اﻟﻘﻴﻤﺔ وﻻ ﻧﻨﺴﻰ أ ﻳﻀﺎ ﻫﻨﺎ ﻛﺘﺎﺑﺔ اﻟﻌﺪاد اﻟﺬي ﻫﻮ اﻟﺰ ﻳﺎدة وﻣﻦ‬
‫ﺛﻢ ﻳﻘﻮم ﺑﺎﻟﺘﺤﻘﻖ ﻣﻦ اﻟﺸـ ـــ ـﺮط وﻫﻮ ﻗﻴﻤﺔ ‪ x‬ﺑﻌﺪ اﻟﺰ ﻳﺎدة ﻫﻞ ﻫﻲ ا ﻛﺒﺮ ﻣﻦ ‪ ١٠‬ام ﻻ واﻟﺸـ ـــ ـﺮط‬
‫ﻫﻨـﺎ ﻏﻴﺮ ﻣﺘﺤﻘﻖ ﻻن ‪ ٦‬اﺻـ ــــــ ـﻐﺮ ﻣﻦ ‪ ١٠‬ﻓﻴﺘﻮﻗﻒ اﻟﺒﺮﻧـﺎﻣﺞ وﺑـﺬﻟـﻚ ﻳﻜﻮن ﻓﻘﻂ اﻟﻘﺮاءة اﻷوﻟﻰ‬
‫ﻫﻲ اﻟﺘﻲ ﺗﺘﻨﻔﺬ ﺑﺪون اﻟﻨﻈﺮ إﻟﻰ اﻟﺸﺮط‪.‬‬

‫‪var x = 5‬‬
‫{‪do‬‬
‫)‪println(x‬‬
‫‪x++‬‬
‫}‬
‫)‪while(x>10‬‬

‫ﻫﻨﺎ ﻓﺘﺤﻨﺎ ‪ do‬وﻣﻦ ﺛﻢ ﻃﻠﺒﻨﺎ ﻣﻦ اﻟﻤﺴـﺘﺨﺪم ادﺧﺎل ﺳـﻠﺴـﻠﺔ ﻧﺼـﻴﺔ اﺳـﻤﻪ وﺳـﻮف ﻳﻘﻮم‬
‫ﺑﻄﺒﺎﻋﺘﻪ وﻣﻦ ﺛﻢ ﻳﻘﻮم ﺑﺎﻟﺪﺧﻮل إﻟﻰ ‪ while‬ﻟﻠﺘﺤﻘﻖ ﻣﻦ اﻟﺸـﺮط ﻓﻲ ﺣﺎل ان اﻟﻤﺴـﺘﺨﺪم ادﺧﻞ‬
‫اﺳـﻢ ﺣﺮوﻓﻪ ﺗﺘﺠﺎوز ‪ ١٠‬اﺣﺮف ﺳـﻮف ﺗﺘﻜﺮر ﻇﻬﻮر اﻟﺮﺳـﺎﻟﺔ ‪ ،‬وﻟﻜﻦ ﻟﻮ ادﺧﻞ اﺳـﻢ ﺣﺮوﻓﻪ اﻗﻞ‬
‫ﻣﻦ ‪ ١٠‬ﺳﻮف ﻳﺘﻮﻗﻒ اﻟﺒﺮﻧﺎﻣﺞ ﻷن اﻟﺸﺮط ﻟﻢ ﻳﺘﺤﻘﻖ‪.‬‬

‫{‪do‬‬
‫)"‪println("please enter your name :‬‬
‫!!)(‪var x:String= readLine‬‬
‫)‪println(x‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪80‬‬

 }
while(x.length >10)

when

‫ ﻓﻲ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ﺑﺤﻴﺚ اﻧﻬﺎ ا ﻛﺜﺮ‬switch-case ‫ ﻫﻲ اﻟﺠﺰء اﻟﻤﻄﻮر واﻟﺒﺪﻳﻞ ﻋﻦ‬when

ً ‫ﻀﺎ‬
‫ واﻟﺠﻤﻴﻞ ا ﻳ ـ‬. ‫ﺼﻴﺺ واﻟﺘﻌﺪﻳﻞ ﺑﺎﻛﺜﺮ ﻣﻦ ﻧﻮع ﻣﻦ اﻟﻤﺘﻐﻴﺮات‬
‫ﻣﺮوﻧﻪ وﻣﻨﻄﻘﻴﺔ وﻗﺎﺑﻠﺔ ﻟﻠﺘﺨ ـ‬
.‫ ﺑﺸﻜﻞ ﺳﺮ ﻳﻊ‬extension ‫او ﻛـ‬-statment ‫اﻧﺎ ﻳﻤﻜﻨﻨﺎ اﺳﺘﺨﺪاﻣﻬﺎ ﻛـ‬

‫ اﻟﺼ ﻴ ﻐ ﺔ اﻟﻌ ﺎﻣ ﺔ ﻟﻬ ﺎ ﺗﻜ ﻮ ن ﺑﻬ ﺬ ا اﻟﺸ ﻜ ﻞ‬v

var dayOfWeek = 4
when(dayOfWeek) {
1 -> println("Monday")
2 -> println("Tuesday")
3 -> println("Wednesday")
4 -> println("Thursday")
5 -> println("Friday")
6 -> println("Saturday")
7 -> println("Sunday")
else -> println("Invalid Day")
}
// Displays - "Thursday"

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 81 ‫اﻟﺼﻔﺤﺔ‬

‫ﻧﻼﺣﻆ اﻧﻨﺎ ﻗﻤﻨﺎ ا ﻳﻀـ ـــــ ـﺎ ً ﺑﺎﺳـ ـــــ ـﺘﺨﺪام ‪ else‬اذا ﻗﺎم اﻟﻤﺴـ ـــــ ـﺘﺨﺪم ﺑﺎدﺧﺎل رﻗﻢ ﺧﺎرج اﻟﺤﺪود‬
‫ﺳﻴﻄﺒﻊ ﻟﻪ ان اﻟﻴﻮم ﻏﻴﺮ ﺻﺤﻴﺢ‪.‬‬

‫‪ v‬اﻟﺪﻣﺞ ﺑﻴﻦ ا ﻛﺜﺮ ﻣﻦ ﻗﻴﻤﺔ او ﺷﺮط‬

‫اذا ﻛﺎن ﻟﺪﻳﻚ ا ﻛﺜﺮ ﻣﻦ ﺣﺎﻟﺔ وﺗﻮد اﺧﺘﺒﺎرﻫﺎ ﻓﻲ ‪ when‬واﺣﺪة ﺳﻴﺘﺤﺘﻢ ﻋﻠﻴﻚ وﺿﻊ ﻓﺎﺻﻠﺔ‬
‫ﺑﻴﻦ ﻛﻞ اﺣﺘﻤﺎل وآﺧﺮ ﻛﻤﺎ ﺳﺘﻼﺣﻆ ﻓﻲ اﻟﺸﻔﺮة اﻟﻘﺎدﻣﺔ‪.‬‬

‫‪var dayOfWeek = 6‬‬

‫{ )‪when (dayOfWeek‬‬
‫)"‪1, 2, 3, 4, 5 -> println("Weekday‬‬
‫)"‪6, 7 -> println("Weekend‬‬
‫)"‪else -> println("Invalid Day‬‬
‫}‬
‫‪// Displays - Weekend‬‬

‫‪ v‬اﺳ ﺘ ﺨ ﺪ اﻣ ﻬ ﺎ ﻣ ﻊ اﻟﻨ ﻄ ﺎق‬

‫‪var dayOfMonth = 5‬‬

‫{ )‪when(dayOfMonth‬‬
‫! )"‪in 1..7 -> println("We're in the first Week of the Month‬‬
‫)"‪in 15..21 -> println("We're not in the third week of the Month‬‬
‫)"‪else -> println("none of the above‬‬
‫}‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪82‬‬

 // Displays - We're in the first Week of the Month

is :‫ اﺳﺘﺨﺪاﻣﻬﺎ ﻛـ‬v

.‫ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‬when ‫ ﻣﻊ‬is ‫اذا اردت اﻟﺘﺤﻘﻖ ﻣﻦ ﻧﻮع اﻟﻤﺘﻐﻴﺮ ﻳﻤﻜﻨﻚ اﺳﺘﺨﺪام‬

var x : Any = 6.86

when(x) {
is Int -> println("$x is an Int")
is String -> println("$x is a String")
!is Double -> println("$x is not Double")
else -> println("none of the above")
}
// Displays - none of the above

if-else-if :‫ اﺳﺘﺨﺪاﻣﻬﺎ ﻛﺒﺪﻳﻞ ﻟـ‬v

‫ ﺳﺘﻜﻮن اﻓﻀﻞ وارﺗﺐ ﻟﻠﻜﻮد وأ ﻛﺜﺮ ﻣﻨﻄﻘﻴﺔ‬if-else-if ‫ ﻛﺒﺪﻳﻞ ﻟﻠ ـ ـ‬when ‫ﻳﻤﻜﻦ اﺳﺘﺨﺪام‬
.‫ﻋﻨﺪﻣﺎ ﺗﻜﻮن اﻻﺣﺘﻤﺎﻻت ﻛﺜﻴﺮة ﻛﻤﺎ ﺳﺘﻼﺣﻆ ﻓﻲ اﻟﺸﻔﺮة اﻟﻘﺎدﻣﺔ‬

var number = 20
when {
number < 0 -> println("$number is less than zero")
number % 2 == 0 -> println("$number is even")
number > 100 -> println("$number is greater than 100")
else -> println("None of the above")
}

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 83 ‫اﻟﺼﻔﺤﺔ‬

 ‫‪// Displays - 20 is even‬‬

‫اﻟﺠﻤﻠﺔ اﻟﺸﺮﻃﻴﺔ‬

‫ﻛﻤـﺎ ﻧﻌﻠﻢ ﺟﻤﻴﻌﻨـﺎ أن اﻻﺣﺘﻤـﺎﻻت واﻟﻤﻘـﺎرﻧـﺎت أﻣﺮ وارد ﻓﻲ اﻟﺤﻴـﺎة ﻛﻤـﺎ أن اﺧﺘﺒـﺎر اﻷﺷـ ــــــ ـﻴـﺎء‬
‫ﻳﺠﻌﻠﻨﺎ ﻧﺘﺤﻘﻖ ﻣﻦ ﻗﻴﻤﺘﻬﺎ ﻛﻤﺜﺎل ﺑﺴـﻴﻂ ﻋﻨﺪﻣﺎ ﻳﻜﻮن ﻟﺪﻳﻚ ﻣﺎدة دراﺳـﻴﺔ ﻣﻌﺪل اﻟﻨﺠﺎح ﺑﻬﺎ‬
‫ﻌﺪل‬
‫ﻫﻞ ﻫﻲ ا ﻛﺒﺮ او اـﻗﻞ ﻣﻦ ﻣ ـ‬
‫ﻣﻦ ‪ ٦٠‬ـﻓﺄـﻧﺖ ﻫـﻨﺎ ﺳـ ــــــ ـﻮف ﺗـﺒﺪأ اﺧﺘـﺒﺎر درﺟـﺘﻚ اﻟﺘﻲ ﺣﻘﻘﺘـﻬﺎ ـ‬
‫ﺟﺔ ﻣﻤـﺘﺎز أم‬
‫ﻫﻞ أـﻧﺎ ـﻧﺎﺟﺢ ـﺑﺪر ـ‬
‫ﺠﺎح ‪ ،‬وإن ـﻛﺎـﻧﺖ أ ﻛﺒﺮ ﻓﻤﻦ اﻟﻄﺒﻴﻌﻲ ﺳـ ــــــ ـﻮف ﻳﺘـﺒﺎدر ـﻟﺬﻫـﻨﻚ ـ‬
‫اﻟﻨ ـ‬
‫ﺟﻴﺪ ؟‪.‬‬

‫ﻣﻦ ﻫﺬه اﻟﻤﻘﺪﻣﺔ ﻳﺘﻀـﺢ ﻟﻨﺎ ﺟﻠﻴﺎ ً أن اﻟﺪرس ﺳـﻮف ﻳﻜﻮن ﻋﻦ اﻟﺠﻤﻞ اﻟﺸـﺮﻃﻴﺔ وﻃﺮ ﻳﻘﺔ‬
‫ﻛﺘﺎﺑﺘﻬﺎ‪.‬‬

‫ﻓﻲ اﻟﺒﺪا ﻳﺔ ﺳﻨﻮﺿﺢ أن اﻟﺠﻤﻞ اﻟﺸﺮﻃﻴﺔ ﻓﻲ ﻟﻐﺔ ‪ Kotlin‬ﻫﻲ ) ‪.( if ..else – when‬‬

‫اﻟﺠﻤﻠﺔ ‪if‬‬

‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ‪:‬‬

‫{ )‪if (testExpression‬‬

‫‪// codes to run if testExpression is true‬‬

‫}‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪84‬‬

 ‫{ ‪else‬‬

‫‪// codes to run if testExpression is false‬‬

‫}‬

‫ﻳﻤﻜﻦ ﻛﺘﺎﺑﺔ ‪ if‬اﻟﺸﺮﻃﻴﺔ ﻟﺘﺤﻘﻖ ﻣﻦ ﺷﺮط واﺣﺪ وﺗﻜﻮن ﺑﺸﻜﻞ ﺑﺴﻴﻂ‪.‬‬

‫اذا ﺗﺤﻘﻖ اﻟﺸ ـﺮط ﻧﻔﺬ ﻣﺎﺑﺪاﺧﻞ ‪ if‬اذا ﻟﻢ ﻳﺘﺤﻘﻖ ﺗﺠﺎوز ﺑﺪون ان ﻳﻜﻮن ﻫﻨﺎك اي اﺣﺘﻤﺎل‬
‫آﺧﺮ‪.‬‬

‫) ‪if ( 5 < 10‬‬

‫) “اﻟﻌدد ﺧﻣﺳﺔ اﻗل ﻣن اﻟﻌدد ﻋﺷرة ‪ ،‬ﻣﺗﻔﺎﺟﺊ ﺣﻘﯾﻘﺔً” (‪print‬‬

‫‪if ..else‬‬

‫ر ﺑﻤﺎ ﻳﻜﻮن ﻟﺪﻳﻨﺎ اﺣﺘﻤﺎﻟﻴﻦ ﻟﻞ ‪ if‬ﻛﻤﺎ ﺳـ ــــــ ـﻨﻼﺣﻆ ﻓﻲ اﻟﻤﺜﺎل اﻟﻘﺎدم وﻟﺬﻟﻚ ﺳـ ــــــ ـﻨﺤﺘﺎج اﻟﻰ‬
‫اﺳ ـﺘﺨﺪام ‪ else‬ﻃﺮ ﻳﻘﺔ ﻛﺘﺎﺑﺔ ﺷ ـﺮط ﺑﺴ ـﻴﻂ ﻋﺒﺎرة اﻟﺸ ـﺮط وإذا ﻟﻢ ﻳﺘﺤﻘﻖ ﻓﺴ ـﻮف ﻳﺘﻨﻔﺬ أﻣﺮ‬
‫أﺧﺮ ‪،‬‬

‫§ ﻣﺜﺎل‬

‫ﻫﻨﺎ ﺳـ ــ ـﻮف ﻳﻄﻠﺐ ﻣﻦ اﻟﻤﺴـ ــ ـﺘﺨﺪم إدﺧﺎل اﺳـ ــ ـﻢ ﺣﺴـ ــ ـﻨﺎ ً و وﻣﻦ ﺛﻢ ﻳﻘﻮم ﺑﻤﻘﺎرﻧﺔ اﻻﺳـ ــ ـﻢ‬
‫اﻟﻤﺪﺧﻞ ﻫﻞ ﻫﻮ أﺣﻤﺪ؟‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪85‬‬

‫إذا ﻛﺎن ﻧﻌﻢ ﻓﺴـ ـﻴﻄﺒﻊ ﻟﻪ ﻣﺮﺣﺒﺎ ً أﺣﻤﺪ وإذا ﻟﻢ ﻳﺘﺤﻘﻖ اﻟﺸـ ـﺮط وأدﺧﻞ اﻟﻤﺴـ ـﺘﺨﺪم اﺳـ ـﻢ‬
‫أﺧﺮ ﺳﻮف ﻳﻄﺒﻊ ﻟﻪ ﺧﻄﺄ‪.‬‬

‫)"‪println("Please enter your name :‬‬

‫!!)(‪var Name:String= readLine‬‬

‫)"‪if(Name == "Ahmed‬‬
‫)"‪println("Welcome $Name‬‬
‫‪else‬‬
‫)"‪println("Error‬‬

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
‫‪Welcome Ahmed‬‬

‫‪if ..else if‬‬

‫ر ﺑﻤﺎ ﺗﺤﺘﺎج او ﻟﺪﻳﻚ ا ﻛﺜﺮ ﻣﻦ ﺷﺮط ﺗﺮ ﻳﺪ اﻟﺘﺤﻘﻖ اي ﻣﻨﻬﻢ ﻗﺪ ﺗﻨﻔﺬ‪.‬‬

‫§ ﻣﺜﺎل‬

‫ﺳﻴﺔ اﻟﺘﻲ ﻃﺮﺣﻨﺎﻫﺎ ﻓﻲ اﻟﻤﻘﺪﻣﺔ ‪ ،‬ﺟﻤﻴﻌﻨﺎ ﻧﻌﻠﻢ أن ﻣﻦ ﻳﺤ ـ‬

‫ﺼﻞ‬ ‫ﺿﻮع اﻟﻤﺎدة اﻟﺪرا ـ‬
‫ﻣﺜﻼ ﻛﻤﻮ ـ‬
‫ﻋﻠﻰ ‪ ٩٠‬وأ ﻛﺜﺮ ﻳﺄﺧﺬ ﻣﻤﺘﺎز ‪ ،‬وﻣﻦ ﻳﺤﺼﻞ ﻣﻦ ‪ ٨٠‬إﻟﻰ ‪ ٨٩‬ﻳﺄﺧﺬ ﺟﻴﺪ ﺟﺪا ً … وﻫﻜﺬا‪.‬‬

‫)"‪println("Please enter your mark :‬‬

‫)(‪var mark: Float = readLine()!!.toFloat‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪86‬‬

 if(mark >= 90)
println("$mark Excellent")
else if(mark >= 80 && mark < 90)
println("$mark Very Good")
else if(mark >= 70 && mark < 80)
println("$mark Good")
else if(mark >= 60 && mark < 70)
println("$mark study hard")
else
println("$mark failed")

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
Please enter your mark :

78

78.0 Good

‫ اﻟﻤﺘﺪاﺧﻠﺔ‬If

.‫ﺑﻌﺾ اﻟﺸﺮوط او اﻟﻤﺘﻄﻠﺒﺎت ﺗﻌﺘﻤﺪ ﻋﻠﻰ ﻣﺘﻄﻠﺒﺎت ﻣﺘﺪاﺧﻠﺔ‬

:‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ‬

if( boolean_expression 1) {

/* Executes when the boolean expression 1 is true */

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 87 ‫اﻟﺼﻔﺤﺔ‬

 if(boolean_expression 2) {

/* Executes when the boolean expression 2 is true */

‫ ﺗﺤﻘﻖ اﻟﺸـ ـــ ـﺮط ﺳـ ـــ ـﻴﺪﺧﻞ‬100 ‫ ﻳﺴـ ـــ ـﺎوي‬a ‫ اذا ﻛﺎن‬a & s ‫ﻣﺜﻼ ً اردﻧﺎ اﻟﺘﺤﻘﻖ ﻣﻦ رﻗﻤﻴﻦ‬
.‫ اﻟﺦ‬.. ‫ وﻫﻜﺬا‬200 ‫ ﺗﺴﺎوي‬s ‫ اﺧﺮى ﺗﺮ ﻳﺪ اﻟﺘﺤﻘﻖ ﻣﻦ ﻫﻞ‬if ‫ ﻟﻴﺠﺪ‬if ‫داﺧﻞ‬

var a = 100
var s = 200
/* check the boolean condition */
if( a == 100 ) {
/* if condition is true then check the following */
if( s == 200 ) {
/* if condition is true then print the following */
print("Value of a is 100 and s is 200\n" );
}
}

if ‫اﻟﺘﻌﺒﻴﺮات ﻣﻊ‬

‫ ﻓﻲ ﺗﻌﺮ ﻳﻒ اﻟﻤﺘﻐﻴﺮات‬if ‫ وﻻ ﺗﻮﺟﺪ ﻓﻲ ﺟﺎﻓﺎ ﻫﻲ اﺳ ـﺘﺨﺪام‬kotlin ‫ﻣﻦ اﻻﺷ ـﻴﺎء اﻟﺠﻤﻴﻠﺔ ﻓﻲ‬
.‫ﻣﺒﺎﺷﺮة واﻋﺎدة ﻗﻴﻤﺔ ﻟﻠﻤﺘﻐﻴﺮ اﻟﻤﻌﺮف‬

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 88 ‫اﻟﺼﻔﺤﺔ‬

 ‫ﻳﻌﻜﺲ ﻫﺬا اﺧﺘﺼﺎر ﻛﺒﻴﺮ ﻓﻲ ﻛﺘﺎﺑﺔ اﻟﺸﻔﺮات اﻟﺒﺮﻣﺠﻴﺔ وﺗﺮﺗﻴﺒﻬﺎ‪.‬‬

‫§ ﻣﺜﺎل‬
‫‪val a = 100‬‬
‫‪val b = 200‬‬

‫{ )‪val max = if (a < b‬‬

‫)"‪print("Choose a‬‬
‫‪a‬‬
‫{ ‪} else‬‬
‫)"‪print("Choose b‬‬
‫‪b‬‬
‫}‬
‫)"‪print("max = $max‬‬

‫ﻋﺮﻓﻨﺎ ﻣﺘﻐﻴﺮ ﻳﻦ واﺳـﻨﺪﻧﺎ ﻟﻬﻢ ﻗﻴﻢ وﻓﻲ اﻟﻤﺘﻐﻴﺮ اﻟﺜﺎﻟﺚ ﻋﺮﻓﻨﺎ ‪ max‬ﺳـﻴﺤﺼـﻞ ﻋﻠﻰ اﻟﻘﻴﻤﺔ‬
‫اﻻﻋﻠﻰ ﺑﻴﻦ ‪.a & b‬‬

‫ﻳﺠﺐ ان ﺗﺤﺘﻮي ‪ if‬ﻋﻠﻰ اﺣﺘﻤﺎﻟﻴﻦ او ا ﻛﺜﺮ ﻟﺴﺘﺨﺪﻣﻬﺎ ﻛـ ‪.Expression‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪89‬‬

 ‫اﻟﺪوال‬

‫اﻟﺪ و ال‬

‫اﻟﺪوال اﺷـ ــــ ـﻬﺮ ﻣﻦ ﻧﺎر ﻋﻠﻰ ﻋﻠﻢ ﻓﻲ ﻋﺎﻟﻢ اﻟﺒﺮﻣﺠﺔ ﺟﻤﻴﻌﻨﺎ ﻧﻌﻠﻢ أﻫﻤﻴﺔ اﺳـ ــــ ـﺘﺨﺪاﻣﻬﺎ واﻧﻬﺎ‬
‫ﺗﺨﺘﺼﺮ اﻟﻮﻗﺖ ﻋﻠﻴﻨﺎ ﻓﻲ ﺗﻜﺮار اﻟﻌﻤﻠﻴﺎت وﺗﻮﻓﺮ اﻟﺠﻬﺪ‪.‬‬

‫أوﻻ ‪ :‬ﻃﺮﻳﻘﺔ ﻛﺘﺎﺑﺘﻬﺎ‬

‫ﺗﻌﺮ ﻳﻔﻬﺎ ﺟﺪا ﺑﺴـﻴﻂ ﻧﺴـﻤﻲ اﻟﺪاﻟﺔ وﻳﻔﻀـﻞ ﺗﺴـﻤﻴﺘﻬﺎ ﻛﻤﺎ ﻧﻌﻠﻢ ﺟﻤﻴﻌﺎ ﺑﺎﺳـﻢ ﻳﻤﺜﻠﻬﺎ أي‬
‫ﻳﻤﺜﻞ اﻟﻐﺮض اﻟﺬي ﻣﻦ اﺟﻠﻪ اﻧﺸـ ـــ ـﺄﺗﻬﺎ ‪:Unit ،‬ﻫﺬا ﻳﻌﻨﻲ ﻧﻮع اﻟﺒﻴﺎﻧﺎت اﻟﻌﺎﺋﺪة وﻫﻨﺎ ﻳﻘﺼـ ـــ ـﺪ‬
‫أﻧﻬﺎ ﻻ ﺗﻌﻮد ﺑﺸـﻲء وﻣﻦ اﻟﻤﻤﻜﻦ أن ﻻ ﻧﻜﺘﺒﻬﺎ وﻫﻮ ﺳـﻴﻌﺮف اﻧﻬﺎ داﻟﺔ ﻻ ﺗﻌﻴﺪ ﻗﻴﻤﺔ ‪ ،‬وﻣﻦ ﺛﻢ‬
‫ﻧﻘﻮم ﺑﻜﺘﺎﺑﺔ اﻷواﻣﺮ اﻟﺘﻲ ار ﻳﺪﻫﺎ ﺑﺪاﺧﻞ اﻻﻗﻮاس‪.‬‬

‫‪fun functionNAme( parameter ):Unit‬‬

‫{‬
‫‪return ...‬‬
‫}‬

‫ﺛﺎﻧﻴﺎ ‪ :‬أﻧﻮاع اﻟﺪوال‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪90‬‬

 ‫ ﻧﻤﺮر ﻟﻬﺎ ﺑﻴﺎﻧﺎت وﺗﻌﻮد ﺑﻘﻴﻤﺔ‬v

fun maxNumber( number1:Int ,number2:Int):Int

{
if(number1<number2)
{
return number2
}
else {
return number1
}
}

.‫ وﺗﻌﻮد ﺑﻘﻴﻤﺔ اﻟﻌﺪد اﻷﻛﺒﺮ‬number1 ,number2 ‫ﻣﺮرﻧﺎ ﻟﻬﺎ ﻣﺘﻐﻴﺮ ﻳﻦ وﻫﻤﺎ‬

‫ ﻧﻤﺮر ﻟﻬﺎ ﺑﻴﺎﻧﺎت وﻻ ﺗﻌﻮد ﺑﻘﻴﻤﺔ‬v

fun circleCirc(radius:Float):Unit
{
val bai=3.14
var circumference = bai *2 * radius
println("the circumference of circle is :" +circumference)
}

‫ ﻻ ﻧﻤﺮر ﻟﻬﺎ ﺑﻴﺎﻧﺎت وﺗﻌﻮد ﺑﻘﻴﻤﺔ‬v

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 91 ‫اﻟﺼﻔﺤﺔ‬

 ‫‪fun minNumber( ):Int‬‬
‫{‬
‫)(‪var number1:Int = readLine()!!.toInt‬‬
‫)(‪var number2:Int = readLine()!!.toInt‬‬
‫)‪if(number1<number2‬‬
‫{‬
‫‪return number1‬‬
‫}‬
‫{ ‪else‬‬
‫‪return number2‬‬
‫}‬
‫}‬

‫‪ v‬ﻻ ﻧﻤﺮر ﻟﻬﺎ ﺑﻴﺎﻧﺎت وﻻ ﺗﻌﻮد ﺑﻘﻴﻤﺔ‬

‫{)(‪fun welcome‬‬
‫)"‪return println("welcome world‬‬
‫}‬

‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻻﺳﺘﺪﻋﺎء‬

‫ﺣﺴـ ــــــ ـﻨﺎ ً ﻧﺤﻦ ﻋﺮﻓﻨﺎ اﻵن اﻟﺪوال وﻃﺮ ﻳﻘﺔ ﻛﺘﺎﺑﺘﻬﺎ‪ ،‬ﺗﺒﻘﻰ ﻋﻠﻴﻨﺎ ﻣﻌﺮﻓﺔ ﻃﺮ ﻳﻘﺔ اﺳـ ــــــ ـﺘﺪﻋﺎﺋﻬﺎ‬
‫وﻫﻲ ﺟﺪا ً ﺑﺴﻴﻄﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫ﻧﻘﻮم ﺑﻜﺘﺎﺑﺔ اﺳﻢ اﻟﺪاﻟﺔ وان ﻛﺎﻧﺖ ﺗﻤﺮر ﻟﻬﺎ ﻗﻴﻢ ﻓﻼ ﻧﻨﺴﻰ ﻛﺘﺎﺑﺔ ﻫﺬه اﻟﻘﻴﻢ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪92‬‬

 :‫§ ﻣﺜﺎل‬

:‫داﻟﺔ ﺗﺤﺴﺐ ﻣﺴﺎﺣﺔ اﻟﻤﺮ ﺑﻊ‬

fun distance( a :Int ):Int{

return a*a
}

:‫داﻟﺔ ﺗﺤﺴﺐ ﻣﺤﻴﻂ اﻟﻤﺮ ﺑﻊ‬

fun circumference(a:Int):Int{
return a*4
}

:‫ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬

fun main(args:Array<String>){

println("enter the length side for square :")

var len:Int= readLine()!!.toInt()
println("the distance is :"+distance(len))
println("the circumference is :"+circumference(len))
}

:‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬

enter the length side for square :
3

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 93 ‫اﻟﺼﻔﺤﺔ‬

‫‪the distance is :9‬‬
‫‪the circumference is :12‬‬

‫‪Extension function‬‬

‫ﺿﺢ‬
‫ﺳﺒﻖ وﺗﻌﺮﻓﻨﺎ وﻟﻜﻦ ﻛﻴﻒ ﺗﻜﻮن اﻣﺘﺪاد او ‪ extension‬؟ او ﻟﻨﻮ ـ‬
‫ﺗﻌﺘﺒﺮ داﻟﺔ ﻋﺎدﻳﺔ ﻛﻤﺎ ـ‬
‫اﻟﺴﺆال أ ﻛﺜﺮ ﻣﺎ ﻓﺎﺋﺪﺗﻬﺎ ؟‬

‫ﻣﺎذا ﻟﻮ اردﻧﺎ اﺿـﺎﻓﺔ داﻟﺔ ﻏﻴﺮ ﻣﻮﺟﻮدة ﻣﺴـﺒﻘﺎ ً ﻓﻲ ‪ class string‬ﻣﺜﻼ ً ؟ ﺣﺘﻤﺎ ً ﺳـﺘﺤﺘﺎج اﻟﻰ‬
‫‪extension‬وﺳﺎوﺿﺤﻬﺎ ﻫﻨﺎ ﻓﻲ ﻣﺜﺎﻟﻴﻦ‪:‬‬

‫ﺣﺴ ـﻨﺎ ﻧﺴ ـﺘﻄﻴﻊ ﺑﻨﺎء داﻟﺔ ﺗﻜﻮن اﻣﺘﺪاد ﻟﻄﺒﻘﺔ ﻣﺎ ‪ class‬دون اﻟﺘﻌﺮ ﻳﻒ ﻋﻨﻬﺎ ‪ ،‬ﻣﺜﺎل ﻋﻠﻰ‬
‫ذﻟﻚ‪:‬‬

‫‪ v‬ﻃﺒﻘﺔ }‪ {class‬ﺧﺎﺻﺔ ﺑﺎﻟﺴﻴﺎرة‬

‫ﻟﻨﻔﺮض اﻧﻨﺎ ﻗﻤﻨﺎ ﺑﺎﻧﺸﺎء ‪ class‬ﻟ ـ ـــــ ـ ‪car‬وﻛﺎن ﻳﺤﺘﻮي ﻋﻠﻰ ‪ func‬واﺣﺔ ﻓﻘﻂ وﻫﻲ ﻟﺤﺴﺎب‬
‫اﻟﺴﺮﻋﺔ اذا ﻛﺎﻧﺖ ﻣﻨﺨﻔﻀﺔ‪.‬‬

‫{‪class Car‬‬
‫{‪fun LowSpeed(sp:Int):Boolean‬‬
‫‪return sp <100‬‬
‫}‬
‫}‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪94‬‬

 ‫‪ v‬داﻟﺔ ‪ extension‬ﻟﻠﻄﺒﻘﺔ ‪car‬‬

‫اﻻن ﺑﻌﺪ ﻓﺘﺮة ﻣﻦ اﻟﻮﻗﺖ اﺣﺘﺠﺖ ان اﻗﻮم ﺑﺎﺿ ـﺎﻓﺔ داﻟﺔ ﺟﺪﻳﺪة ل ‪class car‬وﻟﻜﻦ ﻻ ار ﻳﺪ‬
‫اﻟﺘﻌﺪﻳﻞ ﻋﻠﻴﻪ ؟ ﺳﺎﻗﻮم ﺑﺎﺳﺘﺨﺪام ‪ extension‬ﻛﻤﺎ ﺳﺘﻼﺣﻆ ﻓﻲ اﻟﺸﻔﺮة اﻟﺘﺎﻟﻴﺔ‪:‬‬

‫{‪fun Car.highSpeed(sp:Int):Boolean‬‬
‫‪return sp >100‬‬
‫}‬

‫ﻧﻼﺣﻆ أﻧﻬﺎ داﻟﺔ ﻋﺎدﻳﺔ وﻟﻜﻦ ﻟﺘﻜﻮن اﻣﺘﺪاد ﻟﻄﺒﻘﺔ ﻣﺎ ﻧﻘﻮم ﺑﻮﺿـ ــ ـﻊ اﺳـ ــ ـﻢ اﻟﻄﺒﻘﺔ وﻣﻦ ﺛﻢ‬
‫اﺳﻢ اﻟﺪاﻟﺔ ﻛﻤﺎ ﻫﻮ ﻣﻼﺣﻆ ﻟﺪﻳﻨﺎ‪Car.highSpeed‬‬

‫‪ v‬ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬

‫{)>‪fun main(args:Array<String‬‬

‫)(‪var car1= Car‬‬

‫)"‪println("please enter the speed:‬‬
‫)(‪var speed :Int = readLine()!!.toInt‬‬
‫))‪println("speed is : "+car1.LowSpeed(speed‬‬
‫))‪println("speed is : "+car1.highSpeed(speed‬‬

‫}‬

‫ﻟﺪﻳﻨﺎ أﻧﻮاع اﻟﻤﺘﻐﻴﺮات اﻟﺘﻲ ﻫﻲ )… ‪Int – String – Char‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪95‬‬

‫إﻟﺦ( وﻫﻲ ﺗﻌﺘﺒﺮ ‪ - classes‬ﻃﺒﻘﺎت ﺑﺎﻷﺳ ـﺎس وﻟﻬﺎ دواﻟﻬﺎ اﻟﺨﺎﺻ ـﺔ ﺑﻬﺎ وﺧﺼ ـﺎﺋﺼ ـﻬﺎ وﻣﻦ‬
‫ﺸﺎء داﻟﺔ اﻣﺘﺪاد‬ ‫ﺳﺎﺑﻘﺎ ﺣﻴﺚ ﻧ ـ‬
‫ﺴﺘﻄﻴﻊ اﻧ ـ‬ ‫ﻀﺎ ﻣﺎ ﻓﻌﻠﻨﺎ ـ‬
‫ﺴﺘﻄﻴﻊ اﻟﻘﻮل أﻧﻪ ﻳﻨﻄﺒﻖ ﻋﻠﻴﻬﺎ أ ﻳ ـ‬
‫ﻫﻨﺎ ﻧ ـ‬
‫ﺗﻜﻮن ﻟﻄﺒﻘﺔ ‪ String‬ﻣﺜﻼ أو ‪ Int‬او أي ﻃﺒﻘﺔ‪.‬‬

‫‪ v‬اﻟﻤﺜﺎل اﻟﺜﺎﻧﻲ‬

‫ار ﻳﺪ اﺿﺎﻓﺔ ‪ extension‬ﻟ ـ ـ ‪string class‬ﻟﻴﻘﻮم ﺑﺘﺤﻮﻳﻞ اﻟﻤﺴﺎﻓﺎت اﻟﻰ ‪ camelCase‬ﻻﺣﻆ‬

‫اﻟﺸﻔﺮة اﻟﻘﺎدﻣﺔ‬

‫} ‪fun String.spaceToCamelCase() { ...‬‬

‫ﻛﺘﺒﻨﺎ اﺳـ ــ ـﻢ اﻟﻜﻼس ‪ String‬وﻗﻤﻨﺎ ﺑﺎﻧﺸـ ــ ـﺎء اﻟﺪاﻟﺔ اﻟﺠﺪﻳﺪة ‪ spaceToCamelCase‬واﻟﺘﻲ‬

‫ﺳﺘﻘﻮم ﺑﺘﺤﻮﻳﻞ اﻟﻨﺺ وﻃﺮ ﻳﻘﺔ اﺳﺘﺨﺪاﻣﻬﺎ ﻛﺎﻟﺘﺎﻟﻲ‬

‫)(‪"Convert this to camelcase".spaceToCamelCase‬‬

‫‪lambda function‬‬

‫اﻓﻀ ـﻞ ان اﺳ ـﻤﻴﻬﺎ اﻟﺪاﻟﺔ اﻟﻤﻀ ـﻤﻨﺔ وذﻟﻚ ﻷن ﻣﻦ اﻟﻮﻫﻠﺔ اﻷوﻟﻰ ﻋﻨﺪ اﻟﻨﻈﺮ إﻟﻴﻬﺎ ﺗﺴ ـﺘﻨﻜﺮ‬
‫أﻧﻬـﺎ داﻟـﺔ ﻓﻨﺤﻦ ﻛﻤـﺎ ﺗﻌﻠﻤﻨـﺎ أﻧﻨـﺎ ﻧﻘﻮم ﺑـﺄﻧﺸـ ـــــــ ـﺎء ﻣﺘﻐﻴﺮ وﻓﺘﺢ ﻗﻮﺳـ ــــــ ـﻴﻦ وﻣﻦ اﻟﻤﻤﻜﻦ ﺗﻤﺮ ﻳﺮ‬
‫ﻣﺘﻐﻴﺮات ﻟﻬـﺬا اﻟﻘﻮﺳـ ــــــ ـﻴﻦ اﻟـﺪاﺋﺮ ﻳﻴﻦ وﻣﻦ ﺛﻢ اﻷﻗﻮاس اﻟﻤﺮ ﺑﻌـﺔ وﺑـﺪاﺧﻠﻬـﺎ اﻟﺠﻤـﻞ اﻟﺒﺮﻣﺠﻴـﺔ‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪96‬‬

‫اﻟﻤﺮاد ﺗﻨﻔﻴﺬﻫﺎ ‪ ،‬ﺣﺘﻰ ﺗﺄﺗﻴﻨﺎ ‪ lambda‬وﺗﻜﺴـ ـﺮ ﻫﺬه اﻟﻘﺎﻋﺪة وﺗﺼـ ـﺒﺢ ﻣﻀـ ـﻤﻨﺔ ﺑﺪاﺧﻞ ﻣﺘﻐﻴﺮ‬
‫أي أﻧﻨﺎ ﻧﻌﺮف ﻣﺘﻐﻴﺮ اﻟﻘﻴﻤﺔ اﻟﺬي ﻳﺤﻤﻠﻬﺎ ﻫﻲ داﻟﺔ‪.‬‬

‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ﺗﻜﻮن ﺑﻬﺬا اﻟﺸﻜﻞ‬

‫{ = ‪val printMessage‬‬
‫)"!‪println("Hello, world‬‬
‫}‬

‫ﻳﻤﻜﻦ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ او ﺗﻨﻔﻴﺬﻫﺎ ﺑﻜﺘﺎﺑﺔ اﻟﺸﻔﺮة‬

‫)(‪printMessage‬‬
‫‪// or‬‬
‫)(‪printMessage.invoke‬‬

‫اﻣﺎ اذا اردﻧﺎ ﺗﻤﺮ ﻳﺮ ﻣﺘﻐﻴﺮات اﻟﻰ اﻟﺪاﻟﺔ ﻓﺎﻧﻨﺎ ﺳـﻨﺴـﺘﺨﺪم اﻟﺸـﻔﺮة اﻟﻘﺎدﻣﺔ وﺳـﻴﺘﻢ ﺗﻀـﻤﻴﻦ‬
‫اﻟﻤﺘﻐﻴﺮات داﺧﻠﻬﺎ ﻛﻤﺎ ﺳﺘﻼﺣﻆ‬

‫})"‪var printName = { name :String -> println("Hello $name‬‬

‫ﻧﻘﻮم ﺑﻔﺘﺢ أﻗﻮاس ﻣﺮ ﺑﻌـﺔ وﺑـﺪاﺧﻠﻬـﺎ ﻧﻌﺮف اﻟﻤﺘﻐﻴﺮات اﻟﺘﻲ ﺳـ ــــــ ـﻴﺘﻢ ﺗﻤﺮ ﻳﺮﻫـﺎ وﻣﻦ ﺛﻢ‬
‫اﻟﺴﻬﻢ وﻳﻠﻴﻪ ﺟﺴﻢ اﻟﺪاﻟﺔ وﻫﻲ اﻷواﻣﺮ اﻟﻤﺮاد ﺗﻨﻔﻴﺬﻫﺎ‪.‬‬

‫§ ﻣﺜﺎل‬
‫}‪val total : (Int , Int)->Int = {num1 , num2 -> num1+num2‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪97‬‬

 ‫§ وﺑﺪاﺧﻞ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬
‫{)>‪fun main(args:Array<String‬‬

‫))‪println("the total is :"+total(6,5‬‬

‫}‬

‫‪high level function‬‬

‫ﻫﺬه اـﻟﺪاـﻟﺔ ﻻ ﺗﻜﺘﻔﻲ ﻓﻘﻂ ﺑﺘﻤﺮ ﻳﺮ ﻣﺘﻐﻴﺮات‬ ‫ﻌﺎﻟﻲ و ـ‬

‫ﻫﺬا ﻳﻌﻨﻲ أن ـ‬ ‫اـﻟﺪاـﻟﺔ ﻣﻦ اﻟﻤﺴـ ــــــ ـﺘﻮى اﻟ ـ‬
‫ﻓﺮدﻳﺔ واﻧﻤﺎ أ ﻳﻀﺎ ﺗﻘﻮم ﺑﺘﻤﺮ ﻳﺮ داﻟﺔ وﻣﻦ اﻟﻤﻤﻜﻦ ان ﺗﺮﺟﻊ داﻟﺔ‪.‬‬

‫§ ﻟﻜﻲ ﻧﺴﺘﻄﻴﻊ اﻟﻘﻮل أﻧﻬﺎ داﻟﺔ ﻋﺎﻟﻴﺔ اﻟﻤﺴﺘﻮى ﻻﺑﺪ ﻣﻦ ﺗﻮﻓﺮ اﻻﺗﻲ‬
‫• ﺗﻤﺮر ﻟﻬﺎ داﻟﺔ ﻛﻮﺳﻴﻂ‪.‬‬
‫• ﺗﻌﻴﺪ داﻟﺔ‪.‬‬
‫• ﻧﺴﺘﻄﻴﻊ ﻓﻌﻞ اﻟﺨﻄﻮﺗﻴﻦ اﻟﺴﺎﺑﻘﺘﻴﻦ أ ﻳﻀﺎ ﻣﻌﺎ ً‪.‬‬

‫ﻤﻞ ﻋﻠﻰ‬
‫ﻋﺎﻟـﻴﺔ اﻟﻤﺴـ ــــــ ـﺘﻮى ﻓﻬﺲ ﺗﻌ ـ‬
‫ﺨﺪام ‪ lambda‬ارﺗـﺒﺎط وﺛﻴﻖ ـﺑﺎـﻟﺪاـﻟﺔ ـ‬
‫وﻳﺮﺗﺒﻂ اﺳـ ــــــ ـﺘ ـ‬
‫ﺗﺮﺗﻴﺐ اﻟﺠﻤﻞ اﻟﺒﺮﻣﺠﻴﺔ وﺟﻌﻠﻪ اﺳـ ــ ـﻬﻞ ﻛﻤﺎ ﻻ ﻳﺨﻔﻰ ﻋﻠﻴﻨﺎ ﺗﻘﻠﻞ ﻣﻦ اﻷﺳـ ــ ـﻄﺮ اﻟﺒﺮﻣﺠﻴﺔ ﻣﻤﺎ‬
‫ﻳﻌﻄﻴﻨﺎ ﺷﻜﻞ ﺑﺴﻴﻂ وﻧﻈﻴﻒ‪.‬‬

‫ﺳﻨﻘﻮم ﺑﻌﺮض ﻣﺜﺎل ﻟﺘﻮﺿﻴﺢ ﻣﻔﻬﻮم اﻟﺪاﻟﺔ ﻋﺎﻟﻴﺔ اﻟﻤﺴﺘﻮى‪:‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪98‬‬

 ‫‪ v‬اﻟﺨﻄﻮة اﻷوﻟﻰ‬

‫اﻧﺸﺄﻧﺎ داﻟﺔ ﺑﺴﻴﻄﺔ ﺗﻘﻮم ﺑﺘﻤﺮ ﻳﺮ ﻣﺘﻐﻴﺮ ﻳﻦ‪:‬‬

‫– ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ﻋﺪد ﺻﺤﻴﺢ وﻧﺮ ﻳﺪ ان ﻧﻄﺒﻊ اﻟﻌﺪد اﻟﺬي ﻳﺴﺒﻘﻪ واﻟﻌﺪد اﻟﺘﺎﻟﻲ ﻟﻪ‪.‬‬

‫– اﻟﻤﺘﻐﻴﺮ اﻟﺜﺎﻧﻲ ‪ :‬داﻟﺔ ﺗﻘﻮم ﺑﻄﺒﺎﻋﺔ اﻟﻌﺪد اﻟﻤﺪﺧﻞ )ﻣﻊ اﻟﻌﻠﻢ ﻧﺴـ ـﺘﻄﻴﻊ أن ﻧﻨﺸـ ـﺊ داﻟﺔ‬
‫ﻻ ﻋﻼﻗﺔ ﻟﻬﺎ ﺑﺎﻟﻤﺘﻐﻴﺮ اﻟﺴﺎﺑﻖ ﻛﺄن ﺗﻘﻮم ﺑﺈﻧﺸﺎء داﻟﺔ ﺗﻠﻘﻲ اﻟﺘﺤﻴﺔ ﻣﺜﻼ ً(‪.‬‬

‫{)‪fun calculat( num1:Int , printNumber:(Int)->Unit‬‬

‫‪var PreviousNumber = num1 - 1‬‬

‫‪var NextNumber = num1 + 1‬‬
‫)‪printNumber(num1‬‬
‫‪println("the previous number is : $PreviousNumber and the next‬‬
‫)"‪number is : $NextNumber‬‬

‫}‬

‫ﻟﻨﺮﻛﺰ ﻗﻠﻴﻼ ﺑـﺎﻟـﺪاﻟـﺔ اﻟﻤﻤﺮرة وﻫﻲ ‪ : printNumber:(Int)->Unit‬وﻫـﺬا ﻳﻌﻨﻲ أﻧﻨـﺎ ﻋﻨـﺪﻣـﺎ‬

‫ﻧﻤﺮرﻫـﺎ ﻓﻘﻂ ﻧﻜﺘﻔﻲ ﺑﻜﺘـﺎﺑـﺔ ﻧﻮع اﻟﺒﻴـﺎن اﻟﻤـﺪﺧـﻞ وﻫﻮ ﻛﻤـﺎ ﻫﻮ ﻣﻮﺿـ ــــــ ـﺢ ﻟـﺪﻳﻨـﺎ ﻣﻦ ﻧﻮع ﻋـﺪد‬
‫ﺻـ ـــﺤﻴﺢ وﻣﻦ ﺛﻢ اﻟﺴـ ـــﻬﻢ اﻟﺬي ﻫﻮ أﺳـ ـــﺎﺳـ ـــﻲ وﻣﻦ ﺛﻢ ﻧﻮع اﻟﺨﺮج أو اﻟﺒﻴﺎن اﻟﻌﺎﺋﺪ ﻟﻨﺎ وﻫﻮ ﻓﻲ‬
‫اﻟﻤﺜﺎل ﻻ ﻳﻌﻮد ﺑﻘﻴﻤﺔ‬

‫‪ v‬اﻟﺨﻄﻮة اﻟﺜﺎﻧﻴﺔ‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪99‬‬

 ‫ﺳﻨﻨﺸﺊ داﻟﺔ ﻣﻀﻤﻨﺔ ﺑﺪاﺧﻞ ﻣﺘﻐﻴﺮ‪:‬‬

‫})‪val myNumber : (Int)->Unit = {number -> println(number‬‬

‫ﺣﺴـﻨﺎ ً ﺳـﻨﺘﺤﺪث ﻋﻦ ﻫﺬا اﻷن ﻗﻠﻴﻼ ً ‪ ،‬ﻫﺬه ﻫﻴﺎ اﻟﺼـﻴﻐﺔ اﻟﺘﻲ ﺗﻌﻠﻤﻨﻬﺎ ﻛﻤﺎ ﺳـﺒﻖ ﻟﻨﺎ وﻟﻜﻦ‬
‫ﻧﺮ ﻳﺪ أن ﻧﻮﺿـ ـــ ـﺢ أن أﻫﻤﻴﺘﻬﺎ ﺗﻜﻤﻦ ﻓﻲ أﻧﻨﺎ ﻛﻤﺎ ﺳـ ـــ ـﻨﺮى ﻓﻲ اﻟﺨﻄﻮة اﻟﺜﺎﻟﺜﺔ ﺑﻌﺪ ﻗﻠﻴﻞ أﻧﻬﺎ ﺗﻮﻓﺮ‬
‫ﻋﻠﻴﻨﺎ اﻟﻮﻗﺖ ﺑﺪل ﻣﻦ أن ﻧﻨﺸﺊ داﻟﺔ ﺟﺪﻳﺪة أﺧﺮى ﻋﻨﺪ اﻻﺳﺘﺪﻋﺎء وﺳﻮف ﻧﺮى ذﻟﻚ‪.‬‬

‫‪ v‬اﻟﺨﻄﻮة اﻟﺜﺎﻟﺜﺔ‬

‫اﻻﺳﺘﺪﻋﺎء وﻫﻲ اﻟﺨﻄﻮة اﻟﻨﻬﺎﺋﻴﺔ‪:‬‬

‫{)>‪fun main (args:Array<String‬‬

‫)"‪println("please enter any number :‬‬
‫)(‪var number1 : Int = readLine()!!.toInt‬‬
‫)‪calculat(number1, myNumber‬‬
‫}‬

‫ﻣﻔﻬﻮم ‪jump & return‬‬

‫ﺑﺒﺴـﺎﻃﺔ ﺷـﺪﻳﺪة ﻧﺴـﺘﻄﻴﻊ اﻟﻘﻮل ﻋﻦ ‪ jump‬ﻫﻮ اﻧﻚ ﻋﻨﺪﻣﺎ ﺗﺮ ﻳﺪ اﺳـﺘﺪﻋﺎء داﻟﺔ ﻟﺘﻨﻔﻴﺬ ﻣﺎ‬
‫ﺑﺪاﺧﻠﻬﺎ ﻓﻬﻮ ﻓﻲ ﻋﻤﻠﻴﺔ اﻻﺳﺘﺪﻋﺎء ﻳﻘﻔﺰ او ﻳﻘﻮم ﺑﻌﻤﻠﻴﺔ اﻟ ـ ــ ـ ‪ jump‬إﻟﻰ اﻟﺪاﻟﺔ ﻧﻔﺴﻬﺎ ﻟﺘﻨﻔﻴﺬ ﻣﺎ‬
‫ﺑﺪاﺧﻠﻬﺎ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪100‬‬

‫ﺣﺴـ ـﻨﺎ ً اﻟﻘﻴﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ ﺗﻨﻔﻴﺬ اﻟﺪاﻟﺔ ﺗﺴـ ـﻤﻰ ﻋﻤﻠﻴﺔ ‪ return‬او ارﺟﺎع أي ﺑﻤﻌﻨﻰ ﻟﻮ‬
‫ﻟﺪي داﻟﺔ ﺗﺠﻤﻊ ﻋﺪدﻳﻦ وﺗﻌﻮد ﺑﺎﻟﻨﺎﺗﺞ ﻟﻄﺒﺎﻋﺘﻪ ﻋﻠﻰ اﻟﺸـﺎﺷـﺔ ﻓﻬﻨﺎ ﺣﺼـﻠﺖ ﻋﻤﻠﻴﺔ اﻟﻌﻮدة او‬
‫اﻟﺮﺟﻮع ﺑﻘﻴﻤـﺔ ﻣﻌﻴﻨـﺔ وﻟـﺬﻟـﻚ ﻋﻨـﺪﻣـﺎ ﺗﻜﻮن ﻟـﺪﻳﻨـﺎ داﻟـﺔ ﺗﻌﻴـﺪ ﻗﻴﻤـﺔ ﻣﻌﻴﻨـﺔ ﻳﺠـﺐ ﻋﻠﻴﻨـﺎ ﺗﻌﺮ ﻳﻒ‬
‫ﻣﺘﻐﻴﺮ ﻳﺘﺴﻘﺒﻞ ﻫﺬه اﻟﻘﻴﻤﺔ ﺑﺪاﺧﻠﻪ ‪ ،‬وﺳﻨﻤﺜﻞ ﻣﺎ ﺷﺮﺣﻨﺎه ﺳﺎﺑﻘﺎ ﺑﻤﺜﺎل ﺑﺴﻴﻂ ﻟﻠﺘﻮﺿﻴﺢ‪:‬‬

‫{‪fun sumFunction(num1:Int,num2:Int):Int‬‬
‫‪return num1 + num2‬‬
‫}‬

‫ﺳﻨﺮى اﻷن ﻛﻴﻒ‬

‫ﺴﺒﻘﺎ ‪ ،‬ـ‬
‫ﺿﺤﻨﺎ ﻣ ـ‬
‫ﺴﺎﻃﺔ ﺗﻘﻮم ﺑﺈﻋﺎدة ﻧﺎﺗﺞ اﻟﺠﻤﻊ ﻛﻤﺎ و ـ‬
‫ﻫﺬه اﻟﺪاﻟﺔ وﺑﻜﻞ ﺑ ـ‬
‫ﻳﺘﻢ اﻻﺳﺘﺪﻋﺎء‪:‬‬

‫{)>‪fun main(args:Array<String‬‬

‫)‪var result = sumFunction(4,5‬‬

‫)‪println(result‬‬

‫}‬

‫ﻫﻨﺎ ﻧﺮى ﻓﻲ ﺟﻤﻠﺔ اﻻﺳـ ـﺘﺪﻋﺎء اﻧﻬﺎ أﺳـ ـﻨﺪت إﻟﻰ ﻣﺘﻐﻴﺮ وذﻟﻚ ﻟﺘﺨﺰ ﻳﻦ اﻟﻘﻴﻤﺔ اﻟﺮاﺟﻌﺔ ‪ ،‬ﻟﻮ‬
‫ﻟﻢ ﺗﻜﻦ اﻟﺪاﻟﺔ ﺗﻌﻮد ﺑﻘﻴﻤﺔ ﻓﻬﻨﺎ ﻧﺴﺘﻄﻴﻊ ان ﻧﻜﺘﻔﻲ ﺑﺎﻻﺳﺘﺪﻋﺎء ﻓﻘﻂ ﺑﺪون اﻻﺳﻨﺎد ﻟﻤﺘﻐﻴﺮ‪.‬‬

‫ﺑﺮﻣﺠﺔ ﻛﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪101‬‬

 ‫أوﻻ ‪ :‬اﻟﺒﺮﻣﺠﺔ ﻛﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ‬

‫ـــــــــــ ــ‬ ‫ـــــــــــ ـ ـ‬ ‫ﺳـ ـــ ـﻮف ﻧﺘﻄﺮق ﻟﻤﻔﻬﻮم ﺟﺪﻳﺪ وﻫﻮ اﻟﺒﺮﻣﺠﺔ ﻛﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ أو ﺷـ ـــ ـﻴﺌﻴﺔ ) ‪ ( OOP‬ـ‬
‫)‪ (Object-oriented programming‬اﻟﺘﻲ ﺗﻬـﺪف ﻟﺠﻌـﻞ اﻟﺒﺮﻧـﺎﻣﺞ ﻋﺒـﺎرة ﻋﻦ ﻣﺠﻤﻮﻋـﺔ ﻣﻦ‬
‫اﻟﻜﺎﺋﻨﺎت او ﺑﺎﻟﻤﻔﻬﻮم اﻟﻤﺘﺪاول ﻋﻨﻪ ” ﻛﻞ ﺷـﻲء ﻋﺒﺎرة ﻋﻦ ﻛﺎﺋﻦ ” ‪ .‬ﻛﻞ ﻛﺎﺋﻦ ﻋﺒﺎرة ﻋﻦ ﺣﺰﻣﺔ‬
‫ﻣﻦ اﻟﺒﻴﺎﻧﺎت‪ ،‬وﻳﺘﻢ ﺑﻨﺎء اﻟﺒﺮﻧﺎﻣﺞ ﺑﻮاﺳـ ـــ ـﻄﺔ اﺳـ ـــ ـﺘﺨﺪام اﻟﻜﺎﺋﻨﺎت ور ﺑﻄﻬﺎ ﻣﻊ ﺑﻌﻀـ ـــ ـﻬﺎ اﻟﺒﻌﺾ‬
‫وواﺟﻬﺔ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺨﺎرﺟﻴﺔ ﺑﺎﺳـ ـﺘﺦ دام ﻫﻴﻜﻠﻴﺔ اﻟﺒﺮﻧﺎﻣﺞ وواﺟﻬﺎت اﻻﺳـ ـﺘﺨﺪام اﻟﺨﺎﺻـ ـﺔ ﺑﻜﻞ‬
‫ﻛﺎﺋﻦ ‪.‬وﺗﺸﻤﻞ اﻟﺒﺮﻣﺠﺔ ﻛﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ ﻣﺒﺎدئ رﺋﻴﺴﻴﺔ وﻫﻲ‪:‬‬

‫• اﻟﺘﻐﻠﻴﻒ‪(Encapsulation).‬‬
‫• إﺧﻔﺎء اﻟﺒﻴﺎﻧﺎت‪(Data Hiding).‬‬
‫• اﻟﻤﻴﺮاث‪(Inheritance).‬‬
‫• ﺗﻌﺪاﻷﺷﻜﺎل‪(Polymorphism).‬‬
‫• ﻣﻦ اﻟﻠﻐﺎت اﻟﺘﻲ ﺗﻌﻤﻞ ﺑﺎﻟﻜﺎﺋﻨﻴﺔ‪:‬‬
‫• ﻟﻐﺔ ﺳﻲ‪++‬‬
‫• ﻟﻐﺔ ﺟﺎﻓﺎ‬
‫• ﻟﻐﺔ ﺑﺎﻳﺜﻮن‬
‫• ﻟﻐﺔ دﻟﻔﻲ )ﻟﻐﺔ ﺑﺮﻣﺠﺔ(‬

‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﻣﻘﺪﻣﺔ ﻋﻦ ‪Classes & Object‬‬

‫ﺣﺴﻨﺎ ً ﻣﺎ ﻫﻮ اﻟﻜﺎﺋﻦ ‪ Object‬؟‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪102‬‬

‫ﻛﻞ ﺷـ ــ ـﻲء ﺗﺮاه أﻣﺎﻣﻚ ﻫﻮ ﻛﺎﺋﻦ ‪ ،‬اﻟﻜﺘﺎب ﻳﻌﺘﺒﺮ ﻛﺎﺋﻦ ‪ ،‬اﻟﺴـ ــ ـﻴﺎرة ﻛﺎﺋﻦ ‪ ،‬اﻟﻘﻠﻢ ﻛﺎﺋﻦ وﺣﺘﻰ‬
‫أﻧﺖ ﻳﺎ ﻋﺰ ﻳﺰي اﻟﻘﺎرئ ﻓﻲ ﺑﺮﻣﺠﺘﻨﺎ ﻫﺬه ﺗﻌﺘﺒﺮ ﻛﺎﺋﻦ ‪ ،‬وﻛﻞ ﻛﺎﺋﻦ ﻳﺘﻜﻮن ﻣﻦ ﺷـ ـﻴﺌﻴﻦ رﺋﻴﺴـ ـﻴﻴﻦ‬
‫وﻫﻤﺎ اﻟﺼ ـﻔﺎت واﻷﻓﻌﺎل ‪ ،‬ﻓﺎﻟﺼ ـﻔﺎت ﻫﻲ ﻛﻞ ﺳ ـﻤﺔ ﺗﻤﺘﻠﻜﻬﺎ ﻣﻦ ﺣﻴﺚ اﻻﺳ ـﻢ ‪ ،‬ﻋﻤﺮك ‪ ،‬ﻟﻮن‬
‫ﺷ ـﻌﺮك ‪ ،‬ﻟﻮن ﻋﻴﻨﻴﻚ ‪ ،‬اﻟﻄﻮل ‪ ،‬اﻟﻮزن واﻟﻜﺜﻴﺮ ﻣﻦ اﻟﺼ ـﻔﺎت أ ﻳﻀ ـﺎ ﻏﻴﺮﻫﻢ ‪ ،‬أﻣﺎ اﻷﻓﻌﺎل وﻫﻲ‬
‫اﻟﻮﻇـﺎﺋﻒ اﻟـﺬي ﺗﻘﻮم ﺑﻬـﺎ ﻣﺜـﻞ اﻟﻜﺘـﺎﺑـﺔ ‪ ،‬اﻟﻤﺸـ ــــــ ـﻲ ‪ ،‬وﻳﻨﻄﺒﻖ ﻧﻔﺲ اﻟﺤـﺪﻳـﺚ ﻋﻦ أي ﻛـﺎﺋﻦ أﺧﺮ‬
‫ﻧﻘﻮم ﺑﺘﺤﺪﻳﺪ ﺻـ ـــ ﻔﺎﺗﻪ وﻣﻦ ﺛﻢ وﻇﺎﺋﻔﻪ وﻧﻌﺒﺮ ﻋﻨﻬﺎ ﺑﺮﻣﺠﻴﺎ اﻟﺼـ ـــ ﻔﺎت ﺑﺎﻟﻤﺘﻐﻴﺮات أﻣﺎ اﻷﻓﻌﺎل‬
‫ﻓﻨﻌﺒﺮ ﻋﻨﻬﺎ ﺑﺎﻟﺪوال‪.‬‬

‫‪ Classes‬ﺑﺎﻟﻌﺮ ﺑﻴﺔ ﻳﻌﻨﻲ ﺗﺼـ ــ ـﻨﻴﻔﺎت وﻫﺬا ﻳﻌﻨﻲ أﻧﻨﺎ ﻧﻀـ ــ ـﻊ اﻷﺷـ ــ ـﻴﺎء ﻓﻲ ﺗﺼـ ــ ـﻨﻴﻒ ﻣﻌﻴﻦ ‪،‬‬
‫ﻟﻨﻔﺘﺮض أﻧﻨﺎ ﻧﺘﺤﺪث ﻋﻦ اﻟﺴـ ـﻴﺎرات ﺣﺴـ ـﻨﺎ ً ﻫﻨﺎﻟﻚ ﺳـ ـﻴﺎرة ‪ BMW‬وﻟﻪ ﻟﻮن ﻣﻌﻴﻦ وﺳـ ـﺮﻋﺎت‬
‫ﻣﻌﻴﻨﻪ وﺷـ ـﺮﻛﺔ ﺧﺎﺻـ ـﺔ ﺑﺈﻧﺘﺎﺟﻬﺎ وأ ﻳﻀـ ـﺎ ﻟﺪﻳﻨﺎ ‪ AUDI‬وأ ﻳﻀـ ـﺎ ﻟﻬﺎ ﺷـ ـﺮﻛﺔ ﺧﺎﺻـ ـﺔ وﻟﻮن ﻣﻌﻴﻦ‬
‫ﻋﺔ وﻣﺨﺘﻠـﻔﺔ وﻟﻜﻨﻬﻢ ﺟﻤﻴﻌﻬﻢ ﻳﻌﺘﺒﺮون ﺻـ ــــــ ـﻮرة ﻟﺼـ ــــــ ـﻨﻒ‬
‫ﻋﺔ ﻣﺘﻨﻮ ـ‬
‫ﻜﺬا ـﻟﺪﻳـﻨﺎ ﻣﺠﻤﻮ ـ‬
‫…إﻟﺦ وﻫ ـ‬
‫اﻟﺴـﻴﺎرات ‪ ،‬أي أﻧﻨﺎ ﻓﻲ ﺑﺮﻧﺎﻣﺠﻨﺎ ﺳـﻨﺘﺤﺪث ﻋﻦ اﻟﺴـﻴﺎرات ﺻـﺤﻴﺢ ؟ إذا ﻧﻘﻮم ﺑﺈﻧﺸـﺎء ﺗﺼـﻨﻴﻒ‬
‫ﻟﻠﺴـ ـﻴﺎرات ﻧﻌﺮف ﺑﻪ اﻟﺼـ ـﻔﺎت اﻟﻌﺎﻣﺔ ﺑﻬﺎ ﻣﺜﻞ اﻻﺳـ ـﻢ ‪ ،‬اﻟﺸـ ـﺮﻛﺔ اﻟﻤﺼـ ـﻨﻌﺔ ﻟﻪ ‪ ،‬اﻟﻠﻮن وﻧﻀـ ـﻊ‬
‫ﻛﺬﻟﻚ داﺧﻞ اﻟﺘﺼﻨﻴﻒ اﻟﺪوال اﻟﺨﺎﺻﺔ ﺑﺎﻟﺴﻴﺎرة ﻛﺎﻟﺴﺮﻋﺔ واﻟﺘﻮﻗﻒ ﻣﺜﻼ ً‪.‬‬

‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻟﻔﺮق ﺑﻴﻦ ‪Classes & Object‬‬

‫ﻋﺮﻓﻨﺎ ﻣﺎ ﻫﻮ اﻟﺘﺼـﻨﻴﻒ ]‪ [Class‬وﻣﺎ ﻫﻮ اﻟﻜﺎﺋﻦ ]‪ [Object‬وﺑﺸـﻜﻞ ﺑﺴـﻴﻂ ﺳـﺄوﺿـﺢ ﻟﻚ‬

‫اﻟﻔﺮق ﺑﻴﻨﻬﻢ ‪ ،‬اﻷن ﺑﻌﺪ ﻣﺎ وﺿـ ــ ـﻌﻨﺎ ﺗﺼـ ــ ـﻨﻴﻒ ﺧﺎص ﺑﺎﻟﺴـ ــ ـﻴﺎرات ﻳﺤﻤﻞ اﻟﻤﺘﻐﻴﺮات واﻟﺪوال ‪،‬‬
‫واﻟﺴـ ــــ ـﻴﺎرات اﻟﺬي ذﻛﺮﻧﺎﻫﺎ ﻓﻲ اﻷﻋﻠﻰ ‪ BMW , AUDI ,FORD‬وﻏﻴﺮﻫﻢ ﻣﺎ ﻫﻢ إﻻ ﻛﺎﺋﻨﺎت ﻣﻦ‬
‫ﻫﺬا اﻟﺼﻨﻒ أي أﻧﻬﻢ ﺻﻮرة ﻟﻬﺬا اﻟﺼﻨﻒ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪103‬‬

‫‪Classes OOP‬‬

‫أوﻻ ً ‪ :‬ﻃﺮﻳﻘﺔ إﻧﺸﺎء اﻟﺼﻨﻒ ‪class‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪104‬‬

 ‫{ ‪class Car‬‬
‫""= ‪var name :String‬‬
‫""= ‪var color :String‬‬
‫‪var model :Int = 0‬‬
‫‪var price :Int = 0‬‬

‫{)‪fun spead(sp:Int‬‬
‫{)‪if(sp > 100‬‬
‫)"‪println("Speed is slow‬‬
‫{‪} else‬‬
‫)"‪println("High speed‬‬
‫}‬
‫}‬
‫}‬

‫ﻫﻨﺎ ﻣﺜﺎل ﻟ ـ ـــــ ـ ‪ Class‬اﻟﺴﻴﺎرة وﺿﻌﻨﺎ ﺑﺪاﺧﻠﻪ اﻟﺼﻔﺎت اﻟﺘﻲ ﻋﺮﻓﻨﺎ اﻧﻨﺎ ﻧﻤﺜﻠﻬﺎ ﺑﺮﻣﺠﻴﺎ ً ﺑﺎﻟ ـ ـــــ ـ‬
‫‪Variables‬وﻫﻲ اﻻﺳ ـﻢ واﻟﻠﻮن واﻟﻤﻮدﻳﻞ واﻟﺴ ـﻌﺮ ﻣﺜﻼ وﻟﻜﻦ ﻧﺮ ﻳﺪ ﺗﻮﺿ ـﻴﺢ أﻣﺮ ﻋﻨﺪ ﺗﻌﺮ ﻳﻒ‬
‫اﻟﻤﺘﻐﻴﺮات ﺑﺪاﺧﻞ اﻟﺘﺼﻨﻴﻒ ﻻﺑﺪ ﻣﻦ أن ﺗﻘﻮم ﺑﺘﻤﻬﻴﺪ ﻗﻴﻤﺔ ﻟﻬﺬا اﻟﻤﺘﻐﻴﺮ ﻷن ﻟﻐﺔ اﻟـ ـ ‪kotlin‬‬
‫ﻻ ﺗﺴـ ــــ ـﻤﺢ ﻟﻚ ﺑﺘﻌﺮ ﻳﻔﻪ ﺑﺪون ان ﺗﻤﻬﺪ ﻟﻪ ‪ ،‬وﻧﻼﺣﻆ أ ﻳﻀـ ــــ ـﺎ اﻧﻨﺎ ﻻ ﻧﻘﻮم ﺑﺈﻋﻄﺎء ﻗﻴﻤﺔ ﺣﻘﻴﻘﻴﺔ‬
‫ﻛﻤﺎ ﻋﺮﻓﻨﺎ ﻓﺎﻟﻘﻴﻢ ﺗﻌﻄﻰ ﻋﻨﺪ اﻧﺸﺎء ﻛﺎﺋﻦ أﻣﺎ ﻫﻨﺎ ﻓﻨﺤﻦ ﻓﻘﻂ ﻧﻌﻄﻲ اﻟﺼﻔﺎت واﻻﻓﻌﺎل‪.‬‬

‫ﻃﺮ ﻳﻘﺔ أﺧﺮى ﻟﺘﻤﻬﻴﺪ ﻗﻴﻢ اﻟﻤﺘﻐﻴﺮات ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫‪var name :String? = null‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪105‬‬

‫اﻷن ﺳـ ـــ ـﺘﻘﻮل ﻟﻲ ﻣﺎ ﻫﻮ ﻧﺎﺗﺞ ﺗﻨﻔﻴﺬ ﻫﺬا اﻟﻜﻮد ؟ ﺳـ ـــ ـﺄﻗﻮل ﻟﻚ ﻻ ﺷـ ـــ ـﻲء ﻳﺎﻋﺰ ﻳﺰي ‪ .‬ﻧﻌﻢ ﻻ‬
‫ﺷـ ـﻲء ‪ ،‬ﻟﻤﺎذا ﻷﻧﻨﺎ ﻓﻘﻂ ﻗﻤﻨﺎ ﺑﺈﻋﻼم اﻟﺒﺮﻧﺎﻣﺞ ﺑﺈﻧﺸـ ـﺎء ﺗﺼـ ـﻨﻴﻒ ﻳﻤﺮر ﻟﻪ ﺑﻴﺎﻧﺎت ﻣﻌﻴﻨﺔ ﻓﻘﻂ ‪،‬‬
‫ﻣﺘﻰ ﺳﻴﻨﻔﺬ اﻷﻣﺮ ؟ وﻫﺬا ﻫﻮ اﻟﺠﺰء اﻟﺜﺎﻧﻲ اﻟﻤﻬﻢ ﻓﻲ درﺳﻨﺎ وﻫﻮ اﻟﻜﺎﺋﻦ‪.‬‬

‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﻃﺮﻳﻘﺔ إﻧﺸﺎء ﻛﺎﺋﻦ ‪Object‬‬

‫اﻟﻜﺎﺋﻦ ﻳﺎ ﻋﺰ ﻳﺰي ﻫﻮ ﻋﺒﺎرة ﻋﻦ ﺻـ ـﻮرة ﻟﻠﺘﺼـ ـﻨﻴﻒ اﻟﺬي أﻧﺸـ ـﺄﻧﺎه ﺳـ ـﺄوﺿـ ـﺢ ﻟﻚ اﻷﻣﺮ ﻣﺮة‬
‫أﺧﺮى وﻫﻲ أن اﻟﺴـ ــ ـﻴﺎرات ﺟﻤﻴﻌﻬﺎ ﺑﻤﺨﺘﻠﻒ أﻧﻮاﻋﻬﺎ ﺗﺠﺘﻤﻊ ﺑﺄن ﻟﻬﺎ ﺻـ ــ ـﻔﺎت ﻣﺸـ ــ ـﺘﺮﻛﺔ ﻣﺜﻞ‬
‫ﺼ ﻨﻒ‬
‫ﺸﺊ ﻣ ـ‬
‫ﺳﺮﻋﺔ ﻓﻬﻨﺎ ﻧﻨ ـ‬
‫ﺳﻴﺎرة ﺗﺤﻤﻞ ﻣﻮدﻳﻞ وﻟﻮن و ـ‬
‫ﺳﻢ وﻛﻞ ـ‬
‫ﺳﻴﺎرة ﺗﺤﻤﻞ ا ـ‬
‫ﺳﻢ ﻓﻜﻞ ـ‬
‫اﻻ ـ‬
‫ﻳﻀﻢ ﻛﻞ اﻟﺼﻔﺎت واﻻﻓﻌﺎل اﻟﺘﻲ ﺗﺸﺘﺮك ﻓﻴﻬﺎ ﻛﻞ اﻟﺴﻴﺎرات ﺣﺴﻨﺎ ً أ ﻳﻦ اﻻﺧﺘﻼف ؟ اﻻﺧﺘﻼف‬
‫ﻫﻮ ﻧﻮع اﻟﺒﻴﺎن اﻟﻤﺪﺧﻞ ﻓﺴـ ــــ ـﻴﺎرة ﻣﻦ ﻧﻮع ﻓﻮرد ﻣﺨﺘﻠﻔﺔ ﻋﻦ ﺳـ ــــ ـﻴﺎرة ﻧﻮع اودي وﻫﻜﺬا ‪ ،‬ﻧﻘﻮم‬
‫ﺑﺈﻧﺸﺎء اﻟﻜﺎﺋﻦ ﻓﻲ داﺧﻞ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‪:‬‬

‫)(‪var object1 = Car‬‬

‫ﻫﻜﺬا ﻧﺤﻦ اﻧﺸ ـﺄﻧﺎ ﻛﺎﺋﻦ ﻋﺮﻓﻨﺎه ﻛﻤﺎ ﻧﻘﻮم ﺑﺘﻌﺮ ﻳﻒ اﻟﻤﺘﻐﻴﺮات وﻟﻜﻦ اﻻﺧﺘﻼف ﻫﻮ أﻧﻪ ﺑﻌﺪ‬
‫ﻋﻼﻣﺔ اﻟﻤﺴ ـﺎواة ﻧﻀ ـﻊ اﺳ ـﻢ اﻟﺼ ـﻨﻒ ‪ Class‬اﻟﺬي ﻳﺘﺒﻌﻪ اﻟﻜﺎﺋﻦ اﻟﺬي اﻧﺸ ـﺄﻧﺎه ‪،‬ﻳﻤﻜﻨﻚ أ ﻳﻀ ـﺎ‬
‫ﺗﻌﺮ ﻳﻒ أ ﻛﺜﺮ ﻣﻦ ﻛﺎﺋﻦ ﻟﻨﻔﺲ اﻟﺼﻨﻒ ﺑﺸﺮط أن ﻳﻜﻮن اﻻﺳﻢ ﻣﺨﺘﻠﻒ‪.‬‬

‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻟﻮﺻﻮل إﻟﻰ اﻟﻤﺘﻐﻴﺮات اﻟﺨﺎﺻﺔ ﺑﺎﻟـ ‪Class‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪106‬‬

‫ﻃﺒﻌﺎ اﻵن ﺗﻌﺮف ﻟﺪﻳﻨﺎ ﻛﺎﺋﻦ ﻣﻦ ﺻـ ــ ـﻨﻒ اﻟﺴـ ــ ـﻴﺎرات إذا ﺟﻤﻴﻊ ﻣﺎ ﻋﺮﻓﻨﺎه ﻓﻲ داﺧﻞ ﺻـ ــ ـﻨﻒ‬
‫اﻟﺴـ ـــــ ـﻴﺎرة ﻳﻨﻄﺒﻖ ﺗﻤﺎﻣﺎ ﻋﻠﻰ اﻟﻜﺎﺋﻦ اﻟﺬي اﻧﺸـ ـــــ ـﺄﻧﺎه ﻣﻦ اﺳـ ـــــ ـﻢ وﻣﻮدﻳﻞ وﺳـ ـــــ ـﻌﺮ وﻟﻮن ‪ ،‬وﻫﻨﺎ‬
‫اﻟﺴﺆال ﻛﻴﻒ ﻧﺴﺘﺪﻋﻴﻬﻢ وﻧﻘﻮم ﺑﺘﻌﺒﺌﺘﻬﻢ ؟‬

‫"‪object1.name = "BMW‬‬
‫"‪object1.color = "White‬‬
‫‪object1.model = 2017‬‬
‫‪object1.price = 90872.87f‬‬

‫ﻛﻤﺎ ﻧﺮى ﻓﻲ ﻛﻞ ﻣﺮة ﻧﺮ ﻳﺪ اﻟﻮﺻﻮل إﻟﻰ ﻣﺘﻐﻴﺮ أو داﻟﺔ ﻓﻲ داﺧﻞ ‪ Class‬ﻧﻘﻮم ﺑﻜﺘﺎﺑﺔ‪:‬‬

‫‪Object .Attribute‬‬

‫وﻣﻦ ﺛﻢ ﻧﻘﻮم ﺑﺎﻟﺘﻌﺒﺌﺔ ﻛﻤﺎ ﻧﺮ ﻳﺪ‪.‬‬

‫ﺣﺴﻨﺎ اﻷن ﺗﻢ ﺗﻌﺒﺌﺔ ﺑﻴﺎﻧﺎت ﻫﺬا اﻟﻜﺎﺋﻦ ﺳﻨﻘﻮم ﺑﻌﻤﻠﻴﺔ اﻟﻄﺒﺎﻋﺔ ﻟﻨﺮى ﻣﺎ ﺳﻴﺤﺪث‪:‬‬

‫)‪println(object1.name‬‬
‫)‪println(object1.color‬‬
‫)‪println(object1.model‬‬
‫)‪println(object1.price‬‬

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
‫‪BMW‬‬
‫‪White‬‬
‫‪2017‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪107‬‬

‫‪90872.87‬‬

‫راﺑﻌﺎ ً ‪ :‬اﻟﻮﺻﻮل إﻟﻰ اﻟﺪوال اﻟﺨﺎﺻﺔ ﺑﺎﻟـ ‪Class‬‬

‫ﻣﻦ اﻟﻤﻤﻜﻦ ان ﻧﺴـ ــــــ ـﺘـﺪﻋﻴﻬـﺎ ﺑـﺪاﺧـﻞ ﻣﺘﻐﻴﺮ وﻣﻦ اﻟﻤﻤﻜﻦ اﺟﺮاء اﻣﺮ اﻟﻄﺒـﺎﻋـﺔ ﻣﺒـﺎﺷـ ــــــ ـﺮة‪،‬‬
‫ﺳﻮف ﻧﻘﻮم ﺑﺎﺗﺒﺎع ﻧﻔﺲ اﻟﻄﺮ ﻳﻘﺔ‪:‬‬

‫)‪var speed1 = object1.spead(150)println(speed1‬‬

‫ﺧﺎﻣﺴﺎ ً ‪ :‬ﺗﻤﺮﻳﺮ اﻟﻮﺳﺎﺋﻂ ﻓﻲ ‪Class‬‬

‫ﺑﺈﻣﻜﺎﻧﻨﺎ إﻧﺸﺎء ﺗﺼﻨﻴﻒ ‪ Class‬وﻧﻤﺮر ﻟﻪ وﺳﺎﺋﻂ ﻣﻌﻴﻨﻪ‪:‬‬

‫{ )‪class labtop(id:Int,name:String‬‬

‫‪var serialNum= id‬‬

‫‪var companyName = name‬‬

‫{)(‪fun getInfo‬‬
‫‪println("The labtop is : $companyName , and the serial number‬‬
‫)"‪is : $serialNum‬‬
‫}‬

‫}‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪108‬‬

‫ﻧﻼﺣﻆ ﻗﻤﻨﺎ ﺑﺈﻧﺸـﺎء ﺗﺼـﻨﻴﻒ ‪class‬وﻣﺮرﻧﺎ ﻟﻪ وﺳـﺎﺋﻂ وﻫﺬا ﻳﻌﻨﻲ أﻧﻪ ﻋﻨﺪﻣﺎ ﻧﻘﻮم ﺑﺈﻧﺸـﺎء‬
‫ﻛﺎﺋﻦ ﻣﻦ ﻫﺬا اﻟﺘﺼ ـﻨﻴﻒ ﻳﺴ ـﺘﻮﺟﺐ ﻋﻠﻴﻨﺎ ﺗﻤﺮ ﻳﺮ ﻗﻴﻢ وﺳ ـﻨﺮى ذﻟﻚ ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴ ـﻴﺔ ‪ ،‬وﻓﻲ‬
‫داﺧﻞ اﻟﺘﺼـ ــ ـﻨﻴﻒ ﻋﺮﻓﻨﺎ ﻣﺘﻐﻴﺮات واﺳـ ــ ـﻨﺪﻧﺎ ﻟﻬﺎ ﻗﻴﻢ ﻫﺬي اﻟﻮﺳـ ــ ـﺎﺋﻂ اﻟﻤﻤﺮرة وذﻟﻚ ﻷن ﻫﺬه‬
‫وﺳـ ـــﺎﺋﻂ ﺑﺪاﺧﻞ ﺗﺼـ ـــﻨﻴﻒ ﻟﻦ ﻳﺴـ ـــﺘﻄﻴﻊ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﻣﺒﺎﺷـ ـــﺮة ‪ ،‬وﻣﻦ ﺛﻢ ﻗﻤﻨﺎ ﺑﺈﻧﺸـ ـــﺎء داﻟﺔ‬
‫ﺗﻄﺒﻊ اﻟﻤﻌﻠﻮﻣﺎت‪.‬‬

‫§ ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬
‫{)>‪fun main (args:Array<String‬‬

‫)"‪var dell = labtop(1015,"Dell‬‬

‫)(‪dell.getInfo‬‬
‫}‬

‫ﻧﺮى أﻧﻪ أﻟﺰﻣﻨﺎ ﻋﻨﺪ إﻧﺸ ـﺎء اﻟﻜﺎﺋﻦ ﺑﺘﻤﺮ ﻳﺮ ﻗﻴﻢ ﻟﻬﺬه اﻟﻮﺳ ـﺎﺋﻂ اﻟﺘﻲ ادﺧﻠﻨﺎﻫﺎ ﻓﻲ اﻟﺘﺼ ـﻨﻴﻒ‬
‫ﻓﻮق‪.‬‬

‫ﻟﻮ ﻧﺮ ﻳﺪ أن ﻧﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻮﺳـ ــــ ـﺎﺋﻂ ﻣﺒﺎﺷـ ــــ ـﺮة ﺑﺪون ﺗﻌﺮ ﻳﻒ ﻣﺘﻐﻴﺮات ﻓﻲ داﺧﻞ ﺗﺼـ ــــ ـﻨﻴﻒ‬
‫‪:class‬‬

‫{ )‪class labtop(var id:Int,var name:String‬‬

‫{)(‪fun getInfo‬‬
‫)"‪println("The labtop is : $name , and the serial number is : $id‬‬
‫}‬

‫}‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪109‬‬

 ‫ﻓﻘﻂ ﻧﻘﻮم ﺑﺘﻌﺮ ﻳﻔﻬﻢ ﺑﺪاﺧﻞ اﻗﻮاس اﻟﺘﺼﻨﻴﻒ‪.‬‬

‫ﺳﺎدﺳﺎ ً ‪ :‬ﻛﻠﻤﺔ ‪this‬‬

‫{ )‪class labtop(var id:Int,var name:String‬‬

‫{)‪fun setValues(id:Int , name:String‬‬

‫‪this.id = id‬‬
‫‪this.name = name‬‬
‫}‬

‫{)(‪fun getInfo‬‬
‫)"‪println("The labtop is : $name , and the serial number is : $id‬‬
‫}‬

‫}‬

‫ﺣﺴـ ــــــ ـﻨـﺎ اﻵن ﺳـ ــــــ ـﻨﺘﻌﺮف ﻋﻠﻰ ﻓـﺎﺋـﺪة ‪ this‬ﻧﻼﺣﻆ ﻫﻨـﺎ أن اﻧﺸـ ـــــــ ـﺄﻧـﺎ داﻟـﺔ وﻣﺮرﻧـﺎ ﻟﻬـﺎ ﻧﻔﺲ‬
‫اﻟﻤﺘﻐﻴﺮات ﻟﻠﺘﺼﻨﻴﻒ ‪ class‬وﺑﺪاﺧﻞ اﻟﺪاﻟﺔ‪:‬‬

‫‪this.id = id‬‬
‫‪this.name = name‬‬

‫ﻫﺬه اﻟﻜﻠﻤﺔ ﺗﻌﻨﻲ ‪ id‬اﻟﺨﺎص ﺑﺎﻟﺘﺼـ ـــــ ـﻨﻴﻒ وﻟﻴﺲ ‪ id‬اﻟﻤﻤﺮ ﻟﻠﺪاﻟﺔ ‪ ،‬ﻟﻮ ﻛﺎﻧﺖ اﻟﻤﺘﻐﻴﺮات‬
‫اﻟﻤﻤﺮرة ﻟﻠﺪاﻟﺔ ذات ﻣﺴـ ـــــ ـﻤﻴﺎت ﻣﺨﺘﻠﻔﺔ ﻋﻦ اﻟﺘﻲ ﺗﻢ ﺗﻤﺮ ﻳﺮﻫﺎ ﻟﻠﺘﺼـ ـــــ ـﻨﻴﻒ ﻓﻠﻦ ﻧﺤﺘﺎج ﻟﻬﺬه‬
‫اﻟﻜﻠﻤﺔ ‪ ،‬ﺑﺎﺧﺘﺼﺎر ﺷﺪﻳﺪ ﻛﻠﻤﺔ ‪ this‬ﺧﺎﺻﺔ ﻟﻠﻮﺻﻮل إﻟﻰ ﻣﺤﺘﻮﻳﺎت اﻟﺘﺼﻨﻴﻒ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪110‬‬

 ‫ﺳﺎﺑﻌﺎ ً ‪ :‬داﻟﺔ اﻟﺒﻨﺎء ‪constructor‬‬

‫ﻓﻲ اﻟﺒﺪا ﻳﺔ ﻻﺑﺪ ﻣﻦ ﺗﻮﺿﻴﺢ ﻣﺎﻫﻴﺔ داﻟﺔ اﻟﺒﻨﺎء وﻋﻤﻠﻬﺎ ؟‬

‫داﻟﺔ اﻟﺒﻨﺎء ﻫﻲ ﻋﺒﺎرة ﻋﻦ ﻗﻄﻌﺔ ﺑﺮﻣﺠﻴﺔ ﻳﺘﻢ ﺗﻨﻔﻴﺬﻫﺎ ﻣﺒﺎﺷـ ــ ـﺮة ﻋﻨﺪ إﻧﺸـ ــ ـﺎء ﻛﺎﺋﻦ ﻣﺸـ ــ ـﺘﻖ‬
‫ﻣﻦ اﻟﺘﺼﻨﻴﻒ ‪،‬وﻳﻤﻜﻦ إﻧﺸﺎء أ ﻛﺜﺮ ﻣﻦ داﻟﺔ ﺑﻨﺎء ﺑﺪاﺧﻞ اﻟﺘﺼﻨﻴﻒ‬

‫ﻟﺪﻳﻨﺎ ﻃﺮ ﻳﻘﺘﺎن ﻟﻌﻤﻞ داﻟﺔ اﻟﺒﻨﺎء‪:‬‬

‫‪ v‬اﻟﻄﺮﻳﻘﺔ اﻷوﻟﻰ ‪ :‬داﻟﺔ ﺗﻌﺮﻳﻒ ﺟﺎﻫﺰة ‪init‬‬

‫• ﻫﺬه اﻟﺪاﻟﺔ اﺧﺘﺼﺎر ﻟﻜﻠﻤﺔ‪initialization .‬‬

‫• ﻻ ﻧﺴﺘﻄﻴﻊ ﺗﻤﺮ ﻳﺮ ﻣﺘﻐﻴﺮات ﺑﺪاﺧﻠﻬﺎ اﺑﺪا ً‪.‬‬
‫• ﻟﻬﺎ اﻷوﻟﻮﻳﺔ ﻓﻲ اﻟﺘﻨﻔﻴﺬ ﻟﻮ ﻗﻤﻨﺎ ﺑﺈﻧﺸﺎء أ ﻛﺜﺮ ﻣﻦ داﻟﺔ ﺑﻨﺎء‪.‬‬
‫• ﻧﻘﻮم ﺑـﺪاﺧﻠﻬـﺎ ﺑﺘﻤﻬﻴـﺪ اﻟﻘﻴﻢ وﻋﻨـﺪ إﻧﺸـ ـــــــ ﺎء ﻛـﺎﺋﻦ ﻳﺘﻢ اﺳـ ــــــ ـﺘـﺪﻋـﺎﺋﻬـﺎ ﺗﻠﻘـﺎﺋﻴـﺎ ﺑـﺪون اﻟﻘﻴـﺎم‬
‫ﺑﻜﺘﺎﺑﺘﻬﺎ ﺑﻨﻔﺴﻚ وﺗﻨﻔﻴﺬ ﻣﺎ ﺑﺪاﺧﻠﻬﺎ‪.‬‬

‫§ ﻣﺜﺎل‬
‫‪class employee(var firstName:String,var lastName:String,var‬‬
‫{)‪titleJob:String,var salary :Double‬‬
‫{‪init‬‬
‫‪println("the name of employee is :$firstName $lastName, his title‬‬
‫)" ‪job :$titleJob ,and his salary :$salary‬‬
‫}‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪111‬‬

 ‫}‬

‫ﻓﻲ اﻟﻤﺜﺎل ﻋﺮﻓﻨﺎ اﻟﻤﺘﻐﻴﺮات ﺑﻴﻦ اﻗﻮاس اﻟﺘﺼـﻨﻴﻒ وﻣﻦ ﺛﻢ ﻧﻼﺣﻆ ﺑﺪاﺧﻞ ‪ init‬ﻓﻘﻂ ﻧﺮ ﻳﺪ‬
‫ﻫﺬا اﻟﺘﺼـ ــــــ ـﻨﻴﻒ ﺳـ ــــــ ـﻮف ﻳﻘﻮم ﺑﻮﺿـ ــــــ ـﻊ ﻗﻴﻢ‬
‫ﻫﺬه اﻟﺠﻤـﻠﺔ ‪ ،‬أي ﻋﻦ اﻧﺸـ ــــــ ـﺎء ـﻛﺎﺋﻦ ﻣﻦ ـ‬
‫ﻋﺔ ـ‬
‫ﻃـﺒﺎ ـ‬
‫ﻟﻠﻤﺘﻐﻴﺮات وﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺳﻴﻄﺒﻊ اﻟﺠﻤﻠﺔ اﻟﺘﻲ اردﻧﺎ ﻃﺒﺎﻋﺘﻬﺎ ﻓﻲ داﻟﺔ اﻟﺘﻬﻴﺌﺔ‪.‬‬

‫§ ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬
‫)‪var employee1 = employee("Ahmed","Aljuaid","Teacher",7000.0‬‬

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
‫‪the name of employee is :Ahmed Aljuaid, his title job :Teacher ,and‬‬
‫‪his salary :7000.0‬‬

‫‪ v‬اﻟﻄﺮﻳﻘﺔ اﻟﺜﺎﻧﻴﺔ ‪ :‬داﻟﺔ ‪constructor‬‬

‫ﻧﺴﺘﻄﻴﻊ ﺗﻤﺮ ﻳﺮ ﻣﺘﻐﻴﺮات ﺑﺪاﺧﻠﻬﺎ‪.‬‬

‫أ ﻳﻀـ ــ ـﺎ ﻧﻘﻮم ﺑﺪاﺧﻠﻬﺎ ﺑﺘﻤﻬﻴﺪ اﻟﻘﻴﻢ وﻋﻨﺪ إﻧﺸـ ــ ـﺎء ﻛﺎﺋﻦ ﻳﺘﻢ اﺳـ ــ ـﺘﺪﻋﺎﺋﻬﺎ ﺗﻠﻘﺎﺋﻴﺎ ﺑﺪون اﻟﻘﻴﺎم‬
‫ﺑﻜﺘﺎﺑﺘﻬﺎ ﺑﻨﻔﺴﻚ وﺗﻨﻔﻴﺬ ﻣﺎ ﺑﺪاﺧﻠﻬﺎ‪.‬‬

‫§ ﻣﺜﺎل‬

‫ﺳﻮف ﻧﻘﻮم ﺑﺘﻄﺒﻴﻖ ﻧﻔﺲ اﻟﻤﺜﺎل اﻟﻤﺬﻛﻮر ﻓﻲ ‪:init‬‬

‫{‪class employee‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪112‬‬

 var firstName:String ? = null
var lastName:String ? = null
var titleJob:String ? = null
var salary :Double ? = null

constructor(fName:String,lName:String ,tJob:String ,sal :Double){

firstName = fName
lastName = lName
titleJob = tJob
salary = sal
println("the name of employee is :$firstName $lastName, his
title job :$titleJob ,and his salary :$salary ")
}
}

‫ﻗﻤﻨﺎ ﺑﺘﻌﺮ ﻳﻒ ﻣﺘﻐﻴﺮات ﺑﺪاﺧﻞ اﻟﺘﺼـ ـــــ ـﻨﻴﻒ وﻣﻦ ﺛﻢ اﻧﺸـ ـــــ ـﺄﻧﺎ داﻟﺔ ﺑﻨﺎء ﺗﻤﺮر ﻟﻬﺎ ﻣﺘﻐﻴﺮات‬
.‫وﻗﻤﻨﺎ ﺑﺈﺳﻨﺎد ﻫﺬه اﻟﻤﺘﻐﻴﺮات وﻣﻦ ﺛﻢ أﻣﺮ اﻟﻄﺒﺎﻋﺔ‬

‫§ ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬
var employee1 = employee("Ahmed","Aljuaid","Teacher",7000.0)

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
the name of employee is :Ahmed Aljuaid, his title job :Teacher ,and
his salary :7000.0

‫ﺗﻨﻮﻳﻪ‬

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 113 ‫اﻟﺼﻔﺤﺔ‬

‫ﻟﻮ أردﻧﺎ ﺗﻤﺮ ﻳﺮ ﻣﺘﻐﻴﺮات ﻋﻨﺪ إﻧﺸـﺎء اﻟﺘﺼـﻨﻴﻒ ﻓﺪاﻟﺔ اﻟﺒﻨﺎء اﻟ ـ ــــــ ـ ‪ constructor‬ﻻ ﻧﺴـﺘﻄﻴﻊ‬
‫اﻟﺘﻤﺮ ﻳﺮ ﻟﻬﺎ وﻟﻜﻦ ﻧﺴﺘﻌﻴﺾ ﻋﻨﻬﺎ ﺑﻔﻌﻞ اﻷﺗﻲ‪:‬‬

‫‪class employee (var firstName:String,var lastName:String,var‬‬

‫{)‪titleJob:String,var salary :Double‬‬

‫{)‪constructor():this("Ahmed","Aljuaid","Teacher",7000.0‬‬

‫‪println("the name of employee is :$firstName $lastName, his title‬‬

‫)" ‪job :$titleJob ,and his salary :$salary‬‬

‫}‬

‫}‬

‫ﻧﻼﺣﻆ أﻧﻨﺎ اﺳـ ـﺘﻌﻤﻠﻨﺎ ﻛﻠﻤﺔ ‪ this‬اﻟﺘﻲ ﺗﻘﻮم ﺑﺎﻟﻮﺻـ ـﻮل إﻟﻰ اﻟﻤﺘﻐﻴﺮات اﻟﺘﻲ ﻋﺮﻓﻨﺎﻫﺎ ﻋﻨﺪ‬
‫إﻧﺸﺎء اﻟﺘﺼﻨﻴﻒ‪.‬‬

‫وﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ ﻧﻘﻮم ﻓﻘﻂ ﺑﺈﻧﺸﺎء ﻛﺎﺋﻦ ﺑﺪون ﺗﻤﺮ ﻳﺮ‪:‬‬

‫)(‪var employee1 = employee‬‬

‫ﺗﺘﻨﻮع ﻫﺬه اﻟﻄﺮق وﻛﻼ ً ﺑﺤﺴﺐ ﺣﺎﺟﺘﻚ أﻧﺖ ﻋﻨﺪ إﻧﺸﺎء اﻟﺒﺮﻧﺎﻣﺞ وﺑﺤﺴﺐ ﻣﺎ ﺗﺮاه‪.‬‬

‫‪Inheritance‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪114‬‬

‫ﻟﻮ ﺗﻜﻠﻤﻨﺎ ﻋﻠﻤﻴﺎ ً ﺑﻬﺬا اﻟﻤﻮﺿـ ـــﻮع واردﻧﺎ ﺗﺒﺴـ ـــﻴﻂ ﻣﻔﻬﻮم اﻟﻮراﺛﺔ ﺳـ ـــﻨﻘﻮل أن ﺗﻨﺘﻘﻞ ﺑﻌﺾ‬
‫ﻣﻦ ﺻـ ـــ ـﻔﺎت اﻟﻮاﻟﺪﻳﻦ أو ﺟﻤﻴﻌﻬﺎ ﻟﻠﻄﻔﻞ ‪ ،‬وﻧﻔﺲ اﻟﺸـ ـــ ـﻲء ﻳﺤﺪث ﺑﺮﻣﺠﻴﺎ ﻧﺴـ ـــ ـﺘﻄﻴﻊ إﻧﺸـ ـــ ـﺎء‬
‫ﺗﺼﻨﻴﻒ ‪ class‬ﻳﺮث ﻣﻦ ﺗﺼﻨﻴﻒ ‪ class‬أﺧﺮ‪.‬‬

‫أوﻻ ‪ :‬ﻣﻔﺎﻫﻴﻢ ﻣﺘﻌﻠﻘﺔ ﺑﺎﻟﻮراﺛﺔ‬

‫ﺳﻨﺘﻌﺮف ﻋﻠﻰ ﻃﺮ ﻳﻘﺔ اﻟﻮراﺛﺔ ﺑﺮﻣﺠﻴﺎ وﻟﻜﻦ ﺑﻌﺪ ﺗﻮﺿﻴﺢ ﺑﻌﺾ اﻟﻤﻔﺎﻫﻴﻢ اﻟﻌﺎﻣﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫ﻓﻠﻨﻔﺘﺮض أن ﻟﺪﻳﻨﺎ ‪ class Person‬ﻳﺤﺘﻮي ﻋﻠﻰ اﻻﺗﻲ ‪:‬‬

‫} اﺳـﻢ اﻟﺸـﺨﺺ – ﺗﺎر ﻳﺦ اﻟﻤﻴﻼد – اﻟﺮﻗﻢ اﻟﻤﺪﻧﻲ {‪ ،‬واﻧﺸـﺄﻧﺎ ‪ class Employee‬ﻳﺮث ﻣﻦ‬
‫‪class Person‬ﻳﺤﺘﻮي ﻋﻠﻰ اﻻﺗﻲ ‪ } :‬اﻟﺮﻗﻢ اﻟﻮﻇﻴﻔﻲ { ‪ ،‬ﻓﻬﻨﺎ ‪ class Employee‬ﻳﺴـ ـــــ ـﺘﻄﻴﻊ‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪115‬‬

‫اﻟﻮﺻـ ـﻮل إﻟﻰ ﻣﺤﺘﻮﻳﺎت ‪ class Person‬ﻣﻦ اﻻﺳـ ـﻢ وﺗﺎر ﻳﺦ اﻟﻤﻴﻼد واﻟﺮﻗﻢ اﻟﻤﺪﻧﻲ ﺑﺎﻹﺿـ ـﺎﻓﺔ‬
‫إﻟﻰ ﻣﺎ ﻳﺘﻀﻤﻨﻪ ﻫﺬا اﻟﺘﺼﻨﻴﻒ ﻣﻦ اﻟﺮﻗﻢ اﻟﻮﻇﻴﻔﻲ‪.‬‬

‫ﺣﺴـ ــــ ـﻨﺎ ً ﻧﻜﻤﻞ اﻟﺸـ ــــ ـﺮح وﻧﻼﺣﻆ أن اﻟﻮﻇﺎﺋﻒ أﻧﻮاع ﻓﻠﺪﻳﻨﺎ اﻟﻤﻌﻠﻢ وﻟﺪﻳﻨﺎ اﻟﻤﻬﻨﺪس وﻟﺪﻳﻨﺎ‬
‫ﻤﺎ أﻧﻬﻢ‬
‫ﻫﺎ اﻟﻜﺜﻴﺮ وﺟﻤﻴﻌﻬﻢ ﻳﺮﺛﻮن ﻣﻦ ‪ class Employee‬وـﺑﺎﻟﻄﺒﻊ ـﻳﺎ ﻋﺰ ﻳﺰي ﺑ ـ‬
‫اﻟﻄﺒﻴـﺐ وﻏﻴﺮ ـ‬
‫ﻳﺮﺛﻮن ﻣﻨﻪ وﻫﻮ ﺑﺪوره ﻳﺮث ﻣﻦ ‪ class Person‬ﻓﻬﻢ ﻳﺴـ ــــ ـﺘﻄﻴﻌﻮن اﻟﻮﺻـ ــــ ـﻮل إﻟﻰ ﻣﺤﺘﻮﻳﺎت‬
‫‪class Person‬أ ﻳﻀـﺎ ً ‪ ،‬ﻫﺬا اﻟﺸـﻲء ﻳﺸـﺒﻪ ﻛﺜﻴﺮا ﻣﺎ ﺗﻘﺪم ﺷـﺮﺣﻪ ﻓﻲ اﻟﺘﻤﻬﻴﺪ ﻓﻮق ﺑﺄن اﻟﻄﻔﻞ‬
‫ﻳﺴـﺘﻄﻴﻊ أن ﻳﺮث ﻣﻦ واﻟﺪﻳﻪ وﻟﻜﻦ ﻫﻞ ﻓﻘﻂ واﻟﺪﻳﻪ ؟ ﻻ أ ﻳﻀـﺎ ﻗﺪ ﻳﺮث ﻣﻦ ﺟﺪﻳﻪ ﺻـﻔﺎت‪ .‬إذا‬
‫ﻧﺤﻦ اﻷن ﻧﻌﻠﻢ أن ﻓﻲ اﻟﻮراﺛﺔ ﻧﺴﺘﻄﻴﻊ اﻟﻮﺻﻮل إﻟﻰ ﻛﺎﻓﺔ ﻣﺤﺘﻮﻳﺎت ‪class‬اﻟﻤﻮروث‪.‬‬

‫ﻣﻦ ﻫﻮ اﻟﻮارث وﻣﻦ ﻫﻮ اﻟﻤﻮروث ؟‬

‫اﻟﻤﻮروث ﻓﻲ اﻟﻤﺜ ـﺎل أﻋﻼه ﻫﻮ ‪ class person‬ﻫﻮ اﻷب ﻳﻌﺘﺒﺮ وﻧﻄﻠﻖ ﻋﻠﻴ ـﻪ ‪ ، super‬أﻣ ـﺎ‬
‫اﻟﻮارث ﻓﻬﻮ ‪ class Employee‬وﻧﺴ ـ ـ ـ ـ ـﻤﻴـ ـﻪ ‪ sub‬أي ﻓﺮﻋﻲ‪ .‬وﺑـ ـﺎﻟﻄﺒﻊ اﻟﻤﻌﻠﻢ واﻟﻄﺒﻴـ ـﺐ‬
‫واﻟﻤﻬﻨــﺪس ﻳﻌﺘﺒﺮون وارﺛﻴﻦ وﻳﻌﺘﺒﺮون ‪ ،sub‬واﻟﻤﻮروث ﻫﻮ ‪ class Employee‬اﻟــﺬي‬
‫ﻳﻌﺪ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻬﻢ ‪.super‬‬

‫ﺛﺎﻧﻴﺎ ً ‪ :‬اﻟﻮراﺛﺔ ﻓﻲ اﻟﺒﺮﻣﺠﺔ‬

‫اﻟﺘﺼـﻨﻴﻒ اﻷب أو ‪ super class‬ﻟﻜﻲ ﻧﺴـﺘﻄﻴﻊ أن ﻧﺠﻌﻞ ﺗﺼـﻨﻴﻒ أﺧﺮ ﻳﺮث ﻣﻨﻪ ﻻﺑﺪ ﻣﻦ‬
‫وﺿﻊ ﻛﻠﻤﺔ ‪ open‬ﻋﻨﺪ إﻧﺸﺎﺋﻪ‪.‬‬

‫‪ v‬ﻣ ﺜﺎل‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪116‬‬

 § super class
open class person(){
var name:String? = null
var id :Int? = null

fun getInfo(){
println("The name is :$name your Id is : $id")
}

fun getId(id:Int){
println("your id is :$id")

}
}

‫إذا ﻧﻼﺣﻆ أﻧﻪ ﺗﺼـ ــــ ـﻨﻴﻒ ﻋﺎدي ﻗﻤﻨﺎ ﺑﺈﻧﺸـ ــــ ـﺎﺋﻪ ﻛﻤﺎ ﺗﻌﻠﻤﻨﺎ وﻟﻜﻦ ﻷن ﻫﻨﺎك ﺗﺼـ ــــ ـﻨﻴﻒ أﺧﺮ‬
.‫ﺳﻴﺮث ﻣﻨﻪ ﻓﻴﺠﺐ ﻋﻠﻴﻨﺎ ﺟﻌﻠﻪ ﻣﻔﺘﻮح ﻟﻴﺴﺘﻄﻴﻊ اﻟﻮارث أن ﻳﺼﻞ ﻟﻤﺤﺘﻮﻳﺎت ﻫﺬا اﻟﺘﺼﻨﻴﻒ‬

:‫أﻣﺎ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺘﺼﻨﻴﻒ اﻟﻮارث ﻓﻌﻠﻰ ﻫﺬا اﻟﻨﺤﻮ ﻳﺘﻢ ﻛﺘﺎﺑﺘﻪ‬

§ sub class
class Employee(): person()
{
var idj :Int?=null

fun printAllData(){
println("the ID for your job : $idj")
}

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 117 ‫اﻟﺼﻔﺤﺔ‬

 ‫}‬

‫ﻋﻨﺪ إﻧﺸـﺎء اﻟﺘﺼـﻨﻴﻒ ﻧﻘﻮم ﻓﻮرا ﺑﻌﻤﻠﻴﺔ اﻟﻮراﺛﺔ )(‪ class Employee(): person‬ﻧﻘﻄﺘﻴﻦ‬
‫رأﺳﻴﺘﻴﻦ وﻣﻦ ﺛﻢ اﺳﻢ اﻟﺘﺼﻨﻴﻒ اﻟﻤﻮروث‪.‬‬

‫‪ v‬ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬

‫ﻧﻘﻮم ﺑﺈﻧﺸﺎء ﻛﺎﺋﻦ ﻣﻦ ‪ class Employee‬وذﻟﻚ ﻟﺘﻮﺿﻴﺢ ﻛﻴﻒ ﺗﺘﻢ ﻋﻤﻠﻴﺔ اﻟﻮراﺛﺔ‪:‬‬

‫ﻧﺮى أن اﻟﻜﺎﺋﻦ اﻟﻤﺸـﺘﻖ ﻣﻦ ‪ class Employee‬اﺳـﺘﻄﺎع اﻟﻮﺻـﻮل إﻟﻰ ﻣﺤﺘﻮﻳﺎت ‪class‬‬

‫‪Person‬وﻫـﺬا اﻟﻐﺮض اﻟﺮﺋﻴﺴـ ــــــ ـﻲ ﻣﻦ ﻋﻤﻠﻴـﺔ اﻟﻮراﺛـﺔ أن اﻟﻜـﺎﺋﻦ ﻳﺴـ ــــــ ـﺘﻄﻴﻊ اﻟﻮﺻـ ــــــ ـﻮل إﻟﻰ‬
‫ﻣﺤﺘﻮﻳﺎت‪.super class‬‬

‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻮﺳﺎﺋﻂ اﻟﻤﻤﺮرة ﻟﻠﺘﺼﻨﻴﻒ‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪118‬‬

‫ﻟﻮ ﻛﺎن ‪ class Person‬ﻣﻤﺮر ﻟﻪ وﺳ ـﺎﺋﻂ وﻫﺬا اﻟﺸ ـﻲء ﻃﺒﻴﻌﻲ ﻛﻤﺎ ﺗﻌﺮﻓﻨﺎ ﻋﻠﻴﻪ ﻣﺴ ـﺒﻘﺎ‬
‫ﻋﻨﺪ إﻧﺸﺎء ﺗﺼﻨﻴﻒ ‪ ،‬ﻛﻴﻒ ﺳﻨﺘﻌﺎﻣﻞ ﻣﻌﻪ ﻓﻲ اﻟﻮراﺛﺔ ؟‬

‫اﻟﺠﻮاب ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫• ﻧﻘﻮم ﺑﺈﻧﺸـ ــ ـﺎء ت اﻟﺘﺼـ ـ ـﻨﻴﻒ اﻟﻤﻮروث او ﻣﺎ ﻧﺴـ ـ ـﻤﻴﻪ ﺑـ ـ ـ ـ ـ ـ ـ ـ ‪ super class‬وﻧﻤﺮر ﻟﻪ‬
‫وﺳﺎﺋﻂ‪ .‬ﻣﺜﺎل‪:‬‬

‫{)‪open class person(id :Int , name :String‬‬

‫‪var id:Int = id‬‬

‫‪var name :String = name‬‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫}‬

‫• ﻧﻘﻮم ﺑﺈﻧﺸﺎء ‪ sub class‬وﻧﻤﺮر ﻟﻪ أ ﻳﻀﺎ ﻧﻔﺲ اﻟﻮﺳﺎﺋﻂ اﻟﺬي ﺳﻴﺮﺛﻬﺎ‪ .‬ﻣﺜﺎل‪:‬‬

‫)‪class Employee(id :Int , name :String) : person(id , name‬‬

‫{‬
‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫}‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪119‬‬

‫ﻧﻼﺣﻆ ﻣﺮرﻧﺎ ﻧﻔﺲ اﻟﻮﺳـ ـﺎﺋﻂ ﻟﻠﺘﺼـ ـﻨﻴﻒ اﻟﺬي ﺳـ ـﻴﺮث وﻣﻦ ﺛﻢ وﺿـ ـﻌﻨﺎ اﺳـ ـﻢ اﻟﺘﺼـ ـﻨﻴﻒ‬
.‫اﻟﻤﻮروث وﻣﺮرﻧﺎ اﻟﻤﺘﻐﻴﺮات ﺑﺸﻜﻞ ﻃﺒﻴﻌﻲ ﺑﺪون ﺗﻌﺮ ﻳﻒ ﻟﻬﺎ أو ﻟﻨﻮﻋﻬﺎ‬

:‫ داﻟﺔ ﺑﻨﺎء‬constructor ‫ﺣﺴﻨﺎ ﻧﻔﺲ اﻟﺸﻲء ﻳﻨﻄﺒﻖ ﻟﻮ ﻛﺎن ﻟﺪي‬

§ super class
open class person{

var id:Int? = null

var name :String? = null

constructor(id:Int,name:String){
this.id = id
this.name=name
}

§ sub class
class Employee : person
{
constructor(id:Int,name:String):super(id , name){

this.id = id
this.name=name
}
}

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 120 ‫اﻟﺼﻔﺤﺔ‬

 ‫وﻧﻼﺣﻆ ﻫﻨﺎ أﻧﻨﺎ ﻗﻤﻨﺎ ﺑﺎﺳـ ـﺘﺨﺪام ﻛﻠﻤﺔ ‪ super‬ﻟﻴﺘﻀـ ـﺢ ﻟﻨﺎ أﻧﻬﺎ ‪ keywords‬ﻓﻲ ﻟﻐﺔ اﻟ ـ ـــــــــ ـ‬
‫‪ ،kotlin‬وﻧﻘﺼﺪ ﺑﻬﺎ ﻫﻨﺎ اﻟﻮﺻﻮل إﻟﻰ داﻟﺔ اﻟﺒﻨﺎء اﻟﺨﺎﺻﺔ ﺑﺎﻟﺘﺼﻨﻴﻒ اﻷب‪.‬‬

‫راﺑﻌﺎ ‪ :‬اﻟﻔﺮق ﺑﻴﻦ ‪ this‬و ‪super‬‬

‫اﻟﻔﺮق ﺑﺴﻴﻂ ﺟﺪا ً ‪:‬‬

‫ﻧﺴﺘﺨﺪم ‪ this‬ﻓﻲ اﻟﺘﺼﻨﻴﻒ ﻧﻔﺴﻪ وﻟﻠﺘﻌﺒﻴﺮ ﻋﻦ ﻣﺤﺘﻮﻳﺎﺗﻪ ﻛﻤﺎ ﺗﻌﻠﻤﻨﺎ ﻣﺴﺒﻘﺎ ً‪.‬‬

‫ﻧﺴـ ـــــ ـﺘﺨﺪم ‪ super‬ﻟﻠﻮﺻـ ـــــ ـﻮل إﻟﻲ ﻣﺤﺘﻮﻳﺎت اﻟﺘﺼـ ـــــ ـﻨﻴﻒ اﻷب أي أﻧﻪ ﺧﺎص ﺑﺎﻟﺘﺼـ ـــــ ـﻨﻴﻒ‬
‫اﻟﻤﻮروث ﻟﻠﻮﺻﻮل إﻟﻴﻪ‪.‬‬

‫‪interface‬‬

‫أوﻻ ً ‪ :‬ﺗﻤﻬﻴﺪ‬

‫ﻫﻞ ﻗﺪ ﺧﻄﺮ ﻓﻲ ﺑﺎﻟﻚ أﺛﻨﺎء ﺗﺼــﻤﻴﻢ ﻣﺸــﺮوﻋﻚ أﻧﻚ ﺗﻌﻠﻦ ﻋﻦ داﻟﺔ وﻟﻜﻦ ﻻ ﺗﻌﻠﻢ ﻣﺎ ﻟﺬي‬
‫ﺳـﺘﻀـﻌﻪ ﺑﺪاﺧﻠﻬﺎ أو أﻧﻚ ﺗﺮ ﻳﺪ اﻹﻋﻼن ﻓﻘﻂ وﺳـﺘﺴـﺘﺨﺪﻣﻬﺎ ﻻﺣﻘﺎ ً ؟ ﻓﻲ ﺑﻴﺌﺔ ‪ Kotlin‬ﻧﺴـﺘﻄﻴﻊ‬
‫ﻫﺬه اﻟﻌـﻨﺎﺻـ ــــــ ـﺮ ﺗﻤﻜﻨﻲ ﻣﻦ اﻹﻋﻼن ﻋﻦ‬
‫ﻣﺎ ‪ abstract‬أو ‪ ، interface‬ـ‬
‫ﻌﻞ ذـﻟﻚ ﻋﻦ ﻃﺮ ﻳﻖ إ ـ‬
‫ﻓ ـ‬
‫ﻣﺘﻐﻴﺮات ودوال ﺑـﺪون أن أ ﻛﺘـﺐ ﻗﻄﻊ ﺑﺮﻣﺠﻴـﺔ ﺑﻤﻌﻨﻰ أﻧﻲ ﻓﻘﻂ أﻋﺮف ﻋﻦ داﻟـﺔ وﻟﻜﻨﻲ ﻣـﺎ‬
‫ﺗﺘﻀﻤﻨﻪ ﻫﺬه اﻟﺪاﻟﺔ ﺳﺄؤﺟﻞ ﻛﺘﺎﺑﺘﻪ إﻟﻰ ﺣﻴﻦ أﺣﺘﺎﺟﻪ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪121‬‬

 ‫ﺛﺎﻧﻴﺎ ً ‪ :‬اﻟﺘﻌﺮﻳﻒ ﻋﻦ ‪interface‬‬

‫ﻛﻤﺎ ﻗﻠﻨﺎ ﺳﺎﺑﻘﺎ ﻧﺴﺘﻄﻴﻊ ﻓﻴﻪ اﻹﻋﻼن ﻋﻦ اﻟﺪوال اﻟﺘﻲ ﺳﺄﺳﺘﺨﺪﻣﻬﺎ ﻻﺣﻘﺎ ً‪.‬‬

‫{‪interface myInterface‬‬

‫}‬

‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻹﻋﻼن ﻓﻲ ‪interface‬‬

‫ﺳﻨﻮﺿﺢ اﻷن ﻛﻴﻔﻴﺔ ﺗﺠﻬﻴﺰ اﻟﻤﺘﻐﻴﺮات واﻻﻋﻼن ﻋﻨﻬﺎ وﻋﻦ اﻟﺪوال‪:‬‬

‫{‪interface myInterface‬‬

‫)(‪fun sum‬‬
‫)(‪fun sub‬‬
‫{)‪fun mul(num1:Int,num2:Int‬‬
‫‪var result = num1*num2‬‬
‫}‬
‫‪var num1:Int‬‬

‫}‬

‫اﻋﻠﻨﺎ ﻋﻦ داﻟﺔ ﺟﻤﻊ وﻟﻜﻦ ﺑﺪون أن ﻧﺒﻨﻲ اﻟﻘﻄﻌﺔ اﻟﺒﺮﻣﺠﻴﺔ اﻟﺨﺎﺻﺔ ﺑﻬﺎ‪.‬‬

‫أ ﻳﻀﺎ اﻋﻠﻨﺎ ﻋﻦ داﻟﺔ اﻟﻄﺮح وﻟﻢ ﻧﺴﺘﺨﺪﻣﻬﺎ أ ﻳﻀﺎ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪122‬‬

‫اﻋﻠﻨ ـﺎ ﻋﻦ داﻟ ـﺔ اﻟﻀـ ــــــ ـﺮب وﻗﻤﻨ ـﺎ ﺑﺒﻨ ـﺎﺋﻬ ـﺎ وﺗﻤﺮ ﻳﺮ ﻗﻴﻢ ووﺿـ ــــــ ـﺤﻨ ـﺎ ﻋﻤﻠﻬ ـﺎ وﻫ ـﺬا ﻳ ـﺪل ان‬
‫‪interface‬ﻟﻴﺲ ﺣﻜﺮا ﻓﻘﻂ ﻟﺘﺠﻬﻴﺰ اﻟـﺪوال واﻟﻤﺘﻐﻴﺮات أ ﻳﻀـ ــــــ ـﺎ ﻧﺴـ ــــــ ـﺘﻄﻴﻊ ﺑﻨـﺎء داﻟـﺔ ﻛـﺎﻣﻠـﺔ‪،‬‬
‫وﻟﻜﻦ اﻻﺧﺘﻼف ﻳﻜﻤﻦ ﻓﻲ ﻃﺮ ﻳﻘﺔ اﻟﻌﻤﻞ اﻟﺘﻲ ﺳﻨﻮﺿﺤﻬﺎ ﺑﻌﺪ ﻗﻠﻴﻞ‪.‬‬

‫اﻟﻤﺘﻐﻴﺮات اﻟﺘﻲ ﻳﺘﻢ ﺗﻌﺮ ﻳﻔﻬﺎ ﺑﺪاﺧﻞ ‪ interface‬ﻻ ﻳﺘﻢ اﺳـ ـــــ ـﻨﺎد ﻗﻴﻢ ﻟﻬﺎ اﺑﺪا ‪ ،‬ﻛﻤﺎ ﻻﺣﻈﻨﺎ‬
‫ﻋﺮﻓﻨﺎ ﻣﺘﻐﻴﺮ وﻟﻢ ﻧﺴﻨﺪ ﻟﻪ ﻗﻴﻢ‪.‬‬

‫راﺑﻌﺎ ً ‪ :‬اﺳﺘﺨﺪام ‪interface‬‬

‫‪ Interface‬ﻻ ﻳﺘﻢ اﺳـ ــــ ـﺘﺨﺪاﻣﻬﺎ ﻣﺒﺎﺷـ ــــ ـﺮة ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴـ ــــ ـﻴﺔ وإﻧﻤﺎ ﻧﺴـ ــــ ـﺘﺨﺪﻣﻬﺎ ﺑﻌﻤﻠﻴﺔ‬
‫‪implements‬وﻫﻲ ﺑﺎﻟﻀﺒﻂ ﻣﻤﺎﺛﻠﺔ ﻟﻌﻤﻠﻴﺔ اﻟﻮراﺛﺔ‪ ،‬ﻫﻜﺬا‪:‬‬

‫ﻧﺮى أﻧﻪ ﻋﻨﺪﻣﺎ ﺟﻌﻠﻨﺎ اﻟﺘﺼ ـﻨﻴﻒ ﻳﺮث ﻣﻦ اﻟ ـ ـــــــ ـ ‪ interface‬ﻗﺎم ﺑﻮﺿـﻊ ﺧﻂ اﺣﻤﺮ ‪ ،‬ﻟﻤﺎذا ؟‬
‫ﻌﺪ ـﻓﺈﺟـﺒﺎري أن‬
‫ﻌﻞ اﻟﺘﺼـ ــــــ ـﻨﻴﻒ ﻳﺮث ﻣﻦ ‪ interface‬وـﺑﺪاﺧـﻠﻪ دوال ﻟﻢ ﺗﺒﻨﻰ ﺑ ـ‬
‫ﻣ ﺎ ﺗﺠ ـ‬
‫ﻷـﻧﻪ ﻋﻨـﺪ ـ‬
‫ﺗﺪرﺟﻬﻢ ﺑﺪاﺧﻞ اﻟﺘﺼـ ـــــ ـﻨﻴﻒ ﻛﻠﻬﻢ أو أﺣﺪﻫﻢ ﻋﻠﻰ اﻷﻗﻞ‪ ،‬ﺣﺴـ ـــــ ـﻨﺎ وﻟﻜﻦ ﻛﻴﻒ ﻳﻌﻨﻲ ادرﺟﻬﻢ ؟‬
‫ﺑﻤﻌﻨﻰ أن ﺗﻘﻮم ﺑﻌﻤﻞ ‪ override‬ﻟﻠﺪاﻟﺔ ﻛﻤﺎ ﺗﻌﻠﻤﻨﺎ ﻣﺴﺒﻘﺎ‪ ،‬ﺳﻨﻮﺿﺢ ذﻟﻚ اﻷن‪:‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪123‬‬

‫• ﺑﻌﺪ اﻟﻀـﻐﻂ ﻋﻠﻴﻬﺎ ﻧﻼﺣﻆ أن ﻳﻄﻠﺐ‪implement as constructor parameters‬‬
‫ﻓﻲ أول ﻣﺮة وﻳﻘﺼـ ـــ ـﺪ ﺑﻪ أﻧﻨﺎ ﻋﺮﻓﻨﺎ ﻣﺘﻐﻴﺮ ﻓﻲ ‪ interface‬ﻓﻬﻨﺎ ﻳﺠﺐ ﻓﻲ اﻟﺘﺼـ ـــ ـﻨﻴﻒ‬
‫اﻟﻮارث ان ﻧﺴﺘﺨﺪﻣﻪ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪124‬‬

 ‫ﺑﻌﺪ إدراج اﻟﻤﺘﻐﻴﺮ‪:‬‬

‫{‪class operations(override var num1: Int) :myInterface‬‬

‫}‬
‫• ‪ implement members‬وﻫﻮ ﻳﻌﻨﻲ ﻗﻢ ﺑﺈﺿـ ـﺎﻓﺔ اﻟﺪوال اﻟﺘﻲ ﻋﺮﻓﺘﻬﺎ وﻟﻢ ﺗﺴـ ـﺘﺨﺪﻣﻬﺎ ‪،‬‬
‫وﻫﻨـﺎ ﻧﻨﻮه ﺑـﺄﻧـﻪ إﺟﺒـﺎري اﺳـ ــــــ ـﺘﺨـﺪاﻣﻬـﺎ وﻛﺘـﺎﺑﺘﻬـﺎ ﺑﻤـﺎ أﻧـﻚ ﻗﻤـﺖ ﺑﺠﻌـﻞ اﻟﺘﺼـ ــــــ ـﻨﻴﻒ ﻳﺮث‬
‫ﻣﻦ ‪ ،interface‬أﻣﺎ اﻟﺪاﻟﺔ اﻟﺠﺎﻫﺰة اﻟﺨﺎﺻـﺔ ﺑﻌﻤﻠﻴﺔ اﻟﻀـﺮب ﻓﻨﺤﻦ ﺑﻨﻴﻨﺎﻫﺎ ﻓﻲ ‪interface‬‬
‫ﻓﻠﻚ اﻟﺤﺮ ﻳﺔ ﺑﺄن ﺗﺴﺘﺪﻋﻴﻬﺎ ﻓﻲ اﻟﺘﺼﻨﻴﻒ أو ﻻ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪125‬‬

 :‫ﺑﻌﺪ إدراج اﻟﺪوال‬

class operations(override var num1: Int) :myInterface{

override fun sub() {
TODO("not implemented") //To change body of created functions
use File | Settings | File Templates.
}

override fun sum() {

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 126 ‫اﻟﺼﻔﺤﺔ‬

 TODO("not implemented") //To change body of created functions
use File | Settings | File Templates.
}

interface ‫ ﻣﺜﺎل‬: ً ‫ﺧﺎﻣﺴﺎ‬

interface myInterface{

fun sum(num1:Int,num2:Int)
fun sub(num1:Int,num2:Int)
fun mul(num1:Int,num2:Int){
var result = num1*num2
println("the result :$result")
}

class operations:myInterface{
override fun sub(num1:Int,num2:Int) {
var result = num1 - num2
println("the result :$result")
}

override fun sum(num1:Int,num2:Int) {

var result = num1 + num2
println("the result :$result")
}

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 127 ‫اﻟﺼﻔﺤﺔ‬

 fun dev(num1:Int,num2:Int){
var result = num1 / num2
println("the result :$result")
}

fun main(args:Array<String>){
var op1 = operations()
println("the result of sum :")
op1.sum(4,3)
println("the result of sub :")
op1.sub(4,3)
println("the result of mul :")
op1.mul(3,4)
println("the result of dev :")
op1.dev(4,3)
}

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
the result of sum :
the result :7
the result of sub :
the result :1
the result of mul :
the result :12
the result of dev :
the result :1

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 128 ‫اﻟﺼﻔﺤﺔ‬

 ‫‪abstract‬‬

‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم اﻟـ ‪abstract‬‬

‫ﻧﺴـ ــــــ ـﺘﻄﻴﻊ ﻓﻴـﻪ ﺟﻌـﻞ اﻟـﺪوال واﻟﻤﺘﻐﻴﺮات ﻣﻌﻠﻨـﺔ ﻓﻘﻂ وﻟﻜﻦ ﺑﺸـ ــــــ ـﺮط أن ﻧﻀـ ــــــ ـﻊ ﻛﻠﻤـﺔ‬
‫‪abstract‬أﻣﺎﻣﻬﺎ ‪ ،‬ﺑﻤﻌﻨﻰ أن اﻟﺪوال ﻓﻲ ‪ interface‬ﻛﻨﺎ ﻧﺴـ ــــ ـﺘﻄﻴﻊ أن ﻧﻌﻠﻦ ﻋﻨﻬﺎ ﻓﻘﻂ ﺑﺪون‬
‫أن ﻧﻨﺸـ ــ ـﺊ ﻗﻄﻌﺔ ﺑﺮﻣﺠﻴﺔ ﻟﻬﺎ ﻷﻧﻨﺎ ﺳـ ــ ـﻨﻘﻮم ﺑﺬﻟﻚ ﻓﻲ ﺗﺼـ ــ ـﻨﻴﻒ أﺧﺮ ‪ ،‬ﻫﻨﺎ أ ﻳﻀـ ــ ـﺎ ﻧﺴـ ــ ـﺘﻄﻴﻊ أن‬
‫ﻧﻌﻠﻦ ﻓﻘﻂ ﻋﻦ اﻟﺪاﻟﺔ ﺑﺪاﺧﻞ ﻫﺬا اﻟﺘﺼـ ــــ ـﻨﻴﻒ وﻟﻜﻦ ﻳﺸـ ــــ ـﺘﺮط أن ﻧﻀـ ــــ ـﻊ ﻛﻠﻤﺔ ‪ abstract‬ﻷن‬
‫اﻟﺘﺼﻨﻴﻒ أﺻﻼ ﻫﻮ‪abstract .‬‬

‫ﺛﺎﻧﻴﺎ ً ‪ :‬اﺳﺘﺨﺪام اﻟـ ‪abstract‬‬

‫ﻫﻮ ﻋﺒﺎرة ﻋﻦ ﺗﺼـ ــــ ﻨﻴﻒ ‪ class‬وﻟﻜﻨﻪ ﻻ ﻳﻘﺒﻞ أن ﻧﻨﺸـ ــــ ﺊ ﻣﻨﻪ ﻛﺎﺋﻦ ‪ ،‬ﺗﺼـ ــــ ﻨﻴﻒ ﻧﺼـ ــــ ﻤﻤﻪ‬
‫ﻟﻠﻮراﺛﺔ )أي ﻟﻨﺠﻌﻞ ﺟﻤﻴﻊ ﻣﺤﺘﻮﻳﺎﺗﻪ ﻗﺎﺑﻠﺔ ﻟﻠﻮراﺛﺔ ﻟﺘﺼﻨﻴﻔﺎت أﺧﺮى(‪.‬‬

‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻧﺸﺎء ﺗﺼﻨﻴﻒ ‪abstract‬‬

‫{‪abstract class operation‬‬

‫}‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪129‬‬

‫أﻧﺸـ ــــــ ـﺄـﻧﺎ ﺗﺼـ ــــــ ـﻨﻴﻒ ‪ abstract‬إذا ـﻣﺎ ـﺑﺪاﺧـﻠﻪ ﻣﻦ دوال ﻟﻜﻲ ﻳﺘﻢ اﻹﻋﻼن ﻋﻨـﻬﺎ ﻓﻘﻂ ـﺑﺪون‬
‫ﻋﻤﻠﻴﺔ ﺑﻨﺎء ﻟﻬﺎ ﻧﺠﻌﻠﻬﺎ ‪ abstract‬ﻛﻤﺎ ﺳﻴﺘﻢ ﺗﻮﺿﻴﺤﻪ اﻵن‪:‬‬

‫{‪abstract class operation‬‬

‫)‪abstract fun sum(num1:Int , num2:Int‬‬

‫)‪abstract fun sub(num1:Int , num2:Int‬‬
‫)‪abstract fun mul(num1:Int , num2:Int‬‬
‫)‪abstract fun dev(num1:Int , num2:Int‬‬

‫}‬

‫ﺣﺴﻨﺎ ﻟﻮ أردﻧﺎ ﺗﻌﺮ ﻳﻒ اﻟﻤﺘﻐﻴﺮات‪:‬‬

‫ﻧﺮى أـﻧﻪ ﻋـﻨﺪـﻣﺎ أردـﻧﺎ ﺗﻌﺮ ﻳﻒ ﻣﺘﻐﻴﺮ اﻋﺘﺮض ووﺿـ ــــــ ـﻊ ﺧﻂ أﺣﻤﺮ وﻋـﻨﺪ اﻟﻮﻗﻮف ﻋﻠـﻴﻪ ﻇﻬﺮ‬
‫اﻟﺴـ ــــــ ـﺒـﺐ وﻫﻮ أﻧـﻪ ﻋﻨـﺪﻣـﺎ ﺗﺮ ﻳـﺪ ﺗﻌﺮ ﻳﻒ ﻣﺘﻐﻴﺮ إﻣـﺎ أن ﺗﺠﻌـﻞ ﻟـﻪ ﻗﻴﻤـﺔ ﻣﺒـﺪﺋﻴـﺔ أو أن ﺗﺠﻌﻠـﻪ‬
‫‪abstract‬ﻟﻜﻲ ﺗﺴﺘﻄﻴﻊ أﻻ ﺗﺴﻨﺪ ﻟﻪ ﻗﻴﻤﺔ أي ﻳﻌﻨﻲ ﺳﻮف ﺗﺴﺘﺨﺪﻣﻪ وﺗﺴﻨﺪ ﻟﻪ ﻓﻴﻤﺎ ﺑﻌﺪ‪.‬‬

‫راﺑﻌﺎ ً ‪ :‬ﻣﺜﺎل‬

‫{‪abstract class operation‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪130‬‬

 abstract fun sum(num1:Int , num2:Int)
abstract fun sub(num1:Int , num2:Int)
abstract fun mul(num1:Int , num2:Int)
abstract fun dev(num1:Int , num2:Int)

fun sayWelcome(){
println("Welcome")
}

class oper : operation(){

override fun dev(num1: Int, num2: Int) {

var result = num1 / num2
println("the result :$result")
}

override fun mul(num1: Int, num2: Int) {

var result = num1 * num2
println("the result :$result")
}

override fun sub(num1: Int, num2: Int) {

var result = num1 - num2
println("the result :$result")
}

override fun sum(num1: Int, num2: Int) {

var result = num1 + num2

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 131 ‫اﻟﺼﻔﺤﺔ‬

 println("the result :$result")
}

fun main(args:Array<String>){
var op1 = oper()
println("the result of sum :")
op1.sum(4,3)
println("the result of sub :")
op1.sub(4,3)
println("the result of mul :")
op1.mul(3,4)
println("the result of dev :")
op1.dev(4,3)

println("---------------------------")
op1.sayWelcome()

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
the result of sum :
the result :7
the result of sub :
the result :1
the result of mul :
the result :12

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 132 ‫اﻟﺼﻔﺤﺔ‬

the result of dev :
the result :1
---------------------------
Welcome

multi inheritance ‫ ﻣﺒﺪأ اﻟﻮراﺛﺔ اﻟﻤﺘﻌﺪدة‬: ً ‫ﺧﺎﻣﺴﺎ‬

‫ وﻟﻜﻦ ﻟﻐﺔ‬classes ‫ ﻳﺮث أ ﻛﺜﺮ ﻣﻦ ﺗﺼـ ـــ ـﻨﻴﻒ‬class ‫اﻟﻮراﺛﺔ اﻟﻤﺘﻌﺪدة ﺗﻌﻨﻲ أن ﺗﺼـ ـــ ـﻨﻴﻒ‬
.‫ﺗﺮﻓﺾ ﻣﺒﺪأ اﻟﻮراﺛﺔ اﻟﻤﺘﻌﺪدة وﻟﺤﻞ ﻫﺬه اﻟﻤﻌﻀﻠﺔ‬kotlin

‫ وﻫﻲ ﻣﺎﺗﻌﻠﻤﻨﺎه ﻣﺴـ ــ ـﺒﻘﺎ ﺑﺤﻴﺚ ﻧﺴـ ــ ـﺘﻄﻴﻊ أن ﻧﻨﺸـ ــ ـﺊ ﺗﺼـ ــ ـﻨﻴﻒ‬interface ‫وﺟﺪت ﻟﺪﻳﻨﺎ‬
:‫ ﻣﺜﺎل‬،interface ‫ ﻟـ‬implements ‫ وأ ﻳﻀﺎ ﻧﻘﻮم ﺑﻌﻤﻞ‬class ‫ﻳﺮث ﻣﻦ ﺗﺼﻨﻴﻒ‬class

interface showDepartment{
fun showDept()
}

abstract class salary{

abstract fun getSal()
}

class employee : salary(), showDepartment{

override fun showDept() {
}
override fun getSal() {
}
}

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 133 ‫اﻟﺼﻔﺤﺔ‬

 ‫‪Override‬‬

‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم ‪Override‬‬

‫ﺗﻜﻤﻦ أﻫﻤﻴﺔ ﻫﺬا اﻟﻤﻔﻬﻮم ﺑﺄﻧﻪ ﺗﺘﻴﺢ ﻟﻨﺎ اﻟﻔﺮﺻـ ـــ ـﺔ ﺑﺄن ﻧﻨﺸـ ـــ ـﺊ داﻟﺔ ﻓﻲ اﻟﺘﺼـ ـــ ـﻨﻴﻒ اﻟﻮارث‬
‫ﻫﻲ ﻧﻔﺴـ ــ ـﻬﺎ ﻣﻮﺟﻮدة ﻓﻲ اﻟﺘﺼـ ــ ـﻨﻴﻒ اﻟﻤﻮروث ‪ ،‬ﻟﺘﺒﺴـ ــ ـﻴﻂ اﻷﻣﺮ ﻓﻠﻨﻔﺘﺮض أن ﻟﺪﻳﻨﺎ ﺗﺼـ ــ ـﻨﻴﻒ‬
‫‪class Person‬وﺑﺪاﺧﻠﻪ داﻟﺔ ﺗﻘﻮم ﺑﺎﻟﻄﺒﺎﻋﺔ‪:‬‬

‫• ﻳﺘﻮﺟﺐ ﻋﻠﻴﻨﺎ أن ﻧﺠﻌﻞ اﻟﺪاﻟﺔ ﻓﻲ اﻟﺘﺼﻨﻴﻒ اﻟﻤﻮروث ‪.open‬‬

‫{)(‪open class Person‬‬

‫{)‪open fun getInfo(name:String‬‬

‫)"‪println("welcome $name‬‬
‫}‬
‫{)(‪fun printWelcome‬‬
‫)"‪println("welcome‬‬
‫}‬

‫}‬

‫وﻟﺪي اﻟﺘﺼـ ـــ ـﻨﻴﻒ اﻟﻮارث ‪ class Employee‬ﻳﺮث ﺟﻤﻴﻊ ﻣﺤﺘﻮﻳﺎت ‪ class Person‬وﺑﻤﺎ‬
‫أﻧﻪ ﻳﺮﺛﻬﺎ ﻓﻬﺬا ﻳﻌﻨﻲ أﻧﻪ ﺳـ ـــ ـﻴﻤﻨﻌﻨﻲ ﻣﻦ ﺗﻜﺮار ﻧﻔﺲ ﻣﺴـ ـــ ـﻤﻰ اﻟﺪاﻟﺔ وﻟﻜﻦ ﻟﺘﺠﻨﺐ ﻫﺬا اﻷﻣﺮ‬
‫ﻧﺴﺘﺨﺪم ﻣﻔﻬﻮم ‪:override‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪134‬‬

‫{)(‪class Employee():Person‬‬

‫{)‪override fun getInfo(jobTitle:String‬‬

‫)" ‪println(" your job title :$jobTitle‬‬
‫}‬
‫}‬
‫• ﻧﻼﺣﻆ أن اﻟﺪاﻟﺔ اﻟﻤﻮﺟﻮدة ﺑﺪاﺧﻞ اﻟﺘﺼـ ـﻨﻴﻒ ‪ class Employee‬ﻫﻲ ﻧﻔﺴـ ـﻬﺎ اﻟﻤﻮﺟﻮدة‬
‫ﺼﻨﻴﻒ اﻟﻤﻮروث ‪ class Person‬وﻛﺘﺒﻨﺎ ﻗﺒﻠﻬﺎ ﻛﻠﻤﺔ ‪ override‬وﻫﺬا ﻳﻌﻨﻲ أﻧﻪ‬
‫ﺑﺪاﺧﻞ اﻟﺘ ـ‬
‫ﻋﻨﺪ إﻧﺸـﺎء ﻛﺎﺋﻦ ﻣﻦ ﻫﺬا اﻟﺘﺼـﻨﻴﻒ ﻟﻦ ﻳﺴـﺘﻄﻴﻊ اﻟﻮﺻـﻮل إﻟﻰ اﻟﺪاﻟﺔ ‪ getInfo‬اﻟﻤﻮﺟﻮدة‬
‫ﻓﻲ ‪.class Person‬‬
‫• ﻧﺮ ﻳـﺪ اﻟﺘﻮﺿـ ــــــ ـﻴﺢ ﺑـﺄﻧﻨـﺎ ﻟﻮ أردﻧـﺎ اﻟـﺪاﻟـﺔ أن ﺗﻨﻔـﺬ ﻧﻔﺲ اﻷواﻣﺮ وﻟﻜﻦ ﻧﺮ ﻳـﺪ اﻟﺰ ﻳـﺎدة ﻋﻠﻴﻬـﺎ‬
‫ﺑﻤﻌﻨﻰ أن اﻟـﺪاﻟـﺔ ﻻ ﺗﻜﺘﻔﻲ ﻓﻘﻂ ﺑـﺎﻷواﻣﺮ اﻟﺒﺮﻣﺠﻴـﺔ اﻟﺘﻲ ﺗﻤـﺖ ﻛﺘـﺎﺑﺘﻬـﺎ ﻓﻲ اﻟﺘﺼـ ــــــ ـﻨﻴﻒ‬
‫اﻟﻤﻮروث وإﻧﻤﺎ ﻧﺮ ﻳﺪ أن ﻧﻀﻴﻒ أواﻣﺮ أﺧﺮى‪:‬‬
‫{)(‪open class Employee():Person‬‬
‫{)‪final override fun getInfo(jobTitle:String‬‬
‫)"‪super.getInfo("Ahmed‬‬
‫)" ‪println(" your job title :$jobTitle‬‬
‫}‬
‫}‬

‫§ ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪135‬‬

‫إذا ﻧﻼﺣﻆ أﻧﻪ ﻳﺴﺘﻄﻴﻊ اﻟﻮﺻﻮل ﻷي داﻟﺔ ﻣﺎﻋﺪا ﺗﻠﻚ اﻟﺘﻲ ﻋﻤﻠﻨﺎ ﻟﻬﺎ ‪ override‬ﺣﻴﻨﻬﺎ ﻟﻦ‬
‫ﻳﺴﺘﻄﻴﻊ اﻟﻮﺻﻮل إﻻ ﻟﻠﺪاﻟﺔ اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﺘﺼﻨﻴﻒ ‪.class Employee‬‬

‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﻛﻠﻤﺔ ‪final‬‬

‫اﺳـ ـــــ ـﺘﺨﺪام ﻫﺬه اﻟﻜﻠﻤﺔ ﻣﻊ اﻟﺘﺼـ ـــــ ـﻨﻴﻒ ﻳﻌﻨﻲ أﻧﻪ ﻏﻴﺮ ﻗﺎﺑﻞ ﻟﻠﻮراﺛﺔ وﻫﺬا اﻟﺸـ ـــــ ـﻲء ﻳﺮﺟﻊ‬
‫ﻻﺧﺘﻴﺎراﺗﻚ اﻟﺸـ ــ ـﺨﺼـ ــ ـﻴﺔ ﻓﻨﺤﻦ ﻟﻨﺠﻌﻞ اﻟﺘﺼـ ــ ـﻨﻴﻒ ﻳﻘﺒﻞ اﻟﻮراﺛﺔ ﻻﺑﺪ ﻣﻦ وﺿـ ــ ـﻊ ﻛﻠﻤﺔ ‪،open‬‬
‫ﻛﺬﻟﻚ ﻣﻦ أﺟﻞ ﺟﻌﻠﻪ ﺗﺼـ ــ ـﻨﻴﻒ ﻧﻬﺎﺋﻲ ﻏﻴﺮ ﻗﺎﺑﻞ ﻟﻠﻮراﺛﺔ ﻧﻀـ ــ ـﻊ ‪ ،final‬وﻳﻨﻄﺒﻖ ﻧﻔﺲ اﻟﺸـ ــ ـﻲء‬
‫ﻋﻠﻰ اﻟﺪوال‪.‬‬

‫ﻣﺜﺎل‪:‬‬

‫{)(‪open class Employee():Person‬‬

‫{)‪final override fun getInfo(jobTitle:String‬‬

‫)"‪super.getInfo("Ahmed‬‬
‫)" ‪println(" your job title :$jobTitle‬‬
‫}‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪136‬‬

 ‫}‬

‫ﻫﻨﺎ ﺟﻌﻠﻨﺎ ﻫﺬه اﻟﺪاﻟﺔ ﻻ ﺗﻘﺒﻞ أن ﺗﻜﻮن ﻣﺮة أﺧﺮى ﻓﻴﻤﺎ ﺑﻌﺪ ‪ ،override‬ﺑﻤﻌﻨﻰ ﻟﻮ أﻧﺸﺄت‬
‫ﺗﺼـ ـــــ ـﻨﻴﻒ أﺧﺮ ﺟﺪﻳﺪ ﻓﻴﻤﺎ ﺑﻌﺪ وأردت أن أﺟﻠﺐ اﻟﺪاﻟﺔ ﻧﻔﺴـ ـــــ ـﻬﺎ ﻋﻦ ﻃﺮ ﻳﻖ ‪ ، override‬ﻓﻠﻦ‬
‫ﻧﺴﺘﻄﻴﻊ وذﻟﻚ ﻷﻧﻬﺎ ‪.final‬‬

‫‪Overload‬‬

‫ﻓﻲ ﺑﻌﺾ اﻷﺣﻴﺎن ﻧﺼـﺎدف أ ﻛﺜﺮ ﻣﻦ ﺷـﺨﺺ ﻳﺤﻤﻠﻮن ﻧﻔﺲ اﻻﺳـﻢ وﻟﻬﻢ ﻧﻔﺲ اﺳـﻢ اﻷب‬
‫وﻟﻠﻤﺼـ ـﺎدﻓﺔ أ ﻳﻀـ ـﺎ ﻧﻔﺲ اﺳـ ـﻢ اﻟﻌﺎﺋﻠﺔ ﺻـ ـﺤﻴﺢ وﻟﻜﻨﻚ ﺗﺴـ ـﺘﻄﻴﻊ اﻟﺘﻔﺮ ﻳﻖ ﺑﻴﻦ ﺻـ ـﺪﻳﻘﻚ أي‬
‫واﺣﺪ ﻫﻮ ﻣﻨﻬﻢ وذﻟﻚ ﻷﻧﻪ ﻳﻤﺘﻠﻚ ﺧﺼـﺎﺋﺺ ﺧﺎﺻـﺔ ﺑﻪ وﺳـﻤﺎت ﺗﺪل ﻋﻠﻰ أﻧﻪ ﻫﻮ اﻟﻤﻘﺼـﻮد ‪،‬‬
‫أ ﻳﻀـ ـــــ ـﺎ ﻧﻔﺲ اﻟﺸـ ـــــ ـﻲء ﻳﺤﺪث ﻟﺪﻳﻨﺎ ﻋﻨﺪ اﻟﺒﺮﻣﺠﺔ ﺗﻮاﺟﺪ أ ﻛﺜﺮ ﻣﻦ داﻟﺔ ﻟﻬﻢ ﻧﻔﺲ اﻟﻤﺴـ ـــــ ـﻤﻰ‬
‫ﺑﺎﻟﻀ ـﺒﻂ ﻧﺴ ـﻤﻴﻪ ‪ overload‬وﻟﻜﻦ ﻟﻨﺮﻛﺰ اﻧﺘﺒﺎﻫﻨﺎ ﻗﻠﻴﻼ اﻧﻪ ﻫﺬه اﻟﺪوال ﻓﻘﻂ ﻟﻬﻢ ﻧﻔﺲ اﻻﺳ ـﻢ‬
‫وﻟﻜﻦ ﻳﺨﺘﻠﻔﻮن ﻣﻦ ﺣﻴﺚ ﺗﻤﺮ ﻳﺮ اﻟﻤﺘﻐﻴﺮات وﻧﻮع اﻟﺪاﻟﺔ ﻫﻞ ﺗﺮﺟﻊ ﺑﻘﻴﻤﺔ ام ﻻ وﻫﻜﺬا‪.‬‬

‫ﻣﺜﺎل‪:‬‬

‫{‪fun sum(a:Int , b:Int):Int‬‬

‫‪return a+b‬‬
‫}‬

‫{‪fun sum(a:Float, b:Float):Float‬‬

‫‪return a+b‬‬
‫}‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪137‬‬

‫اﻧﺸـ ـــــــ ـﺄﻧـﺎ داﻟﺘﻴﻦ ﻟﻬﻢ ﻧﻔﺲ اﻟﻤﺴـ ــــــ ـﻤﻰ وﻟﻜﻦ ﻛـﻞ واﺣـﺪة ﻣﻨﻬﻢ ﺗﺨﺘﻠﻒ ﻣﻦ ﺣﻴـﺚ ﻧﻮع‬
‫اﻟﻤﺘﻐﻴﺮات اﻟﻤﻤﺮرة ‪ ،‬أ ﻳﻀ ـﺎ ﻛﺎن ﺑﺎﻹﻣﻜﺎن ﺗﻌﺮ ﻳﻒ اﻟﺪاﻟﺔ اﻟﺜﺎﻧﻴﺔ وان ﻧﻮع اﻟﻤﺘﻐﻴﺮات ‪ int‬وﻟﻜﻦ‬
‫ﺑﺪل ﻣﻦ أن ﺗﻘﻮم ﺑﺠﻤﻊ ﻣﺘﻐﻴﺮ ﻳﻦ ﺗﻘﻮم ﻣﺜﻼ ﺑﺠﻤﻊ أ ﻛﺜﺮ‪.‬‬

‫§ ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬

‫ﻧﻼﺣﻆ أﻧﻪ ﻋﻨﺪﻣﺎ اردﻧﺎ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ﺑﺎﺳﻤﻬﺎ ﻃﻠﺐ ﻣﻨﺎ ان ﻧﺤﺪد أي داﻟﺔ ﻣﻨﻬﻢ ﻫﻞ اﻟﺘﻲ‬
‫ﻣﺘﻐﻴﺮاﺗﻬﺎ ‪ Int‬او ﺗﻠﻚ اﻟﺘﻲ ﻣﺘﻐﻴﺮاﺗﻬﺎ ‪.Float‬‬

‫{)>‪fun main(args:Array<String‬‬

‫)‪var result = sum(4,9‬‬

‫)"‪println ("the first function result is : $result‬‬
‫)‪var result1 = sum(2.3f,1.9f‬‬
‫)"‪println ("the second function result is : $result1‬‬

‫}‬

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
‫‪the first function result is : 13‬‬
‫‪the second function result is : 4.2‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪138‬‬

‫ﻣﻔﻬﻮم ‪ overload‬ﻧﺴ ـﺘﻄﻴﻊ ﺗﻨﻔﻴﺬه ﺣﺘﻰ ﺑﺪاﺧﻞ اﻟﺘﺼ ـﻨﻴﻒ ﻓﻴﻤﻜﻨﻨﺎ ﻣﻦ إﻧﺸ ـﺎء أ ﻛﺜﺮ ﻣﻦ‬
‫داﻟﺔ ﺑﻨﺎء وﻟﻜﻦ ﻣﻊ ﻣﺮاﻋﺎة ﻣﺎ ذﻛﺮﻧﺎه ﺳﺎﺑﻘﺎ‪.‬‬

‫‪Companion object‬‬

‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم ‪companion object‬‬

‫ﻫـﺬا اﻟﻤﻔﻬﻮم ﻳﻌﺒﺮ ﻋﻦ إﻣﻜـﺎﻧﻴـﺔ وﺻـ ــــــ ـﻮﻟـﻚ ﻟـﺪوال و ﻣﺘﻐﻴﺮات ﻣﻌﻴﻨـﺔ ﺗﻢ ﺗﻌﺮ ﻳﻔﻬـﺎ ﺑـﺪاﺧـﻞ‬
‫اﻟﺘﺼـ ــ ـﻨﻴﻒ ﺑﺪون اﺷـ ــ ـﺘﻘﺎق ﻛﺎﺋﻦ‪ ،‬ﻫﺬه اﻟﻤﺘﻐﻴﺮات ﻋﻤﻠﻬﺎ ﻣﺴـ ــ ـﺘﻘﻞ ﻋﻦ ﻣﺎ ﺑﺪاﺧﻞ اﻟﺘﺼـ ــ ـﻨﻴﻒ‬
‫ﻳﻌﻨﻲ أﻧﻨﻲ اﻧﺸـ ـــ ـﺄﺗﻬﺎ ﻟﻌﻤﻞ ﻣﻌﻴﻦ ﺑﺪون ان ﺗﺮﺗﺒﻂ ﺑﺎﻟﻤﺘﻐﻴﺮات اﻷﺧﺮى أو اﻟﺪوال اﻟﺘﻲ ﺑﺪاﺧﻞ‬
‫اﻟﺘﺼﻨﻴﻒ‪ ،‬وﻳﺘﻢ ﺗﻌﺮ ﻳﻒ ﻫﺬه اﻟﻤﺘﻐﻴﺮات واﻟﺪوال ﺑﺪاﺧﻞ ﻗﻄﻌﺔ ﺑﺮﻣﺠﻴﺔ ﺗﺴﻤﻰ ‪companion‬‬
‫‪.object‬‬

‫ﺛﺎﻧﻴﺎ ِ ‪ :‬ﻃﺮﻳﻘﺔ ﻛﺘﺎﺑﺘﻪ‬

‫{ ‪companion object‬‬

‫}‬

‫ﺛﺎﻟﺜﺎ ً ‪ :‬ﻣﺜﺎل‬

‫{ ‪class labtop‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪139‬‬

 ‫{ ‪companion object‬‬
‫{)(‪fun sayHello‬‬
‫)"‪println("Welcome in my project‬‬
‫}‬
‫}‬
‫‪var serialNum:Int = 0‬‬
‫" " = ‪var company:String‬‬
‫{)(‪fun getData‬‬
‫‪println(" labtop : $company \n the serial number is :‬‬
‫)"‪$serialNum‬‬
‫}‬

‫}‬

‫ﺳـ ــ ـﺘﻼﺣﻆ ﺑﺄﻧﻬﺎ ﻗﻄﻌﺔ ﺑﺮﻣﺠﻴﺔ ﻣﺴـ ــ ـﺘﻘﻠﺔ اﻧﺸـ ــ ـﺄﻧﺎ ﺑﺪاﺧﻠﻬﺎ داﻟﺔ ﺗﻘﻮم ﺑﺎﻟﺘﺮﺣﻴﺐ ‪ ،‬ﻛﻤﺎ ﻗﻠﻨﺎ‬
‫ﺟﻪ أي أـﻧﻪ ﻻ ﻋﻼـﻗﺔ ـﻟﻪ ﺑﻤﺤﺘﻮـﻳﺎت‬
‫ﺧ ﺎر ـ‬
‫ﻣﻪ ـ‬
‫ﺨﺪ ـ‬
‫ﻌﺔ ﻟﻦ ﺗﺴـ ــــــ ـﺘ ـ‬
‫ﻫﺬه اﻟﻘﻄ ـ‬
‫ﺧﻞ ـ‬
‫ﻣﺎ ﻳﺘﻢ ﻛﺘـﺎﺑﺘـﻪ ـﺑﺪا ـ‬
‫أـﻧﻪ ـ‬
‫اﻟﺘﺼﻨﻴﻒ اﻟﺒﺎﻗﻴﺔ‪.‬‬

‫§ ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪140‬‬

‫ﻧﻼﺣﻆ أﻧﻨﺎ ﻗﻤﻨﺎ ﺑﻜﺘﺎﺑﺔ اﺳـ ـــ ـﻢ اﻟﺘﺼـ ـــ ـﻨﻴﻒ ‪ class‬وﻣﻦ ﺛﻢ ﻇﻬﺮت ﻟﻨﺎ اﻟﺪاﻟﺔ اﻟﺘﻲ اﻧﺸـ ـــ ـﺄﻧﺎﻫﺎ‬
‫ﺑﺪاﺧﻞ ‪ companion object‬وﻫﻨﺎ ﻳﺘﺠﻠﻰ ﻟﻨﺎ اﻟﻬﺪف ﻣﻨﻬﺎ أﻧﻨﺎ ﻧﺴـ ــ ـﺘﻄﻴﻊ ان ﻧﻀـ ــ ـﻊ اﻟﻌﻤﻠﻴﺎت‬
‫واﻟﻤﺘﻐﻴﺮات ﺑﺪاﺧﻞ ﻫﺬه اﻟﻘﻄﻌﺔ اﻟﺒﺮﻣﺠﻴﺔ ﻟﻠﻮﺻﻮل إﻟﻴﻬﺎ ﺳﺮ ﻳﻌﺎ ﻣﻦ اﺳﻢ اﻟﺘﺼﻨﻴﻒ‪.‬‬

‫ﻫﻨﺎ ﻗﻤﻨﺎ ﺑﺎﺷـ ــ ـﺘﻘﺎق ﻛﺎﺋﻦ ﻣﻦ اﻟﺘﺼـ ــ ـﻨﻴﻒ وﻧﻼﺣﻆ أﻧﻪ ﻻ ﻳﺴـ ــ ـﺘﻄﻴﻊ اﻟﻮﺻـ ــ ـﻮل إﻟﻰ ﻣﺎ ﺑﺪاﺧﻞ‬
‫‪.companion object‬‬

‫راﺑﻌﺎ ً ‪ :‬ﻣﺘﻐﻴﺮ ﻳﺴﺘﻘﺒﻞ ‪companion object‬‬

‫ﻧﺴـ ـــــ ـﺘﻄﻴﻊ أن ﻧﻌﺮف ﻣﺘﻐﻴﺮ ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴـ ـــــ ـﻴﺔ ﻗﻴﻤﺘﻪ ﻋﺒﺎرة ﻋﻦ ‪companion object‬‬
‫ﻫﻜﺬا‪:‬‬

‫‪var quiz: Float = 0f‬‬

‫‪var midterm: Float = 0f‬‬
‫‪var final: Float = 0f‬‬
‫{ ‪class student‬‬

‫{ ‪companion object‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪141‬‬

 fun totalQuiz() {
println("Enter first Degree : ")
var quiz1: Float = readLine()!!.toFloat()
println("Enter second Degree : ")
var quiz2: Float = readLine()!!.toFloat()
var totalQuiz: Float = (quiz1 + quiz2) / 2
println("your quiz degree is : $totalQuiz")
}

fun totalDegree(quiz: Float, midterm: Float, final: Float) {

var result = quiz + midterm + final

if (result >= 90 && result <= 100) {

println("A")
} else if (result >= 80 && result <= 89) {
println("B")
} else if (result >= 70 && result <= 79) {
println("C")
} else if (result >= 60 && result <= 69) {
println("D")
} else {
println("F")
}
}
}

‫ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬

fun main(args:Array<String>){

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 142 ‫اﻟﺼﻔﺤﺔ‬

 var tQuiz = student.Companion

tQuiz.totalQuiz()
}

.companion object ‫ﻧﻌﺮف ﻣﺘﻐﻴﺮ وﻧﺮى أﻧﻨﺎ اﺳﻨﺪﻧﺎ ﻟﻪ‬

companion object ‫ ﻣﻌﻠﻮﻣﺎت ﺣﻮل‬: ً ‫ﺧﺎﻣﺴﺎ‬

‫ﻓﻲ ﺣﺎل أﻧﻨﺎ ﻋﺮﻓﻨﺎ ﻣﺘﻐﻴﺮات ﺑﺪاﺧﻠﻪ واﺳـ ــ ـﻨﺪﻧﺎ ﻟﻬﺎ ﻗﻴﻢ ﻓﺈﻧﻪ ﻋﻨﺪ اﺳـ ــ ـﺘﺪﻋﺎﺋﻬﺎ وﺗﻐﻴﺮ ﻗﻴﻤﺘﻬﺎ‬
:‫ ﺳﻨﻮﺿﺢ ذﻟﻚ‬، ‫ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ﺳﻮف ﺗﺘﻐﻴﺮ ﺑﺸﻜﻞ ﻋﺎم أي ﻟﻴﺲ ﻓﻲ اﻷﻣﺮ ﻓﻘﻂ اﻟﻤﺤﺪد‬

class compan {
companion object {
var yourName = "Ahmed"
var familyName = "Aljuaid"
fun show() {
println("Hello $yourName $familyName")
}
}
var yourName = "Ahmed"
var familyName = "Aljuaid"
fun show() {
println("Hello $yourName $familyName")
}
}

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 143 ‫اﻟﺼﻔﺤﺔ‬

 fun main(args:Array<String>){
var name = compan.Companion
var name1 = compan.Companion

name.show()
name1.show()
}

‫اﻟﺘﻨﻔﻴﺬ‬

Hello Ahmed Aljuaid

Hello Ahmed Aljuaid

‫ ﻓﻲ‬، ‫ ﻣﺎ ﻟﺬي ﺳـ ــ ـﻴﺤﺪث‬name ‫ﺣﺴـ ــ ـﻨﺎ ﻟﻨﻼﺣﻆ ﻗﻠﻴﻼ ﻟﻮ أردﻧﺎ ﺗﻐﻴﺮ اﻻﺳـ ــ ـﻢ اﻷول ﻓﻲ ﻣﺘﻐﻴﺮ‬
:‫اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬

fun main(args:Array<String>){

var name = compan.Companion

var name1 = compan.Companion

name.yourName="Ali"
name.show()
name1.show()

‫اﻟﺘﻨﻔﻴﺬ‬

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 144 ‫اﻟﺼﻔﺤﺔ‬

‫‪Hello Ali Aljuaid‬‬
‫‪Hello Ali Aljuaid‬‬

‫ﺗﻢ ﺗﻐﻴﻴﺮ اﻻﺳـ ـــــ ـﻢ ﻓﻲ اﻟﻤﺘﻐﻴﺮ ﻳﻦ ‪ name and nam1‬ﺑﺎﻟﺮﻏﻢ ﻣﻦ أﻧﻨﺎ اﺳـ ـــــ ـﺘﺪﻋﻴﻨﺎ ‪name‬‬
‫وﻋﺪﻟﻨﺎ ﺑﻬﺎ ‪ ،‬وﻫﺬا ﻳﺪل ﻋﻠﻰ أﻧﻪ ﻏﻴﺮ ﻣﺴـ ــــ ـﺘﻘﻞ ﺑﺤﻴﺚ أﻧﻪ ﻗﻴﻤﺔ ﻣﺘﻐﻴﺮ ﻓﻲ ﻛﺎﺋﻦ واﺣﺪ ﻳﺠﻌﻠﻚ‬
‫ﻋﻨﺪﻣﺎ ﺗﺴﺘﺪﻋﻲ ﻧﻔﺲ اﻟﻤﺘﻐﻴﺮ ﻟﻜﺎﺋﻦ ﺟﺪﻳﺪ ﻫﻴﺎ ﻧﻔﺴﻬﺎ اﻟﻘﻴﻤﺔ‪.‬‬

‫اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ ‪Nasted classes‬‬

‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ‬

‫ﻟﻐﺔ ‪ Kotlin‬ﺗﺪﻋﻢ ﻃﺮ ﻳﻘﺔ اﻟﺘﺼـ ـــ ـﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ ﻫﻲ ﻋﺒﺎرة ﻋﻦ ﺗﺼـ ـــ ـﻨﻴﻒ ﻛﺒﻴﺮ وﺑﺪاﺧﻠﻪ‬
‫ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺘﺼﻨﻴﻔﺎت‪ ،‬ﻳﻌﻨﻲ ﺗﻌﺮ ﻳﻒ ‪ class‬ﺑﺪاﺧﻞ ‪.class‬‬

‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﻃﺮﻳﻘﺔ ﺗﻌﺮﻳﻒ اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ‬

‫{‪class school‬‬

‫{‪class employee‬‬
‫}‬

‫{‪class student‬‬
‫}‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪145‬‬

 ‫}‬

‫ﺛﺎﻟﺜﺎ ً ‪ :‬أﻫﻤﻴﺔ اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ‬

‫ﺗﻔﻴﺪ ﻓﻲ ﻋﻤﻠﻴﺔ اﻟﺘﻐﻠﻴﻒ ‪.Encapsulation‬‬

‫ﺗﻌﺘﺒﺮ ﻃﺮ ﻳﻘﺔ ﻋﻤﻠﻴﺔ ﻟﻮ ﻟﺪﻳﻨﺎ ﻋﺪد ﻣﻦ اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺮﺗﺒﻄﺔ ﺑﺒﻌﺾ‪.‬‬

‫راﺑﻌﺎ ً ‪ :‬ﻣﺼﻄﻠﺤﺎت ﻣﻬﻤﺔ ﻓﻲ اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ‬

‫اﻟﺘﺼﻨﻴﻒ اﻟﺨﺎرﺟﻲ اﻟﻜﺒﻴﺮ ﻳﺴﻤﻰ‪:‬‬

‫‪OUTER CLASS‬‬

‫اﻟﺘﺼﻨﻴﻔﺎت اﻟﺪاﺧﻠﻴﺔ اﻟﺘﻲ ﺑﺪاﺧﻞ ‪ outer class‬ﺗﺴﻤﻰ‪:‬‬

‫‪INNER CLASS‬‬

‫ﺧﺎﻣﺴﺎ ً ‪ :‬اﻧﺸﺎء ﻛﺎﺋﻦ ﻣﻦ ‪inner class‬‬

‫ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬

‫)(‪var obj= outerClass.innerClass‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪146‬‬

 ‫ ﻣﺜﺎل‬: ً ‫ﺳﺎدﺳﺎ‬

class school{

class employee{
val id:Int = 0
var name :String =" "
fun getInfo(){
println("The Id of Employee is :$id \n Name :$name")
}
}

class student{
var grade:Char = ' '
var level:Int =0
var name :String =" "
fun getInfo(){
println("The student name is :$name \n Level : $level \n
Grade:$grade")
}
}

fun main (args:Array<String>){

var stu = school.student()
stu.name="Khalid Ali"
stu.level=5
stu.grade='A'

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 147 ‫اﻟﺼﻔﺤﺔ‬

 ‫)(‪stu.getInfo‬‬
‫}‬

‫‪ENUM class‬‬

‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم ‪Enum class‬‬

‫ﻫﻮ ﺗﺼ ـﻨﻴﻒ ﻧﺴ ـﺘﺨﺪﻣﻪ ﻟﻠﺘﻌﺪاد واﻷﺷ ـﻴﺎء اﻟﺜﺎﺑﺘﺔ اﻟﻐﻴﺮ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻐﻴﻴﺮ ‪ ،‬ﻣﺜﻼ اﻷﺳ ـﺒﻮع ﻳﺒﺪأ‬
‫ﻣﻦ اﻷﺣﺪ وﻳﻨﺘﻬﻲ اﻟﺴﺒﺖ وأﺳﻤﺎء اﻷﻳﺎم ﺛﺎﺑﺘﻪ وﻣﻌﺮوﻓﺔ وﻻ ﻳﻤﻜﻦ ﻟﻚ ﺗﻐﻴﻴﺮﻫﺎ‪.‬‬

‫ﺛﺎﻧﻴﺎ ً ‪ :‬اﺳﺘﺨﺪاﻣﻬﺎ ‪Enum class‬‬

‫ﻫﻮ ﺗﺼـ ــــ ـﻨﻴﻒ ﻧﻌﺮﻓﻪ وﻧﻀـ ــــ ـﻊ ﺑﺪاﺧﻠﻪ اﻟﺸـ ــــ ـﻲء اﻟﺬي ﻧﺮ ﻳﺪ أن ﻧﺜﺒﺘﻪ ‪ ،‬ﺑﻤﻌﻨﻰ أﻧﻨﻲ أر ﻳﺪ أن‬
‫اﺻـ ــ ـﻤﻢ ﻣﺸـ ــ ـﺮوع ﻳﺘﺤﺪث ﻋﻦ اﻟﻌﻤﻞ ﻓﻲ أ ﻳﺎم اﻷﺳـ ــ ـﺒﻮع ﻣﺜﻼ ﻓﺄﻋﺮف ﺗﺼـ ــ ـﻨﻴﻒ واﺿـ ــ ـﻊ ﺑﻪ أ ﻳﺎم‬
‫اﻷﺳﺒﻮع اﻟﺴﺒﻌﺔ وﻋﻨﺪﻣﺎ أﻗﻮم ﺑﺎﻟﻌﻤﻞ داﺧﻞ اﻟﻤﺸﺮوع ﻟﻦ ﻳﻘﺒﻞ ﻣﻨﻲ ﻳﻮم أﺧﺮ ﻏﻴﺮﻫﻢ‪.‬‬

‫ﺛﺎﻟﺜﺎ ً ‪ :‬ﺗﻌﺮﻳﻒ ‪Enum class‬‬

‫{‪enum class weekDays‬‬

‫‪Sunday , Monday , Tuesday , Wednesday , Thursday , Friday , Saturday‬‬

‫}‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪148‬‬

 ‫§ ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬
‫{)>‪fun main(args:Array<String‬‬

‫‪ weekDays‬ﻧﻌرف ﻣﺗﻐﯾر ﻣن اﻟﺗﺻﻧﯾف‪var myDay : weekDays //‬‬

‫ھﻧﺎ ﻟو أردﻧﺎ أن ﻧﻧﺎدي ﯾوم ﻣن اﻷﯾﺎم ‪myDay = weekDays.Tuesday //‬‬

‫ھﻧﺎ اﻋﺗرض ﻷﻧﮫ ﻟﯾس ﻣن ﺿﻣن اﻟﻌﻧﺎﺻر اﻟﻣوﺟودة ‪myDay = weekDays.Ahmed //‬‬
‫ﻓﻲ اﻟﺗﺻﻧﯾف‬

‫}‬

‫‪data class‬‬

‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم ‪data class‬‬

‫ﻣﺎذا ﻟﻮ ﻛﺎن ﻟﺪﻳﻚ ‪ .class‬واردت ﻃﺒﺎﻋﺔ اﻟﻘﻴﻢ اﻟﺘﻲ داﺧﻠﻪ او ﻃﺒﺎﻋﺘﻪ ﻛ ـ ـــــــــ ـ ‪ Object‬ﻓﺎﻧﺖ‬
‫ﻋﻨﺪ اﻟﻘﻴﺎم ﺑﺎﻣﺮ اﻟﻄﺒﺎﻋﺔ ﺳ ـﻴﻘﻮم اﻟﻤﺘﺮﺟﻢ ﺑﻄﺒﺎﻋﺔ ‪ hashcode‬ﻟﻠ ـ ـــــــ ـ ‪ Object‬وﻟﻴﺲ ﻟﻠﺒﻴﺎﻧﺎت!‬
‫ﺣﺘﻰ ﻟﻮ اردت اﻟﻤﻘﺎرﻧﺔ ﺑﻴﻦ ا ﻛﺜﺮ ﻣﻦ ‪ Object‬ﻓﺴـ ـــ ـﻴﻘﻮم اﻟﻤﺘﺮﺟﻢ ﺑﺎﻟﻤﻘﺎرﻧﺔ ﺑﻴﻦ ‪hashcode‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪149‬‬

‫وﻟﻴﺲ ﺑﻴﻦ اﻟﻘﻴﻢ ﻟﻠ ـ ــــــ ـ ‪ .Object‬ا ﻳﻀـﺎ ً اذا اردت ﻧﺴـﺦ ﺑﻴﺎﻧﺎت ‪ Object‬اﻟﻰ ‪ Object‬ﺟﺪﻳﺪ ﻓﺎﻧﺖ‬
‫ﻟﺴﺖ ﻗﺎدر ﻋﻠﻰ ذﻟﻚ ﻣﻊ ‪ class‬ﺑﺼﻴﻐﺘﻪ اﻟﻌﺎﻣﺔ‪.‬‬

‫ﻟـﺬﻟـﻚ ﻛـﺎن ﻻﺑـﺪ ﻣﻦ ا ﻳﺠـﺎد ﻃﺮ ﻳﻘـﺔ ﺟـﺪﻳـﺪة او ﻣﻔﻬﻮم ﺟـﺪﻳـﺪ وﻫﻮ اﺳـ ــــــ ـﺘﺨـﺪام ‪data class‬‬
‫واﻟﺬي ﺳـ ـﻴﻘﻮم ﺑﺠﻤﻴﻊ اﻟﻤﻬﺎم ﻣﻦ ﻣﻘﺎرﻧﺔ وﻧﺴـ ـﺦ وﻃﺒﺎﻋﺔ ﺑﺸـ ـﻜﻞ ﺳـ ـﺮ ﻳﻊ ودون ﻛﺘﺎﺑﺔ اﻟﻜﺜﻴﺮ‬
‫ﻣﻦ اﻟﺪوال واﻟﺸﻔﺮات اﻟﺒﺮﻣﺠﻴﺔ‪.‬‬

‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﻃﺮﻳﻘﺔ ‪data class‬‬

‫{)‪data class employee(var id:Int , var name:String , var department:String‬‬

‫}‬

‫ﺛﺎﻟﺜﺎ ً ‪ :‬ﻣﺜﺎل ﻻﺳﺘﺨﺪام ‪class‬‬

‫ﻻﺣﻆ ﻓﻲ ﻫﺬه اﻟﺸـ ـــــ ـﻔﺮة اﻧﺸـ ـــــ ـﺌﻨﺎ ‪ class‬وﻗﻤﻨﺎ ﺑﺎرﺳـ ـــــ ـﺎل ﻟﻪ اﻻﺳـ ـــــ ـﻢ واﻟﻘﻴﻤﺔ وﻧﺮ ﻳﺪ ﻋﻤﻞ‬
‫ﻋﺔ ﻟﻠﻘﻴﻢ ﻓﻲ ‪ class‬وﻟﻜﻦ ﻳﺘﻀـ ــــــ ـﺢ ﻟـﻨﺎ ﻫـﻨﺎ اـﻧﻪ ﻻﻳﻘﻮم ـﺑﺎﻟﻄـﺒﺎ ـ‬
‫ﻋﺔ واﻟﻤـﻘﺎرـﻧﺔ ﻣـﺜﻞ‬ ‫ﻣـﻘﺎرـﻧﺎت وﻃـﺒﺎ ـ‬
‫ﻣﺎﻛﺎن ﻣﺘﻮﻗﻊ ﻓﻬﻮ ﻳﻘﻮم ﺑﺎﻟﻤﻘﺎرﻧﺔ ‪ hashcode‬او ﻳﻘﻮم ﺑﻄﺒﺎﻋﺘﻪ‪.‬‬

‫{ )‪class Employee(name: String, salary: Int‬‬

‫{ )(‪fun display‬‬
‫)"‪print("Hello Employee‬‬
‫}‬
‫}‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪150‬‬

 fun main(args: Array<String>) {
val emp1 = Employee("Ahmed", 11200)
val emp2 = Employee("Ahmed", 11200)
//compare
print(emp1 == emp2) //false
//copy
val emp3 = emp1.copy() // unresolved reference
//print
print(emp1) // hashcode 'Employee@27c170f0'
}

class ‫ ﻗﺒﻞ ﺗﻌﺮﻳﻒ‬data ‫ اﺿﺎﻓﺔ‬: ً ‫راﺑﻌﺎ‬

‫اﻟﻘﻴﺎم ﺑﻬﺎ وﻳﺠﺐ ﻋﻠﻴﻚ‬class ‫اﻻن ﺑﻌﺪ ان اﺗﻀـ ـــ ـﺢ ﻟﻚ ان ﺑﻌﺾ اﻟﻌﻤﻠﻴﺎت ﻻﻳﻤﻜﻦ ﻟﻠ ـ ــــــــــ ـ‬
‫ ﻛﻞ ﻣﺎﻓﻲ اﻻﻣﺮ اﻧﻚ ﺗﺤﺘﺎج اﻟﻰ اﺿـ ـﺎﻓﺔ‬kotlin ‫ وﻟﻜﻦ ﻣﻊ‬. ‫ﻛﺘﺎﺑﺘﻬﺎ وﺗﻌﺮ ﻳﻔﻬﺎ ﻟﻠﻄﺒﺎﻋﺔ واﻟﻨﺴـ ـﺦ‬
‫ وﺳـ ـــــ ـﺘﻜﻮن ﻗﺎدر ﻋﻠﻰ اﻟﻘﻴﺎم ﺑﺠﻤﻴﻊ اﻟﻌﻤﻠﻴﺎت ﻣﻦ ﻧﺴـ ـــــ ـﺦ وﻃﺒﺎﻋﺔ‬class ‫ﻗﺒﻞ اﺳـ ـــــ ـﻢ‬data
.‫وﻣﻘﺎرﻧﺔ ﻛﻤﺎ ﺳﺘﻼﺣﻆ ﻓﻲ اﻟﺸﻔﺮة اﻟﻘﺎدﻣﺔ‬

data class Employee(val name: String, val salary: Int) {

fun display() {
print("Hello Employee")
}
}

fun main(args: Array<String>) {

val emp1 = Employee("Ahmed", 11200)
val emp2 = Employee("Ahmed", 11200)
//compare

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 151 ‫اﻟﺼﻔﺤﺔ‬

 print(emp1 == emp2) //true
//copy
val emp3 = emp1.copy(salary = 2000) // Employee(name=Ahmed,
salary=2000)
//compare
print(emp1 == emp3) //false
//print
println(emp1) // Employee(name=Ahmed, salary=11200)
println(emp3) // Employee(name=Ahmed, salary=2000)
}

‫ ﻣﺒﺎﺷـ ـ ـﺮة‬salary ‫ ﻣﻊ ﺗﻌﺪﻳﻞ ﻗﻴﻤﺔ‬emp1 ‫ﺗﻼﺣﻆ ﻓﻲ اﻟﺸـ ـ ـﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﻧﻲ ﻗﻤﺖ ﺑﻨﺴـ ـ ـﺦ‬
.‫وﻧﺴﺦ اﺳﻢ اﻟﻤﻮﻇﻒ دون ﺗﻌﺪﻳﻞ‬

Polymorphism

Polymorphism ‫ ﻣﺒﺪأ‬: ً ‫أوﻻ‬

‫ وﻟﺪﻳﻨﺎ أ ﻳﻀﺎ‬، ‫ إذا ﻫﻲ داﻟﺔ رﺋﻴﺴﻴﺔ‬super class ‫ﻫﺬا اﻟﻤﻔﻬﻮم ﻳﻌﻨﻲ ﺑﺄن ﻟﺪﻳﻨﺎ داﻟﺔ ﻓﻲ اﻟـ‬
.super class ‫ ﻟﻠﺪاﻟﺔ اﻟﺘﻲ ﻓﻲ‬override ‫ﻧﻘﻮم ﺑﻌﻤﻞ‬sub classes

.‫إذا ﺑﺸﻜﻞ ﻋﺎم ﻫﻲ داﻟﺔ ﻟﻬﺎ أ ﻛﺜﺮ ﻣﻦ وﺟﻪ‬

Polymorphism ‫ ﺷﺮوط‬: ً ‫ﺛﺎﻧﻴﺎ‬

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 152 ‫اﻟﺼﻔﺤﺔ‬

 .sub classes ‫ و‬super class ‫• ﻻﺑﺪ ﻣﻦ ﺗﻮاﺟﺪ‬
‫ إذ ﺗـﻌـﺘـﺒـﺮ اﻟـﻮراﺛـ ــ ـﺔ ﻋـ ــ ـﺎﻣـ ــ ـﻞ ﻣـﻬـﻢ ﻟـﻨـﺘـﻤـﻜـﻦ ﻣـﻦ ﻗـﻮل أن اﻟـﻌـﻤـﻠـﻴـ ــ ـﺔ اﻟـﺘـﻲ‬،‫• اﻟـﻮراﺛـ ــ ـﺔ‬
.polymorphism ‫أﻣﺎﻣﻨﺎ‬
.sub ‫ ﻟﻬﺎ ﻓﻲ‬override ‫ وﻧﻘﻮم ﺑﻌﻤﻠﻴﺔ‬،open ‫ ﻧﺠﻌﻠﻬﺎ‬super class ‫ـ‬ ‫ــــــــــــــ‬ ‫• اﻟﺪاﻟﺔ اﻟﺘﻲ ﺑﺎﻟ ـ‬
classes

Polymorphism ‫ أﻣﺜﻠﺔ ﻣﺘﻨﻮﻋﺔ ﻟﻤﻔﻬﻮم‬: ً ‫ﺛﺎﻟﺜﺎ‬

(١) ‫ ﻣﺜﺎل‬v

open class schools(){

open fun getInfo(){

var name:String = readLine()!!
println("Welcome in to our schools $name")
}

class employees():schools(){
override fun getInfo() {
println("every employee in this school have ID")
}
}

class students():schools(){
override fun getInfo() {
println("we are proud of our students")

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 153 ‫اﻟﺼﻔﺤﺔ‬

 ‫}‬
‫}‬

‫}‬

‫• ﻧﻼﺣﻆ أﻧﻨـﺎ ﻗﻤﻨـﺎ ﺑﻌﻤـﻞ ‪ sub classes‬ﺑـﺪاﺧـﻞ ‪ super class‬وﻫـﺬا ﻟﻴﺲ ﻟﻠﺘﻌﻘﻴـﺪ‬
‫إﻧﻤﺎ ﻧﺮ ﻳﺪ ﺗﻮﺿـ ــــــ ـﻴﺢ ﺑﺄﻧﻚ ﺗﺴـ ــــــ ـﺘﻄﻴﻊ ﺻـ ــــــ ـﻨﻊ ﻧﻔﺲ اﻟﻌﻤﻞ ﺑﺄ ﻛﺜﺮ ﻣﻦ ﻃﺮ ﻳﻘﺔ )ﻛﻞ‬
‫اﻟﻄﺮق ﺗﺆدي إﻟﻰ روﻣﺎ( اﻟﻤﻬﻢ أن ﻳﻜﻮن اﻟﻌﻤﻞ ﺻﺤﻴﺢ وﻣﻨﻄﻘﻲ‪.‬‬

‫• ﻧﻼﺣﻆ أن اﻟﺘﺼـ ـﻨﻴﻒ اﻟﺮﺋﻴﺴـ ـﻲ ‪ super class‬ﻳﺤﺘﻮي ﻋﻠﻰ داﻟﺔ ﺗﺮﺣﻴﺒﻴﺔ واﻓﺘﺮﺿـ ـﻨﺎ اﻧﻚ‬
‫ﺳـ ــ ـﺘﻤﺮر ﻗﻴﻤﺔ اﻟﺘﻲ ﻫﻲ اﺳـ ــ ـﻢ اﻟﻤﺪرﺳـ ــ ـﺔ وﻣﻦ ﺛﻢ ﺗﻘﻮم ﺑﻄﺒﺎﻋﺔ رﺳـ ــ ـﺎﻟﺔ ﺗﺮﺣﻴﺒﻴﺔ ﺑﺎﺳـ ــ ـﻢ‬
‫اﻟﻤﺪرﺳﺔ اﻟﺘﻲ ﻣﺮرﺗﻬﺎ‪.‬‬
‫• ﻗﻤﻨﺎ ﺑﻌﻤﻞ ‪ override‬ﻟﻨﻔﺲ اﻟﺪاﻟﺔ ﻓﻲ ‪ sub classes‬وﻟﻜﻦ ﻛﻞ داﻟﺔ ﺗﻘﻮم ﺑﻌﻤﻞ ﻣﻌﻴﻦ‬
‫ﺣﺴـ ـــ ـﺐ اﻟﺘﺼـ ـــ ـﻨﻴﻒ اﻟﺘﻲ ﺗﺘﺒﻌﻪ ﻓﻤﺜﻼ ﺗﺼـ ـــ ـﻨﻴﻒ اﻟﻤﻮﻇﻔﻴﻦ ﻫﻲ ﻧﻔﺲ اﻟﺪاﻟﺔ ﻓﻴﻪ وﻟﻜﻦ‬
‫ﺗﻘﻮم ﺑﻄﺒﺎﻋﺔ ﻣﻌﻠﻮﻣﺔ أن ﻛﻞ ﻣﻮﻇﻒ ﻟﺪﻳﻬﻢ ﻳﺤﻤﻞ رﻗﻢ وﻇﻴﻔﻲ‪.‬‬
‫• ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ ‪:‬‬

‫ﻧﺴﺘﻄﻴﻊ أن ﻧﻘﻮم ﺑﻄﺮ ﻳﻘﺘﻴﻦ ﻻﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ذات اﻟﻮﺟﻮه اﻟﻤﺘﻌﺪدة‪:‬‬

‫§ اﻟﻄﺮﻳﻘﺔ اﻷوﻟﻰ ‪ :‬ﻋﻤﻞ داﻟﺔ ﺧﺎرﺟﻴﺔ وﻳﺘﻢ اﻻﺳﺘﺪاﻋﺎء ﻣﻦ ﺧﻼﻟﻬﺎ‬

‫{)‪fun showInfo(s:schools‬‬
‫)(‪s.getInfo‬‬
‫}‬

‫{)>‪fun main (args:Array<String‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪154‬‬

 ‫)(‪var sch = schools‬‬
‫)‪showInfo(sch‬‬

‫}‬

‫ﻧﻼﺣﻆ ﻗﻤﻨﺎ ﺑﺘﻤﺮ ﻳﺮ ﻛﺎﺋﻦ ﻣﻦ اﻟﺘﺼـ ـــ ـﻨﻴﻒ اﻟﺮﺋﻴﺴـ ـــ ـﻲ وﺑﺪاﺧﻞ اﻟﺪاﻟﺔ ﻫﺬه ﺟﻠﺒﻨﺎ اﻟﺪاﻟﺔ اﻟﺘﻲ‬
‫ﺗﻄﺒﻊ اﻟﺒﻴﺎﻧﺎت ‪ ،‬وﻣﻦ ﺛﻢ ﻋﺮﻓﻨﺎ ﻛﺎﺋﻦ ﻣﻦ اﻟﺘﺼـﻨﻴﻒ اﻟﺮﺋﻴﺴـﻲ واﺳـﺘﺪﻋﻴﻨﺎ اﻟﺪاﻟﺔ اﻟﺘﻲ ﻋﺮﻓﻨﺎﻫﺎ‬
‫وﻣﺮرﻧﺎ ﻟﻬﺎ ﻧﻔﺲ اﻟﻜﺎﺋﻦ‪.‬‬

‫• ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‪:‬‬
‫‪happy kids‬‬
‫‪Welcome in to our schools happy kids‬‬

‫§ اﻟﻄﺮﻳﻘﺔ اﻟﺜﺎﻧﻴﺔ ‪ :‬ﺗﻌﺮﻳﻒ ﻛﺎﺋﻦ ﻣﺮﺟﻌﻪ اﻟـ ‪super class‬‬

‫{)>‪fun main (args:Array<String‬‬

‫)(‪var emp:schools = schools.employees‬‬

‫)(‪emp.getInfo‬‬
‫}‬
‫• ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‪:‬‬
‫‪every employee in this school have ID‬‬

‫‪ v‬ﻣﺜﺎل )‪(٢‬‬

‫{ )(‪open class primaryOperator‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪155‬‬

 open fun operator() {
println("primary operator")
println("please choose between this operators(+ , -) :")
var c = readLine()!!
if (c == "+") {
println("Enter first number :")
var a: Int = readLine()!!.toInt()
println("Enter second number :")
var b: Int = readLine()!!.toInt()
var result = a + b
println("The result is = $result")
} else if (c == "-") {
println("Enter first number :")
var a: Int = readLine()!!.toInt()
println("Enter second number :")
var b: Int = readLine()!!.toInt()
var result = a – b
println("The result is = $result")
}
}

open class seconderyOperator() : primaryOperator() {

override fun operator() {
println("secondary operator")
println("please choose between this operators(* , /) :")
var c = readLine()!!
if (c == "*") {
println("Enter first number :")

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 156 ‫اﻟﺼﻔﺤﺔ‬

 var a: Int = readLine()!!.toInt()
println("Enter second number :")
var b: Int = readLine()!!.toInt()
var result = a * b
println("The result is = $result")
} else if (c == "/") {
println("Enter first number :")
var a: Int = readLine()!!.toInt()
println("Enter second number :")
var b: Int = readLine()!!.toInt()
var result = a / b
println("The result is = $result")
}
}
}

fun main(args:Array<String>){
var secOp: primaryOperator=seconderyOperator()
secOp.operator()
}
:‫• ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
secondary operator
please choose between this operators(* , /) :
*
Enter first number :
3
Enter second number :
8
The result is = 24

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 157 ‫اﻟﺼﻔﺤﺔ‬

 (٣) ‫ ﻣﺜﺎل‬v

open class shapes(){

open fun getShape(){

println("shape")
}

class rectangle():shapes(){
override fun getShape() {
println("Rectangle")
}
}

class circle():shapes(){
override fun getShape() {
println("Circle")
}
}

class triangle():shapes(){
override fun getShape() {
println("Triangle")
}
}

fun showShapes(s:shapes){

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 158 ‫اﻟﺼﻔﺤﺔ‬

 ‫)(‪s.getShape‬‬
‫}‬

‫{)>‪fun main (args:Array<String‬‬

‫)(‪var shape1 = triangle‬‬
‫)‪showShapes(shape1‬‬
‫}‬
‫• ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‪:‬‬
‫‪Triangle‬‬

‫اﻻﺳﺘﺜﻨﺎءات ‪exception -‬‬

‫أوﻻ ‪ :‬ﻣﺎ ﻫﻲ اﻻﺳﺘﺜﻨﺎءات‬

‫ﻫﻮ ﻋﺒﺎرة ﻋﻦ ﺧﻄﺄ ﺣﺪث وﻟﻤﻌﺎﻟﺠﺔ ﻫﺬا اﻟﺨﻄﺄ وﺟﺪت ﻣﺎ ﺗﺴﻤﻰ ﺑﺎﻻﺳﺘﺜﻨﺎءات‪.‬‬

‫ﺛﺎﻧﻴﺎ ‪ :‬ﺗﻜﻮﻳﻦ اﻻﺳﺘﺜﻨﺎءات‬

‫ﺗﺘﻜﻮن ﺟﻤﻠﺔ اﻻﺳـ ـﺘﺜﻨﺎء ﻣﻦ ﻗﻄﻌﺘﻴﻦ ﺑﺮﻣﺠﻴﺘﻴﻦ أﺳـ ـﺎﺳـ ـﻴﺘﻴﻦ ﻫﻲ ‪ : try , catch‬وﻗﻄﻌﺔ‬
‫ﺛﺎﻟﺜﺔ اﺧﺘﻴﺎر ﻳﺔ وﻫﻲ ‪.finally :‬‬

‫‪try v‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪159‬‬

‫ﻄﺄ ﻓﻴـﻬﺎ ﺑﻤﻌﻨﻰ ﻟﺴـ ــــــ ــﻨﺎ‬
‫ﻤﻞ وﻗﻮع اﻟﺨ ـ‬
‫ﻌﺔ اﻟﺒﺮﻣﺠـﻴﺔ اﻷواﻣﺮ اﻟﺘﻲ ﻧﺤﺘ ـ‬ ‫• ﻧﻜـﺘﺐ ﻓﻲ ـ‬
‫ﻫﺬه اﻟﻘﻄ ـ‬
‫ﻣﺘﺄ ﻛﺪﻳﻦ ﻣﻦ ﻣﺪى ﺻﺤﺔ ﻣﺎ ﻛﺘﺒﻨﺎه‪ ،‬وﻣﻦ اﻟﻤﺤﺘﻤﻞ أن ﻻ ﻳﻜﻮن ﺑﻬﺎ ﺧﻄﺄ‪.‬‬
‫• ﻓﻲ ﺣﺎل ﻗﺎم اﻟﺒﺮﻧﺎﻣﺞ ﺑﻘﺮاءة ﻫﺬه اﻟﻘﻄﻌﺔ ووﺟﺪ ﺧﻄﺄ ﻳﻘﻮم ﺑﺘﺠﺎﻫﻞ ﺑﺎﻗﻲ اﻷواﻣﺮ وﻳﻨﺘﻘﻞ‬
‫إﻟﻰ ﻗﻄﻌﺔ‪catch .‬‬
‫ـ ‪ catch‬وﻳﻨﺘﻘﻞ إﻟﻰ‬ ‫ـــــــــــــ‬ ‫• ﻓﻲ ﺣﺎل ﺗﻤﺖ ﻗﺮاءة ﻗﻄﻌﺔ ‪ try‬وﻟﻢ ﻳﻜﻦ ﻓﻴﻬﺎ ﺧﻄﺄ ﻻ ﻳﺪﺧﻞ اﻟ ـ‬
‫‪finally‬ﻓﻲ ﺣﺎل ﺗﻮﻓﺮﻫﺎ‪.‬‬
‫{‪try‬‬

‫}‬

‫‪catch v‬‬

‫• ﻓﻲ اﻟـﺒﺪا ـﻳﺔ ﻧﻌﺮف ﻣﺘﻐﻴﺮ ﺑﻴﻦ اﻟﻘﻮﺳـ ــــــ ـﻴﻦ وﻧﻌﻴﻦ ﻧﻮع اﻟﻤﺘﻐﻴﺮ وﻫﻮ ﻧﻮع اﻟﺨ ـ‬
‫ﻄﺄ ﻣﻨﻄﻘﻲ ‪،‬‬
‫ر ﻳﺎﺿﻲ …إﻟﺦ‬
‫• ﺑﺪاﺧﻞ اﻟﻘﻄﻌﺔ اﻟﺒﺮﻣﺠﻴﺔ ﻧﻜﺘﺐ أواﻣﺮ ﺧﺎﺻـﺔ ﺑﻨﻮع اﻟﺨﻄﺄ اﻟﺬي ﻗﻤﻨﺎ ﺑﺘﻤﺮ ﻳﺮه ﺑﻤﻌﻨﻰ ﻟﻮ‬
‫ﻫﺬه‬ ‫ﻄﺄ ﻓﻲ اﻟﺒﺮـﻧﺎﻣﺞ ﻧﻮ ـ‬
‫ﻋﻪ ر ـﻳﺎﺿـ ــــــ ـﻲ ﻟﻦ ﺗﺴـ ــــــ ـﺘﻄﻴﻊ ـ‬ ‫ﺣﺪث ﺧ ـ‬
‫ﻄﺄ ﻣﻨﻄﻘﻲ ‪ ،‬و ـ‬
‫ـﻛﺎن ﻧﻮع اﻟﺨ ـ‬
‫اﻟﻘﻄﻌﺔ ﺣﻞ اﻟﻤﺸـ ـﻜﻠﺔ وﻟﺤﻞ اﻟﻤﺸـ ـﻜﻠﺔ ﻧﻘﻮم ﺑﺈﻧﺸـ ـﺎء ﻗﻄﻌﺔ ‪ catch‬أﺧﺮى ﻣﺨﺼـ ـﺼـ ـﺔ‬
‫ﻟﻨﻔﺲ ﻧﻮع اﻟﺨﻄﺄ‪.‬‬
‫{)‪catch(variable:exceptionType‬‬

‫}‬

‫‪finaly v‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪160‬‬

 .‫ﻗﻄﻌﺔ اﺧﺘﻴﺎر ﻳﺔ ﺗﺘﻀﻤﻦ أواﻣﺮ ﻣﻌﻴﻨﺔ ﻋﺎدﻳﺔ ﻟﻴﺲ ﻟﻬﺎ ﻋﻼﻗﺔ ﺑﺎﻟﺨﻄﺄ‬

‫ ﻣﺜﺎل‬: ً ‫ﺛﺎﻟﺜﺎ‬

try{
println("enter first number :")
var number1:Int = readLine()!!.toInt()
println("enter second number :")
var number2:Int = readLine()!!.toInt()
var result = number1+number2
println("The result is: $result")
}

catch(numEx:NumberFormatException){
println("only integer number entered")
}

‫ وﻟﻜﻦ ﻟﻨﻔﺘﺮض‬، ‫ر ﺑﻤﺎ ﻟﻠﻮﻫﻠﺔ اﻷوﻟﻰ ﺗﺮى اﻟﺒﺮﻧﺎﻣﺞ ﻓﺘﺴـ ــ ـﺘﻐﺮب ﺑﺄﻧﻪ ﺻـ ــ ـﺤﻴﺢ ﻻ ﻳﻮﺟﺪ ﺧﻄﺄ‬
‫ﺠﺔ‬
‫ﻌ ﺎﻟ ـ‬
‫ﺧﺎل ﻧﺺ ﻓﻼـﺑﺪ ﻫـﻨﺎ ﻣﻦ ﻣ ـ‬
‫ﺤﺔ ـﻗﺎم ـﺑﺈد ـ‬
‫ﺧﻞ ارـﻗﺎم ﺻـ ــــــ ـﺤﻴ ـ‬
‫ﺨﺪم ـﺑﺪل ﻣﻦ أن ـﻳﺪ ـ‬
‫أن اﻟﻤﺴـ ــــــ ـﺘ ـ‬
.‫اﻟﺨﻄﺄ‬

Multi-threading

multi-thread ‫ ﻣﻔﻬﻮم‬: ً ‫أوﻻ‬

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 161 ‫اﻟﺼﻔﺤﺔ‬

 .‫ﻫﻮ ﻛﻴﻔﻴﺔ ﺗﻨﻔﻴﺬ ﻋﻤﻞ أ ﻛﺜﺮ ﻣﻦ داﻟﺔ ﻓﻲ أن واﺣﺪ‬

multi-thread ‫ ﻋﻤﻞ‬: ً ‫ﺛﺎﻧﻴﺎ‬

‫ اﻟﺬي ﻳﺤﺘﻮي ﻋﻠﻰ اﻟﻌﺪﻳﺪ ﻣﻦ‬Thread class ‫ﻟﻨﺘﻌﺎﻣﻞ ﻣﻊ ﻋﺬا اﻟﻤﻔﻬﻮم ﺳـﻨﺴـﺘﻌﻴﻦ ﺑ ـ ـــــــ ـ‬
:‫ ﻣﺜﺎل‬.‫اﻟﺪوال اﻟﺘﻲ ﺗﻔﻴﺪﻧﺎ ﻓﻲ ﻣﻮﺿﻮﻋﻨﺎ ﻫﺬا‬

class first :Thread() {

override fun run() {

var num = 0

for (i in 1..3) {
num = num + i
println(num)
Thread.sleep(1000)
}

println("-----------------------\n The result is :$num")

}}

class second :Thread() {

override fun run() {

var num = 1

for (i in 1..3) {
num = num * i

Kotlin ‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬ 162 ‫اﻟﺼﻔﺤﺔ‬

 ‫)‪println(num‬‬
‫)‪Thread.sleep(1000‬‬
‫}‬
‫}})"‪println("-----------------------\n The result is :$num‬‬

‫{)>‪fun main(args:Array<String‬‬

‫)(‪var F = first‬‬
‫)(‪var S = second‬‬

‫)(‪F.start‬‬
‫)(‪S.start‬‬

‫}‬
‫• ﻗﻤﻨﺎ ﺑﺈﻧﺸ ـﺎء ﺗﺼ ـﻨﻴﻔﻴﻦ ﻣﺨﺘﻠﻔﻴﻦ اﺣﺪﻫﻤﺎ ﻟﺠﻤﻊ اﻷرﻗﺎم اﻟﻮاﻗﻌﺔ ﺑﻴﻦ ‪ ٠‬و ‪ ، ٥‬وﺗﺼ ـﻨﻴﻒ‬
‫ﻟﻨﺎﺗﺞ ﺿﺮب اﻷﻋﺪاد اﻟﻮاﻗﻌﺔ ﺑﻴﻦ ‪ ٠‬و ‪.٥‬‬
‫• ﺗﻤﺖ ﻋﻤﻠﻴﺔ اﻟﻮراﺛﺔ ﻓﻲ اﻟﺘﺼﻨﻴﻔﻴﻦ ﻣﻦ ‪.Thread‬‬
‫• ﻓﻲ ﻛﻞ ﻣﻦ اﻟﺘﺼـ ـــــ ـﻨﻴﻔﻴﻦ اﺳـ ـــــ ـﺘﻌﻤﻠﻨﺎ داﻟﺔ ﻣﻨﺸـ ـــــ ـﺄة ﻓﻲ ‪ Thread‬ﻟﻠﻌﻤﻞ وﺗﺠﻬﻴﺰ اﻷواﻣﺮ‬
‫ﺑـﺪاﺧﻠﻬـﺎ وﻫﻲ ‪ run‬وﺑﻤـﺎ أﻧﻬـﺎ ﻣﻨﺸـ ـــــــ ﺄة ﻣﻦ ﻗﺒـﻞ ﻓﻲ ﺗﺼـ ــــــ ـﻨﻴﻒ ‪ Thread‬ﻓﻨﻘﻮم ﺑﻌﻤـﻞ‬
‫‪override‬ﻟﻬﺎ‪.‬‬
‫ﻌﻞ اـﻟﺪاﻟﺘﻴﻦ ﻓﻲ اﻟﺘﺼـ ــــــ ـﻨﻴﻔﻴﻦ ﻳﻌﻤﻠﻮن ـﺑﺎﻟﺘﺰاﻣﻦ ﺑﻤﻌﻨﻰ أﻧـﻨﺎ ﻟﻦ ﻧﻨﺘﻈﺮ داـﻟﺔ ‪ run‬ﻓﻲ‬
‫• ﻟﺠ ـ‬
‫ﺗﺼــﻨﻴﻒ ‪ first‬ﻟﻠﻌﻤﻞ وﻣﻦ ﺑﻌﺪ اﻧﺘﻬﺎﺋﻬﺎ ﻧﻨﺘﻘﻞ إﻟﻰ اﻟﺪاﻟﺔ ‪ run‬ﻓﻲ اﻟﺘﻨﺼــﻴﻒ ‪، second‬‬
‫ﻧﺴـ ـــ ـﺘﺨﺪم داﻟﺔ ‪ sleep‬اﻟﺘﻲ ﻧﺤﺪد ﻟﻬﺎ اﻟﻮﻗﺖ ﺑﺎﻟ ـ ــــــــــ ـ )‪ ،Millis (milliseconds‬ﺗﻘﻮم ﻫﺬه‬
‫اﻟﺪاﻟﺔ ﺑﺘﻌﻄﻴﻞ ﻋﻤﻞ اﻟﺪاﻟﺔ اﻟﺤﺎﻟﻴﺔ ﻣﺪة زﻣﻨﻴﺔ ﻣﻌﻴﻨﺔ وﻣﻦ ﺛﻢ ﺗﻌﻮد ﻟﻌﻤﻠﻬﺎ ﻣﻦ ﺟﺪﻳﺪ‪.‬‬
‫• اﻷن ﻟﻠﺘﺤﻘﻖ ﻣﻦ ﻋﻤﻠﻨﺎ ﻧﻘﻮم ﺑﻌﻤﻞ ﻛﺎﺋﻦ ﻣﻦ ﻛﻼ اﻟﺘﺼﻨﻴﻔﻴﻦ واﻟﻌﻤﻞ ﺑﻬﻤﺎ‪.‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪163‬‬

 ‫• ﻧﻼﺣﻆ أﻧﻨﺎ ﻟﻢ ﻧﺴـ ـﺘﺪﻋﻲ داﻟﺔ ‪ run‬ﻟﺘﻨﻔﻴﺬﻫﺎ وﻫﺬا ﺻـ ـﺤﻴﺢ ﻷن اﻟﻤﺴـ ـﺆول ﻋﻦ ﺗﻨﻔﻴﺬﻫﺎ‬
‫ﻫﻲ اﻟﺪاﻟﺔ اﻟﻤﻮﺿﺤﺔ ﺑﺎﻟﻤﺜﺎل وﻫﻲ‬
‫‪start : start() .‬‬

‫§ ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‬
‫‪1‬‬
‫‪1‬‬
‫‪3‬‬
‫‪2‬‬
‫‪6‬‬
‫‪6‬‬
‫–———————‬
‫‪The result is :6‬‬
‫–———————‬
‫‪The result is :6‬‬

‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻟﺪوال اﻟﺘﻲ ﺗﻌﻤﻞ ﻣﻊ ‪thread‬‬

‫‪Start v‬‬

‫• ﻳﻌﻮد ﺑﻘﻴﻤﺔ ﻣﻨﻄﻘﻴﺔ‬

‫• إذا ﻛﺎﻧﺖ ﻗﻴﻤﺘﻪ ‪ true‬ﻳﺘﻢ ﺗﺸﻐﻴﻞ اﻟـ ‪.thread‬‬

‫‪run v‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪164‬‬

 ‫• ﻟﻜﺘﺎﺑﺔ اﻷواﻣﺮ اﻟﺘﻲ ﺳﻴﺘﻢ ﺗﻨﻔﻴﺬﻫﺎ ﻋﻨﺪ ﻋﻤﻞ ‪ start‬ﻟـ‪.Thread‬‬

‫‪sleep v‬‬

‫• ﻹﻳﻘﺎف ﻋﻤﻞ اﻟﺪاﻟﺔ ﻣﺪة ﻣﻌﻴﻨﻪ ﻧﻘﻮم ﺑﺘﺤﺪﻳﺪﻫﺎ ﺑﺎﻟـ‪. milliseconds‬‬

‫‪Suspend v‬‬

‫• ﻹﻳﻘـﺎف ﻋﻤـﻞ اﻟـﺪاﻟـﺔ ﻣـﺪة ﻏﻴﺮ ﻣﺤـﺪدة ‪ ،‬وﻻﺳـ ــــــ ـﺘﺌﻨـﺎف ﻋﻤﻠﻬـﺎ ﻧﻘﻮم ﺑـﺎﺳـ ــــــ ـﺘـﺪﻋـﺎء اﻟـﺪاﻟـﺔ‬
‫‪.resume‬‬

‫‪resume v‬‬

‫• ﺗﻜﻤﻞ ﺗﻨﻔﻴﺬ اﻷواﻣﺮ اﻟﺘﻲ ﺗﻮﻗﻔﺖ ﺑﺴﺒﺐ اﻟﺪاﻟﺔ ‪.Suspend‬‬

‫‪stop v‬‬

‫• ﺗﻮﻗﻒ ﻋﻤﻞ اﻟﻜﺎﺋﻦ اﻟﺬي ﻳﺮث ‪.Thread‬‬

‫‪id v‬‬

‫• ﻟﻠﺤﺼﻮل ﻋﻠﻰ ‪ id‬اﻟﺨﺎص ﺑﻜﺎﺋﻦ ‪.Thread‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪165‬‬

 ‫‪setName v‬‬

‫• ﻟﺘﻌﻴﻴﻦ اﺳﻢ ﺑﺎﻟﻜﺎﺋﻦ اﻟﺨﺎص ﺑـ ‪.Thread‬‬

‫‪getName v‬‬

‫• ﻟﻠﺤﺼﻮل ﻋﻠﻰ اﺳﻢ اﻟﻜﺎﺋﻦ اﻟﺨﺎص ﺑـ ‪.Thread‬‬

‫‪getPriority v‬‬

‫• ﻳﻌﻮد ﺑﻘﻴﻤﺔ ﻣﻦ ‪.١٠-١‬‬

‫• ﻳﻌﺒﺮ ﻋﻦ اﻷوﻟﻮﻳﺔ اﻟﺘﻲ ﻳﻤﺘﻠﻜﻬﺎ اﻟﻜﺎﺋﻦ اﻟﺨﺎص ﺑـ ‪.Thread‬‬
‫• اﻷوﻟﻮﻳﺔ اﻻﻓﺘﺮاﺿـ ــــ ـﻴﺔ ﻫﻲ ‪ ٥‬وﻟﻜﻦ ﻟﻮ أردﻧﺎ ﺗﻐﻴﻴﺮ ﻗﻴﻤﺘﻬﺎ ﻧﺴـ ــــ ـﺘﺨﺪم ‪ setPriority‬اﻟﺘﻲ‬
‫ﺗﺴﻤﺢ ﻟﻨﺎ ﺑﺘﻌﻴﻴﻦ ﻗﻴﻤﺔ ﺟﺪﻳﺪة ﻟﻸوﻟﻮﻳﺔ‪.‬‬

‫‪toString v‬‬

‫• ﺗﻌﻮد ﺑﻤﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻤﻌﻠﻮﻣﺎت ﻋﻦ اﻟﻜﺎﺋﻦ اﻟﺨﺎص ﺑـ‬

‫‪Thread ( name – id – group).‬‬

‫‪Interrupt v‬‬

‫• ﻟﻤﻘﺎﻃﻌﺔ ﻋﻤﻞ اﻟﻜﺎﺋﻦ اﻟﺨﺎص ﺑـ ‪.Thread‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪166‬‬

 ‫‪join v‬‬

‫• ﺗﻬﺘﻢ ﺑﺈﻧﺠﺎز ﺟﻤﻴﻊ اﻷواﻣﺮ اﻟﺨﺎﺻﺔ ﺑﻜﺎﺋﻦ اﻟ ـ ــ ‪ Thread‬وﺑﻌﺪ اﻻﻧﺘﻬﺎء ﻣﻨﻬﺎ اﻻﻧﺘﻘﺎل إﻟﻰ ﻣﺎ‬
‫ﺗﺒﻘﻰ ﻓﻲ ‪.main‬‬

‫‪State v‬‬

‫• ﻳﻌﻮد ﺑﺤﺎﻟﺔ ﻛﺎﺋﻦ اﻟـ ‪.Thread‬‬

‫‪any‬‬

‫أوﻻ ً ‪ :‬ﻣﺎ ﻫﻮ ‪class any‬‬

‫ﻫﻮ ﻋﺒﺎرة ﻋﻦ ﺗﺼ ـﻨﻴﻒ رﺋﻴﺴ ـﻲ ﻣﻮﺟﻮد ﻓﻲ ﻟﻐﺔ ‪ Kotlin‬ﻳﺤﺘﻮي ﺑﺪاﺧﻠﻬﺎ ﻋﻠﻰ دوال واﺣﺪاث‬
‫ﺟﺎﻫﺰة ﻟﻠﺘﻨﻔﻴﺬ ‪ ،‬ﻓﻲ ﺣﺎل إﻧﺸـﺎﺋﻚ ﺗﺼـﻨﻴﻒ ﺟﺪﻳﺪ ﻓﺈن ﻫﺬا اﻟﺘﺼـﻨﻴﻒ ﺗﻠﻘﺎﺋﻴﺎ ﻳﺮث ﻣﻦ ﺗﺼـﻨﻴﻒ‬
‫‪ . any‬إذا ﻳﻌﺘﺒﺮ ‪ class any‬ﻫﻮ ‪ super class‬ﻟﺠﻤﻴﻊ اﻟﺘﺼﻨﻴﻔﺎت ‪.classes‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪167‬‬

‫ﻟﺬﻟﻚ ﻋﻨﺪ اﺷـﺘﻘﺎق ﻛﺎﺋﻦ ﻣﻦ اﻟﺘﺼـﻨﻴﻒ اﻟﺬي اﻧﺸـﺄﻧﺎه ﻓﺈﻧﻨﺎ ﺑﺎﻟﺘﺄ ﻛﻴﺪ ﺳـﻨﻼﺣﻆ وﺟﻮد دوال‬
‫ﺟﺎﻫﺰة أ ﻳﻀﺎ ﻏﻴﺮ ﺗﻠﻚ اﻟﺘﻲ ﻛﺘﺒﻨﺎﻫﺎ ‪ ،‬ﻣﺜﻞ‪.hashCode , toString , equales,…etc :‬‬

‫| ﻣﺨﺘﺼﺮ ﻟﻐﺔ ‪Kotlin‬‬ ‫اﻟﺼﻔﺤﺔ ‪168‬‬