تعلم لغة الكوتلن

‫ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬
‫‪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‬‬

‫)‪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 ......................................................................................................................................‬‬

‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻻﺳﺘﺪﻋﺎء‪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 ...............................................................................................................................................‬‬

‫ﺛﺎﻧﻴﺎ ً ‪ :‬اﻟﺘﻌﺮﻳﻒ ﻋﻦ‪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 .........................................................................‬‬

‫ﺧﺎﻣﺴﺎ ً ‪ :‬اﻧﺸﺎء ﻛﺎﺋﻦ ﻣﻦ‪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‬اﺣﺪى اﻟﻠﻐﺎت اﻟﺘﻲ ﻻﻗﺖ رواﺟﺎ ً ﻓﻲ اﻟﺴـﻨﺘﻴﻦ اﻟﻤﺎﺿـﻴﺔ وزادت ﺷـﻌﺒﻴﺘﻬﺎ ﺑﻌﺪ دﻋﻤﻬﺎ اﻻﻧﺪروﻳﺪ‬
‫ﺑﺸﻜﻞ رﺳﻤﻲ ﻓﻲ اﻧﺪروﻳﺪ اﺳﺘﺪﻳﻮ ﻟﺒﺮﻣﺠﺔ ﺗﻄﺒﻴﻘﺎت اﻻﻧﺪروﻳﺪ ‪..‬‬
‫ﻟﻐﺔ ‪ Kotlin‬ﻗﺎدرة ﻋﻠﻰ ﺑﺮﻣﺠﺔ ﺗﻄﺒﻴﻘﺎت اﻟﻮﻳﺐ واﻟ ـ ــــــــــ ـ‪ IOS‬ﺑﺸـ ــ ـﻜﻞ ﻃﺒﻴﻌﻲ ﺑﺎﺳـ ــ ـﺘﺨﺪام أدوات‬
‫ﻟﻠﺘﻄﻮﻳﺮ ﻣﺪﻋﻮﻣﺔ ﻣﺒﺎﺷﺮة ﻣﻦ اﻟﺸﺮﻛﺔ اﻟﻤﻄﻮرة ﻟـ‪Kotlin‬‬
‫ﻜﺘﻴـﺐ ا ﻳﺠـﺎز ﻟﻐـﺔ ‪ Kotlin‬ﺑﺸـ ــــــ ـﻜـﻞ ﻋـﺎم ﻟﻴﺘﻤﻜﻦ اﻟﻤﺴـ ــــــ ـﺘﺨـﺪم اﻟﻤﺒﺘـﺪئ ﻓﻲ‬
‫ﺣـﺎوﻟـﺖ ﻓﻲ ﻫـﺬا اﻟ ُ‬
‫اﻟﺒﺮﻣﺠﺔ ﻣﻦ ﻣﻌﺮﻓﺔ ﺟﻤﻴﻊ ﺟﻮاﻧﺐ اﻟﻠﻐﺔ‪.‬‬
‫وﻓﻲ اﻟﻨﻬـﺎﻳـﺔ اﺣﻤـﺪ ﷲ ﻋﻠﻰ اﻧﻬـﺎء ﻫـﺬا اﻟﻌﻤـﻞ وارﺟﻮا ان ﻳﻜﻮن ﻧـﺎﻓﻌـﺎ ً ﻻﺛﺮاء اﻟﻤﺤﺘﻮى اﻟﻌﺮﺑﻲ ﻓﻲ‬
‫ﻣﺠﺎل اﻟﺒﺮﻣﺠﺔ‪.‬‬
‫اﺣﻤﺪ اﻟﺠﻌﻴﺪ‬
‫ﻣﻌﻠﻢ ﺣﺎﺳﺐ آﻟﻲ – وزارة اﻟﺘﺮ ﺑﻴﺔ واﻟﺘﻌﻠﻴﻢ‬
‫ا ﻟﺴﻌﻮدﻳﺔ‬
‫ﺗﻮاﺻﻞ‪aljo3aid@gmail.com :‬‬
‫‪966504511433.‬‬

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

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

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

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

‫ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﺷﻜﺎل اﻻﻳﻘﻮﻧﺎت اﻟﺨﺎﺻﺔ ﺑﻠﻐﺎت اﻟﺒﺮﻣﺠﺔ‬
‫اﻵن اﺻﺒﺢ ﻟﺪﻳﻚ ﻣﺤﺮر أ ﻛﻮاد ﻗﻮي وﻣﻨﺎﻓﺲ ﻛﺒﻴﺮ‪.‬‬
‫ﻣﻮﺟﻪ اﻷواﻣﺮ‬
‫ـــــــــــ ـ ‪Kotlin‬‬ ‫اﻻن ﻧﺤﺘﺎج ﻟﺘﺤﻤﻴﻞ اﺿـ ـــ ـﺎﻓﺎت ﻟﻠﻨﻈﺎم ﻟﻌﻤﻞ ‪ compiler‬ﻟﻠﺸـ ـــ ـﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﻟ ـ‬
‫ﺑﺎﺳﺘﺨﺪام ﻣﻮﺟﻪ اﻻواﻣﺮ ﻻن اﻻﺿﺎﻓﺔ ﺗﻌﺘﻤﺪ ﻋﻠﻴﻪ ﺑﺸﻜﻞ اﺳﺎﺳﻲ‪.‬‬
‫ﻗﻢ ﺑﺘﺤﻤﻴﻞ اﺧﺮ اﺻﺪار ﻣﻦ ﻫﻨﺎ وﺳﻴﻘﻮم ﺑﺎﻟﺘﺜﺒﻴﺖ ﺑﺸﻜﻞ ﺗﻠﻘﺎﺋﻲ‬

‫اﻻن ﻳﻤﻜﻨﻚ اﻻﻧﺘﻘﺎل ﻟﻠﺪروس وﻣﺘﺎﺑﻌﺘﻬﺎ‬
‫ﺗﻬﻴﺌﺔ ‪ Eclipse‬ﻟﺒﺮﻣﺠﺔ ‪Kotlin‬‬
‫ﻳﻌﺘﺒﺮ ‪ Eclipse‬ﻣﻦ أﻗﻮى ‪ IDE‬اﻟﻤﺠﺎﻧﻴﺔ ﻓﻲ اﻟﺒﺮﻣﺠﺔ ﻻﺣﺘﻮاﺋﻪ ﻋﻠﻲ ﻣﺘﺠﺮ وإﺿـ ـــ ـﺎﻓﺎت ﻛﺜﻴﺮة‬
‫ﺗﺪﻋﻢ اﻟﻌﺪﻳﺪ ﻣﻦ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ واﻟﺪﻋﻢ اﻟﻜﺒﻴﺮ ﻣﻦ اﻟﻤﻄﻮر ﻳﻦ‪.‬‬
‫ﻧﺤﺘﺎج اﺿﺎﻓﺔ ﺑﻌﺾ اﻻدوات ﻟﻠﺒﺮﻧﺎﻣﺞ ﺣﺘﻰ ﻧﺴﺘﻄﻴﻊ اﺳﺘﺨﺪاﻣﺔ ﻓﻲ ﺑﺮﻣﺠﺔ ‪.Kotlin‬‬
‫ﺗﺜﺒﻴﺖ اﻻدوات‬
‫اﻓﺘﺢ ﺑﺮﻧـﺎﻣﺞ ‪ Eclipse‬واذﻫـﺐ اﻟﻰ ﺧﻴـﺎر ”‪ “Eclipse Market Place‬ﺳـ ــــــ ـﺘﻈﻬﺮ ﻟـﻚ ﻧـﺎﻓـﺬه‬
‫ﻣﺸﺎﺑﻬﻪ ﻟﻤﺎ ﻓﻲ اﻻﺳﻔﻞ‪.‬‬

‫ﻓﻲ ﻣﺮ ﺑﻊ اﻟﺒﺤﺚ ا ﻛﺘﺐ ‪ kotlin‬وﺳﺘﻈﻬﺮ ﻟﻚ ﻧﺘﻴﺠﺔ ﻣﺸﺎﺑﻬﺔ ﻟﻤﺎ ﻓﻲ اﻟﺼﻮرة ﻗﻢ ﺑﺘﺜﺒﻴﺘﻬﺎ ﻓﻲ‬
‫اﻟﻐﺎﻟﺐ ﺳـ ـﺘﺤﺘﺎج اﻻﻧﺘﻈﺎر ﻟﺒﻌﺾ اﻟﻮﻗﺖ ﻟﺘﺤﻤﻴﻞ وذﻟﻚ ﻳﻌﺘﻤﺪ ﻋﻠﻰ ﺳـ ـﺮﻋﺔ اﻻﻧﺘﺮﻧﺖ ﻟﺪﻳﻚ ‪.‬‬
‫ﻓﻲ اﻟﻐﺎﻟﺐ ﺑﻌﺪ اﻟﺘﺤﺪﻳﺚ ﺳﺘﺤﺘﺎج اﻟﻰ اﻋﺎدة ﺗﺸﻐﻴﻞ‪Eclipse .‬‬
‫ﻣﺸﺮوع ‪Kotlin‬‬
‫اﻵن ﺑﻌﺪ اﻋﺎدة اﻟﺘﺸـﻐﻴﻞ ﺳـﺘﺴـﻄﻴﻊ اﺳـﺘﺨﺪام ‪ Eclipse‬ﻓﻲ ﺑﺮﻣﺠﺔ ﻣﺸـﺎر ﻳﻊ ‪ Kotlin .‬ﻣﻦ‬
‫ﻗﺎﺋﻤﺔ ‪ File -> New -> Others‬ﺑﻌﺪ ذﻟﻚ ﻗﻢ ﺑﺎﺧﺘﻴﺎر ”‪ “Kotlin project‬ﻣﻦ اﻟﻘﺎﺋﻤﺔ‪.‬‬

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

‫ﻋﻨـﺪ ﻓﺘﺢ ﻣﻠﻒ ‪ Hello.kt‬ﺳـ ــــــ ـﺘﺠـﺪ ﺷـ ــــــ ـﻔﺮة ﺑﺮﻣﺠﻴـﺔ اﻟﺘﻲ ﻻ ـ‬
‫اﻟﺒﺮﻣﺠﺔ‪“Hello World” .‬‬
‫{ )>‪fun main(args: Array<String‬‬

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

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

‫ﺛﺎﻟﺜﺎ ً ‪ :‬ﻣﺰا ﻳﺎ ﻟﻐﺔ ﻛﻮﺗﻠﻦ ‪Kotlin‬‬
‫• ﻟﻐﺔ ﻣﻔﺘﻮﺣﺔ اﻟﻤﺼﺪر‪.‬‬

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

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

‫• اﻟﺘﻌﻠﻴﻘﺎت‬
‫• اﻟﻌﻤﻠﻴﺎت اﻟﺮ ﻳﺎﺿﻴﺔ‬
‫• اﻟﻌﻤﻠﻴﺎت اﻟﻤﻨﻄﻘﻴﺔ‬
‫• اﻟﺴﻼﺳﻞ اﻟﻨﺼﻴﺔ‬
‫• اﻟﻤﺼﻔﻮﻓﺎت‬
‫• اﻟﻨﻄﺎق‬
‫• ‪Visibility Modifiers‬‬
‫• ‪ESCAPE SEQUENCE‬‬
‫• ‪UNICODE‬‬
‫• )‪REGEX (Regular Expression‬‬
‫اﻟﻤﺘﻐﻴﺮات‬
‫ﻋﻨﺪ ﺗﻌﻠﻢ أي ﻟﻐﺔ ﻓﻼﺑﺪ ﻣﻦ اﻟﺘﻄﺮق ﻷﺳـ ـﺎﺳـ ـﻴﺎﺗﻬﺎ وﻣﻦ ﺿـ ـﻤﻦ ﻫﺬه اﻷﺳـ ـﺎﺳـ ـﻴﺎت اﻟﻤﻬﻤﺔ‬
‫ﻫﻲ ﻛﺘﺎﺑﺔ اﻟﻤﺘﻐﻴﺮات ﺑﻄﺮ ﻳﻘﺔ ﺻـ ــ ـﺤﻴﺤﺔ وﺳـ ــ ـﻨﺘﻌﺮف ﻓﻲ ﻫﺬا اﻟﺪرس ﻋﻠﻰ ﺗﻌﺮ ﻳﻒ اﻟﻤﺘﻐﻴﺮات‪،‬‬
‫واﻟﺜﻮاﺑﺖ‪ ،‬وﺷﺮوط اﻟﺘﺴﻤﻴﺔ ‪ ،‬ﺟﻤﻠﺔ اﻟﻄﺒﺎﻋﺔ واﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‪.‬‬
‫اﻟﻤﺘﻐﻴﺮات ﻫﻲ ﻋﺒـﺎرة ﻋﻦ ﻗﻴﻤـﺔ ﻗـﺎﺑﻠـﺔ ﻟﻠﺘﻐﻴﻴﺮ اﺛﻨـﺎء ﻛﺘـﺎﺑـﺔ اﻟﺒﺮﻧـﺎﻣﺞ‪ ،‬ﻟﺘﻌﺮ ﻳﻒ اﻟﻤﺘﻐﻴﺮات‬
‫ﻓﻲ ﻟﻐﺔ ‪ kotlin‬ﻧﺴﺘﺨﺪام ﻛﻠﻤﺔ ‪ ،var‬وﺳﻨﺮى اﻷن أﺷﻜﺎل ﻣﺨﺘﻠﻔﺔ ﻟﻠﺘﻌﺮ ﻳﻒ ﺑﺎﻟﻤﺘﻐﻴﺮات‪.‬‬
‫أوﻻ ‪ :‬ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات‬

‫‪ 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‬‬

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

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

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

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

‫ﻣﻊ ﻣﻼﺣﻈـ ـ ـﺔ ان اﻟﻤﺘﻐﻴﺮ ‪ double‬ﻳﺘﻜﻮن ﻣﻦ ‪ bit64‬ﺑﻌﻜﺲ ‪ float‬اﻟـ ـ ـﺬي ﻳﺘﻜﻮن ﻣﻦ‬
‫‪ bit32‬ﻓﻘﻂ‬
‫‪var cost:Double=12.9001111‬‬
‫‪var cost = 14.1655f‬‬
‫‪ v‬اﻟﺜ ﻮ اﺑﺖ‬
‫ﺗﻨﻄﺒﻖ ﻋﻠﻴﻪ ﻧﻔﺲ ﻣﻮاﺻـ ـــــ ـﻔﺎت اﻟﻤﺘﻐﻴﺮات ﺑﺎﺳـ ـــــ ـﺘﺜﻨﺎء أﻧﻪ ﻗﻴﻤﺔ ﻏﻴﺮ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻌﺪﻳﻞ أﺛﻨﺎء‬
‫اﻟﺒﺮﻧﺎﻣﺞ وﻟﺘﻌﺮ ﻳﻒ اﻟﺜﺎﺑﺖ ﻧﺴـ ـــ ـﺘﺨﺪم ﻛﻠﻤﺔ ‪ ، val‬ﻳﻤﻜﻨﻨﺎ اﻻﺳـ ـــ ـﺘﻔﺎدة ﻣﻨﻪ ﻓﻲ ﺗﻌﺮ ﻳﻒ اﻟﻘﻮاﻧﻴﻦ‬
‫اﻟﺮ ﻳـﺎﺿـ ــــــ ـﻴـﺔ أو ﻟﻮ ﻛـﺎن ﻫﻨـﺎﻟـﻚ رﻗﻢ وﻇﻴﻔﻲ ﻓﻬﻮ ﺛـﺎﺑـﺖ ﺑـﺎﻟﻄﺒﻊ ﻻ ﻳﻤﻜﻦ ﺗﻐﻴﻴﺮه آو رﻗﻢ اﻟﻬﻮﻳـﺔ‬
‫اﻟﻮﻃﻨﻲ‪.‬‬
‫‪val id:Int=601121‬‬
‫‪id = 1234 // Error‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬ﺗﺤﻮﻳﻞ اﻟﻤﺘﻐﻴﺮات‬
‫ر ﺑﻤﺎ ﻛﺘﺒﺖ ﻣﺘﻐﻴﺮ واردت ﺗﺤﻮﻳﻞ اﻟﻰ اي ﻧﻮع آﺧﺮ ﻓﺎﻧﻚ ﻟﻦ ﺗﺴـﺘﻄﻴﻊ ذﻟﻚ ﺑﺴـﺒﺐ اﻧﻚ ﻗﺪ‬
‫ﺣـﺪدت ﻧﻮع اﻟﻤﺘﻐﻴﺮ او ان ‪ Compiler‬ﻗـﺪ ﻗـﺎم ﺑﺘﺤـﺪﻳـﺪ ﻧﻮع اﻟﻤﺘﻐﻴﺮ اذا ﻛـﺎن اﺳـ ــــــ ـﻨـﺎد اﻟﻘﻴﻤـﺔ‬
‫ﺑﺸ ـﻜﻞ ﻣﺒﺎﺷ ـﺮ‪ .‬ﺗﺤﻮﻳﻞ اﻟﻤﺘﻐﻴﺮات اﺑﺴ ـﻂ ﻣﻤﺎ ﺗﺘﺨﻴﻞ ﻟﻦ ﺗﺤﺘﺎج اﻟﻰ ا ﻛﺜﺮ ﻣﻦ ﺳ ـﻄﺮ او ذا ﻛﺮة‬
‫ﻛﺒﻴﺮه ﻟﺤﻔﻆ اﻟﻄﺮ ﻳﻘﺔ‪ .‬ﺗﺎﺑﻊ اﻟﺸﻔﺮة اﻟﻘﺎدﻣﺔ‪.‬‬

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‬‬
‫اد ﺧ ﺎل اﻟﺒﻴﺎﻧﺎت‬

‫ﺳﺘﻘﺒﺎل اﻟﺒﻴﺎﻧﺎت ﻣﻦ اﻟﻤ ـ‬
‫ﺴﺘﺨﺪم وﻛﻴﻔﻴﺔ اﻟﺘﺤﻮﻳﻞ‬ ‫ﻓﻲ ﻫﺬا اﻟﺪرس ـ‬
‫ﺳﻨﺘﻌﺮف ﻋﻠﻰ ﻃﺮ ﻳﻘﺔ ا ـ‬
‫ﺑﻴﻦ اﻟﻤﺘﻐﻴﺮات ‪.‬‬
‫أوﻻ ‪ :‬داﻟﺔ ‪readLine‬‬
‫ﻧﺴـ ــــــ ـﺘﺨـﺪم ﻫـﺬه اﻟـﺪاﻟـﺔ ﻋﻨـﺪﻣـﺎ ﻧﺮ ﻳـﺪ اﺳـ ــــــ ـﺘﻘﺒـﺎل ﻗﻴﻤـﺔ ﻣﻦ اﻟﻤﺴـ ــــــ ـﺘﺨـﺪم ‪ ،‬ﻣﺜﻼ ﻃﻠﺒـﺖ ﻣﻦ‬
‫اﻟﻤﺴـﺘﺨﺪم أن ﻳﺪﺧﻞ اﺳـﻤﻪ و ﻋﻤﺮه واﻟﻤﺮﺣﻠﺔ اﻟﺪراﺳـﻴﺔ ﻓﻬﻨﺎ ﻧﻘﻮم ﺑﺎﺳـﺘﺨﺪام ﻫﺬه اﻟﺪاﻟﺔ ﻛﻤﺎ‬
‫ﺳﻨﺮى‪.‬‬
‫)"‪println("please enter your name‬‬

‫!!)(‪var yourName:String= readLine‬‬
‫)" ‪println("Hello $yourName‬‬
‫ﻓﻲ اﻟﻤﺜﺎل أﻋﻼه ﻃﻠﺒﻨﺎ ﻣﻦ اﻟﻤﺴﺘﺨﺪم أن ﻳﺪﺧﻞ اﺳﻤﻪ ﻣﻦ ﺧﻼل ﺟﻤﻠﺔ اﻟﻄﺒﺎﻋﺔ ‪ ،‬وﻣﻦ ﺛﻢ‬
‫ﻋﺮﻓﻨﺎ ﻣﺘﻐﻴﺮ وﺣﺪدﻧﺎ ﻧﻮﻋﻪ وﻗﻤﻨﺎ ﺑﺈﺳﻨﺎد اﻟﺪاﻟﺔ اﻟﺘﻲ ﺗﻘﻮم ﺑﺎﺳﺘﻘﺒﺎل ﻫﺬه اﻟﻘﻴﻤﺔ‪.‬‬
‫ﺗﻌﻨﻲ ﻗﻢ ﺑﻘﺮاءة ﻣﺎ ﺳﻮف ﻳﺪﺧﻠﻪ اﻟﻤﺴﺘﺨﺪم‪.‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬اﻟﺘﺤﻮﻳﻞ‬
‫‪ readLine‬ﻫﺬه اﻟﺪاﻟﺔ ﺗﺴـ ـــ ـﺘﻘﺒﻞ ﻗﻴﻤﺔ ﻓﻘﻂ ﻧﺼـ ـــ ـﻴﺔ أي ﻣﻦ ﻧﻮع ‪ ،String‬وﻟﻜﻦ ﻓﻠﻨﻔﺮض‬
‫أﻧﻨﺎ أردﻧﺎ ﻣﻦ اﻟﻤﺴﺘﺨﺪم إدﺧﺎل ﻋﻤﺮه واﻟﻌﻤﺮ ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ﺻﺤﻴﺢ‪ ،‬ﻣﺎ اﻟﻌﻤﻞ إذا ؟‬
‫اﻟﺤﻞ ﺑﺴﻴﻂ ﺟﺪا ً ﻛﺎﻟﺘﺎﻟﻲ ‪:‬‬

‫)"‪println("please enter your age‬‬
‫)(‪var yourAge:Int= readLine()!!.toInt‬‬
‫)(‪yourAge.toInt‬‬
‫ﻋﺮﻓﻨﺎ ﻣﺘﻐﻴﺮ اﻟﻌﻤﺮ ﻣﻦ ﻧﻮع ﻋﺪد ﺻـ ـــــ ـﺤﻴﺢ وﻣﻦ ﺛﻢ ﻗﻤﻨﺎ ﺑﺈﺳـ ـــــ ـﻨﺎد اﻟﺪاﻟﺔ ﻟﺘﻘﻮم ﺑﻘﺮاءة ﻣﺎ‬
‫ﻳﺪﺧﻠﻪ اﻟﻤﺴﺘﺨﺪم وﻣﻦ ﺛﻢ ﻗﻤﻨﺎ ﺑﺎﻟﺨﻄﻮة اﻟﺠﺪﻳﺪة اﻟﺘﺎﻟﻴﺔ وﻫﻲ اﻟﺘﺤﻮﻳﻞ ‪:‬‬
‫)(‪.toInt‬‬
‫ﻫـﺬا اﻟﺴـ ــــــ ـﻄﺮ ﻳﻌﻨﻲ أن ﻧﻘﻮم ﺑﺘﺤﻮﻳـﻞ اﻟﻌﻤﺮ ﻣﻦ ﻣﺘﻐﻴﺮ ﻧﺼـ ــــــ ـﻲ إﻟﻰ ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ﻋـﺪد‬
‫ﺻﺤﻴﺢ وذﻟﻚ ﻷن داﻟﺔ‬
‫ﺗﻘﺮأ اﻟﻨﺺ ﻋﻠﻰ أﻧﻪ ﺳﻠﺴﻠﺔ ﻧﺼﻴﺔ ‪.readline‬‬
‫ﻟﻮ أردﻧﺎ اﻟﺘﺤﻮﻳﻞ إﻟﻰ ﻣﺘﻐﻴﺮ ﻧﻮﻋﻪ ﻋﺪد ﻋﺸﺮي‪:‬‬
‫)(‪Age.toFloat‬‬
‫ﻫﻨﺎ ﻟﻮ أردﻧﺎ اﻟﺘﺤﻮﻳﻞ إﻟﻰ ﻣﺘﻐﻴﺮ ﻧﻮﻋﻪ ﻋﺪد ﻋﺸﺮي ﻣﺰدوج ‪:‬‬
‫)(‪Age.toDouble‬‬
‫ﻻ ﻳﻘﺘﺼﺮ اﻟﺘﺤﻮﻳﻞ ﻋﻠﻴﻬﻢ ﻓﻴﻤﻜﻨﻨﺎ اﻟﺘﺤﻮﻳﻞ إﻟﻰ أي ﻧﻮع‪ ،‬ﺑﺎﺳﺘﺜﻨﺎء ‪:‬‬
‫ﻋﺪد ﺻـ ــــــ ـﺤﻴﺢ ﻻ ﻳﻤﻜﻦ ﺗﺤﻮﻳـﻠﻪ إﻟﻰ ﻣﻨﻄﻘﻲ وذـﻟﻚ ﻷن اﻟﻤﻨﻄﻘﻲ ﻳﺤ ـ‬

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

‫ ﻣ ﺜﺎل‬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
‫اﻟﺘﻌ ﻠﻴﻘ ﺎت‬

‫ﻻ ﻳﺨﻔﻰ ﻋﻠﻴﻨ ـﺎ أن ﻛﺘ ـﺎﺑ ـﺔ اﻟﺘﻌﻠﻴﻘ ـﺎت ﻣﻔﻴ ـﺪة ﺟ ـﺪا ً ﻟﻠﻤﺒﺮﻣﺠﻴﻦ ﻓﻬﻲ ﺗﻌﻤ ـﻞ ﻋﻠﻰ ﺗﻌﺮ ﻳﻒ‬
‫ﻌﺔ اﻟﺒﺮﻣﺠـﻴﺔ ﻛـﻔﺎـﺋﺪﺗـﻬﺎ أو ـﻣﺎ اﻟﻐﺮض ﻣﻨـﻬﺎ ﻓﻲ ﺣﻴﻦ أـﻧﻪ ﻧﺴـ ــــــ ـﻲ ـﻣﺎ اﻟـﻬﺪف اـﻟﺬي ﻣﻦ أﺟـﻠﻪ‬
‫اﻟﻘﻄ ـ‬
‫ﻛﺘﺒﻬﺎ ‪ ،‬وﻫﻲ ﻻ ﺗﺆﺛﺮ ﻓﻲ ﻋﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻛﻤﺎ ﻧﻌﻠﻢ ﻓﻼ ﻳﺘﻢ ﺗﻨﻔﻴﺬﻫﺎ ﻣﻦ اﻷﺳـﺎس ﻷن اﻟﺒﺮﻧﺎﻣﺞ ﻻ‬
‫ﻳﺴﺘﻄﻴﻊ ﻗﺮأﺗﻬﺎ ‪.‬‬
‫وﻟﻠﺘﻌﻠﻴﻘـﺎت ﻧﻮﻋـﺎن اﻣـﺎ ان ﺗﻜﻮن ﺳـ ــــــ ـﻄﺮ ﻳـﺔ أي ﺗﻌﻠﻴﻖ ﻓﻲ ﺳـ ــــــ ـﻄﺮ واح ﻓﻘﻂ أو ﻣﺘﻌـﺪدة‬
‫اﻷﺳﻄﺮ‪ ،‬ﻣﺜﺎل‪:‬‬
‫‪ 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--‬‬

‫اﻟﻌ ﻤ ﻠﻴﺎت اﻟﺮ ﻳﺎﺿ ﻴﺔ‬
‫ﺳـ ـﻨﺘﻄﺮق إﻟﻰ اﻟﻌﻤﻠﻴﺎت اﻟﺮ ﻳﺎﺿـ ـﻴﺔ اﻟﺘﻲ ﺗﻠﻌﺐ دور ﻣﻬﻢ وﻛﺒﻴﺮ ﻓﻲ اﻟﺒﺮﻣﺠﺔ ‪ ،‬ﺳـ ـﻮف ﻧﻘﻮم‬
‫ﺑﺸـ ــ ـﺮح اﻟﻌﻤﻠﻴﺎت ‪ ،‬رﻣﻮزﻫﺎ ‪ ،‬ﻃﺮق ﻣﺨﺘﺼـ ــ ـﺮة ﻹﺟﺮاء اﻟﻌﻤﻠﻴﺎت وأ ﻳﻀـ ــ ـﺎ ً ﺳـ ــ ـﻨﺘﻌﻠﻢ ﻛﻴﻔﻴﺔ ﻛﺘﺎﺑﺔ‬
‫اﻟﺘﻌﻠﻴﻘﺎت‪.‬‬
‫أوﻻ ‪ :‬اﻟﺮﻣﻮز اﻟﺮﻳﺎﺿﻴﺔ‬
‫ﻓﻲ اﻟﺒﺪا ﻳﺔ ﻧﺤﺐ أن ﻧﻘﻮم ﺑﺘﻌﺮ ﻳﻒ اﻟﻌﻤﻠﻴﺎت اﻷﺳـ ــ ـﺎﺳـ ــ ـﻴﺔ وﻫﻲ ‪ :‬اﻟﺠﻤﻊ‪ ،‬اﻟﻄﺮح‪ ،‬اﻟﻀـ ــ ـﺮب‪،‬‬
‫اﻟﻘﺴﻤﺔ وﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ‪.‬‬
‫اﻟﻌﻤﻠﻴﺔ‬ ‫اﻟﺮﻣﺰ‬
‫اﻟﺠﻤﻊ‬ ‫‪+‬‬
‫اﻟﻄﺮح‬ ‫–‬
‫اﻟﻀﺮب‬ ‫*‬
‫اﻟﻘﺴﻤﺔ‬ ‫‪/‬‬
‫ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ‬ ‫‪٪‬‬
‫ﻓﻲ اﻟﻌﻤﻠﻴﺎت اﻟﺮ ﻳﺎﺿـﻴﺔ ﻳﺮاﻋﻰ ﻋﻨﺪ ﺗﻨﻔﻴﺬﻫﺎ إذا ﻛﺎﻧﺖ ﺗﺘ ـ‬
‫ﻀﻤﻦ اﻷﻗﻮاس‪ ،‬وﻋﻤﻠﻴﺔ اﻟﻀـﺮب‪/‬‬
‫اﻟﻘﺴﻤﺔ‪ ،‬واﻟﺠﻤﻊ‪ /‬اﻟﻄﺮح اﻟﺘﺎﻟﻲ‪:‬‬

‫ﻧﺒﺪأ ﺑﺘﻨﻔﻴﺬ ﻣﺎ ﺑﻴﻦ اﻷﻗﻮاس وﻣﻦ ﺛﻢ ﻋﻤﻠﻴﺔ اﻟﻀﺮب‪ /‬اﻟﻘﺴﻤﺔ وﻣﻦ ﺛﻢ اﻟﺠﻤﻊ‪ /‬اﻟﻄﺮح‪.‬‬
‫ﻫﺬا ﻣﺜﺎل ﻳﺤﺴـﺐ ﻟﻨﺎ ﻣﺴـﺎﺣﺔ اﻟﻤﺴـﺘﻄﻴﻞ وﻣﺤﻴﻄﻪ‪ ،‬ﻧﺠﺪ أن اﻟﻤﺴـﺎﺣﺔ ﻫﻲ ﻣﺠﺮد ﻋﻤﻠﻴﺔ‬
‫ﺿـ ـــ ـﺮب ﻋﺎدﻳﺔ ‪ ،‬وﺑﺎﻟﻨﺴـ ـــ ـﺒﺔ ﻟﻠﻤﺤﻴﻂ ﻓﻬﻮ ﻳﻌﻄﻲ أوﻟﻮﻳﺔ اﻟﺘﻨﻔﻴﺬ إﻟﻰ اﻷﻗﻮاس وﻣﻦ ﺛﻢ ﻳﻀـ ـــ ـﺮب‬
‫اﻟﻨﺎﺗﺞ ﻓﻲ ‪.٢‬‬
‫‪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‬‬
‫ﺛﺎﻧﻴﺎ ‪Decrement & Increment :‬‬

‫ﻟﻨﻔﺮض أن ﻟﺪي ﻣﺘﻐﻴﺮ وأر ﻳﺪ ز ﻳﺎدﺗﻪ ﺑﻌﺪد واﺣﺪ ﻓﻘﻂ ﺳـ ـﻮف ﻧﻘﻮم ﺑﻌﻤﻠﻴﺔ ﺑﺴـ ـﻴﻄﺔ ﺟﺪا ً‬
‫وﻫﻲ ﺗﻌﺮف ﺑﺎﻟﺰ ﻳﺎدة أو‪.Increment‬‬
‫‪var num1=5‬‬
‫‪num1++‬‬
‫ﻫﻨﺎ ﻗﻤﻨﺎ ﺑﺎﻹﺧﺘﺼﺎر ﻓﺒﺪﻻ ﻣﻦ ﻛﺘﺎﺑﺔ ‪:‬‬
‫‪num=num+1‬‬
‫ﻗﻤﻨﺎ ﺑﻜﺘﺎﺑﺔ ‪:‬‬
‫‪num1++‬‬
‫ﻟﻮ أردﻧﺎ ﻃﺮح ﻋﺪد واﺣﺪ ﻣﻦ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﺳـ ـــــ ـﻮف ﻧﻘﻮم ﺑﻌﻤﻠﻴﺔ اﻟﻨﻘﺼـ ـــــ ـﺎن أو ﻣﺎ ﺗﻌﺮف‬
‫ﺑـ ‪Decrement‬‬
‫‪var num1=5‬‬
‫‪num1--‬‬
‫اﻟﻌ ﻤ ﻠﻴﺎت اﻟﻤ ﻨﻄ ﻘ ﻴﺔ‬

‫ﺳـ ــــــ ـﻨﺘﻄﺮق إﻟﻰ اﻟﻌﻤﻠﻴـﺎت اﻟﻤﻨﻄﻘﻴـﺔ اﻟﺘﻲ ﻫﻲ أ ﻳﻀـ ـــــــ ـﺎ ﺑـﺪورﻫـﺎ ﺗﻠﻌـﺐ دور ﻣﻬﻢ وﻛﺒﻴﺮ ﻓﻲ‬
‫اﻟﺒﺮﻣﺠﺔ‪ ،‬ﺳـ ـــ ـﻮف ﻧﻘﻮم ﺑﺸـ ـــ ـﺮح اﻟﻌﻤﻠﻴﺎت‪ ،‬رﻣﻮزﻫﺎ‪ ،‬ﻃﺮق ﻣﺨﺘﺼـ ـــ ـﺮة ﻹﺟﺮاء اﻟﻌﻤﻠﻴﺎت وأ ﻳﻀـ ـــ ـﺎ ً‬
‫ﺳﻨﺘﻌﻠﻢ ﻛﻴﻔﻴﺔ ﻛﺘﺎﺑﺔ اﻟﺘﻌﻠﻴﻘﺎت‪.‬‬
‫أوﻻ ‪ :‬اﻟﺮﻣﻮز اﻟﻤﻨﻄﻘﻴﺔ‬
‫ﻓﻲ اﻟﺒـﺪا ﻳـﺔ ﻧﺤـﺐ أن ﻧﻘﻮم ﺑﺘﻌﺮ ﻳﻒ اﻟﻌﻤﻠﻴـﺎت اﻷﺳـ ـــــــ ـﺎﺳـ ــــــ ـﻴـﺔ وﻫﻲ‪ :‬اﺻـ ــــــ ـﻐﺮ‪ ،‬ا ﻛﺒﺮ‪ ،‬اﻟﻨﻔﻲ‪،‬‬
‫اﻟﻤﺴﺎواة‪.‬‬
‫اﻟﻌﻤﻠﻴﺔ‬ ‫اﻟﺮﻣﺰ‬
‫اﺻﻐﺮ‬ ‫<‬
‫ا ﻛﺒﺮ‬ ‫>‬
‫اﺻﻐﺮ ﻣﻦ او ﻳﺴﺎوي‬ ‫>=‬
‫ا ﻛﺒﺮ ﻣﻦ او ﻳﺴﺎوي‬ ‫<=‬
‫ﻳﺴﺎوي‬ ‫==‬
‫ﻋﻼﻣﺔ اﻟﻨﻔﻲ‬ ‫!‬
‫ﻻ ﻳﺴﺎوي‬ ‫=!‬
‫‪ v‬أﻣ ﺜ ﻠﺔ‬
‫§ ﻫﻨـﺎ ﻧﻄﻠـﺐ اﻟﺘﺤﻘﻖ ﺑﻴﻦ اﻟﻘﻴﻤﺘﻴﻦ ‪ number1‬و ‪ number2‬واﻟﻨـﺎﺗﺞ اﻟﻌـﺎﺋـﺪ ﻟﻨـﺎ‬

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

‫‪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‬‬

‫ﻟﻮ ﻛ ـﺎن ﻟ ـﺪي ﻗﻴﻤ ـﺔ ار ﻳ ـﺪ اﻟﺘﺤﻘﻖ ﻣﻨﻬ ـﺎ وﻟ ـﺪي ﻗﻴﻤ ـﺔ أﺧﺮى وأر ﻳ ـﺪ اﻟﺘﺤﻘﻖ ﻣﻨﻬ ـﺎ أ ﻳﻀـ ـــــــ ـﺎ‬
‫ﻌﺎ ﻣﺘﺤﻘﻖ‬ ‫ﺠﺐ ان ﻳﻜﻮن ـﻧﺎﺗﺠﻬ ـ‬
‫ﻤﺎ ﺟﻤﻴ ـ‬ ‫ﻌﻞ ذـﻟﻚ ﻋﻦ ﻃﺮ ﻳﻖ ﺑﻮاـﺑﺔ ‪ AND‬وﻟﻜﻦ ﻳ ـ‬
‫‪،‬ﻧﺴـ ــــــ ـﺘﻄﻴﻊ ﻓ ـ‬
‫أي اﻧﻪ ﻻ ﻳﻜﻮن اﻟﺸﺮط اﻷول ﺻﺤﻴﺤﺎ واﻷﺧﺮ ﺧﻄﺎء‪.‬‬
‫ﻟﺬﻟﻚ ﻧﺴـ ــــــ ـﺘﺨﺪﻣﻬﺎ ﻛﺜﻴﺮا ﻓﻲ اﻟﺘﺤﻘﻖ ﻣﻦ اﺳـ ــــــ ـﻢ اﻟﻤﺴـ ــــــ ـﺘﺨﺪم وﻛﻠﻤﺔ اﻟﻤﺮور ﻋﻨﺪﻣﺎ ﻳﻘﻮم‬
‫اﻟﻤﺴـ ـــ ـﺘﺨﺪم ﻣﻦ ادﺧﺎل اﻟﻤﻌﺮف اﻟﺨﺎص ﺑﻪ وﻛﻠﻤﺔ اﻟﻤﺮور اﻟﺨﺎﺻـ ـــ ـﺔ أ ﻳﻀـ ـــ ـﺎ ﺑﻪ وﻛﺎﻧﺘﺎ ﻛﻠﺘﺎﻫﻤﺎ‬
‫ﺻـ ــــــ ـﺤﻴﺤﺘـﺎن ﺣﻴﻨﻬـﺎ ﻳﻜﻮن اﻟﻨـﺎﺗﺞ ﻟـﺪﻳﻨـﺎ ‪ true‬ﺑـﺪاﺧـﻞ اﻟﺒﺮﻧـﺎﻣﺞ وﻧـﺎﺗﺞ اﻟﺘﻨﻔﻴـﺬ ﻫﻮ اﻟـﺪﺧﻮل إﻟﻰ‬
‫اﻟﺒﺮﻧﺎﻣﺞ وﻟﻜﻦ ﻓﻲ ﺣﺎل اﻧﻪ ادﺧﻞ اﻟﻤﻌﺮف اﻟﺨﺎص ﺑﻪ ﺑﺸـ ـﻜﻞ ﺻـ ـﺤﻴﺢ واﺧﻄﺎء ﻓﻲ ﻛﺘﺎﺑﺔ ﻛﻠﻤﺔ‬
‫اﻟﻤﺮور ﻓـﺎﻟﻨـﺎﺗﺞ ﺑـﺎﻟـﺪاﺧـﻞ ﺳـ ــــــ ـﻴﻜﻮن ﺧﻄـﺎء وﻧـﺎﺗﺞ اﻟﺘﻨﻔﻴـﺬ اﻟـﺬي ﻧﺮاه ﻟﻦ ﻳﺴـ ــــــ ـﻤﺢ ﻟﻲ ﺑـﺪﺧﻮل‬
‫اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫ﺗﻤﺜﻞ ﺑﺮﻣﺠﻴﺎ ً ﺑﻬﺬا اﻟﺮﻣﺰ )&&(‪.‬‬
‫وﻓﻲ اﻟﻤﺜﺎل ﻧﺠﺪ أﻧﻪ ﻟﺪي ﻗﻴﻤﺘﻴﻦ ار ﻳﺪ اﻟﺘﺤﻘﻖ ﻣﻨﻬﻤﺎ ﻛﻠﻬﻤﺎ ﺑﺄﻧﻬﻤﺎ ﻳﻌﻴﺪان ﻟﻲ ‪.true‬‬
‫‪var number1:Int = 7‬‬

‫)‪println(number1 < 10 && number2 < 5‬‬
‫‪output : true‬‬
‫‪ v‬ﺑﻮاﺑﺔ ‪OR‬‬

‫ﻫـﺬه اﻟﺒﻮاﺑـﺔ ﺗﺨـﺎﻟﻒ ‪ AND‬ﻓﻲ اﻧﻬـﺎ اذا ﻛـﺎن اﺣـﺪ اﻟﺸـ ــــــ ـﺮﻃﻴﻦ ﺻـ ــــــ ـﺤﻴﺢ ﻓﻬﻲ ﺗﻌﻴـﺪ ﻗﻴﻤـﺔ‬
‫ﺻﺤﻴﺤﺔ ‪ true‬أي اﻧﻬﺎ ﻻ ﺗﺸﺘﺮط ان ﻳﻜﻮن ﻛﻼﻫﻤﺎ ﺻﺤﻴﺤﻴﻦ‪.‬‬
‫ﺗﻤﺜﻞ ﺑﺮﻣﺠﻴﺎ ً ﺑﻬﺬا اﻟﺮﻣﺰ )||(‪.‬‬
‫اذا ﻛـﺎن اﺣـﺪﻫﻤـﺎ ﺻـ ــــــ ـﺤﻴﺢ ﻋﻠﻰ اﻷﻗـﻞ ﻓﻬﻲ ﺗﻌﻴـﺪ ‪ true‬اذا ﻻ ﺗﺸـ ــــــ ـﺘﺮط ان ﻳﻜﻮن ﻛﻼﻫﻤـﺎ‬
‫ﺻﺤﻴﺢ ﻛﻤﺎ ﻓﻲ ‪.AND‬‬

‫)‪println(number1 < 10 || number2 > 5‬‬
‫‪output : true‬‬
‫‪ v‬ﺑﻮاﺑﺔ ‪NOT‬‬
‫ﺗﻘﻮم ﺑﻨﻔﻲ اﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ ﻛﻤﺎ ﺷﺮﺣﻨﺎه ﻓﻲ اﻟﻤﺜﺎل اﻋﻼه‪.‬‬
‫‪ v‬ﺟﺪول ﻣﻘﺎرﻧﺔ‬
‫ﺑﻮاﺑﺔ ‪OR‬‬ ‫ﺑﻮاﺑﺔ ‪AND‬‬

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

‫اذا ﻛ ـﺎن اﺣ ـﺪﻫﻤ ـﺎ ﺻـ ــــــ ـﺤﻴﺢ ﻋﻠﻰ اﻷﻗ ـﻞ ﻓﻬﻲ‬ ‫‪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‬‬

‫ﻋﻨﺪﻣﺎ ﻧﺮ ﻳﺪ ﻣﻌﺮﻓﺔ ﻃﻮل اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ‪.‬‬
‫)‪println(name.length‬‬
‫‪plus v‬‬
‫ﻋﻨﺪﻣﺎ ﻧﺮ ﻳﺪ إﺿﺎﻓﺔ ﺳﻠﺴﻠﺔ ﻧﺼﻴﺔ ﻟﻠﺴﻠﺴﻠﺔ اﻟﺴﺎﺑﻘﺔ‪.‬‬
‫))"‪println(name.plus(" aljuaid‬‬
‫‪get v‬‬
‫ﻋﻨﺪﻣﺎ ﻧﺮ ﻳﺪ اﺳﺘﺮﺟﺎع اﻟﻘﻴﻤﺔ اﻟﺘﻲ ﻳﺸﻴﺮ إﻟﻴﻬﺎ اﻟﻌﻨﻮان أو اﻟﻤﺆﺷﺮ ]‪.[index‬‬
‫))‪println(name.get(3‬‬
‫‪equals v‬‬
‫اﻟﻘﻴﻤﺔ اﻟﻌﺎﺋﺪة ﻣﻦ اﻟﺪاﻟﺔ ﻫﻴﺎ ﻣﻨﻄﻘﻴﺔ ﻓﻬﻲ ﺗﺴ ـﺘﺨﺪم ﻟﻠﺘﺤﻘﻖ ﻣﻦ ﺗﻄﺎﺑﻖ اﻟﻘﻴﻢ وﺳ ـﻮف‬
‫ﻧﺮى ذﻟﻚ ﺑﺎﻟﻤﺜﺎل‪.‬‬

var name:String="Ahmed"
println(name.equals("Khaled"))
hashCode v
.‫وﻫﻲ ﻟﺠﻠﺐ اﻟﺘﺮﻣﻴﺰ اﻟﺨﺎص ﺑﺎﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ‬
println(name.hashCode())
replaceFirst v
.‫ﺗﻘﻮم ﺑﺎﺳﺘﺒﺪال اول ﺣﺮف ﻣﻦ اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ ﻓﻘﻂ‬
println(name.replaceFirst("A","G"))
reversed v
.‫ﺗﻘﻮم ﺑﻌﻜﺲ اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ‬
println(name.reversed())

‫‪toLowerCase v‬‬
‫ﺗﻘﻮم ﺑﺘﺤﻮﻳﻞ ﺣﺮوف اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ إﻟﻰ ﺣﺮوف ﺻﻐﻴﺮة‪.‬‬
‫))(‪println(name.toLowerCase‬‬
‫‪toUpperCase v‬‬
‫ﺗﻘﻮم ﺑﺘﺤﻮﻳﻞ ﺣﺮوف اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ إﻟﻰ ﺣﺮوف ﻛﺒﻴﺮة‪.‬‬
‫))(‪println(name.toUpperCase‬‬
‫‪removeRange v‬‬
‫ﻟﻮ ﻃﺮأ ﻓﻲ ﺑﺎﻟﻚ ﺣﺬف ﺣﺮف ﻣﻦ اﻟﺴـ ـﻠﺴـ ـﻠﺔ اﻟﻨﺼـ ـﻴﺔ أو ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺤﺮوف اﻟﻤﺘﺼـ ـﻠﺔ‬
‫ﻓﻜﻞ ﻣﺎ ﻳﺘﻮﺟﺐ ﻋﻠﻴﻚ ﻓﻌﻠﻪ ﻫﻮ ﺗﺤﺪﻳﺪ اﻟﻌﻨﻮان اﻟﺬي ﺳـ ـــ ـﺘﺒﺪأ ﺑﻪ ]‪ [index‬واﻟﺬي ﺳـ ـــ ـﺘﻨﺘﻬﻲ‬
‫ﻋﻨﺪه‪.‬‬
‫))‪println(name.removeRange(2,4‬‬

‫”‪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‬‬

‫ﻓﻲ اﻟﺒﺪا ﻳﺔ ﻧﻌﺮف اﻟﻤﺘﻐﻴﺮ وﻣﻦ ﺛﻢ ﺑﻌﺪ ﻋﻼﻣﺔ = ﻧﺤﺪد أن ﻧﻮع اﻟﻤﺘﻐﻴﺮ ﻣﺼـ ـﻔﻮﻓﺔ وﻣﻦ ﺛﻢ‬
‫ﻧﺤﺪد ﻧﻮﻋﻬﺎ >‪ <Int‬أﻧﻬﺎ ﻣﻦ ﻧﻮع ﻋﺪد ﺻ ـﺤﻴﺢ )‪(5‬ﺗﺸ ـﻴﺮ إﻟﻰ ﻃﻮل اﻟﻤﺼ ـﻔﻮﻓﺔ أي أﻧﻬﺎ ﺗﺤﻮي‬
‫ﺑﺪاﺧﻠﻬﺎ ‪ ٥‬ﻋﻨﺎﺻﺮ‪ ،‬وﻓﻲ اﻟﻨﻬﺎﻳﺔ }‪ {0‬ﻧﺤﺪد أن اﻟﻤﺆﺷﺮ أو ‪ index‬ﻳﺒﺪأ ﻣﻦ اﻟﺼﻔﺮ‪.‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬إدﺧﺎل ﻗﻴﻢ ﻟﻠﻤﺼﻔﻮﻓﺔ‬
‫ﺣﺴﻨﺎ ً اﻷن ﻋﺮﻓﻨﺎ ﻫﺬه اﻟﻤﺼﻔﻮﻓﺔ أر ﻳﺪ إدﺧﺎل ﻗﻴﻢ ﺑﺪاﺧﻠﻬﺎ أي ﺗﻌﺒﺌﺘﻬﺎ ‪ ،‬ﻧﺴﺘﻄﻴﻊ ﺗﻌﺒﺌﺘﻬﺎ‬
‫ﺑﻬﺬه اﻟﻄﺮ ﻳﻘﺔ‬
‫‪myArray[0]=12‬‬
‫وﻟﻜﻦ ﻫﺬه اﻟﻄﺮ ﻳﻘﺔ ﺳـ ـﺘﻜﻮن ﻣﺮﻫﻘﺔ ﻟﻮ ﻛﺎﻧﺖ اﻟﻤﺼـ ـﻔﻮﻓﺔ ﻟﺪي ﻃﻮ ﻳﻠﺔ أي ﺗﺤﻤﻞ ﻋﻨﺎﺻـ ـﺮ‬
‫ﻛﺜﻴﺮة‪ ،‬واﻟﺤﻞ اﻟﺴﺤﺮي ﻛﺎﻟﻌﺎدة ﻫﻮ اﺳﺘﺨﺪام اﻟﺪوارة أو ‪ ، loop‬ﻓﻘﻤﻨﺎ ﺑﺎﺳﺘﺨﺪام ‪: for loop‬‬
‫ﻃﺒﻌـﺎ ً ﻫـﺬا اﻟﻤﺜـﺎل اﻟـﺬي ﺳـ ــــــ ـﻮف ﻧﻄﺮﺣـﻪ ﻫﻮ ﻟﻮ أﻧﻨـﺎ أردﻧـﺎ ﻃﺒـﺎﻋـﺔ اﻷرﻗـﺎم ﻣﻦ ‪ ٤-٠‬ﺑـﺎﻟﺘﺮﺗﻴـﺐ‬
‫ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ‪:‬‬
‫)‪for(i in 0..5‬‬
‫{‬
‫‪myArray[i]=i‬‬
‫)]‪println(myArray[i‬‬
‫}‬
‫أوﻻ ً ‪:‬‬

‫)‪for(i in 0..5‬‬
‫اﻟﺤﻠﻘﺔ اﻟﺘﻲ ﻟﺪي ﻋﺪد ﻋﻨﺎﺻﺮﻫﺎ ﺳﺘﺔ ‪ ،‬ﻣﻦ ‪ ٠‬إﻟﻰ ‪.٥‬‬
‫ﺛﺎﻧﻴﺎ ً ‪:‬‬
‫‪ i myArray[i]=i‬ﺗﻌﺒﺮ ﻋﻦ إذا ﻛﺎﻧﺖ اﻟﺤﻠﻘﺔ ﺗﺒﺪأ ﻣﻦ ‪ ٠‬ﻓﺄﺟﻌﻞ أ ﻳﻀ ـﺎ ﻗﻴﻤﺔ اﻟﻌﻨﺼ ـﺮ = ‪، ٠‬‬

‫وﻫﻜﺬا‪:‬‬
‫…‬
‫ﺛﺎﻟﺜﺎ ً ‪:‬‬
‫وﻫﻲ اﻟﺨﻄﻮة اﻷﺧﻴﺮة ﺑﻌﺪ اﻟﺘﻌﺒﺌﺔ وﻫﻲ ﻃﺒﺎﻋﺔ اﻟﻌﻨﺎﺻﺮ‪.‬‬
‫ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ ‪:‬‬
‫‪0‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫ﺣﺴﻨﺎ ً وﻟﻜﻦ ﻟﻮ أردﻧﺎ ﻣﻦ اﻟﻤﺴﺘﺨﺪم ﺗﻌﺒﺌﺔ ﻫﺬه اﻟﻤﺼﻔﻮﻓﺔ ؟ اﻟﺤﻞ ﺑﺴﻴﻂ ﺟﺪا ً ‪:‬‬

‫)"‪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‬‬

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")

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

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

‫اﻻﺛﻨﺎن ﻟﻬﻢ ﻧﻔﺲ اﻻﺳـ ـــﺘﺨﺪام وﻫﻮ ﻣﻌﺮﻓﺔ ﻋﺪد ﻋﻨﺎﺻـ ـــﺮ اﻟﻤﺼـ ـــﻔﻮﻓﺔ‬ ‫‪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‬‬

‫ﻫﻨﺎ ﺳـ ــــ ـﻴﻘﻮم ﺑﻄﺒﺎﻋﺔ اﻟﻌﻨﺎﺻـ ــــ ـﺮ داﺧﻞ اﻟﻤﺼـ ــــ ـﻔﻮﻓﺔ ذات اﻟﻘﻴﻢ ‪ 3‬او‬
‫اﻗﻞ‪.‬‬
‫ﻟﻌﺮض اﻟﺘﺮﻣﻴﺰ اﻟﺨﺎص ﺑﺎﻟﻤﺼﻔﻮﻓﺔ‪:‬‬ ‫‪hashcode‬‬
‫))(‪println(myArray.hashCode‬‬
‫ﺗﻘﻮم ﺑﻌﻜﺲ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ‪:‬‬ ‫‪reserved‬‬
‫))(‪println(myArray.reversed‬‬
‫اﻟﻨﻄ ﺎق‬
‫اﻟﺤﺪود او اﻟﻨﻄﺎق ﻣﻦ اﻟﻤﺴـ ـــــ ـﻤﻰ ﻧﻌﻠﻢ او ﻧﻔﻬﻢ ان ﻟﻬﺎ ﻗﻴﻤﺔ ﺑﺪا ﻳﺔ وﻗﻴﻤﺔ ﻧﻬﺎﻳﺔ ﻣﺤﺪودة‬
‫وﺑﺪاﺧﻠﻬﺎ ارﻗﺎم او ﺣﺮوف اﻟﺦ‪.‬‬
‫أوﻻ ‪ :‬اﻟﻨﻄﺎق‬
‫ﻌﺔ ﺑﻴﻦ ‪ ١‬إﻟﻰ ‪ ١٠‬أو اﻷﺣﺮف ﻣﻦ أ إﻟﻰ ي ‪ ،‬أي اـﻧﻪ ﻣﺠﻤﻮ ـ‬

‫ﻋﺔ ﻗﻴﻢ‬ ‫ﻳﻌﺒﺮ ﻋﻦ اﻷرـﻗﺎم ﻣﺜﻼ اﻟﻮاﻗ ـ‬
‫ﻣﺘﺴـ ــــــ ـﻠﺴـ ــــــ ـﻠـﺔ ﻟﻬـﺎ ﻗﻴﻤـﺔ ﺑـﺪا ﻳـﺔ وﻟﻬـﺎ ﻧﻬـﺎﻳـﺔ ‪ ،‬ﻓﻲ ﺗﻌﺒﻴﺮاﺗﻨـﺎ اﻟﺒﺮﻣﺠﻴـﺔ ﻧﺤﺘـﺎﺟﻬـﺎ ﻓﻬﻲ ﺗﻮﻓﺮ اﻟﻮﻗـﺖ‬
‫وﺗﻌﺘﺒﺮ ﺗﻌﺒﻴﺮ ﻣﻤﺘﺎز وﺳﺮ ﻳﻊ‪.‬‬
‫‪ v‬أﻣ ﺜ ﻠﺔ‬
‫ﻟﻄﺒﺎﻋﺔ اﻷرﻗﺎم اﻟﺰوﺟﻴﺔ ﻣﻦ ‪ ١‬إﻟﻰ ‪: ٢٠‬‬
‫‪var evenNumbers=1..20‬‬

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")

‫{ ‪} else‬‬
‫)"‪println("not found‬‬
‫}‬
‫‪not found‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬اﻟﻘﻔﺰة أو ‪step‬‬
‫اﻟﻘﻔﺰة ﻫﻮ ﺑﻤﻌﻨﻰ ﻳﻜﻮن ﻟﺪي ﻧﻄﺎق وﻟﻜﻦ ار ﻳﺪ ﻋﻨﺎﺻـﺮ ﻣﻌﻴﻨﺔ ﺗﺒﻌﺪ ﻋﻦ ﺑﻌﻀـﻬﺎ ﺑﻤﺴـﺎﻓﺔ‬
‫ﺛـﺎﺑﺘـﻪ‪ ،‬ﺑﻤﻌﻨﻰ أﺧﺮ ﻧﻌﻠﻢ أن اﻷرﻗـﺎم اﻟﺰوﺟﻴـﺔ ﺗﺒﻌـﺪ ﻋﻦ ﺑﻌﻀـ ــــــ ـﻬـﺎ رﻗﻤﻴﻦ ﻓﻌﻨـﺪﻣـﺎ اﻋﻤـﻞ ﻗﻔﺰ ﻓﻲ‬
‫اﻟﻨﻄﺎق اﺳﺘﻄﻴﻊ اﻟﻮﺻﻮل إﻟﻴﻪ‪.‬‬
‫‪var numbers= 2..20‬‬

‫{)‪for(i in numbers step 2‬‬
‫}‬
‫‪output : 2 4 6 8 10 ..20‬‬
‫ﺛﺎﻟﺜﺎ ‪ :‬اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻨﻄﺎق‬
‫‪downTo v‬‬
‫ﻟﻄﺒﺎﻋﺔ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﺗﻨﺎزﻟﻴﺎ‪ ،‬ﻣﺜﺎل‪:‬‬

‫{)‪for (i in 10 downTo 0‬‬
‫}‬
‫‪until v‬‬
‫ﻟﻄﺒﺎﻋﺔ اﻟﻌﻨﺎﺻﺮ ﺗﺼﺎﻋﺪﻳﺎ‪ ،‬ﻣﺜﺎل‪:‬‬
‫{)‪for (i in 1 until 10‬‬

‫}‬
‫ﻫﻨـﺎ ﻳﺒـﺪأ ﻳﻄﺒﻊ ﻣﻦ رﻗﻢ ‪ ١‬وﻳﺘﻮﻗﻒ ﻋﻨـﺪ ‪ ، ٩‬وذﻟـﻚ ﻷن ‪ until‬ﺗﻌﻨﻲ ﺣﺘﻰ أي ﻛـﺂﻧﻨـﺎ ﻧﻘﻮل‬
‫ﺣﺘﻰ ﺗﺮى ‪ ١٠‬ﻓﺘﻮﻗﻒ ﻟﻮ أردﻧﺎ ﻃﺒﺎﻋﺔ اﻟﺮﻗﻢ ‪ ١٠‬ﻓﺴﻨﺠﻌﻞ اﻟﺮﻗﻢ ﻳﻨﺘﻬﻲ ﻋﻨﺪ ‪١١‬‬
‫داﻟ ـﺔ ﺟ ـﺎﻫﺰة ﻟﻮ اردﻧ ـﺎ اﻟﺒﺤ ـﺚ ﺑ ـﺪاﺧ ـﻞ اﻟﻨﻄ ـﺎق و واﻟﻘﻴﻤ ـﺔ اﻟﻌ ـﺎﺋ ـﺪة ﻣﻦ‬ ‫‪contains‬‬
‫اﻟﺒﺤﺚ ﻣﻨﻄﻘﻴﺔ‪ ،‬ﻣﺜﺎل‪:‬‬
‫"‪var letter="A".."Z‬‬
‫))"‪println(letter.contains("D‬‬
‫داﻟﺔ ﻟﻠﺘﺤﻘﻖ ﻫﻞ اﻟﻨﻄﺎق ﺧﺎﻟﻲ ام ﻻ واﻟﻘﻴﻤﺔ اﻟﻌﺎﺋﺪة ﻣﻨﻄﻘﻴﺔ‪ ،‬ﻣﺜﺎل‪:‬‬ ‫‪isEmpty‬‬
‫))(‪println(letter.isEmpty‬‬
‫ﺗﻘﻮم ﺑﻄﺒﺎﻋﺔ اﻟﻌﻨﺼﺮ اﻟﺬي ﻳﺒﺪأ ﻓﻴﻪ اﻟﻨﻄﺎق "ﻧﻘﻂ؛ اﻟﺒﺪا ﻳﺔ"‪ ،‬ﻣﺜﺎل‪:‬‬ ‫‪start‬‬
‫‪var letter="A".."Z‬‬
‫)‪println(letter.start‬‬

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

‫‪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‬‬

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

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

‫ﻳﺸﻴﺮ إﻟﻰ ﻧﺰول ﺳﻄﺮ ﻋﻨﺪ ﻋﻤﻠﻴﺔ اﻟﻄﺒﺎﻋﺔ وﻫﻜﺬا ﻳﻜﺘﺐ‪:‬‬
‫)"‪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‬‬

‫{)‪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‬اﻟﺮ ﻣ ﺰ \ \‬

‫ﻣﺨﺼﺺ ﻟﻄﺒﺎﻋﺔ ﻋﻼﻣﺔ \ ﻟﻮ أردﻧﺎ ﻃﺒﺎﻋﺘﻬﺎ ﻓﻲ اﻟﻨﺺ ‪ ،‬ﻣﺜﺎل‪:‬‬
‫)"‪println("hello \\ welcome‬‬
‫‪UNICODE‬‬
‫ﺗﺘﻨﻮع اﻟﺮﻣﻮز واﻟﺤﺮوف اﻟﻤﺴـﺘﺨﺪﻣﺔ ﻣﻦ ﺑﻠﺪ ﻷﺧﺮ واﻟﻴﻮﻧﻴﻜﻮد ﻫﻮ ﻋﺒﺎرة ﻋﻦ ﺷـﻔﺮة ﺧﺎﺻـﺔ‬
‫ﻟﺤﺮوف ورﻣﻮز ﻣﺨﺼﺼﺔ ﻛﻤﺎ ﻫﻮ ﻣﻮﺿﺢ ﻓﻲ اﻟﺼﻮرة اﻟﺘﺎﻟﻴﺔ‪:‬‬

‫ﻫﺬه اﻟﺮﻣﻮز اﻟﻤﺨﺼـﺼـﺔ ﻳﻤﻜﻨﻚ اﻟﻮﺻـﻮل إﻟﻴﻬﺎ ﻣﻦ ﺧﻼل اﻟﻤﻮﻗﻊ‪ UNICODE‬وﻟﺠﻠﺐ ال‬
‫‪Unicode‬اﻟﺨﺎص ﺑﻬﺎ ﻧﻘﻮم ﺑﺎﻟﺘﺎﻟﻲ‪:‬‬
‫ﺑﻤﺠﺮد اﻟﻮﻗﻮف ﻋﻠﻰ اﻟﺮﻣﺰ واﻟﻀﻐﻂ ﻇﻬﺮ ﻟﻨﺎ ﻣﺮ ﺑﻊ اﺧﺘﺼﺎر ﻓﻴﻪ اﻟﻤﻌﻠﻮﻣﺎت اﻟﺘﻲ ﻧﺤﺘﺎﺟﻬﺎ‬
‫وﻧﻼﺣﻆ رﻣﺰ ‪ Unicode‬ﻇﻬﺮ ﻟﻨﺎ‪.‬‬
‫ﻟﻜﺘﺎﺑﺔ اﻟﺮﻣﺰ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ واﻻﺳﺘﻔﺎدة ﻣﻨﻪ ﻧﻜﺘﺐ ﻫﻜﺬا\‪:u2101‬‬
‫ﻻﺑﺪ ﻣﻦ رﻣﺰ ‪ \u‬ﻓﻲ اﻟﺒﺪا ﻳﺔ وﻣﻦ ﺛﻢ اﻟﺮﻗﻢ اﻟﺨﺎص ﺑﺎﻟﺮﻣﺰ‪ ،‬ﻣﺜﺎل‪:‬‬
‫{)>‪fun main(args:Array<String‬‬

var c='\u2101'
println(c)
}
:‫وﻫﻨﺎ ﻗﻤﻨﺎ ﺑﻌﻤﻠﻴﺔ ﻃﺒﺎﻋﺔ ﻟﻠﺮﻣﻮز اﻟﻮاﻗﻌﺔ ﺑﻴﻦ ﻣﺪى ﻣﻌﻴﻦ‬
fun main(args:Array<String>){
var e1='\u0200'
var e2='\u0218'
for ( i in '\u0200' .. '\u0218')

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

Ȋ
ȋ
Ȍ
ȍ
Ȏ
ȏ
Ȑ
ȑ
Ȓ
ȓ
Ȕ
ȕ
Ȗ
ȗ
Ș
:‫ اﻟﺨﺎص ﺑﺤﺮف أو رﻣﺰ ﻣﻌﻴﻦ‬Unicode ‫ ﻟﺠﻠﺐ‬v
:‫ ﻣﺜﺎل‬،‫ اﻟﺨﺎص ﺑﻪ‬Unicode ‫ﻟﻮ أردت ﻛﻤﺴﺘﺨﺪم أن ﺗﻘﻮم ﺑﺈدﺧﺎل ﺣﺮف ﻣﻌﻴﻦ ﻟﻤﻌﺮﻓﺔ‬
println("enter any character :")
var ch:Char = readLine()!!.single()
println("unicode of this character is : ${ch.toInt()}")
}
var ch:Char = readLine()!!.single()

‫ إذا ﻟﺘﺤﻮﻳﻞ اﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ‬،toChar ‫اﻟﺤﺮف ﻫﻮ اﻟﻮﺣﻴﺪ اﻟﺬي ﻻ ﺗﺴـ ـــــ ـﺘﻄﻴﻊ ﻛﺘﺎﺑﺘﻪ ﻫﻜﺬا‬
.single ‫إﻟﻰ ﺣﺮف ﻧﻘﻮم ﺑﺎﺳﺘﺨﺪام‬
${toInt()}
.Unicode ‫ﻋﻦ ﻃﺮ ﻳﻖ ﻫﺬا اﻷﻣﺮ ﺳﻴﻈﻬﺮ ﻟﻨﺎ‬
Unicode ‫ ﻟﺠﻠﺐ اﻟﺤﺮف أو رﻣﺰ ﻣﻌﻴﻦ ﻋﻦ ﻃﺮﻳﻖ إدﺧﺎل‬v
println("enter the unicode :")

var uniNum:Int= readLine()!!.toInt()
println("unicode of this character is : ${uniNum.toChar()}")
REGEX (Regular Expression)
‫ اﻟﺘﻌﺒﻴﺮات اﻟﻘﻴﺎﺳﻴﺔ‬: ‫أوﻻ‬

‫اﻟﺘﻌﺒﻴﺮات اﻟﻘﻴﺎﺳـﻴﺔ ﻣﻔﻴﺪة ﺑﺸـﻜﻞ ﻛﺒﻴﺮ ﺧﺼـﻮﺻـﺎ ﻟﻮ أردت أن ﻳﺪﺧﻞ اﻟﻤﺴـﺘﺨﺪم ﺑﻴﺎﻧﺎت‬
‫وﻟﻜﻦ ﺑﻘﻴﻮد ﻣﻌﻴﻨـﺔ ‪ ،‬ﻣﺜﻼ اﻟﺒﺮ ﻳـﺪ اﻹﻟﻜﺘﺮوﻧﻲ ﺗﺮ ﻳـﺪه أن ﻳﻘﻮم ﺑـﺈدﺧـﺎﻟـﻪ ﺑﺼـ ــــــ ـﻴﻐﺘـﻪ اﻟﺼـ ــــــ ـﺤﻴﺤـﺔ‬
‫ﻛﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫‪Ahmed1431@gmail.com‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬ﻃﺮﻳﻘﺔ اﻟﺘﻌﺒﻴﺮ ﻋﻦ اﻟﺘﻌﺒﻴﺮات اﻟﻘﻴﺎﺳﻴﺔ‬
‫ﻻﺑﺪ ﻣﻦ اﻟﺘﻌﺮف ﻋﻠﻰ اﻟﺮﻣﻮز اﻟﻤﺴﺘﺨﺪﻣﺔ ﻟﻠﺘﻌﺒﻴﺮ ﻋﻦ اﻟﺮﻣﻮز اﻟﻘﻴﺎﺳﻴﺔ‪:‬‬
‫§ \‪d‬‬
‫ﻣﺨﺼـ ــــــ ـﺺ ﻹدﺧـﺎل رﻗﻢ ﻣﻦ ‪ ٩-٠‬ﻓﻘﻂ أي ﻟﻮ ﻗﻤـﺖ ﺑـﺈدﺧـﺎل أي ﺣﺮف او رﻣﺰ ﺳـ ــــــ ـﺘﻜﻮن‬
‫اﻟﻨﺘﻴﺠﺔ ‪.false‬‬
‫§ \‪w‬‬
‫ﻹدﺧﺎل أي ﻣﻦ اﻟﻘﻴﻢ اﻟﺘﺎﻟﻴﺔ ‪ : a-z ,A-Z ,0-9‬اﻟﺤﺮوف ﺳـﻮاء ﻛﺎﻧﺖ ﻛﺒﻴﺮة أو ﺻـﻐﻴﺮة وأي‬
‫رﻗﻢ ﻣﻦ ‪.٩-٠‬‬
‫§ \‪s‬‬
‫ﻟﻄﺒﺎﻋﺔ ﻣﺴﺎﻓﺔ‪.‬‬
‫§ ][‬

‫ﻟﻠﺘﻨﺴـ ـﻴﻖ ﺑﻤﻌﻨﻰ ﻟﻮ أردت أن ﺗﻄﻠﺐ ﻣﻦ اﻟﻤﺴـ ـﺘﺨﺪم إدﺧﺎل ﺣﺮوف ﻣﻦ ‪ a-z‬وﻧﻼﺣﻆ أﻧﻨﺎ‬
‫ﻃﻠﺒﻨﺎ ﺣﺮوف ﺻﻐﻴﺮة ﻧﻘﻮم ﺑﻮﺿﻌﻬﺎ ﺑﻴﻦ ﻫﺬه اﻷﻗﻮاس اﻟﻤﺮ ﺑﻌﺔ ﻫﻜﺬا]‪: [a-z‬‬
‫§ }{‬
‫ﻧﺴﺘﺨﺪﻣﻬﺎ ﻟﺘﺤﺪﻳﺪ ﻋﺪد اﻟﺨﺎﻧﺎت اﻟﻤﺪﺧﻠﺔ ﻓﻤﺜﻼ ﺑﻌﺪ ﻃﻠﺒﻚ ﻣﻦ اﻟﻤﺴﺘﺨﺪم ادﺧﺎل اﺳﻤﻪ‬
‫ﺳـ ــــ ـﻨﻘﻮم ﺑﺘﺤﺪﻳﺪ ﻋﺪد اﻟﺤﺮوف اﻟﻤﺪﺧﻠﺔ ﺑﺤﻴﺚ أن اﺳـ ــــ ـﻤﻪ ﻻ ﻳﺘﺠﺎوز ‪ ٢٠‬ﺣﺮف وﻻ ﻳﻘﻞ ﻋﻦ ‪٥‬‬
‫ﻣﺜﻼ ﻫﻜﺬا‪:‬‬
‫}‪[a-z]{5,20‬‬
‫§ \*‬
‫ﻟﻮ أردت أن ﻳﻘﻮم اﻟﻤﺴـ ــــ ـﺘﺨﺪم ﺑﺈدﺧﺎل ﺧﺎﻧﺎت ﻛﺜﻴﺮة وﻓﻲ ﺣﺎل أ ﻳﻀـ ــــ ـﺎ ﺗﺮﻛﺖ ﻟﻪ ﺧﻴﺎر ﺑﺄن ﻻ‬
‫ﻳﻘﻮم ﺑﺎﻹدﺧﺎل أ ﻳﻀﺎ‪ .‬ﻣﺜﻼ‪:‬‬
‫*‪\w‬‬
‫§ \‪+‬‬
‫ﻟﻮ أردت أن ﻳﻘﻮم اﻟﻤﺴـ ــــــ ـﺘﺨـﺪم ﺑـﺈدﺧـﺎل ﺧـﺎﻧـﺎت ﻛﺜﻴﺮة أو ﻋﻠﻰ اﻷﻗـﻞ ﻻﺑـﺪ ﻣﻦ إدﺧـﺎل ﺧـﺎﻧـﺔ‬
‫ﺨﺎـﻧﺎت ﻛﺜﻴﺮة أو ﻋﻠﻰ اﻷـﻗﻞ‬
‫ﻤﻞء اﻟﻔﺮاغ ﺑ ـ‬
‫ﺠﺎل ﻟﺘﺮـﻛﻪ ـﻓﺎﺿـ ــــــ ـﻲ إـﻣﺎ إن ﺗﻘﻮم ﺑ ـ‬
‫ﺣﺪة ﺑﻤﻌﻨﻰ ﻻ ﻣ ـ‬
‫وا ـ‬
‫أدﺧﻞ ﺧﺎﻧﺔ‪ .‬ﻣﺜﻼ‪:‬‬
‫‪\w+‬‬

‫§ \?‬
‫ﻳﺪع اﻟﻤﺠﺎل ﻟﻠﻤﺴﺘﺨﺪم إﻣﺎ أن ﻻ ﻳﺪﺧﻞ أﺑﺪا أو ﻳﺪﺧﻞ ﺧﺎﻧﺔ واﺣﺪة ﻓﻘﻂ ‪ ،‬ﻣﺜﻼ‪:‬‬
‫?‪\w‬‬
‫§ )(‬
‫ﻟﺘﺠﻤﻴﻊ اﻟﺘﻨﺴﻴﻖ اﻟﺬي ﺗﺨﻄﻂ ﻟﻪ ‪ ،‬ﻣﺜﻼ‪:‬‬
‫)"}‪("\\d{4‬‬
‫ﻧﻼﺣﻆ أﻧﻨﺎ وﺿﻌﻨﺎ ﻗﻮﺳﻴﻦ داﺋﺮ ﻳﻴﻦ وﻣﻦ ﺛﻢ ﻋﻼﻣﺔ اﻟﺘﻨﺼﻴﺺ‪.‬‬
‫§ |‬
‫ﻟﻨﻔﺮض أﻧﻚ ﻃﻠﺒﺖ ﻣﻦ اﻟﻤﺴـ ــ ـﺘﺨﺪم إدﺧﺎل ﺑﻴﺎن ﻣﻌﻴﻦ وﻳﺤﺘﻤﻞ إدﺧﺎﻟﻪ أ ﻛﺜﺮ ﻣﻦ ﺷـ ــ ـﻜﻞ‬
‫)ﺗﻨﺴـ ــــــ ـﻴﻖ( ﻓﻨﺴـ ــــــ ـﺘﺨـﺪم ﻫـﺬه اﻟﻌﻼﻣـﺔ ﻟﻠﺘﺨﻴﻴﺮ ﺑﻤﻌﻨﻰ ﻟﻮ أدﺧـﻞ اﻟﺘﻨﺴـ ــــــ ـﻴﻖ اﻟـﺬي ﻋﺮﻓﻨـﺎه أو‬
‫اﻟﺘﻨﺴﻴﻖ اﻷﺧﺮ ﻓﻬﻮ ﺻﺤﻴﺢ‪ ،‬ﻣﺜﻼ‪:‬‬
‫ﺧﺎـﻟﻪ ﺑﻄﺮ ﻳﻘﺘﻴﻦ إـﻣﺎ‬

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

‫)"}‪var exp1 = Regex("\\+966\\d{9‬‬
‫وﻋﻨﺪ اﻻﺧﺘﻴﺎر ﺳﻨﻘﻮم ﻫﻜﺬا‪:‬‬
‫‪exp |exp1‬‬
‫§ ﻟﻠﻮﺻﻮل إﻟﻰ اﻟﺮﻣﻮز ﻛـ )& ‪ ، * ،‬؟ ‪… ، . ، !، @ ، # ،‬إﻟﺦ(‬

‫?\‬
‫‪\$‬‬
‫&\‬
‫*\‬
‫§ ‪. Dout‬‬
‫ﺗﺴﺘﺨﺪم ﻟﻠﺘﺠﺎﻫﻞ ﻓﻤﺜﻼ ﺗﺮ ﻳﺪ ﺗﺠﺎﻫﻞ ﺧﺎﻧﺔ أو أ ﻛﺜﺮ ﻓﻲ اﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ‪ ،‬ﻣﺜﻼ‪:‬‬
‫}‪\\d..\\d{4‬‬
‫ﻧﻼﺣﻆ ﻃﻠﺒﻨـﺎ أﻧـﻪ ﻳـﺪﺧـﻞ ﻓﻲ اﻟﺒـﺪا ﻳـﺔ رﻗﻢ ﺛﻢ ‪ .‬ﻟﺘﺠـﺎﻫـﻞ ﺧـﺎﻧـﺔ و ‪ .‬ﻣﺮة أﺧﺮى ﻟﺘﺠـﺎﻫـﻞ ﺧـﺎﻧـﺔ‬
‫ﺛﺎﻧﻴﺔ وﻣﻦ ﺛﻢ رﻗﻢ‪.‬‬
‫ﺛﺎﻟﺜﺎ‪ :‬ﻣﺜﺎل‪:‬‬
‫)"‪println("Hello , please complete this form :\n Enter your name :‬‬
‫)"}‪val nameEx = Regex("\\w{3,10}\\s\\w{3,15‬‬

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 :

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)

‫ادﺧﻠﻨﺎ ﻗﻴﻤﺔ ﻏﻴﺮ ﻣﻄﺎﺑﻘﺔ ﻟﻠﺘﻨﺴﻴﻖ ﻓﻨﻼﺣﻆ اﻧﻪ ﺳﻴﻄﺒﻊ ‪.null‬‬
‫‪findAll v‬‬
‫اﻟﻘﻴﻤﺔ اﻟﻌﺎﺋﺪة ‪ :‬ﺗﻌﻮد ﺑﺠﻤﻴﻊ اﻟﻘﻴﻢ اﻟﻤﺘﻄﺎﺑﻘﺔ ﻣﻊ اﻟﺘﻨﺴﻴﻖ اﻟﻤﻄﻠﻮب‪ .‬ﻣﺜﻼ‪:‬‬
‫= ‪val matchedResults = Regex(pattern = """\d+""").findAll(input‬‬

‫)"‪"1as232v4‬‬
‫{ )‪for (i in matchedResults‬‬
‫)" " ‪print(i.value +‬‬
‫}‬
‫اﻟﺘﻨﺴـ ـــ ـﻴﻖ اﻟﻤﻄﻠﻮب ﻓﻲ اﻟﻤﺜﺎل ﻫﻮ رﻗﻢ ﻓﻘﻂ ﻓﻨﻘﻮم ﺑﻌﻤﻞ ﺣﻠﻘﺔ ﺗﻌﻮد ﺑﺎﻷرﻗﺎم اﻟﻤﻮﺟﻮدة‬
‫ﻓﻲ اﻟﻨﺺ ﻣﻊ ﻃﺒﺎﻋﺔ ﻣﺴﺎﻓﺔ‪:‬‬
‫‪1 232 4‬‬
‫ﻧﻼﺣﻆ أﻧﻪ ﻃﺒﻊ رﻗﻢ ‪ ١‬وﻣﻦ ﺛﻢ ﻣﺴـ ـــﺎﻓﺔ وﻣﻦ ﺛﻢ ﻃﺒﻊ اﻷرﻗﺎم ‪ ٢٣٢‬ﻣﺘﺘﺎﻟﻴﺔ ﺑﺪون ﻣﺴـ ـــﺎﺣﺔ‬
‫ﻷﻧﻬﺎ ﻓﻲ اﻟﻨﺺ أﺗﺖ ﻣﻊ ﺑﻌﻀـ ـــ ـﻬﺎ ﻟﻢ ﻳﻔﺼـ ـــ ـﻠﻬﺎ ﺣﺮف أو رﻣﺰ وﻣﻦ ﺛﻢ ﻣﺴـ ـــ ـﺎﺣﺔ وﻫﻜﺬا ﻳﺴـ ـــ ـﺘﻤﺮ‬
‫ﻋﻤﻠﻬﺎ‪.‬‬
‫‪matchEntire v‬‬

‫اﻟﻘﻴﻤﺔ اﻟﻌﺎﺋﺪة‪.[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‬‬

‫)"""‪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‬وذﻟﻚ ﻷن اﻟﻮﻇﻴﻔﺔ اﻟﺮﺋﻴﺴﻴﺔ ﻟﻴﺴﺖ ﺗﻄﺎﺑﻖ ﺟﻤﻴﻊ اﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ‬
‫إﻧﻤﺎ ﻳﺘﺤﻘﻖ ﻫﻞ أدﺧﻠﺖ رﻗﻢ ﻛﻤﺎ ﻫﻮ ﻣﻄﻠﻮب ﻓﻲ اﻟﺘﻨﺴﻴﻖ‪.‬‬

‫‪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‬‬

‫ﻧـ ــ ـﻼﺣـ ــ ـﻆ أن )”””‪ Regex(“””\d+‬ﺣـ ــ ـﺪدﻧـ ــ ـﺎ أﻧـ ــ ـﻨـ ــ ـﺎ ﻧـ ــ ـﺮ ﻳـ ــ ـﺪ اﺳـ ــــــــــ ـﺘـ ــ ـﺒـ ــ ـﺪال ﻛـ ــ ـﻞ رﻗـ ــ ـﻢ ﻓـ ــ ـﻲ‬
‫اﻟﻨﺺ )”‪ replace(“ab12cd34ef”,“x‬ﺣـﺪدﻧـﺎ وﻣﻦ ﺛﻢ ﺣـﺪدﻧـﺎ اﻟﺤﺮف اﻟ ـﺬي ﻧﺮ ﻳـﺪه أن ﻳﺤـﻞ‬
‫ﻣﻜﺎن اﻟﺮﻗﻢ اﻟﺬي ﻧﺮ ﻳﺪ ﺗﺒﺪﻳﻠﻪ‪.‬‬
‫إذا ﺗﻘﻮم ﺑﺎﺳﺘﺒﺪال ﻗﻴﻤﺔ ﻣﻌﻴﻨﺔ ﻓﻲ اﻟﻨﺺ ﺑﻘﻴﻤﺔ أﺧﺮى ﻋﻦ ﻃﺮ ﻳﻖ ﺗﺤﺪﻳﺪﻫﺎ ﻓﻲ اﻟﺘﻨﺴﻴﻖ‪.‬‬
‫‪abxcdxef‬‬

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

‫{ )‪for (item in collection‬‬
‫‪// body of loop‬‬
‫}‬
‫ﻫﻨ ـﺎ أردﻧ ـﺎ ﻃﺒ ـﺎﻋ ـﺔ اﻷﻋ ـﺪاد ﻣﻦ ‪ ١٠-١‬أي أن اﻟﻨﻄ ـﺎق ﻋﻨ ـﺪي ﻣﻌﻠﻮم ﻓﻘﻂ ‪ ١٠‬ارﻗ ـﺎم ار ﻳ ـﺪ‬
‫ﻃﺒـﺎﻋﺘﻬـﺎ ﻣﻊ ﻣﺮاﻋـﺎة ان اﻟﻨﻘﻄﺘﻴﻦ ﺑﻴﻦ اﻟﻌـﺪدﻳﻦ ﻣﻬﻤﻴﻦ ﻷﻧﻨـﺎ ﻧﺮ ﻳـﺪ اﻷﻋـﺪاد اﻟﺘﻲ ﺗﻘﻊ ﻓﻲ ﻫـﺬا‬
‫اﻟﻨﻄﺎق‪.‬‬
‫)‪for ( i in 1..10‬‬
‫{‬
‫}‬
‫ﺳﻢ ﺣﺮف ﺣﺮف أي‬

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

‫!!)(‪var name:String= readLine‬‬
‫)‪for(i in name‬‬
‫{‬
‫}‬
‫وﻧﺴـﺘﻄﻴﻊ ﺗﻄﺒﻴﻖ ﻣﺎ ﺗﻌﻠﻤﻨﺎه ﻓﻲ درس اﻟﺴـﻼﺳـﻞ اﻟﻨﺼـﻴﺔ وﻫﻮ اﺳـﺘﺨﺪام اﻟﺪوال اﻟﺨﺎﺻـﺔ‬
‫ﺑﻬﺎ‪.‬‬

‫!!)(‪var name:String= readLine‬‬
‫))(‪for(i in name.reversed‬‬
‫{‬
‫}‬
‫ﺛﺎﻧﻴﺎ ‪ nested for :‬واﻟﻤﻘﺼﻮد ﻫﻨﺎ اﻟﺤﻠﻘﺎت اﻟﻤﺘﺪاﺧﻠﺔ‬
‫ﻣﺜﻼ ﻟﻮ أردﻧﺎ ﻃﺒﺎﻋﺔ ﺟﺪول اﻟﻀ ـﺮب ﻣﻦ ‪ ٥-١‬ﺟﺪول ‪ ١‬وﺟﺪول ‪ ٢‬وﺟﺪول ‪ ٣‬وﻫﻜﺬا وﺻ ـﻮﻻ ً‬
‫ﻟ ـ ــــــــ ـ ‪ ، ٥‬وﻟﻜﻨﻨﺎ ﻻ ﻧﺮ ﻳﺪ ﻃﺒﺎﻋﺔ ﺟﺪول اﻟﻀ ـﺮب ﻛﺎﻣﻼ ﻣﻦ ‪ ١٠-١‬ﺳ ـﻮف ﻧﻜﺘﻔﻲ ﻣﻦ ‪، ٣-١‬ﺳ ـﻮف‬
‫ﻧﺴﺘﺨﺪم ﺣﻠﻘﺘﻴﻦ ﻣﺘﺪاﺧﻠﺘﻴﻦ ﻛﻤﺎ ﻓﻲ اﻟﻤﺜﺎل‪.‬‬
‫ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ i‬ﻓﻲ اﻟﺤﻠﻘﺔ اﻷوﻟﻰ ﺗﻌﺒﺮ ﻋﻦ ﻋﺪد ﺟﺪاول اﻟﻀـ ـــ ـﺮب اﻟﺬي ﻧﺮ ﻳﺪﻫﺎ ﻓﻨﺤﻦ ﻧﺮ ﻳﺪ‬
‫ﻣﻦ ﺟـﺪول ‪ ١‬إﻟﻰ ﺟـﺪول ‪ ، ٥‬وﻣﻦ ﺛﻢ ﻗﻤﻨـﺎ ﺑﻔﺘﺢ اﻷﻗﻮاس اﻟﻤﺮ ﺑﻌـﺔ وﻛﺘﺒـﺎن ﺑـﺪاﺧﻠﻬـﺎ اﻟﺤﻠﻘـﺔ‬
‫اﻟﺜـﺎﻧﻴـﺔ وﻫﻲ ﻣـﺎ ﺗﻌﺮف ﺑـﺎﻟﻤﺘـﺪاﺧﻠـﺔ ﻷﻧﻬـﺎ دﺧﻠـﺖ ﻋﻠﻰ اﻷوﻟﻰ ‪ ،‬ﻗﻴﻤـﺔ اﻟﻤﺘﻐﻴﺮ ‪ x‬ﺗﻌﺒﺮ ﻋﻦ أﻧﻨـﺎ‬
‫ﻧﺮ ﻳﺪ ﺑﺪء اﻟﻀﺮب ﻣﻦ رﻗﻢ ‪ ١‬واﻟﺘﻮﻗﻒ ﻋﻨﺪ ‪ ٣‬ﻻ ﻧﺮ ﻳﺪ ﻃﺒﺎﻋﺔ اﻟﺠﺪول ﻛﺎﻣﻞ‪.‬‬
‫{)‪for(i in 1..5‬‬
‫{ )‪for(x in 1..3‬‬
‫)‪println("$i * $x = " +i*x‬‬
‫}‬
‫)"‪println("--------------‬‬
‫}‬
‫‪ v‬ﺑﺮﻧﺎﻣﺞ اﺧﺘﺒﺎر اﻟﺮﻗﻢ زوﺟﻲ ام ﻓﺮدي‬

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
21
number is odd
10
number is even

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

‫‪var i=2‬‬
‫)‪while(i<10‬‬
‫{‬
‫‪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‬‬

‫ﻓﻲ ﻫﺬه اﻟﺤﻠﻘﺔ اﻷﻣﺮ ﻣﺨﺘﻠﻒ ﻗﻠﻴﻼ ً ﻫﻮ أﻧﻪ ﺣﺘﻰ ﻟﻮ اﻟﺸـ ـــــ ـﺮط ﻏﻴﺮ ﻣﺘﺤﻘﻖ ﻓﺴـ ـــــ ـﻮف ﻳﻘﻮم‬
‫ﺑﺘﻨﻔﻴﺬ اﻷﻣﺮ ﻟﻤﺮة واﺣﺪة ‪ ،‬ﻣﺜﺎل ﺗﻮﺿﻴﺤﻲ ﻋﻠﻰ ذﻟﻚ‪.‬‬
‫ﻫﻨـﺎ ﻓﻲ اﻟﺒـﺪا ﻳـﺔ ﻋﺮﻓﻨـﺎ اﻟﻤﺘﻐﻴﺮ ‪ x‬وﻗﻴﻤﺘـﻪ ‪ ، ٥‬اﻟﺒﺮﻧـﺎﻣﺞ ﺳـ ــــــ ـﻮف ﻳـﺪﺧـﻞ إﻟﻰ ‪ do‬ﻓﻲ اﻟﺒـﺪا ﻳـﺔ‬
‫وﻳﻨﻔﺬ ﻣﺎ ﺑﺪاﺧﻠﻬﺎ وﻫﻲ ﻃﺒﺎﻋﺔ اﻟﻘﻴﻤﺔ وﻻ ﻧﻨﺴﻰ أ ﻳﻀﺎ ﻫﻨﺎ ﻛﺘﺎﺑﺔ اﻟﻌﺪاد اﻟﺬي ﻫﻮ اﻟﺰ ﻳﺎدة وﻣﻦ‬
‫ﺛﻢ ﻳﻘﻮم ﺑﺎﻟﺘﺤﻘﻖ ﻣﻦ اﻟﺸـ ـــ ـﺮط وﻫﻮ ﻗﻴﻤﺔ ‪ x‬ﺑﻌﺪ اﻟﺰ ﻳﺎدة ﻫﻞ ﻫﻲ ا ﻛﺒﺮ ﻣﻦ ‪ ١٠‬ام ﻻ واﻟﺸـ ـــ ـﺮط‬
‫ﻫﻨـﺎ ﻏﻴﺮ ﻣﺘﺤﻘﻖ ﻻن ‪ ٦‬اﺻـ ــــــ ـﻐﺮ ﻣﻦ ‪ ١٠‬ﻓﻴﺘﻮﻗﻒ اﻟﺒﺮﻧـﺎﻣﺞ وﺑـﺬﻟـﻚ ﻳﻜﻮن ﻓﻘﻂ اﻟﻘﺮاءة اﻷوﻟﻰ‬
‫ﻫﻲ اﻟﺘﻲ ﺗﺘﻨﻔﺬ ﺑﺪون اﻟﻨﻈﺮ إﻟﻰ اﻟﺸﺮط‪.‬‬
‫‪var x = 5‬‬
‫{‪do‬‬
‫)‪println(x‬‬
‫‪x++‬‬
‫}‬
‫)‪while(x>10‬‬
‫ﻫﻨﺎ ﻓﺘﺤﻨﺎ ‪ do‬وﻣﻦ ﺛﻢ ﻃﻠﺒﻨﺎ ﻣﻦ اﻟﻤﺴـﺘﺨﺪم ادﺧﺎل ﺳـﻠﺴـﻠﺔ ﻧﺼـﻴﺔ اﺳـﻤﻪ وﺳـﻮف ﻳﻘﻮم‬
‫ﺑﻄﺒﺎﻋﺘﻪ وﻣﻦ ﺛﻢ ﻳﻘﻮم ﺑﺎﻟﺪﺧﻮل إﻟﻰ ‪ while‬ﻟﻠﺘﺤﻘﻖ ﻣﻦ اﻟﺸـﺮط ﻓﻲ ﺣﺎل ان اﻟﻤﺴـﺘﺨﺪم ادﺧﻞ‬
‫اﺳـﻢ ﺣﺮوﻓﻪ ﺗﺘﺠﺎوز ‪ ١٠‬اﺣﺮف ﺳـﻮف ﺗﺘﻜﺮر ﻇﻬﻮر اﻟﺮﺳـﺎﻟﺔ ‪ ،‬وﻟﻜﻦ ﻟﻮ ادﺧﻞ اﺳـﻢ ﺣﺮوﻓﻪ اﻗﻞ‬
‫ﻣﻦ ‪ ١٠‬ﺳﻮف ﻳﺘﻮﻗﻒ اﻟﺒﺮﻧﺎﻣﺞ ﻷن اﻟﺸﺮط ﻟﻢ ﻳﺘﺤﻘﻖ‪.‬‬
‫{‪do‬‬
‫!!)(‪var x:String= readLine‬‬
‫)‪println(x‬‬

}
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"

‫ﻧﻼﺣﻆ اﻧﻨﺎ ﻗﻤﻨﺎ ا ﻳﻀـ ـــــ ـﺎ ً ﺑﺎﺳـ ـــــ ـﺘﺨﺪام ‪ 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‬‬
‫}‬

// 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")
}

‫‪// Displays - 20 is even‬‬
‫اﻟﺠﻤﻠﺔ اﻟﺸﺮﻃﻴﺔ‬
‫ﻛﻤـﺎ ﻧﻌﻠﻢ ﺟﻤﻴﻌﻨـﺎ أن اﻻﺣﺘﻤـﺎﻻت واﻟﻤﻘـﺎرﻧـﺎت أﻣﺮ وارد ﻓﻲ اﻟﺤﻴـﺎة ﻛﻤـﺎ أن اﺧﺘﺒـﺎر اﻷﺷـ ــــــ ـﻴـﺎء‬
‫ﻳﺠﻌﻠﻨﺎ ﻧﺘﺤﻘﻖ ﻣﻦ ﻗﻴﻤﺘﻬﺎ ﻛﻤﺜﺎل ﺑﺴـﻴﻂ ﻋﻨﺪﻣﺎ ﻳﻜﻮن ﻟﺪﻳﻚ ﻣﺎدة دراﺳـﻴﺔ ﻣﻌﺪل اﻟﻨﺠﺎح ﺑﻬﺎ‬
‫ﻌﺪل‬
‫ﻫﻞ ﻫﻲ ا ﻛﺒﺮ او اـﻗﻞ ﻣﻦ ﻣ ـ‬
‫ﻣﻦ ‪ ٦٠‬ـﻓﺄـﻧﺖ ﻫـﻨﺎ ﺳـ ــــــ ـﻮف ﺗـﺒﺪأ اﺧﺘـﺒﺎر درﺟـﺘﻚ اﻟﺘﻲ ﺣﻘﻘﺘـﻬﺎ ـ‬
‫ﺟﺔ ﻣﻤـﺘﺎز أم‬
‫ﻫﻞ أـﻧﺎ ـﻧﺎﺟﺢ ـﺑﺪر ـ‬
‫ﺠﺎح ‪ ،‬وإن ـﻛﺎـﻧﺖ أ ﻛﺒﺮ ﻓﻤﻦ اﻟﻄﺒﻴﻌﻲ ﺳـ ــــــ ـﻮف ﻳﺘـﺒﺎدر ـﻟﺬﻫـﻨﻚ ـ‬
‫اﻟﻨ ـ‬
‫ﺟﻴﺪ ؟‪.‬‬
‫ﻣﻦ ﻫﺬه اﻟﻤﻘﺪﻣﺔ ﻳﺘﻀـﺢ ﻟﻨﺎ ﺟﻠﻴﺎ ً أن اﻟﺪرس ﺳـﻮف ﻳﻜﻮن ﻋﻦ اﻟﺠﻤﻞ اﻟﺸـﺮﻃﻴﺔ وﻃﺮ ﻳﻘﺔ‬
‫ﻛﺘﺎﺑﺘﻬﺎ‪.‬‬
‫ﻓﻲ اﻟﺒﺪا ﻳﺔ ﺳﻨﻮﺿﺢ أن اﻟﺠﻤﻞ اﻟﺸﺮﻃﻴﺔ ﻓﻲ ﻟﻐﺔ ‪ Kotlin‬ﻫﻲ ) ‪.( if ..else – when‬‬
‫اﻟﺠﻤﻠﺔ ‪if‬‬
‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ‪:‬‬
‫{ )‪if (testExpression‬‬
‫‪// codes to run if testExpression is true‬‬
‫}‬

‫{ ‪else‬‬
‫‪// codes to run if testExpression is false‬‬
‫}‬
‫ﻳﻤﻜﻦ ﻛﺘﺎﺑﺔ ‪ if‬اﻟﺸﺮﻃﻴﺔ ﻟﺘﺤﻘﻖ ﻣﻦ ﺷﺮط واﺣﺪ وﺗﻜﻮن ﺑﺸﻜﻞ ﺑﺴﻴﻂ‪.‬‬
‫اذا ﺗﺤﻘﻖ اﻟﺸ ـﺮط ﻧﻔﺬ ﻣﺎﺑﺪاﺧﻞ ‪ if‬اذا ﻟﻢ ﻳﺘﺤﻘﻖ ﺗﺠﺎوز ﺑﺪون ان ﻳﻜﻮن ﻫﻨﺎك اي اﺣﺘﻤﺎل‬
‫آﺧﺮ‪.‬‬
‫) ‪if ( 5 < 10‬‬
‫) “اﻟﻌدد ﺧﻣﺳﺔ اﻗل ﻣن اﻟﻌدد ﻋﺷرة ‪ ،‬ﻣﺗﻔﺎﺟﺊ ﺣﻘﯾﻘﺔً” (‪print‬‬
‫‪if ..else‬‬
‫ر ﺑﻤﺎ ﻳﻜﻮن ﻟﺪﻳﻨﺎ اﺣﺘﻤﺎﻟﻴﻦ ﻟﻞ ‪ if‬ﻛﻤﺎ ﺳـ ــــــ ـﻨﻼﺣﻆ ﻓﻲ اﻟﻤﺜﺎل اﻟﻘﺎدم وﻟﺬﻟﻚ ﺳـ ــــــ ـﻨﺤﺘﺎج اﻟﻰ‬
‫اﺳ ـﺘﺨﺪام ‪ else‬ﻃﺮ ﻳﻘﺔ ﻛﺘﺎﺑﺔ ﺷ ـﺮط ﺑﺴ ـﻴﻂ ﻋﺒﺎرة اﻟﺸ ـﺮط وإذا ﻟﻢ ﻳﺘﺤﻘﻖ ﻓﺴ ـﻮف ﻳﺘﻨﻔﺬ أﻣﺮ‬
‫أﺧﺮ ‪،‬‬
‫ﻫﻨﺎ ﺳـ ــ ـﻮف ﻳﻄﻠﺐ ﻣﻦ اﻟﻤﺴـ ــ ـﺘﺨﺪم إدﺧﺎل اﺳـ ــ ـﻢ ﺣﺴـ ــ ـﻨﺎ ً و وﻣﻦ ﺛﻢ ﻳﻘﻮم ﺑﻤﻘﺎرﻧﺔ اﻻﺳـ ــ ـﻢ‬
‫اﻟﻤﺪﺧﻞ ﻫﻞ ﻫﻮ أﺣﻤﺪ؟‬

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

if(mark >= 90)
println("$mark Excellent")
else if(mark >= 80 && mark < 90)
println("$mark Very Good")
println("$mark Good")
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 */

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 ‫ﻣﻦ اﻻﺷ ـﻴﺎء اﻟﺠﻤﻴﻠﺔ ﻓﻲ‬
.‫ﻣﺒﺎﺷﺮة واﻋﺎدة ﻗﻴﻤﺔ ﻟﻠﻤﺘﻐﻴﺮ اﻟﻤﻌﺮف‬

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

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

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

‫ ﻧﻤﺮر ﻟﻬﺎ ﺑﻴﺎﻧﺎت وﺗﻌﻮد ﺑﻘﻴﻤﺔ‬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

‫‪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‬‬
‫}‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻻﺳﺘﺪﻋﺎء‬
‫ﺣﺴـ ــــــ ـﻨﺎ ً ﻧﺤﻦ ﻋﺮﻓﻨﺎ اﻵن اﻟﺪوال وﻃﺮ ﻳﻘﺔ ﻛﺘﺎﺑﺘﻬﺎ‪ ،‬ﺗﺒﻘﻰ ﻋﻠﻴﻨﺎ ﻣﻌﺮﻓﺔ ﻃﺮ ﻳﻘﺔ اﺳـ ــــــ ـﺘﺪﻋﺎﺋﻬﺎ‬
‫وﻫﻲ ﺟﺪا ً ﺑﺴﻴﻄﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫ﻧﻘﻮم ﺑﻜﺘﺎﺑﺔ اﺳﻢ اﻟﺪاﻟﺔ وان ﻛﺎﻧﺖ ﺗﻤﺮر ﻟﻬﺎ ﻗﻴﻢ ﻓﻼ ﻧﻨﺴﻰ ﻛﺘﺎﺑﺔ ﻫﺬه اﻟﻘﻴﻢ‪.‬‬

:‫§ ﻣﺜﺎل‬
:‫داﻟﺔ ﺗﺤﺴﺐ ﻣﺴﺎﺣﺔ اﻟﻤﺮ ﺑﻊ‬
fun distance( a :Int ):Int{

return a*a
}
:‫داﻟﺔ ﺗﺤﺴﺐ ﻣﺤﻴﻂ اﻟﻤﺮ ﺑﻊ‬
fun circumference(a:Int):Int{
return a*4
}
:‫ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬
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

‫‪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‬‬
‫}‬
‫}‬

‫‪ v‬داﻟﺔ ‪ extension‬ﻟﻠﻄﺒﻘﺔ ‪car‬‬
‫اﻻن ﺑﻌﺪ ﻓﺘﺮة ﻣﻦ اﻟﻮﻗﺖ اﺣﺘﺠﺖ ان اﻗﻮم ﺑﺎﺿ ـﺎﻓﺔ داﻟﺔ ﺟﺪﻳﺪة ل ‪class car‬وﻟﻜﻦ ﻻ ار ﻳﺪ‬
‫اﻟﺘﻌﺪﻳﻞ ﻋﻠﻴﻪ ؟ ﺳﺎﻗﻮم ﺑﺎﺳﺘﺨﺪام ‪ extension‬ﻛﻤﺎ ﺳﺘﻼﺣﻆ ﻓﻲ اﻟﺸﻔﺮة اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫{‪fun Car.highSpeed(sp:Int):Boolean‬‬
‫‪return sp >100‬‬
‫}‬
‫ﻧﻼﺣﻆ أﻧﻬﺎ داﻟﺔ ﻋﺎدﻳﺔ وﻟﻜﻦ ﻟﺘﻜﻮن اﻣﺘﺪاد ﻟﻄﺒﻘﺔ ﻣﺎ ﻧﻘﻮم ﺑﻮﺿـ ــ ـﻊ اﺳـ ــ ـﻢ اﻟﻄﺒﻘﺔ وﻣﻦ ﺛﻢ‬
‫اﺳﻢ اﻟﺪاﻟﺔ ﻛﻤﺎ ﻫﻮ ﻣﻼﺣﻆ ﻟﺪﻳﻨﺎ‪Car.highSpeed‬‬
‫‪ v‬ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬
‫)(‪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‬‬

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

‫اﻟﺸﻔﺮة اﻟﻘﺎدﻣﺔ‬
‫} ‪fun String.spaceToCamelCase() { ...‬‬
‫ﻛﺘﺒﻨﺎ اﺳـ ــ ـﻢ اﻟﻜﻼس ‪ String‬وﻗﻤﻨﺎ ﺑﺎﻧﺸـ ــ ـﺎء اﻟﺪاﻟﺔ اﻟﺠﺪﻳﺪة ‪ spaceToCamelCase‬واﻟﺘﻲ‬

‫ﺳﺘﻘﻮم ﺑﺘﺤﻮﻳﻞ اﻟﻨﺺ وﻃﺮ ﻳﻘﺔ اﺳﺘﺨﺪاﻣﻬﺎ ﻛﺎﻟﺘﺎﻟﻲ‬
‫)(‪"Convert this to camelcase".spaceToCamelCase‬‬
‫‪lambda function‬‬
‫اﻓﻀ ـﻞ ان اﺳ ـﻤﻴﻬﺎ اﻟﺪاﻟﺔ اﻟﻤﻀ ـﻤﻨﺔ وذﻟﻚ ﻷن ﻣﻦ اﻟﻮﻫﻠﺔ اﻷوﻟﻰ ﻋﻨﺪ اﻟﻨﻈﺮ إﻟﻴﻬﺎ ﺗﺴ ـﺘﻨﻜﺮ‬
‫أﻧﻬـﺎ داﻟـﺔ ﻓﻨﺤﻦ ﻛﻤـﺎ ﺗﻌﻠﻤﻨـﺎ أﻧﻨـﺎ ﻧﻘﻮم ﺑـﺄﻧﺸـ ـــــــ ـﺎء ﻣﺘﻐﻴﺮ وﻓﺘﺢ ﻗﻮﺳـ ــــــ ـﻴﻦ وﻣﻦ اﻟﻤﻤﻜﻦ ﺗﻤﺮ ﻳﺮ‬
‫ﻣﺘﻐﻴﺮات ﻟﻬـﺬا اﻟﻘﻮﺳـ ــــــ ـﻴﻦ اﻟـﺪاﺋﺮ ﻳﻴﻦ وﻣﻦ ﺛﻢ اﻷﻗﻮاس اﻟﻤﺮ ﺑﻌـﺔ وﺑـﺪاﺧﻠﻬـﺎ اﻟﺠﻤـﻞ اﻟﺒﺮﻣﺠﻴـﺔ‬

‫اﻟﻤﺮاد ﺗﻨﻔﻴﺬﻫﺎ ‪ ،‬ﺣﺘﻰ ﺗﺄﺗﻴﻨﺎ ‪ 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‬‬

‫§ وﺑﺪاﺧﻞ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬
‫))‪println("the total is :"+total(6,5‬‬
‫}‬
‫‪high level function‬‬
‫ﻫﺬه اـﻟﺪاـﻟﺔ ﻻ ﺗﻜﺘﻔﻲ ﻓﻘﻂ ﺑﺘﻤﺮ ﻳﺮ ﻣﺘﻐﻴﺮات‬ ‫ﻌﺎﻟﻲ و ـ‬

‫ﻫﺬا ﻳﻌﻨﻲ أن ـ‬ ‫اـﻟﺪاـﻟﺔ ﻣﻦ اﻟﻤﺴـ ــــــ ـﺘﻮى اﻟ ـ‬
‫ﻓﺮدﻳﺔ واﻧﻤﺎ أ ﻳﻀﺎ ﺗﻘﻮم ﺑﺘﻤﺮ ﻳﺮ داﻟﺔ وﻣﻦ اﻟﻤﻤﻜﻦ ان ﺗﺮﺟﻊ داﻟﺔ‪.‬‬
‫§ ﻟﻜﻲ ﻧﺴﺘﻄﻴﻊ اﻟﻘﻮل أﻧﻬﺎ داﻟﺔ ﻋﺎﻟﻴﺔ اﻟﻤﺴﺘﻮى ﻻﺑﺪ ﻣﻦ ﺗﻮﻓﺮ اﻻﺗﻲ‬
‫• ﺗﻤﺮر ﻟﻬﺎ داﻟﺔ ﻛﻮﺳﻴﻂ‪.‬‬
‫• ﺗﻌﻴﺪ داﻟﺔ‪.‬‬
‫• ﻧﺴﺘﻄﻴﻊ ﻓﻌﻞ اﻟﺨﻄﻮﺗﻴﻦ اﻟﺴﺎﺑﻘﺘﻴﻦ أ ﻳﻀﺎ ﻣﻌﺎ ً‪.‬‬
‫ﻤﻞ ﻋﻠﻰ‬
‫ﻋﺎﻟـﻴﺔ اﻟﻤﺴـ ــــــ ـﺘﻮى ﻓﻬﺲ ﺗﻌ ـ‬
‫ﺨﺪام ‪ lambda‬ارﺗـﺒﺎط وﺛﻴﻖ ـﺑﺎـﻟﺪاـﻟﺔ ـ‬
‫وﻳﺮﺗﺒﻂ اﺳـ ــــــ ـﺘ ـ‬
‫ﺗﺮﺗﻴﺐ اﻟﺠﻤﻞ اﻟﺒﺮﻣﺠﻴﺔ وﺟﻌﻠﻪ اﺳـ ــ ـﻬﻞ ﻛﻤﺎ ﻻ ﻳﺨﻔﻰ ﻋﻠﻴﻨﺎ ﺗﻘﻠﻞ ﻣﻦ اﻷﺳـ ــ ـﻄﺮ اﻟﺒﺮﻣﺠﻴﺔ ﻣﻤﺎ‬
‫ﻳﻌﻄﻴﻨﺎ ﺷﻜﻞ ﺑﺴﻴﻂ وﻧﻈﻴﻒ‪.‬‬
‫ﺳﻨﻘﻮم ﺑﻌﺮض ﻣﺜﺎل ﻟﺘﻮﺿﻴﺢ ﻣﻔﻬﻮم اﻟﺪاﻟﺔ ﻋﺎﻟﻴﺔ اﻟﻤﺴﺘﻮى‪:‬‬

‫‪ 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‬اﻟﺨﻄﻮة اﻟﺜﺎﻧﻴﺔ‬

‫ﺳﻨﻨﺸﺊ داﻟﺔ ﻣﻀﻤﻨﺔ ﺑﺪاﺧﻞ ﻣﺘﻐﻴﺮ‪:‬‬
‫})‪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‬إﻟﻰ اﻟﺪاﻟﺔ ﻧﻔﺴﻬﺎ ﻟﺘﻨﻔﻴﺬ ﻣﺎ‬
‫ﺑﺪاﺧﻠﻬﺎ‪.‬‬

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

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

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

‫أوﻻ ‪ :‬اﻟﺒﺮﻣﺠﺔ ﻛﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ‬
‫ـــــــــــ ــ‬ ‫ـــــــــــ ـ ـ‬ ‫ﺳـ ـــ ـﻮف ﻧﺘﻄﺮق ﻟﻤﻔﻬﻮم ﺟﺪﻳﺪ وﻫﻮ اﻟﺒﺮﻣﺠﺔ ﻛﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ أو ﺷـ ـــ ـﻴﺌﻴﺔ ) ‪ ( OOP‬ـ‬
‫)‪ (Object-oriented programming‬اﻟﺘﻲ ﺗﻬـﺪف ﻟﺠﻌـﻞ اﻟﺒﺮﻧـﺎﻣﺞ ﻋﺒـﺎرة ﻋﻦ ﻣﺠﻤﻮﻋـﺔ ﻣﻦ‬
‫اﻟﻜﺎﺋﻨﺎت او ﺑﺎﻟﻤﻔﻬﻮم اﻟﻤﺘﺪاول ﻋﻨﻪ ” ﻛﻞ ﺷـﻲء ﻋﺒﺎرة ﻋﻦ ﻛﺎﺋﻦ ” ‪ .‬ﻛﻞ ﻛﺎﺋﻦ ﻋﺒﺎرة ﻋﻦ ﺣﺰﻣﺔ‬
‫ﻣﻦ اﻟﺒﻴﺎﻧﺎت‪ ،‬وﻳﺘﻢ ﺑﻨﺎء اﻟﺒﺮﻧﺎﻣﺞ ﺑﻮاﺳـ ـــ ـﻄﺔ اﺳـ ـــ ـﺘﺨﺪام اﻟﻜﺎﺋﻨﺎت ور ﺑﻄﻬﺎ ﻣﻊ ﺑﻌﻀـ ـــ ـﻬﺎ اﻟﺒﻌﺾ‬
‫وواﺟﻬﺔ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺨﺎرﺟﻴﺔ ﺑﺎﺳـ ـﺘﺦ دام ﻫﻴﻜﻠﻴﺔ اﻟﺒﺮﻧﺎﻣﺞ وواﺟﻬﺎت اﻻﺳـ ـﺘﺨﺪام اﻟﺨﺎﺻـ ـﺔ ﺑﻜﻞ‬
‫ﻛﺎﺋﻦ ‪.‬وﺗﺸﻤﻞ اﻟﺒﺮﻣﺠﺔ ﻛﺎﺋﻨﻴﺔ اﻟﺘﻮﺟﻪ ﻣﺒﺎدئ رﺋﻴﺴﻴﺔ وﻫﻲ‪:‬‬
‫• اﻟﺘﻐﻠﻴﻒ‪(Encapsulation).‬‬
‫• إﺧﻔﺎء اﻟﺒﻴﺎﻧﺎت‪(Data Hiding).‬‬
‫• اﻟﻤﻴﺮاث‪(Inheritance).‬‬
‫• ﺗﻌﺪاﻷﺷﻜﺎل‪(Polymorphism).‬‬
‫• ﻣﻦ اﻟﻠﻐﺎت اﻟﺘﻲ ﺗﻌﻤﻞ ﺑﺎﻟﻜﺎﺋﻨﻴﺔ‪:‬‬
‫• ﻟﻐﺔ ﺳﻲ‪++‬‬
‫• ﻟﻐﺔ ﺟﺎﻓﺎ‬
‫• ﻟﻐﺔ ﺑﺎﻳﺜﻮن‬
‫• ﻟﻐﺔ دﻟﻔﻲ )ﻟﻐﺔ ﺑﺮﻣﺠﺔ(‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﻣﻘﺪﻣﺔ ﻋﻦ ‪Classes & Object‬‬
‫ﺣﺴﻨﺎ ً ﻣﺎ ﻫﻮ اﻟﻜﺎﺋﻦ ‪ Object‬؟‬

‫ﻛﻞ ﺷـ ــ ـﻲء ﺗﺮاه أﻣﺎﻣﻚ ﻫﻮ ﻛﺎﺋﻦ ‪ ،‬اﻟﻜﺘﺎب ﻳﻌﺘﺒﺮ ﻛﺎﺋﻦ ‪ ،‬اﻟﺴـ ــ ـﻴﺎرة ﻛﺎﺋﻦ ‪ ،‬اﻟﻘﻠﻢ ﻛﺎﺋﻦ وﺣﺘﻰ‬
‫أﻧﺖ ﻳﺎ ﻋﺰ ﻳﺰي اﻟﻘﺎرئ ﻓﻲ ﺑﺮﻣﺠﺘﻨﺎ ﻫﺬه ﺗﻌﺘﺒﺮ ﻛﺎﺋﻦ ‪ ،‬وﻛﻞ ﻛﺎﺋﻦ ﻳﺘﻜﻮن ﻣﻦ ﺷـ ـﻴﺌﻴﻦ رﺋﻴﺴـ ـﻴﻴﻦ‬
‫وﻫﻤﺎ اﻟﺼ ـﻔﺎت واﻷﻓﻌﺎل ‪ ،‬ﻓﺎﻟﺼ ـﻔﺎت ﻫﻲ ﻛﻞ ﺳ ـﻤﺔ ﺗﻤﺘﻠﻜﻬﺎ ﻣﻦ ﺣﻴﺚ اﻻﺳ ـﻢ ‪ ،‬ﻋﻤﺮك ‪ ،‬ﻟﻮن‬
‫ﺷ ـﻌﺮك ‪ ،‬ﻟﻮن ﻋﻴﻨﻴﻚ ‪ ،‬اﻟﻄﻮل ‪ ،‬اﻟﻮزن واﻟﻜﺜﻴﺮ ﻣﻦ اﻟﺼ ـﻔﺎت أ ﻳﻀ ـﺎ ﻏﻴﺮﻫﻢ ‪ ،‬أﻣﺎ اﻷﻓﻌﺎل وﻫﻲ‬
‫اﻟﻮﻇـﺎﺋﻒ اﻟـﺬي ﺗﻘﻮم ﺑﻬـﺎ ﻣﺜـﻞ اﻟﻜﺘـﺎﺑـﺔ ‪ ،‬اﻟﻤﺸـ ــــــ ـﻲ ‪ ،‬وﻳﻨﻄﺒﻖ ﻧﻔﺲ اﻟﺤـﺪﻳـﺚ ﻋﻦ أي ﻛـﺎﺋﻦ أﺧﺮ‬
‫ﻧﻘﻮم ﺑﺘﺤﺪﻳﺪ ﺻـ ـــ ﻔﺎﺗﻪ وﻣﻦ ﺛﻢ وﻇﺎﺋﻔﻪ وﻧﻌﺒﺮ ﻋﻨﻬﺎ ﺑﺮﻣﺠﻴﺎ اﻟﺼـ ـــ ﻔﺎت ﺑﺎﻟﻤﺘﻐﻴﺮات أﻣﺎ اﻷﻓﻌﺎل‬
‫ﻓﻨﻌﺒﺮ ﻋﻨﻬﺎ ﺑﺎﻟﺪوال‪.‬‬
‫‪ Classes‬ﺑﺎﻟﻌﺮ ﺑﻴﺔ ﻳﻌﻨﻲ ﺗﺼـ ــ ـﻨﻴﻔﺎت وﻫﺬا ﻳﻌﻨﻲ أﻧﻨﺎ ﻧﻀـ ــ ـﻊ اﻷﺷـ ــ ـﻴﺎء ﻓﻲ ﺗﺼـ ــ ـﻨﻴﻒ ﻣﻌﻴﻦ ‪،‬‬
‫ﻟﻨﻔﺘﺮض أﻧﻨﺎ ﻧﺘﺤﺪث ﻋﻦ اﻟﺴـ ـﻴﺎرات ﺣﺴـ ـﻨﺎ ً ﻫﻨﺎﻟﻚ ﺳـ ـﻴﺎرة ‪ BMW‬وﻟﻪ ﻟﻮن ﻣﻌﻴﻦ وﺳـ ـﺮﻋﺎت‬
‫ﻣﻌﻴﻨﻪ وﺷـ ـﺮﻛﺔ ﺧﺎﺻـ ـﺔ ﺑﺈﻧﺘﺎﺟﻬﺎ وأ ﻳﻀـ ـﺎ ﻟﺪﻳﻨﺎ ‪ AUDI‬وأ ﻳﻀـ ـﺎ ﻟﻬﺎ ﺷـ ـﺮﻛﺔ ﺧﺎﺻـ ـﺔ وﻟﻮن ﻣﻌﻴﻦ‬
‫ﻋﺔ وﻣﺨﺘﻠـﻔﺔ وﻟﻜﻨﻬﻢ ﺟﻤﻴﻌﻬﻢ ﻳﻌﺘﺒﺮون ﺻـ ــــــ ـﻮرة ﻟﺼـ ــــــ ـﻨﻒ‬
‫ﻋﺔ ﻣﺘﻨﻮ ـ‬
‫ﻜﺬا ـﻟﺪﻳـﻨﺎ ﻣﺠﻤﻮ ـ‬
‫…إﻟﺦ وﻫ ـ‬
‫اﻟﺴـﻴﺎرات ‪ ،‬أي أﻧﻨﺎ ﻓﻲ ﺑﺮﻧﺎﻣﺠﻨﺎ ﺳـﻨﺘﺤﺪث ﻋﻦ اﻟﺴـﻴﺎرات ﺻـﺤﻴﺢ ؟ إذا ﻧﻘﻮم ﺑﺈﻧﺸـﺎء ﺗﺼـﻨﻴﻒ‬
‫ﻟﻠﺴـ ـﻴﺎرات ﻧﻌﺮف ﺑﻪ اﻟﺼـ ـﻔﺎت اﻟﻌﺎﻣﺔ ﺑﻬﺎ ﻣﺜﻞ اﻻﺳـ ـﻢ ‪ ،‬اﻟﺸـ ـﺮﻛﺔ اﻟﻤﺼـ ـﻨﻌﺔ ﻟﻪ ‪ ،‬اﻟﻠﻮن وﻧﻀـ ـﻊ‬
‫ﻛﺬﻟﻚ داﺧﻞ اﻟﺘﺼﻨﻴﻒ اﻟﺪوال اﻟﺨﺎﺻﺔ ﺑﺎﻟﺴﻴﺎرة ﻛﺎﻟﺴﺮﻋﺔ واﻟﺘﻮﻗﻒ ﻣﺜﻼ ً‪.‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻟﻔﺮق ﺑﻴﻦ ‪Classes & Object‬‬
‫ﻋﺮﻓﻨﺎ ﻣﺎ ﻫﻮ اﻟﺘﺼـﻨﻴﻒ ]‪ [Class‬وﻣﺎ ﻫﻮ اﻟﻜﺎﺋﻦ ]‪ [Object‬وﺑﺸـﻜﻞ ﺑﺴـﻴﻂ ﺳـﺄوﺿـﺢ ﻟﻚ‬

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

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

‫{ ‪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‬‬

‫اﻷن ﺳـ ـــ ـﺘﻘﻮل ﻟﻲ ﻣﺎ ﻫﻮ ﻧﺎﺗﺞ ﺗﻨﻔﻴﺬ ﻫﺬا اﻟﻜﻮد ؟ ﺳـ ـــ ـﺄﻗﻮل ﻟﻚ ﻻ ﺷـ ـــ ـﻲء ﻳﺎﻋﺰ ﻳﺰي ‪ .‬ﻧﻌﻢ ﻻ‬
‫ﺷـ ـﻲء ‪ ،‬ﻟﻤﺎذا ﻷﻧﻨﺎ ﻓﻘﻂ ﻗﻤﻨﺎ ﺑﺈﻋﻼم اﻟﺒﺮﻧﺎﻣﺞ ﺑﺈﻧﺸـ ـﺎء ﺗﺼـ ـﻨﻴﻒ ﻳﻤﺮر ﻟﻪ ﺑﻴﺎﻧﺎت ﻣﻌﻴﻨﺔ ﻓﻘﻂ ‪،‬‬
‫ﻣﺘﻰ ﺳﻴﻨﻔﺬ اﻷﻣﺮ ؟ وﻫﺬا ﻫﻮ اﻟﺠﺰء اﻟﺜﺎﻧﻲ اﻟﻤﻬﻢ ﻓﻲ درﺳﻨﺎ وﻫﻮ اﻟﻜﺎﺋﻦ‪.‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﻃﺮﻳﻘﺔ إﻧﺸﺎء ﻛﺎﺋﻦ ‪Object‬‬
‫اﻟﻜﺎﺋﻦ ﻳﺎ ﻋﺰ ﻳﺰي ﻫﻮ ﻋﺒﺎرة ﻋﻦ ﺻـ ـﻮرة ﻟﻠﺘﺼـ ـﻨﻴﻒ اﻟﺬي أﻧﺸـ ـﺄﻧﺎه ﺳـ ـﺄوﺿـ ـﺢ ﻟﻚ اﻷﻣﺮ ﻣﺮة‬
‫أﺧﺮى وﻫﻲ أن اﻟﺴـ ــ ـﻴﺎرات ﺟﻤﻴﻌﻬﺎ ﺑﻤﺨﺘﻠﻒ أﻧﻮاﻋﻬﺎ ﺗﺠﺘﻤﻊ ﺑﺄن ﻟﻬﺎ ﺻـ ــ ـﻔﺎت ﻣﺸـ ــ ـﺘﺮﻛﺔ ﻣﺜﻞ‬
‫ﺼ ﻨﻒ‬
‫ﺸﺊ ﻣ ـ‬
‫ﺳﺮﻋﺔ ﻓﻬﻨﺎ ﻧﻨ ـ‬
‫ﺳﻴﺎرة ﺗﺤﻤﻞ ﻣﻮدﻳﻞ وﻟﻮن و ـ‬
‫ﺳﻢ وﻛﻞ ـ‬
‫ﺳﻴﺎرة ﺗﺤﻤﻞ ا ـ‬
‫ﺳﻢ ﻓﻜﻞ ـ‬
‫اﻻ ـ‬
‫ﻳﻀﻢ ﻛﻞ اﻟﺼﻔﺎت واﻻﻓﻌﺎل اﻟﺘﻲ ﺗﺸﺘﺮك ﻓﻴﻬﺎ ﻛﻞ اﻟﺴﻴﺎرات ﺣﺴﻨﺎ ً أ ﻳﻦ اﻻﺧﺘﻼف ؟ اﻻﺧﺘﻼف‬
‫ﻫﻮ ﻧﻮع اﻟﺒﻴﺎن اﻟﻤﺪﺧﻞ ﻓﺴـ ــــ ـﻴﺎرة ﻣﻦ ﻧﻮع ﻓﻮرد ﻣﺨﺘﻠﻔﺔ ﻋﻦ ﺳـ ــــ ـﻴﺎرة ﻧﻮع اودي وﻫﻜﺬا ‪ ،‬ﻧﻘﻮم‬
‫ﺑﺈﻧﺸﺎء اﻟﻜﺎﺋﻦ ﻓﻲ داﺧﻞ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‪:‬‬
‫)(‪var object1 = Car‬‬
‫ﻫﻜﺬا ﻧﺤﻦ اﻧﺸ ـﺄﻧﺎ ﻛﺎﺋﻦ ﻋﺮﻓﻨﺎه ﻛﻤﺎ ﻧﻘﻮم ﺑﺘﻌﺮ ﻳﻒ اﻟﻤﺘﻐﻴﺮات وﻟﻜﻦ اﻻﺧﺘﻼف ﻫﻮ أﻧﻪ ﺑﻌﺪ‬
‫ﻋﻼﻣﺔ اﻟﻤﺴ ـﺎواة ﻧﻀ ـﻊ اﺳ ـﻢ اﻟﺼ ـﻨﻒ ‪ Class‬اﻟﺬي ﻳﺘﺒﻌﻪ اﻟﻜﺎﺋﻦ اﻟﺬي اﻧﺸ ـﺄﻧﺎه ‪،‬ﻳﻤﻜﻨﻚ أ ﻳﻀ ـﺎ‬
‫ﺗﻌﺮ ﻳﻒ أ ﻛﺜﺮ ﻣﻦ ﻛﺎﺋﻦ ﻟﻨﻔﺲ اﻟﺼﻨﻒ ﺑﺸﺮط أن ﻳﻜﻮن اﻻﺳﻢ ﻣﺨﺘﻠﻒ‪.‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻟﻮﺻﻮل إﻟﻰ اﻟﻤﺘﻐﻴﺮات اﻟﺨﺎﺻﺔ ﺑﺎﻟـ ‪Class‬‬

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

‫‪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‬‬
‫}‬
‫}‬

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

‫)(‪dell.getInfo‬‬
‫}‬
‫ﻧﺮى أﻧﻪ أﻟﺰﻣﻨﺎ ﻋﻨﺪ إﻧﺸ ـﺎء اﻟﻜﺎﺋﻦ ﺑﺘﻤﺮ ﻳﺮ ﻗﻴﻢ ﻟﻬﺬه اﻟﻮﺳ ـﺎﺋﻂ اﻟﺘﻲ ادﺧﻠﻨﺎﻫﺎ ﻓﻲ اﻟﺘﺼ ـﻨﻴﻒ‬
‫ﻓﻮق‪.‬‬
‫ﻟﻮ ﻧﺮ ﻳﺪ أن ﻧﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻮﺳـ ــــ ـﺎﺋﻂ ﻣﺒﺎﺷـ ــــ ـﺮة ﺑﺪون ﺗﻌﺮ ﻳﻒ ﻣﺘﻐﻴﺮات ﻓﻲ داﺧﻞ ﺗﺼـ ــــ ـﻨﻴﻒ‬
‫‪:class‬‬
‫{ )‪class labtop(var id:Int,var name:String‬‬
‫)"‪println("The labtop is : $name , and the serial number is : $id‬‬
‫}‬
‫}‬

‫ﻓﻘﻂ ﻧﻘﻮم ﺑﺘﻌﺮ ﻳﻔﻬﻢ ﺑﺪاﺧﻞ اﻗﻮاس اﻟﺘﺼﻨﻴﻒ‪.‬‬
‫ﺳﺎدﺳﺎ ً ‪ :‬ﻛﻠﻤﺔ ‪this‬‬
‫{ )‪class labtop(var id:Int,var name:String‬‬
‫{)‪fun setValues(id:Int , name:String‬‬

‫‪this.id = id‬‬
‫‪this.name = name‬‬
‫}‬
‫)"‪println("The labtop is : $name , and the serial number is : $id‬‬
‫}‬
‫}‬
‫ﺣﺴـ ــــــ ـﻨـﺎ اﻵن ﺳـ ــــــ ـﻨﺘﻌﺮف ﻋﻠﻰ ﻓـﺎﺋـﺪة ‪ this‬ﻧﻼﺣﻆ ﻫﻨـﺎ أن اﻧﺸـ ـــــــ ـﺄﻧـﺎ داﻟـﺔ وﻣﺮرﻧـﺎ ﻟﻬـﺎ ﻧﻔﺲ‬
‫اﻟﻤﺘﻐﻴﺮات ﻟﻠﺘﺼﻨﻴﻒ ‪ class‬وﺑﺪاﺧﻞ اﻟﺪاﻟﺔ‪:‬‬
‫‪this.id = id‬‬
‫‪this.name = name‬‬
‫ﻫﺬه اﻟﻜﻠﻤﺔ ﺗﻌﻨﻲ ‪ id‬اﻟﺨﺎص ﺑﺎﻟﺘﺼـ ـــــ ـﻨﻴﻒ وﻟﻴﺲ ‪ id‬اﻟﻤﻤﺮ ﻟﻠﺪاﻟﺔ ‪ ،‬ﻟﻮ ﻛﺎﻧﺖ اﻟﻤﺘﻐﻴﺮات‬
‫اﻟﻤﻤﺮرة ﻟﻠﺪاﻟﺔ ذات ﻣﺴـ ـــــ ـﻤﻴﺎت ﻣﺨﺘﻠﻔﺔ ﻋﻦ اﻟﺘﻲ ﺗﻢ ﺗﻤﺮ ﻳﺮﻫﺎ ﻟﻠﺘﺼـ ـــــ ـﻨﻴﻒ ﻓﻠﻦ ﻧﺤﺘﺎج ﻟﻬﺬه‬
‫اﻟﻜﻠﻤﺔ ‪ ،‬ﺑﺎﺧﺘﺼﺎر ﺷﺪﻳﺪ ﻛﻠﻤﺔ ‪ this‬ﺧﺎﺻﺔ ﻟﻠﻮﺻﻮل إﻟﻰ ﻣﺤﺘﻮﻳﺎت اﻟﺘﺼﻨﻴﻒ‪.‬‬

‫ﺳﺎﺑﻌﺎ ً ‪ :‬داﻟﺔ اﻟﺒﻨﺎء ‪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‬‬
‫}‬

‫}‬
‫ﻓﻲ اﻟﻤﺜﺎل ﻋﺮﻓﻨﺎ اﻟﻤﺘﻐﻴﺮات ﺑﻴﻦ اﻗﻮاس اﻟﺘﺼـﻨﻴﻒ وﻣﻦ ﺛﻢ ﻧﻼﺣﻆ ﺑﺪاﺧﻞ ‪ 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‬‬

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
‫ﺗﻨﻮﻳﻪ‬

‫ﻟﻮ أردﻧﺎ ﺗﻤﺮ ﻳﺮ ﻣﺘﻐﻴﺮات ﻋﻨﺪ إﻧﺸـﺎء اﻟﺘﺼـﻨﻴﻒ ﻓﺪاﻟﺔ اﻟﺒﻨﺎء اﻟ ـ ــــــ ـ ‪ 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‬‬

‫ﻟﻮ ﺗﻜﻠﻤﻨﺎ ﻋﻠﻤﻴﺎ ً ﺑﻬﺬا اﻟﻤﻮﺿـ ـــﻮع واردﻧﺎ ﺗﺒﺴـ ـــﻴﻂ ﻣﻔﻬﻮم اﻟﻮراﺛﺔ ﺳـ ـــﻨﻘﻮل أن ﺗﻨﺘﻘﻞ ﺑﻌﺾ‬
‫ﻣﻦ ﺻـ ـــ ـﻔﺎت اﻟﻮاﻟﺪﻳﻦ أو ﺟﻤﻴﻌﻬﺎ ﻟﻠﻄﻔﻞ ‪ ،‬وﻧﻔﺲ اﻟﺸـ ـــ ـﻲء ﻳﺤﺪث ﺑﺮﻣﺠﻴﺎ ﻧﺴـ ـــ ـﺘﻄﻴﻊ إﻧﺸـ ـــ ـﺎء‬
‫ﺗﺼﻨﻴﻒ ‪ class‬ﻳﺮث ﻣﻦ ﺗﺼﻨﻴﻒ ‪ class‬أﺧﺮ‪.‬‬
‫أوﻻ ‪ :‬ﻣﻔﺎﻫﻴﻢ ﻣﺘﻌﻠﻘﺔ ﺑﺎﻟﻮراﺛﺔ‬
‫ﺳﻨﺘﻌﺮف ﻋﻠﻰ ﻃﺮ ﻳﻘﺔ اﻟﻮراﺛﺔ ﺑﺮﻣﺠﻴﺎ وﻟﻜﻦ ﺑﻌﺪ ﺗﻮﺿﻴﺢ ﺑﻌﺾ اﻟﻤﻔﺎﻫﻴﻢ اﻟﻌﺎﻣﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫ﻓﻠﻨﻔﺘﺮض أن ﻟﺪﻳﻨﺎ ‪ class Person‬ﻳﺤﺘﻮي ﻋﻠﻰ اﻻﺗﻲ ‪:‬‬
‫} اﺳـﻢ اﻟﺸـﺨﺺ – ﺗﺎر ﻳﺦ اﻟﻤﻴﻼد – اﻟﺮﻗﻢ اﻟﻤﺪﻧﻲ {‪ ،‬واﻧﺸـﺄﻧﺎ ‪ class Employee‬ﻳﺮث ﻣﻦ‬
‫‪class Person‬ﻳﺤﺘﻮي ﻋﻠﻰ اﻻﺗﻲ ‪ } :‬اﻟﺮﻗﻢ اﻟﻮﻇﻴﻔﻲ { ‪ ،‬ﻓﻬﻨﺎ ‪ class Employee‬ﻳﺴـ ـــــ ـﺘﻄﻴﻊ‬

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

‫اﻟﻤﻮروث ﻓﻲ اﻟﻤﺜ ـﺎل أﻋﻼه ﻫﻮ ‪ class person‬ﻫﻮ اﻷب ﻳﻌﺘﺒﺮ وﻧﻄﻠﻖ ﻋﻠﻴ ـﻪ ‪ ، super‬أﻣ ـﺎ‬
‫اﻟﻮارث ﻓﻬﻮ ‪ class Employee‬وﻧﺴ ـ ـ ـ ـ ـﻤﻴـ ـﻪ ‪ sub‬أي ﻓﺮﻋﻲ‪ .‬وﺑـ ـﺎﻟﻄﺒﻊ اﻟﻤﻌﻠﻢ واﻟﻄﺒﻴـ ـﺐ‬
‫واﻟﻤﻬﻨــﺪس ﻳﻌﺘﺒﺮون وارﺛﻴﻦ وﻳﻌﺘﺒﺮون ‪ ،sub‬واﻟﻤﻮروث ﻫﻮ ‪ class Employee‬اﻟــﺬي‬
‫ﻳﻌﺪ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻬﻢ ‪.super‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬اﻟﻮراﺛﺔ ﻓﻲ اﻟﺒﺮﻣﺠﺔ‬
‫اﻟﺘﺼـﻨﻴﻒ اﻷب أو ‪ super class‬ﻟﻜﻲ ﻧﺴـﺘﻄﻴﻊ أن ﻧﺠﻌﻞ ﺗﺼـﻨﻴﻒ أﺧﺮ ﻳﺮث ﻣﻨﻪ ﻻﺑﺪ ﻣﻦ‬
‫وﺿﻊ ﻛﻠﻤﺔ ‪ open‬ﻋﻨﺪ إﻧﺸﺎﺋﻪ‪.‬‬
‫‪ v‬ﻣ ﺜﺎل‬

§ 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")
}

‫}‬
‫ﻋﻨﺪ إﻧﺸـﺎء اﻟﺘﺼـﻨﻴﻒ ﻧﻘﻮم ﻓﻮرا ﺑﻌﻤﻠﻴﺔ اﻟﻮراﺛﺔ )(‪ class Employee(): person‬ﻧﻘﻄﺘﻴﻦ‬
‫رأﺳﻴﺘﻴﻦ وﻣﻦ ﺛﻢ اﺳﻢ اﻟﺘﺼﻨﻴﻒ اﻟﻤﻮروث‪.‬‬
‫‪ v‬ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬
‫ﻧﻘﻮم ﺑﺈﻧﺸﺎء ﻛﺎﺋﻦ ﻣﻦ ‪ class Employee‬وذﻟﻚ ﻟﺘﻮﺿﻴﺢ ﻛﻴﻒ ﺗﺘﻢ ﻋﻤﻠﻴﺔ اﻟﻮراﺛﺔ‪:‬‬
‫ﻧﺮى أن اﻟﻜﺎﺋﻦ اﻟﻤﺸـﺘﻖ ﻣﻦ ‪ class Employee‬اﺳـﺘﻄﺎع اﻟﻮﺻـﻮل إﻟﻰ ﻣﺤﺘﻮﻳﺎت ‪class‬‬

‫‪Person‬وﻫـﺬا اﻟﻐﺮض اﻟﺮﺋﻴﺴـ ــــــ ـﻲ ﻣﻦ ﻋﻤﻠﻴـﺔ اﻟﻮراﺛـﺔ أن اﻟﻜـﺎﺋﻦ ﻳﺴـ ــــــ ـﺘﻄﻴﻊ اﻟﻮﺻـ ــــــ ـﻮل إﻟﻰ‬
‫ﻣﺤﺘﻮﻳﺎت‪.super class‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻮﺳﺎﺋﻂ اﻟﻤﻤﺮرة ﻟﻠﺘﺼﻨﻴﻒ‬

‫ﻟﻮ ﻛﺎن ‪ 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‬‬

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

‫ﻧﻼﺣﻆ ﻣﺮرﻧﺎ ﻧﻔﺲ اﻟﻮﺳـ ـﺎﺋﻂ ﻟﻠﺘﺼـ ـﻨﻴﻒ اﻟﺬي ﺳـ ـﻴﺮث وﻣﻦ ﺛﻢ وﺿـ ـﻌﻨﺎ اﺳـ ـﻢ اﻟﺘﺼـ ـﻨﻴﻒ‬
.‫اﻟﻤﻮروث وﻣﺮرﻧﺎ اﻟﻤﺘﻐﻴﺮات ﺑﺸﻜﻞ ﻃﺒﻴﻌﻲ ﺑﺪون ﺗﻌﺮ ﻳﻒ ﻟﻬﺎ أو ﻟﻨﻮﻋﻬﺎ‬
:‫ داﻟﺔ ﺑﻨﺎء‬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
}
}

‫وﻧﻼﺣﻆ ﻫﻨﺎ أﻧﻨﺎ ﻗﻤﻨﺎ ﺑﺎﺳـ ـﺘﺨﺪام ﻛﻠﻤﺔ ‪ super‬ﻟﻴﺘﻀـ ـﺢ ﻟﻨﺎ أﻧﻬﺎ ‪ keywords‬ﻓﻲ ﻟﻐﺔ اﻟ ـ ـــــــــ ـ‬
‫‪ ،kotlin‬وﻧﻘﺼﺪ ﺑﻬﺎ ﻫﻨﺎ اﻟﻮﺻﻮل إﻟﻰ داﻟﺔ اﻟﺒﻨﺎء اﻟﺨﺎﺻﺔ ﺑﺎﻟﺘﺼﻨﻴﻒ اﻷب‪.‬‬
‫راﺑﻌﺎ ‪ :‬اﻟﻔﺮق ﺑﻴﻦ ‪ this‬و ‪super‬‬
‫اﻟﻔﺮق ﺑﺴﻴﻂ ﺟﺪا ً ‪:‬‬
‫ﻧﺴﺘﺨﺪم ‪ this‬ﻓﻲ اﻟﺘﺼﻨﻴﻒ ﻧﻔﺴﻪ وﻟﻠﺘﻌﺒﻴﺮ ﻋﻦ ﻣﺤﺘﻮﻳﺎﺗﻪ ﻛﻤﺎ ﺗﻌﻠﻤﻨﺎ ﻣﺴﺒﻘﺎ ً‪.‬‬
‫ﻧﺴـ ـــــ ـﺘﺨﺪم ‪ super‬ﻟﻠﻮﺻـ ـــــ ـﻮل إﻟﻲ ﻣﺤﺘﻮﻳﺎت اﻟﺘﺼـ ـــــ ـﻨﻴﻒ اﻷب أي أﻧﻪ ﺧﺎص ﺑﺎﻟﺘﺼـ ـــــ ـﻨﻴﻒ‬
‫اﻟﻤﻮروث ﻟﻠﻮﺻﻮل إﻟﻴﻪ‪.‬‬
‫‪interface‬‬
‫أوﻻ ً ‪ :‬ﺗﻤﻬﻴﺪ‬
‫ﻫﻞ ﻗﺪ ﺧﻄﺮ ﻓﻲ ﺑﺎﻟﻚ أﺛﻨﺎء ﺗﺼــﻤﻴﻢ ﻣﺸــﺮوﻋﻚ أﻧﻚ ﺗﻌﻠﻦ ﻋﻦ داﻟﺔ وﻟﻜﻦ ﻻ ﺗﻌﻠﻢ ﻣﺎ ﻟﺬي‬
‫ﺳـﺘﻀـﻌﻪ ﺑﺪاﺧﻠﻬﺎ أو أﻧﻚ ﺗﺮ ﻳﺪ اﻹﻋﻼن ﻓﻘﻂ وﺳـﺘﺴـﺘﺨﺪﻣﻬﺎ ﻻﺣﻘﺎ ً ؟ ﻓﻲ ﺑﻴﺌﺔ ‪ Kotlin‬ﻧﺴـﺘﻄﻴﻊ‬
‫ﻫﺬه اﻟﻌـﻨﺎﺻـ ــــــ ـﺮ ﺗﻤﻜﻨﻲ ﻣﻦ اﻹﻋﻼن ﻋﻦ‬
‫ﻣﺎ ‪ abstract‬أو ‪ ، interface‬ـ‬
‫ﻌﻞ ذـﻟﻚ ﻋﻦ ﻃﺮ ﻳﻖ إ ـ‬
‫ﻓ ـ‬
‫ﻣﺘﻐﻴﺮات ودوال ﺑـﺪون أن أ ﻛﺘـﺐ ﻗﻄﻊ ﺑﺮﻣﺠﻴـﺔ ﺑﻤﻌﻨﻰ أﻧﻲ ﻓﻘﻂ أﻋﺮف ﻋﻦ داﻟـﺔ وﻟﻜﻨﻲ ﻣـﺎ‬
‫ﺗﺘﻀﻤﻨﻪ ﻫﺬه اﻟﺪاﻟﺔ ﺳﺄؤﺟﻞ ﻛﺘﺎﺑﺘﻪ إﻟﻰ ﺣﻴﻦ أﺣﺘﺎﺟﻪ‪.‬‬

‫ﺛﺎﻧﻴﺎ ً ‪ :‬اﻟﺘﻌﺮﻳﻒ ﻋﻦ ‪interface‬‬
‫ﻛﻤﺎ ﻗﻠﻨﺎ ﺳﺎﺑﻘﺎ ﻧﺴﺘﻄﻴﻊ ﻓﻴﻪ اﻹﻋﻼن ﻋﻦ اﻟﺪوال اﻟﺘﻲ ﺳﺄﺳﺘﺨﺪﻣﻬﺎ ﻻﺣﻘﺎ ً‪.‬‬
‫{‪interface myInterface‬‬
‫}‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻹﻋﻼن ﻓﻲ ‪interface‬‬
‫ﺳﻨﻮﺿﺢ اﻷن ﻛﻴﻔﻴﺔ ﺗﺠﻬﻴﺰ اﻟﻤﺘﻐﻴﺮات واﻻﻋﻼن ﻋﻨﻬﺎ وﻋﻦ اﻟﺪوال‪:‬‬
‫{‪interface myInterface‬‬
‫)(‪fun sum‬‬
‫)(‪fun sub‬‬
‫{)‪fun mul(num1:Int,num2:Int‬‬
‫‪var result = num1*num2‬‬
‫}‬
‫‪var num1:Int‬‬
‫}‬
‫اﻋﻠﻨﺎ ﻋﻦ داﻟﺔ ﺟﻤﻊ وﻟﻜﻦ ﺑﺪون أن ﻧﺒﻨﻲ اﻟﻘﻄﻌﺔ اﻟﺒﺮﻣﺠﻴﺔ اﻟﺨﺎﺻﺔ ﺑﻬﺎ‪.‬‬
‫أ ﻳﻀﺎ اﻋﻠﻨﺎ ﻋﻦ داﻟﺔ اﻟﻄﺮح وﻟﻢ ﻧﺴﺘﺨﺪﻣﻬﺎ أ ﻳﻀﺎ‪.‬‬

‫اﻋﻠﻨ ـﺎ ﻋﻦ داﻟ ـﺔ اﻟﻀـ ــــــ ـﺮب وﻗﻤﻨ ـﺎ ﺑﺒﻨ ـﺎﺋﻬ ـﺎ وﺗﻤﺮ ﻳﺮ ﻗﻴﻢ ووﺿـ ــــــ ـﺤﻨ ـﺎ ﻋﻤﻠﻬ ـﺎ وﻫ ـﺬا ﻳ ـﺪل ان‬
‫‪interface‬ﻟﻴﺲ ﺣﻜﺮا ﻓﻘﻂ ﻟﺘﺠﻬﻴﺰ اﻟـﺪوال واﻟﻤﺘﻐﻴﺮات أ ﻳﻀـ ــــــ ـﺎ ﻧﺴـ ــــــ ـﺘﻄﻴﻊ ﺑﻨـﺎء داﻟـﺔ ﻛـﺎﻣﻠـﺔ‪،‬‬
‫وﻟﻜﻦ اﻻﺧﺘﻼف ﻳﻜﻤﻦ ﻓﻲ ﻃﺮ ﻳﻘﺔ اﻟﻌﻤﻞ اﻟﺘﻲ ﺳﻨﻮﺿﺤﻬﺎ ﺑﻌﺪ ﻗﻠﻴﻞ‪.‬‬
‫اﻟﻤﺘﻐﻴﺮات اﻟﺘﻲ ﻳﺘﻢ ﺗﻌﺮ ﻳﻔﻬﺎ ﺑﺪاﺧﻞ ‪ interface‬ﻻ ﻳﺘﻢ اﺳـ ـــــ ـﻨﺎد ﻗﻴﻢ ﻟﻬﺎ اﺑﺪا ‪ ،‬ﻛﻤﺎ ﻻﺣﻈﻨﺎ‬
‫ﻋﺮﻓﻨﺎ ﻣﺘﻐﻴﺮ وﻟﻢ ﻧﺴﻨﺪ ﻟﻪ ﻗﻴﻢ‪.‬‬
‫راﺑﻌﺎ ً ‪ :‬اﺳﺘﺨﺪام ‪interface‬‬
‫‪ Interface‬ﻻ ﻳﺘﻢ اﺳـ ــــ ـﺘﺨﺪاﻣﻬﺎ ﻣﺒﺎﺷـ ــــ ـﺮة ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴـ ــــ ـﻴﺔ وإﻧﻤﺎ ﻧﺴـ ــــ ـﺘﺨﺪﻣﻬﺎ ﺑﻌﻤﻠﻴﺔ‬
‫‪implements‬وﻫﻲ ﺑﺎﻟﻀﺒﻂ ﻣﻤﺎﺛﻠﺔ ﻟﻌﻤﻠﻴﺔ اﻟﻮراﺛﺔ‪ ،‬ﻫﻜﺬا‪:‬‬
‫ﻧﺮى أﻧﻪ ﻋﻨﺪﻣﺎ ﺟﻌﻠﻨﺎ اﻟﺘﺼ ـﻨﻴﻒ ﻳﺮث ﻣﻦ اﻟ ـ ـــــــ ـ ‪ interface‬ﻗﺎم ﺑﻮﺿـﻊ ﺧﻂ اﺣﻤﺮ ‪ ،‬ﻟﻤﺎذا ؟‬
‫ﻌﺪ ـﻓﺈﺟـﺒﺎري أن‬
‫ﻌﻞ اﻟﺘﺼـ ــــــ ـﻨﻴﻒ ﻳﺮث ﻣﻦ ‪ interface‬وـﺑﺪاﺧـﻠﻪ دوال ﻟﻢ ﺗﺒﻨﻰ ﺑ ـ‬
‫ﻣ ﺎ ﺗﺠ ـ‬
‫ﻷـﻧﻪ ﻋﻨـﺪ ـ‬
‫ﺗﺪرﺟﻬﻢ ﺑﺪاﺧﻞ اﻟﺘﺼـ ـــــ ـﻨﻴﻒ ﻛﻠﻬﻢ أو أﺣﺪﻫﻢ ﻋﻠﻰ اﻷﻗﻞ‪ ،‬ﺣﺴـ ـــــ ـﻨﺎ وﻟﻜﻦ ﻛﻴﻒ ﻳﻌﻨﻲ ادرﺟﻬﻢ ؟‬
‫ﺑﻤﻌﻨﻰ أن ﺗﻘﻮم ﺑﻌﻤﻞ ‪ override‬ﻟﻠﺪاﻟﺔ ﻛﻤﺎ ﺗﻌﻠﻤﻨﺎ ﻣﺴﺒﻘﺎ‪ ،‬ﺳﻨﻮﺿﺢ ذﻟﻚ اﻷن‪:‬‬

‫• ﺑﻌﺪ اﻟﻀـﻐﻂ ﻋﻠﻴﻬﺎ ﻧﻼﺣﻆ أن ﻳﻄﻠﺐ‪implement as constructor parameters‬‬
‫ﻓﻲ أول ﻣﺮة وﻳﻘﺼـ ـــ ـﺪ ﺑﻪ أﻧﻨﺎ ﻋﺮﻓﻨﺎ ﻣﺘﻐﻴﺮ ﻓﻲ ‪ interface‬ﻓﻬﻨﺎ ﻳﺠﺐ ﻓﻲ اﻟﺘﺼـ ـــ ـﻨﻴﻒ‬
‫اﻟﻮارث ان ﻧﺴﺘﺨﺪﻣﻪ‪.‬‬

‫ﺑﻌﺪ إدراج اﻟﻤﺘﻐﻴﺮ‪:‬‬
‫{‪class operations(override var num1: Int) :myInterface‬‬
‫}‬
‫• ‪ implement members‬وﻫﻮ ﻳﻌﻨﻲ ﻗﻢ ﺑﺈﺿـ ـﺎﻓﺔ اﻟﺪوال اﻟﺘﻲ ﻋﺮﻓﺘﻬﺎ وﻟﻢ ﺗﺴـ ـﺘﺨﺪﻣﻬﺎ ‪،‬‬
‫وﻫﻨـﺎ ﻧﻨﻮه ﺑـﺄﻧـﻪ إﺟﺒـﺎري اﺳـ ــــــ ـﺘﺨـﺪاﻣﻬـﺎ وﻛﺘـﺎﺑﺘﻬـﺎ ﺑﻤـﺎ أﻧـﻚ ﻗﻤـﺖ ﺑﺠﻌـﻞ اﻟﺘﺼـ ــــــ ـﻨﻴﻒ ﻳﺮث‬
‫ﻣﻦ ‪ ،interface‬أﻣﺎ اﻟﺪاﻟﺔ اﻟﺠﺎﻫﺰة اﻟﺨﺎﺻـﺔ ﺑﻌﻤﻠﻴﺔ اﻟﻀـﺮب ﻓﻨﺤﻦ ﺑﻨﻴﻨﺎﻫﺎ ﻓﻲ ‪interface‬‬
‫ﻓﻠﻚ اﻟﺤﺮ ﻳﺔ ﺑﺄن ﺗﺴﺘﺪﻋﻴﻬﺎ ﻓﻲ اﻟﺘﺼﻨﻴﻒ أو ﻻ‪.‬‬

:‫ﺑﻌﺪ إدراج اﻟﺪوال‬
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() {

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
}
override fun sum(num1:Int,num2:Int) {

var result = num1 + num2
}

fun dev(num1:Int,num2:Int){
var result = num1 / num2
}
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

‫‪abstract‬‬
‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم اﻟـ ‪abstract‬‬
‫ﻧﺴـ ــــــ ـﺘﻄﻴﻊ ﻓﻴـﻪ ﺟﻌـﻞ اﻟـﺪوال واﻟﻤﺘﻐﻴﺮات ﻣﻌﻠﻨـﺔ ﻓﻘﻂ وﻟﻜﻦ ﺑﺸـ ــــــ ـﺮط أن ﻧﻀـ ــــــ ـﻊ ﻛﻠﻤـﺔ‬
‫‪abstract‬أﻣﺎﻣﻬﺎ ‪ ،‬ﺑﻤﻌﻨﻰ أن اﻟﺪوال ﻓﻲ ‪ interface‬ﻛﻨﺎ ﻧﺴـ ــــ ـﺘﻄﻴﻊ أن ﻧﻌﻠﻦ ﻋﻨﻬﺎ ﻓﻘﻂ ﺑﺪون‬
‫أن ﻧﻨﺸـ ــ ـﺊ ﻗﻄﻌﺔ ﺑﺮﻣﺠﻴﺔ ﻟﻬﺎ ﻷﻧﻨﺎ ﺳـ ــ ـﻨﻘﻮم ﺑﺬﻟﻚ ﻓﻲ ﺗﺼـ ــ ـﻨﻴﻒ أﺧﺮ ‪ ،‬ﻫﻨﺎ أ ﻳﻀـ ــ ـﺎ ﻧﺴـ ــ ـﺘﻄﻴﻊ أن‬
‫ﻧﻌﻠﻦ ﻓﻘﻂ ﻋﻦ اﻟﺪاﻟﺔ ﺑﺪاﺧﻞ ﻫﺬا اﻟﺘﺼـ ــــ ـﻨﻴﻒ وﻟﻜﻦ ﻳﺸـ ــــ ـﺘﺮط أن ﻧﻀـ ــــ ـﻊ ﻛﻠﻤﺔ ‪ abstract‬ﻷن‬
‫اﻟﺘﺼﻨﻴﻒ أﺻﻼ ﻫﻮ‪abstract .‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬اﺳﺘﺨﺪام اﻟـ ‪abstract‬‬
‫ﻫﻮ ﻋﺒﺎرة ﻋﻦ ﺗﺼـ ــــ ﻨﻴﻒ ‪ class‬وﻟﻜﻨﻪ ﻻ ﻳﻘﺒﻞ أن ﻧﻨﺸـ ــــ ﺊ ﻣﻨﻪ ﻛﺎﺋﻦ ‪ ،‬ﺗﺼـ ــــ ﻨﻴﻒ ﻧﺼـ ــــ ﻤﻤﻪ‬
‫ﻟﻠﻮراﺛﺔ )أي ﻟﻨﺠﻌﻞ ﺟﻤﻴﻊ ﻣﺤﺘﻮﻳﺎﺗﻪ ﻗﺎﺑﻠﺔ ﻟﻠﻮراﺛﺔ ﻟﺘﺼﻨﻴﻔﺎت أﺧﺮى(‪.‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻧﺸﺎء ﺗﺼﻨﻴﻒ ‪abstract‬‬
‫{‪abstract class operation‬‬
‫}‬

‫أﻧﺸـ ــــــ ـﺄـﻧﺎ ﺗﺼـ ــــــ ـﻨﻴﻒ ‪ abstract‬إذا ـﻣﺎ ـﺑﺪاﺧـﻠﻪ ﻣﻦ دوال ﻟﻜﻲ ﻳﺘﻢ اﻹﻋﻼن ﻋﻨـﻬﺎ ﻓﻘﻂ ـﺑﺪون‬
‫ﻋﻤﻠﻴﺔ ﺑﻨﺎء ﻟﻬﺎ ﻧﺠﻌﻠﻬﺎ ‪ abstract‬ﻛﻤﺎ ﺳﻴﺘﻢ ﺗﻮﺿﻴﺤﻪ اﻵن‪:‬‬
‫)‪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 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
}
override fun mul(num1: Int, num2: Int) {

var result = num1 * num2
}
override fun sub(num1: Int, num2: Int) {

var result = num1 - num2
}
override fun sum(num1: Int, num2: Int) {

var result = num1 + num2

}
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

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() {
}
}

‫‪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‬‬

‫{)(‪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‬‬
‫}‬
‫}‬

‫إذا ﻧﻼﺣﻆ أﻧﻪ ﻳﺴﺘﻄﻴﻊ اﻟﻮﺻﻮل ﻷي داﻟﺔ ﻣﺎﻋﺪا ﺗﻠﻚ اﻟﺘﻲ ﻋﻤﻠﻨﺎ ﻟﻬﺎ ‪ override‬ﺣﻴﻨﻬﺎ ﻟﻦ‬
‫ﻳﺴﺘﻄﻴﻊ اﻟﻮﺻﻮل إﻻ ﻟﻠﺪاﻟﺔ اﻟﻤﻮﺟﻮدة ﻓﻲ اﻟﺘﺼﻨﻴﻒ ‪.class Employee‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﻛﻠﻤﺔ ‪final‬‬
‫اﺳـ ـــــ ـﺘﺨﺪام ﻫﺬه اﻟﻜﻠﻤﺔ ﻣﻊ اﻟﺘﺼـ ـــــ ـﻨﻴﻒ ﻳﻌﻨﻲ أﻧﻪ ﻏﻴﺮ ﻗﺎﺑﻞ ﻟﻠﻮراﺛﺔ وﻫﺬا اﻟﺸـ ـــــ ـﻲء ﻳﺮﺟﻊ‬
‫ﻻﺧﺘﻴﺎراﺗﻚ اﻟﺸـ ــ ـﺨﺼـ ــ ـﻴﺔ ﻓﻨﺤﻦ ﻟﻨﺠﻌﻞ اﻟﺘﺼـ ــ ـﻨﻴﻒ ﻳﻘﺒﻞ اﻟﻮراﺛﺔ ﻻﺑﺪ ﻣﻦ وﺿـ ــ ـﻊ ﻛﻠﻤﺔ ‪،open‬‬
‫ﻛﺬﻟﻚ ﻣﻦ أﺟﻞ ﺟﻌﻠﻪ ﺗﺼـ ــ ـﻨﻴﻒ ﻧﻬﺎﺋﻲ ﻏﻴﺮ ﻗﺎﺑﻞ ﻟﻠﻮراﺛﺔ ﻧﻀـ ــ ـﻊ ‪ ،final‬وﻳﻨﻄﺒﻖ ﻧﻔﺲ اﻟﺸـ ــ ـﻲء‬
‫ﻋﻠﻰ اﻟﺪوال‪.‬‬
‫ﻣﺜﺎل‪:‬‬
‫{)(‪open class Employee():Person‬‬
‫{)‪final override fun getInfo(jobTitle:String‬‬

‫)"‪super.getInfo("Ahmed‬‬
‫}‬

‫}‬
‫ﻫﻨﺎ ﺟﻌﻠﻨﺎ ﻫﺬه اﻟﺪاﻟﺔ ﻻ ﺗﻘﺒﻞ أن ﺗﻜﻮن ﻣﺮة أﺧﺮى ﻓﻴﻤﺎ ﺑﻌﺪ ‪ ،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‬‬
‫}‬

‫اﻧﺸـ ـــــــ ـﺄﻧـﺎ داﻟﺘﻴﻦ ﻟﻬﻢ ﻧﻔﺲ اﻟﻤﺴـ ــــــ ـﻤﻰ وﻟﻜﻦ ﻛـﻞ واﺣـﺪة ﻣﻨﻬﻢ ﺗﺨﺘﻠﻒ ﻣﻦ ﺣﻴـﺚ ﻧﻮع‬
‫اﻟﻤﺘﻐﻴﺮات اﻟﻤﻤﺮرة ‪ ،‬أ ﻳﻀ ـﺎ ﻛﺎن ﺑﺎﻹﻣﻜﺎن ﺗﻌﺮ ﻳﻒ اﻟﺪاﻟﺔ اﻟﺜﺎﻧﻴﺔ وان ﻧﻮع اﻟﻤﺘﻐﻴﺮات ‪ int‬وﻟﻜﻦ‬
‫ﺑﺪل ﻣﻦ أن ﺗﻘﻮم ﺑﺠﻤﻊ ﻣﺘﻐﻴﺮ ﻳﻦ ﺗﻘﻮم ﻣﺜﻼ ﺑﺠﻤﻊ أ ﻛﺜﺮ‪.‬‬
‫ﻧﻼﺣﻆ أﻧﻪ ﻋﻨﺪﻣﺎ اردﻧﺎ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ﺑﺎﺳﻤﻬﺎ ﻃﻠﺐ ﻣﻨﺎ ان ﻧﺤﺪد أي داﻟﺔ ﻣﻨﻬﻢ ﻫﻞ اﻟﺘﻲ‬
‫ﻣﺘﻐﻴﺮاﺗﻬﺎ ‪ Int‬او ﺗﻠﻚ اﻟﺘﻲ ﻣﺘﻐﻴﺮاﺗﻬﺎ ‪.Float‬‬
‫)‪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‬‬

‫ﻣﻔﻬﻮم ‪ overload‬ﻧﺴ ـﺘﻄﻴﻊ ﺗﻨﻔﻴﺬه ﺣﺘﻰ ﺑﺪاﺧﻞ اﻟﺘﺼ ـﻨﻴﻒ ﻓﻴﻤﻜﻨﻨﺎ ﻣﻦ إﻧﺸ ـﺎء أ ﻛﺜﺮ ﻣﻦ‬
‫داﻟﺔ ﺑﻨﺎء وﻟﻜﻦ ﻣﻊ ﻣﺮاﻋﺎة ﻣﺎ ذﻛﺮﻧﺎه ﺳﺎﺑﻘﺎ‪.‬‬
‫‪Companion object‬‬
‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم ‪companion object‬‬
‫ﻫـﺬا اﻟﻤﻔﻬﻮم ﻳﻌﺒﺮ ﻋﻦ إﻣﻜـﺎﻧﻴـﺔ وﺻـ ــــــ ـﻮﻟـﻚ ﻟـﺪوال و ﻣﺘﻐﻴﺮات ﻣﻌﻴﻨـﺔ ﺗﻢ ﺗﻌﺮ ﻳﻔﻬـﺎ ﺑـﺪاﺧـﻞ‬
‫اﻟﺘﺼـ ــ ـﻨﻴﻒ ﺑﺪون اﺷـ ــ ـﺘﻘﺎق ﻛﺎﺋﻦ‪ ،‬ﻫﺬه اﻟﻤﺘﻐﻴﺮات ﻋﻤﻠﻬﺎ ﻣﺴـ ــ ـﺘﻘﻞ ﻋﻦ ﻣﺎ ﺑﺪاﺧﻞ اﻟﺘﺼـ ــ ـﻨﻴﻒ‬
‫ﻳﻌﻨﻲ أﻧﻨﻲ اﻧﺸـ ـــ ـﺄﺗﻬﺎ ﻟﻌﻤﻞ ﻣﻌﻴﻦ ﺑﺪون ان ﺗﺮﺗﺒﻂ ﺑﺎﻟﻤﺘﻐﻴﺮات اﻷﺧﺮى أو اﻟﺪوال اﻟﺘﻲ ﺑﺪاﺧﻞ‬
‫اﻟﺘﺼﻨﻴﻒ‪ ،‬وﻳﺘﻢ ﺗﻌﺮ ﻳﻒ ﻫﺬه اﻟﻤﺘﻐﻴﺮات واﻟﺪوال ﺑﺪاﺧﻞ ﻗﻄﻌﺔ ﺑﺮﻣﺠﻴﺔ ﺗﺴﻤﻰ ‪companion‬‬
‫‪.object‬‬
‫ﺛﺎﻧﻴﺎ ِ ‪ :‬ﻃﺮﻳﻘﺔ ﻛﺘﺎﺑﺘﻪ‬
‫{ ‪companion object‬‬
‫}‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬ﻣﺜﺎل‬
‫{ ‪class labtop‬‬

‫{)(‪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‬‬
‫}‬
‫}‬
‫ﺳـ ــ ـﺘﻼﺣﻆ ﺑﺄﻧﻬﺎ ﻗﻄﻌﺔ ﺑﺮﻣﺠﻴﺔ ﻣﺴـ ــ ـﺘﻘﻠﺔ اﻧﺸـ ــ ـﺄﻧﺎ ﺑﺪاﺧﻠﻬﺎ داﻟﺔ ﺗﻘﻮم ﺑﺎﻟﺘﺮﺣﻴﺐ ‪ ،‬ﻛﻤﺎ ﻗﻠﻨﺎ‬
‫ﺟﻪ أي أـﻧﻪ ﻻ ﻋﻼـﻗﺔ ـﻟﻪ ﺑﻤﺤﺘﻮـﻳﺎت‬
‫ﺧ ﺎر ـ‬
‫ﻣﻪ ـ‬
‫ﺨﺪ ـ‬
‫ﻌﺔ ﻟﻦ ﺗﺴـ ــــــ ـﺘ ـ‬
‫ﻫﺬه اﻟﻘﻄ ـ‬
‫ﺧﻞ ـ‬
‫ﻣﺎ ﻳﺘﻢ ﻛﺘـﺎﺑﺘـﻪ ـﺑﺪا ـ‬
‫أـﻧﻪ ـ‬
‫اﻟﺘﺼﻨﻴﻒ اﻟﺒﺎﻗﻴﺔ‪.‬‬

‫ﻧﻼﺣﻆ أﻧﻨﺎ ﻗﻤﻨﺎ ﺑﻜﺘﺎﺑﺔ اﺳـ ـــ ـﻢ اﻟﺘﺼـ ـــ ـﻨﻴﻒ ‪ class‬وﻣﻦ ﺛﻢ ﻇﻬﺮت ﻟﻨﺎ اﻟﺪاﻟﺔ اﻟﺘﻲ اﻧﺸـ ـــ ـﺄﻧﺎﻫﺎ‬
‫ﺑﺪاﺧﻞ ‪ companion object‬وﻫﻨﺎ ﻳﺘﺠﻠﻰ ﻟﻨﺎ اﻟﻬﺪف ﻣﻨﻬﺎ أﻧﻨﺎ ﻧﺴـ ــ ـﺘﻄﻴﻊ ان ﻧﻀـ ــ ـﻊ اﻟﻌﻤﻠﻴﺎت‬
‫واﻟﻤﺘﻐﻴﺮات ﺑﺪاﺧﻞ ﻫﺬه اﻟﻘﻄﻌﺔ اﻟﺒﺮﻣﺠﻴﺔ ﻟﻠﻮﺻﻮل إﻟﻴﻬﺎ ﺳﺮ ﻳﻌﺎ ﻣﻦ اﺳﻢ اﻟﺘﺼﻨﻴﻒ‪.‬‬
‫ﻫﻨﺎ ﻗﻤﻨﺎ ﺑﺎﺷـ ــ ـﺘﻘﺎق ﻛﺎﺋﻦ ﻣﻦ اﻟﺘﺼـ ــ ـﻨﻴﻒ وﻧﻼﺣﻆ أﻧﻪ ﻻ ﻳﺴـ ــ ـﺘﻄﻴﻊ اﻟﻮﺻـ ــ ـﻮل إﻟﻰ ﻣﺎ ﺑﺪاﺧﻞ‬
‫‪.companion object‬‬
‫راﺑﻌﺎ ً ‪ :‬ﻣﺘﻐﻴﺮ ﻳﺴﺘﻘﺒﻞ ‪companion object‬‬
‫ﻧﺴـ ـــــ ـﺘﻄﻴﻊ أن ﻧﻌﺮف ﻣﺘﻐﻴﺮ ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴـ ـــــ ـﻴﺔ ﻗﻴﻤﺘﻪ ﻋﺒﺎرة ﻋﻦ ‪companion object‬‬
‫ﻫﻜﺬا‪:‬‬
‫‪var quiz: Float = 0f‬‬

‫‪var midterm: Float = 0f‬‬
‫‪var final: Float = 0f‬‬
‫{ ‪class student‬‬

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")
println("C")
println("D")
} else {
println("F")
}
}
}
‫ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬

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")
}
}

var name = compan.Companion
var name1 = compan.Companion
name.show()
name1.show()
}
‫اﻟﺘﻨﻔﻴﺬ‬
Hello Ahmed Aljuaid

Hello Ahmed Aljuaid
‫ ﻓﻲ‬، ‫ ﻣﺎ ﻟﺬي ﺳـ ــ ـﻴﺤﺪث‬name ‫ﺣﺴـ ــ ـﻨﺎ ﻟﻨﻼﺣﻆ ﻗﻠﻴﻼ ﻟﻮ أردﻧﺎ ﺗﻐﻴﺮ اﻻﺳـ ــ ـﻢ اﻷول ﻓﻲ ﻣﺘﻐﻴﺮ‬
:‫اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬
var name = compan.Companion

var name1 = compan.Companion
name.yourName="Ali"
name.show()
name1.show()
‫اﻟﺘﻨﻔﻴﺬ‬

‫‪Hello Ali Aljuaid‬‬
‫‪Hello Ali Aljuaid‬‬
‫ﺗﻢ ﺗﻐﻴﻴﺮ اﻻﺳـ ـــــ ـﻢ ﻓﻲ اﻟﻤﺘﻐﻴﺮ ﻳﻦ ‪ name and nam1‬ﺑﺎﻟﺮﻏﻢ ﻣﻦ أﻧﻨﺎ اﺳـ ـــــ ـﺘﺪﻋﻴﻨﺎ ‪name‬‬
‫وﻋﺪﻟﻨﺎ ﺑﻬﺎ ‪ ،‬وﻫﺬا ﻳﺪل ﻋﻠﻰ أﻧﻪ ﻏﻴﺮ ﻣﺴـ ــــ ـﺘﻘﻞ ﺑﺤﻴﺚ أﻧﻪ ﻗﻴﻤﺔ ﻣﺘﻐﻴﺮ ﻓﻲ ﻛﺎﺋﻦ واﺣﺪ ﻳﺠﻌﻠﻚ‬
‫ﻋﻨﺪﻣﺎ ﺗﺴﺘﺪﻋﻲ ﻧﻔﺲ اﻟﻤﺘﻐﻴﺮ ﻟﻜﺎﺋﻦ ﺟﺪﻳﺪ ﻫﻴﺎ ﻧﻔﺴﻬﺎ اﻟﻘﻴﻤﺔ‪.‬‬
‫اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ ‪Nasted classes‬‬
‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ‬
‫ﻟﻐﺔ ‪ Kotlin‬ﺗﺪﻋﻢ ﻃﺮ ﻳﻘﺔ اﻟﺘﺼـ ـــ ـﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ ﻫﻲ ﻋﺒﺎرة ﻋﻦ ﺗﺼـ ـــ ـﻨﻴﻒ ﻛﺒﻴﺮ وﺑﺪاﺧﻠﻪ‬
‫ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺘﺼﻨﻴﻔﺎت‪ ،‬ﻳﻌﻨﻲ ﺗﻌﺮ ﻳﻒ ‪ class‬ﺑﺪاﺧﻞ ‪.class‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬ﻃﺮﻳﻘﺔ ﺗﻌﺮﻳﻒ اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ‬
‫{‪class school‬‬
‫{‪class employee‬‬
‫}‬
‫{‪class student‬‬
‫}‬

‫}‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬أﻫﻤﻴﺔ اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ‬
‫ﺗﻔﻴﺪ ﻓﻲ ﻋﻤﻠﻴﺔ اﻟﺘﻐﻠﻴﻒ ‪.Encapsulation‬‬
‫ﺗﻌﺘﺒﺮ ﻃﺮ ﻳﻘﺔ ﻋﻤﻠﻴﺔ ﻟﻮ ﻟﺪﻳﻨﺎ ﻋﺪد ﻣﻦ اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺮﺗﺒﻄﺔ ﺑﺒﻌﺾ‪.‬‬
‫راﺑﻌﺎ ً ‪ :‬ﻣﺼﻄﻠﺤﺎت ﻣﻬﻤﺔ ﻓﻲ اﻟﺘﺼﻨﻴﻔﺎت اﻟﻤﺘﺪاﺧﻠﺔ‬
‫اﻟﺘﺼﻨﻴﻒ اﻟﺨﺎرﺟﻲ اﻟﻜﺒﻴﺮ ﻳﺴﻤﻰ‪:‬‬
‫‪OUTER CLASS‬‬
‫اﻟﺘﺼﻨﻴﻔﺎت اﻟﺪاﺧﻠﻴﺔ اﻟﺘﻲ ﺑﺪاﺧﻞ ‪ outer class‬ﺗﺴﻤﻰ‪:‬‬
‫‪INNER CLASS‬‬
‫ﺧﺎﻣﺴﺎ ً ‪ :‬اﻧﺸﺎء ﻛﺎﺋﻦ ﻣﻦ ‪inner class‬‬
‫ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ‬
‫)(‪var obj= outerClass.innerClass‬‬

‫ ﻣﺜﺎل‬: ً ‫ﺳﺎدﺳﺎ‬
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'

‫)(‪stu.getInfo‬‬
‫}‬
‫‪ENUM class‬‬
‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم ‪Enum class‬‬
‫ﻫﻮ ﺗﺼ ـﻨﻴﻒ ﻧﺴ ـﺘﺨﺪﻣﻪ ﻟﻠﺘﻌﺪاد واﻷﺷ ـﻴﺎء اﻟﺜﺎﺑﺘﺔ اﻟﻐﻴﺮ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻐﻴﻴﺮ ‪ ،‬ﻣﺜﻼ اﻷﺳ ـﺒﻮع ﻳﺒﺪأ‬
‫ﻣﻦ اﻷﺣﺪ وﻳﻨﺘﻬﻲ اﻟﺴﺒﺖ وأﺳﻤﺎء اﻷﻳﺎم ﺛﺎﺑﺘﻪ وﻣﻌﺮوﻓﺔ وﻻ ﻳﻤﻜﻦ ﻟﻚ ﺗﻐﻴﻴﺮﻫﺎ‪.‬‬
‫ﺛﺎﻧﻴﺎ ً ‪ :‬اﺳﺘﺨﺪاﻣﻬﺎ ‪Enum class‬‬
‫ﻫﻮ ﺗﺼـ ــــ ـﻨﻴﻒ ﻧﻌﺮﻓﻪ وﻧﻀـ ــــ ـﻊ ﺑﺪاﺧﻠﻪ اﻟﺸـ ــــ ـﻲء اﻟﺬي ﻧﺮ ﻳﺪ أن ﻧﺜﺒﺘﻪ ‪ ،‬ﺑﻤﻌﻨﻰ أﻧﻨﻲ أر ﻳﺪ أن‬
‫اﺻـ ــ ـﻤﻢ ﻣﺸـ ــ ـﺮوع ﻳﺘﺤﺪث ﻋﻦ اﻟﻌﻤﻞ ﻓﻲ أ ﻳﺎم اﻷﺳـ ــ ـﺒﻮع ﻣﺜﻼ ﻓﺄﻋﺮف ﺗﺼـ ــ ـﻨﻴﻒ واﺿـ ــ ـﻊ ﺑﻪ أ ﻳﺎم‬
‫اﻷﺳﺒﻮع اﻟﺴﺒﻌﺔ وﻋﻨﺪﻣﺎ أﻗﻮم ﺑﺎﻟﻌﻤﻞ داﺧﻞ اﻟﻤﺸﺮوع ﻟﻦ ﻳﻘﺒﻞ ﻣﻨﻲ ﻳﻮم أﺧﺮ ﻏﻴﺮﻫﻢ‪.‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬ﺗﻌﺮﻳﻒ ‪Enum class‬‬
‫{‪enum class weekDays‬‬
‫‪Sunday , Monday , Tuesday , Wednesday , Thursday , Friday , Saturday‬‬
‫}‬

‫‪ weekDays‬ﻧﻌرف ﻣﺗﻐﯾر ﻣن اﻟﺗﺻﻧﯾف‪var myDay : weekDays //‬‬
‫ھﻧﺎ ﻟو أردﻧﺎ أن ﻧﻧﺎدي ﯾوم ﻣن اﻷﯾﺎم ‪myDay = weekDays.Tuesday //‬‬
‫ھﻧﺎ اﻋﺗرض ﻷﻧﮫ ﻟﯾس ﻣن ﺿﻣن اﻟﻌﻧﺎﺻر اﻟﻣوﺟودة ‪myDay = weekDays.Ahmed //‬‬
‫ﻓﻲ اﻟﺗﺻﻧﯾف‬
‫}‬
‫‪data class‬‬
‫أوﻻ ً ‪ :‬ﻣﻔﻬﻮم ‪data class‬‬
‫ﻣﺎذا ﻟﻮ ﻛﺎن ﻟﺪﻳﻚ ‪ .class‬واردت ﻃﺒﺎﻋﺔ اﻟﻘﻴﻢ اﻟﺘﻲ داﺧﻠﻪ او ﻃﺒﺎﻋﺘﻪ ﻛ ـ ـــــــــ ـ ‪ Object‬ﻓﺎﻧﺖ‬
‫ﻋﻨﺪ اﻟﻘﻴﺎم ﺑﺎﻣﺮ اﻟﻄﺒﺎﻋﺔ ﺳ ـﻴﻘﻮم اﻟﻤﺘﺮﺟﻢ ﺑﻄﺒﺎﻋﺔ ‪ hashcode‬ﻟﻠ ـ ـــــــ ـ ‪ Object‬وﻟﻴﺲ ﻟﻠﺒﻴﺎﻧﺎت!‬
‫ﺣﺘﻰ ﻟﻮ اردت اﻟﻤﻘﺎرﻧﺔ ﺑﻴﻦ ا ﻛﺜﺮ ﻣﻦ ‪ Object‬ﻓﺴـ ـــ ـﻴﻘﻮم اﻟﻤﺘﺮﺟﻢ ﺑﺎﻟﻤﻘﺎرﻧﺔ ﺑﻴﻦ ‪hashcode‬‬

‫وﻟﻴﺲ ﺑﻴﻦ اﻟﻘﻴﻢ ﻟﻠ ـ ــــــ ـ ‪ .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‬‬
‫}‬
‫}‬

fun main(args: Array<String>) {
val emp1 = 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>) {

//compare

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 ‫ ﺷﺮوط‬: ً ‫ﺛﺎﻧﻴﺎ‬

.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")

‫}‬
‫}‬
‫}‬
‫• ﻧﻼﺣﻆ أﻧﻨـﺎ ﻗﻤﻨـﺎ ﺑﻌﻤـﻞ ‪ sub classes‬ﺑـﺪاﺧـﻞ ‪ super class‬وﻫـﺬا ﻟﻴﺲ ﻟﻠﺘﻌﻘﻴـﺪ‬
‫إﻧﻤﺎ ﻧﺮ ﻳﺪ ﺗﻮﺿـ ــــــ ـﻴﺢ ﺑﺄﻧﻚ ﺗﺴـ ــــــ ـﺘﻄﻴﻊ ﺻـ ــــــ ـﻨﻊ ﻧﻔﺲ اﻟﻌﻤﻞ ﺑﺄ ﻛﺜﺮ ﻣﻦ ﻃﺮ ﻳﻘﺔ )ﻛﻞ‬
‫اﻟﻄﺮق ﺗﺆدي إﻟﻰ روﻣﺎ( اﻟﻤﻬﻢ أن ﻳﻜﻮن اﻟﻌﻤﻞ ﺻﺤﻴﺢ وﻣﻨﻄﻘﻲ‪.‬‬
‫• ﻧﻼﺣﻆ أن اﻟﺘﺼـ ـﻨﻴﻒ اﻟﺮﺋﻴﺴـ ـﻲ ‪ super class‬ﻳﺤﺘﻮي ﻋﻠﻰ داﻟﺔ ﺗﺮﺣﻴﺒﻴﺔ واﻓﺘﺮﺿـ ـﻨﺎ اﻧﻚ‬
‫ﺳـ ــ ـﺘﻤﺮر ﻗﻴﻤﺔ اﻟﺘﻲ ﻫﻲ اﺳـ ــ ـﻢ اﻟﻤﺪرﺳـ ــ ـﺔ وﻣﻦ ﺛﻢ ﺗﻘﻮم ﺑﻄﺒﺎﻋﺔ رﺳـ ــ ـﺎﻟﺔ ﺗﺮﺣﻴﺒﻴﺔ ﺑﺎﺳـ ــ ـﻢ‬
‫اﻟﻤﺪرﺳﺔ اﻟﺘﻲ ﻣﺮرﺗﻬﺎ‪.‬‬
‫• ﻗﻤﻨﺎ ﺑﻌﻤﻞ ‪ override‬ﻟﻨﻔﺲ اﻟﺪاﻟﺔ ﻓﻲ ‪ sub classes‬وﻟﻜﻦ ﻛﻞ داﻟﺔ ﺗﻘﻮم ﺑﻌﻤﻞ ﻣﻌﻴﻦ‬
‫ﺣﺴـ ـــ ـﺐ اﻟﺘﺼـ ـــ ـﻨﻴﻒ اﻟﺘﻲ ﺗﺘﺒﻌﻪ ﻓﻤﺜﻼ ﺗﺼـ ـــ ـﻨﻴﻒ اﻟﻤﻮﻇﻔﻴﻦ ﻫﻲ ﻧﻔﺲ اﻟﺪاﻟﺔ ﻓﻴﻪ وﻟﻜﻦ‬
‫ﺗﻘﻮم ﺑﻄﺒﺎﻋﺔ ﻣﻌﻠﻮﻣﺔ أن ﻛﻞ ﻣﻮﻇﻒ ﻟﺪﻳﻬﻢ ﻳﺤﻤﻞ رﻗﻢ وﻇﻴﻔﻲ‪.‬‬
‫• ﻓﻲ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ ‪:‬‬
‫ﻧﺴﺘﻄﻴﻊ أن ﻧﻘﻮم ﺑﻄﺮ ﻳﻘﺘﻴﻦ ﻻﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ذات اﻟﻮﺟﻮه اﻟﻤﺘﻌﺪدة‪:‬‬
‫§ اﻟﻄﺮﻳﻘﺔ اﻷوﻟﻰ ‪ :‬ﻋﻤﻞ داﻟﺔ ﺧﺎرﺟﻴﺔ وﻳﺘﻢ اﻻﺳﺘﺪاﻋﺎء ﻣﻦ ﺧﻼﻟﻬﺎ‬

‫{)‪fun showInfo(s:schools‬‬
‫)(‪s.getInfo‬‬
‫}‬

‫)(‪var sch = schools‬‬
‫)‪showInfo(sch‬‬
‫}‬
‫ﻧﻼﺣﻆ ﻗﻤﻨﺎ ﺑﺘﻤﺮ ﻳﺮ ﻛﺎﺋﻦ ﻣﻦ اﻟﺘﺼـ ـــ ـﻨﻴﻒ اﻟﺮﺋﻴﺴـ ـــ ـﻲ وﺑﺪاﺧﻞ اﻟﺪاﻟﺔ ﻫﺬه ﺟﻠﺒﻨﺎ اﻟﺪاﻟﺔ اﻟﺘﻲ‬
‫ﺗﻄﺒﻊ اﻟﺒﻴﺎﻧﺎت ‪ ،‬وﻣﻦ ﺛﻢ ﻋﺮﻓﻨﺎ ﻛﺎﺋﻦ ﻣﻦ اﻟﺘﺼـﻨﻴﻒ اﻟﺮﺋﻴﺴـﻲ واﺳـﺘﺪﻋﻴﻨﺎ اﻟﺪاﻟﺔ اﻟﺘﻲ ﻋﺮﻓﻨﺎﻫﺎ‬
‫وﻣﺮرﻧﺎ ﻟﻬﺎ ﻧﻔﺲ اﻟﻜﺎﺋﻦ‪.‬‬
‫• ﻧﺎﺗﺞ اﻟﺘﻨﻔﻴﺬ‪:‬‬
‫‪happy kids‬‬
‫‪Welcome in to our schools happy kids‬‬
‫§ اﻟﻄﺮﻳﻘﺔ اﻟﺜﺎﻧﻴﺔ ‪ :‬ﺗﻌﺮﻳﻒ ﻛﺎﺋﻦ ﻣﺮﺟﻌﻪ اﻟـ ‪super class‬‬

‫)(‪var emp:schools = schools.employees‬‬

‫)(‪emp.getInfo‬‬
‫}‬
‫‪every employee in this school have ID‬‬
‫‪ v‬ﻣﺜﺎل )‪(٢‬‬
‫{ )(‪open class primaryOperator‬‬

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 == "-") {
var result = a – b
}
}
open class seconderyOperator() : primaryOperator() {

override fun operator() {
println("secondary operator")
println("please choose between this operators(* , /) :")
var c = readLine()!!
if (c == "*") {

var result = a * b
} else if (c == "/") {
var result = a / b
}
}
}
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

(٣) ‫ ﻣﺜﺎل‬v
open class shapes(){
open fun getShape(){

println("shape")
}
class rectangle():shapes(){
override fun getShape() {
println("Rectangle")
}
}
class circle():shapes(){
println("Circle")
}
}
class triangle():shapes(){
println("Triangle")
}
}
fun showShapes(s:shapes){

‫)(‪s.getShape‬‬
‫}‬

‫)(‪var shape1 = triangle‬‬
‫)‪showShapes(shape1‬‬
‫}‬
‫‪Triangle‬‬
‫اﻻﺳﺘﺜﻨﺎءات ‪exception -‬‬
‫أوﻻ ‪ :‬ﻣﺎ ﻫﻲ اﻻﺳﺘﺜﻨﺎءات‬
‫ﻫﻮ ﻋﺒﺎرة ﻋﻦ ﺧﻄﺄ ﺣﺪث وﻟﻤﻌﺎﻟﺠﺔ ﻫﺬا اﻟﺨﻄﺄ وﺟﺪت ﻣﺎ ﺗﺴﻤﻰ ﺑﺎﻻﺳﺘﺜﻨﺎءات‪.‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬ﺗﻜﻮﻳﻦ اﻻﺳﺘﺜﻨﺎءات‬
‫ﺗﺘﻜﻮن ﺟﻤﻠﺔ اﻻﺳـ ـﺘﺜﻨﺎء ﻣﻦ ﻗﻄﻌﺘﻴﻦ ﺑﺮﻣﺠﻴﺘﻴﻦ أﺳـ ـﺎﺳـ ـﻴﺘﻴﻦ ﻫﻲ ‪ : try , catch‬وﻗﻄﻌﺔ‬
‫ﺛﺎﻟﺜﺔ اﺧﺘﻴﺎر ﻳﺔ وﻫﻲ ‪.finally :‬‬
‫‪try v‬‬

‫ﻄﺄ ﻓﻴـﻬﺎ ﺑﻤﻌﻨﻰ ﻟﺴـ ــــــ ــﻨﺎ‬
‫ﻤﻞ وﻗﻮع اﻟﺨ ـ‬
‫ﻌﺔ اﻟﺒﺮﻣﺠـﻴﺔ اﻷواﻣﺮ اﻟﺘﻲ ﻧﺤﺘ ـ‬ ‫• ﻧﻜـﺘﺐ ﻓﻲ ـ‬
‫ﻫﺬه اﻟﻘﻄ ـ‬
‫ﻣﺘﺄ ﻛﺪﻳﻦ ﻣﻦ ﻣﺪى ﺻﺤﺔ ﻣﺎ ﻛﺘﺒﻨﺎه‪ ،‬وﻣﻦ اﻟﻤﺤﺘﻤﻞ أن ﻻ ﻳﻜﻮن ﺑﻬﺎ ﺧﻄﺄ‪.‬‬
‫• ﻓﻲ ﺣﺎل ﻗﺎم اﻟﺒﺮﻧﺎﻣﺞ ﺑﻘﺮاءة ﻫﺬه اﻟﻘﻄﻌﺔ ووﺟﺪ ﺧﻄﺄ ﻳﻘﻮم ﺑﺘﺠﺎﻫﻞ ﺑﺎﻗﻲ اﻷواﻣﺮ وﻳﻨﺘﻘﻞ‬
‫إﻟﻰ ﻗﻄﻌﺔ‪catch .‬‬
‫ـ ‪ catch‬وﻳﻨﺘﻘﻞ إﻟﻰ‬ ‫ـــــــــــــ‬ ‫• ﻓﻲ ﺣﺎل ﺗﻤﺖ ﻗﺮاءة ﻗﻄﻌﺔ ‪ try‬وﻟﻢ ﻳﻜﻦ ﻓﻴﻬﺎ ﺧﻄﺄ ﻻ ﻳﺪﺧﻞ اﻟ ـ‬
‫‪finally‬ﻓﻲ ﺣﺎل ﺗﻮﻓﺮﻫﺎ‪.‬‬
‫{‪try‬‬
‫}‬
‫‪catch v‬‬
‫• ﻓﻲ اﻟـﺒﺪا ـﻳﺔ ﻧﻌﺮف ﻣﺘﻐﻴﺮ ﺑﻴﻦ اﻟﻘﻮﺳـ ــــــ ـﻴﻦ وﻧﻌﻴﻦ ﻧﻮع اﻟﻤﺘﻐﻴﺮ وﻫﻮ ﻧﻮع اﻟﺨ ـ‬
‫ﻄﺄ ﻣﻨﻄﻘﻲ ‪،‬‬
‫ر ﻳﺎﺿﻲ …إﻟﺦ‬
‫• ﺑﺪاﺧﻞ اﻟﻘﻄﻌﺔ اﻟﺒﺮﻣﺠﻴﺔ ﻧﻜﺘﺐ أواﻣﺮ ﺧﺎﺻـﺔ ﺑﻨﻮع اﻟﺨﻄﺄ اﻟﺬي ﻗﻤﻨﺎ ﺑﺘﻤﺮ ﻳﺮه ﺑﻤﻌﻨﻰ ﻟﻮ‬
‫ﻫﺬه‬ ‫ﻄﺄ ﻓﻲ اﻟﺒﺮـﻧﺎﻣﺞ ﻧﻮ ـ‬
‫ﻋﻪ ر ـﻳﺎﺿـ ــــــ ـﻲ ﻟﻦ ﺗﺴـ ــــــ ـﺘﻄﻴﻊ ـ‬ ‫ﺣﺪث ﺧ ـ‬
‫ﻄﺄ ﻣﻨﻄﻘﻲ ‪ ،‬و ـ‬
‫ـﻛﺎن ﻧﻮع اﻟﺨ ـ‬
‫اﻟﻘﻄﻌﺔ ﺣﻞ اﻟﻤﺸـ ـﻜﻠﺔ وﻟﺤﻞ اﻟﻤﺸـ ـﻜﻠﺔ ﻧﻘﻮم ﺑﺈﻧﺸـ ـﺎء ﻗﻄﻌﺔ ‪ catch‬أﺧﺮى ﻣﺨﺼـ ـﺼـ ـﺔ‬
‫ﻟﻨﻔﺲ ﻧﻮع اﻟﺨﻄﺄ‪.‬‬
‫{)‪catch(variable:exceptionType‬‬
‫}‬
‫‪finaly v‬‬

.‫ﻗﻄﻌﺔ اﺧﺘﻴﺎر ﻳﺔ ﺗﺘﻀﻤﻦ أواﻣﺮ ﻣﻌﻴﻨﺔ ﻋﺎدﻳﺔ ﻟﻴﺲ ﻟﻬﺎ ﻋﻼﻗﺔ ﺑﺎﻟﺨﻄﺄ‬
‫ ﻣﺜﺎل‬: ً ‫ﺛﺎﻟﺜﺎ‬
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 ‫ ﻣﻔﻬﻮم‬: ً ‫أوﻻ‬

.‫ﻫﻮ ﻛﻴﻔﻴﺔ ﺗﻨﻔﻴﺬ ﻋﻤﻞ أ ﻛﺜﺮ ﻣﻦ داﻟﺔ ﻓﻲ أن واﺣﺪ‬
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

‫)‪Thread.sleep(1000‬‬
‫}‬
‫}})"‪println("-----------------------\n The result is :$num‬‬
‫)(‪var F = first‬‬
‫)(‪var S = second‬‬
‫)(‪F.start‬‬
‫)(‪S.start‬‬
‫}‬
‫• ﻗﻤﻨﺎ ﺑﺈﻧﺸ ـﺎء ﺗﺼ ـﻨﻴﻔﻴﻦ ﻣﺨﺘﻠﻔﻴﻦ اﺣﺪﻫﻤﺎ ﻟﺠﻤﻊ اﻷرﻗﺎم اﻟﻮاﻗﻌﺔ ﺑﻴﻦ ‪ ٠‬و ‪ ، ٥‬وﺗﺼ ـﻨﻴﻒ‬
‫ﻟﻨﺎﺗﺞ ﺿﺮب اﻷﻋﺪاد اﻟﻮاﻗﻌﺔ ﺑﻴﻦ ‪ ٠‬و ‪.٥‬‬
‫• ﺗﻤﺖ ﻋﻤﻠﻴﺔ اﻟﻮراﺛﺔ ﻓﻲ اﻟﺘﺼﻨﻴﻔﻴﻦ ﻣﻦ ‪.Thread‬‬
‫• ﻓﻲ ﻛﻞ ﻣﻦ اﻟﺘﺼـ ـــــ ـﻨﻴﻔﻴﻦ اﺳـ ـــــ ـﺘﻌﻤﻠﻨﺎ داﻟﺔ ﻣﻨﺸـ ـــــ ـﺄة ﻓﻲ ‪ Thread‬ﻟﻠﻌﻤﻞ وﺗﺠﻬﻴﺰ اﻷواﻣﺮ‬
‫ﺑـﺪاﺧﻠﻬـﺎ وﻫﻲ ‪ run‬وﺑﻤـﺎ أﻧﻬـﺎ ﻣﻨﺸـ ـــــــ ﺄة ﻣﻦ ﻗﺒـﻞ ﻓﻲ ﺗﺼـ ــــــ ـﻨﻴﻒ ‪ Thread‬ﻓﻨﻘﻮم ﺑﻌﻤـﻞ‬
‫‪override‬ﻟﻬﺎ‪.‬‬
‫ﻌﻞ اـﻟﺪاﻟﺘﻴﻦ ﻓﻲ اﻟﺘﺼـ ــــــ ـﻨﻴﻔﻴﻦ ﻳﻌﻤﻠﻮن ـﺑﺎﻟﺘﺰاﻣﻦ ﺑﻤﻌﻨﻰ أﻧـﻨﺎ ﻟﻦ ﻧﻨﺘﻈﺮ داـﻟﺔ ‪ run‬ﻓﻲ‬
‫• ﻟﺠ ـ‬
‫ﺗﺼــﻨﻴﻒ ‪ first‬ﻟﻠﻌﻤﻞ وﻣﻦ ﺑﻌﺪ اﻧﺘﻬﺎﺋﻬﺎ ﻧﻨﺘﻘﻞ إﻟﻰ اﻟﺪاﻟﺔ ‪ run‬ﻓﻲ اﻟﺘﻨﺼــﻴﻒ ‪، second‬‬
‫ﻧﺴـ ـــ ـﺘﺨﺪم داﻟﺔ ‪ sleep‬اﻟﺘﻲ ﻧﺤﺪد ﻟﻬﺎ اﻟﻮﻗﺖ ﺑﺎﻟ ـ ــــــــــ ـ )‪ ،Millis (milliseconds‬ﺗﻘﻮم ﻫﺬه‬
‫اﻟﺪاﻟﺔ ﺑﺘﻌﻄﻴﻞ ﻋﻤﻞ اﻟﺪاﻟﺔ اﻟﺤﺎﻟﻴﺔ ﻣﺪة زﻣﻨﻴﺔ ﻣﻌﻴﻨﺔ وﻣﻦ ﺛﻢ ﺗﻌﻮد ﻟﻌﻤﻠﻬﺎ ﻣﻦ ﺟﺪﻳﺪ‪.‬‬
‫• اﻷن ﻟﻠﺘﺤﻘﻖ ﻣﻦ ﻋﻤﻠﻨﺎ ﻧﻘﻮم ﺑﻌﻤﻞ ﻛﺎﺋﻦ ﻣﻦ ﻛﻼ اﻟﺘﺼﻨﻴﻔﻴﻦ واﻟﻌﻤﻞ ﺑﻬﻤﺎ‪.‬‬

‫• ﻧﻼﺣﻆ أﻧﻨﺎ ﻟﻢ ﻧﺴـ ـﺘﺪﻋﻲ داﻟﺔ ‪ run‬ﻟﺘﻨﻔﻴﺬﻫﺎ وﻫﺬا ﺻـ ـﺤﻴﺢ ﻷن اﻟﻤﺴـ ـﺆول ﻋﻦ ﺗﻨﻔﻴﺬﻫﺎ‬
‫ﻫﻲ اﻟﺪاﻟﺔ اﻟﻤﻮﺿﺤﺔ ﺑﺎﻟﻤﺜﺎل وﻫﻲ‬
‫‪start : start() .‬‬
‫‪1‬‬
‫‪1‬‬
‫‪3‬‬
‫‪2‬‬
‫‪6‬‬
‫‪6‬‬
‫–———————‬
‫‪The result is :6‬‬
‫–———————‬
‫‪The result is :6‬‬
‫ﺛﺎﻟﺜﺎ ً ‪ :‬اﻟﺪوال اﻟﺘﻲ ﺗﻌﻤﻞ ﻣﻊ ‪thread‬‬
‫‪Start v‬‬
‫• ﻳﻌﻮد ﺑﻘﻴﻤﺔ ﻣﻨﻄﻘﻴﺔ‬

‫• إذا ﻛﺎﻧﺖ ﻗﻴﻤﺘﻪ ‪ true‬ﻳﺘﻢ ﺗﺸﻐﻴﻞ اﻟـ ‪.thread‬‬
‫‪run v‬‬

‫• ﻟﻜﺘﺎﺑﺔ اﻷواﻣﺮ اﻟﺘﻲ ﺳﻴﺘﻢ ﺗﻨﻔﻴﺬﻫﺎ ﻋﻨﺪ ﻋﻤﻞ ‪ start‬ﻟـ‪.Thread‬‬
‫‪sleep v‬‬
‫• ﻹﻳﻘﺎف ﻋﻤﻞ اﻟﺪاﻟﺔ ﻣﺪة ﻣﻌﻴﻨﻪ ﻧﻘﻮم ﺑﺘﺤﺪﻳﺪﻫﺎ ﺑﺎﻟـ‪. milliseconds‬‬
‫‪Suspend v‬‬
‫• ﻹﻳﻘـﺎف ﻋﻤـﻞ اﻟـﺪاﻟـﺔ ﻣـﺪة ﻏﻴﺮ ﻣﺤـﺪدة ‪ ،‬وﻻﺳـ ــــــ ـﺘﺌﻨـﺎف ﻋﻤﻠﻬـﺎ ﻧﻘﻮم ﺑـﺎﺳـ ــــــ ـﺘـﺪﻋـﺎء اﻟـﺪاﻟـﺔ‬
‫‪.resume‬‬
‫‪resume v‬‬
‫• ﺗﻜﻤﻞ ﺗﻨﻔﻴﺬ اﻷواﻣﺮ اﻟﺘﻲ ﺗﻮﻗﻔﺖ ﺑﺴﺒﺐ اﻟﺪاﻟﺔ ‪.Suspend‬‬
‫‪stop v‬‬
‫• ﺗﻮﻗﻒ ﻋﻤﻞ اﻟﻜﺎﺋﻦ اﻟﺬي ﻳﺮث ‪.Thread‬‬
‫‪id v‬‬
‫• ﻟﻠﺤﺼﻮل ﻋﻠﻰ ‪ id‬اﻟﺨﺎص ﺑﻜﺎﺋﻦ ‪.Thread‬‬

‫‪setName v‬‬
‫• ﻟﺘﻌﻴﻴﻦ اﺳﻢ ﺑﺎﻟﻜﺎﺋﻦ اﻟﺨﺎص ﺑـ ‪.Thread‬‬
‫‪getName v‬‬
‫• ﻟﻠﺤﺼﻮل ﻋﻠﻰ اﺳﻢ اﻟﻜﺎﺋﻦ اﻟﺨﺎص ﺑـ ‪.Thread‬‬
‫‪getPriority v‬‬
‫• ﻳﻌﻮد ﺑﻘﻴﻤﺔ ﻣﻦ ‪.١٠-١‬‬

‫• ﻳﻌﺒﺮ ﻋﻦ اﻷوﻟﻮﻳﺔ اﻟﺘﻲ ﻳﻤﺘﻠﻜﻬﺎ اﻟﻜﺎﺋﻦ اﻟﺨﺎص ﺑـ ‪.Thread‬‬
‫• اﻷوﻟﻮﻳﺔ اﻻﻓﺘﺮاﺿـ ــــ ـﻴﺔ ﻫﻲ ‪ ٥‬وﻟﻜﻦ ﻟﻮ أردﻧﺎ ﺗﻐﻴﻴﺮ ﻗﻴﻤﺘﻬﺎ ﻧﺴـ ــــ ـﺘﺨﺪم ‪ setPriority‬اﻟﺘﻲ‬
‫ﺗﺴﻤﺢ ﻟﻨﺎ ﺑﺘﻌﻴﻴﻦ ﻗﻴﻤﺔ ﺟﺪﻳﺪة ﻟﻸوﻟﻮﻳﺔ‪.‬‬
‫‪toString v‬‬
‫• ﺗﻌﻮد ﺑﻤﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻤﻌﻠﻮﻣﺎت ﻋﻦ اﻟﻜﺎﺋﻦ اﻟﺨﺎص ﺑـ‬

‫‪Thread ( name – id – group).‬‬
‫‪Interrupt v‬‬
‫• ﻟﻤﻘﺎﻃﻌﺔ ﻋﻤﻞ اﻟﻜﺎﺋﻦ اﻟﺨﺎص ﺑـ ‪.Thread‬‬

‫‪join v‬‬
‫• ﺗﻬﺘﻢ ﺑﺈﻧﺠﺎز ﺟﻤﻴﻊ اﻷواﻣﺮ اﻟﺨﺎﺻﺔ ﺑﻜﺎﺋﻦ اﻟ ـ ــ ‪ Thread‬وﺑﻌﺪ اﻻﻧﺘﻬﺎء ﻣﻨﻬﺎ اﻻﻧﺘﻘﺎل إﻟﻰ ﻣﺎ‬
‫ﺗﺒﻘﻰ ﻓﻲ ‪.main‬‬
‫‪State v‬‬
‫• ﻳﻌﻮد ﺑﺤﺎﻟﺔ ﻛﺎﺋﻦ اﻟـ ‪.Thread‬‬
‫‪any‬‬
‫أوﻻ ً ‪ :‬ﻣﺎ ﻫﻮ ‪class any‬‬
‫ﻫﻮ ﻋﺒﺎرة ﻋﻦ ﺗﺼ ـﻨﻴﻒ رﺋﻴﺴ ـﻲ ﻣﻮﺟﻮد ﻓﻲ ﻟﻐﺔ ‪ Kotlin‬ﻳﺤﺘﻮي ﺑﺪاﺧﻠﻬﺎ ﻋﻠﻰ دوال واﺣﺪاث‬
‫ﺟﺎﻫﺰة ﻟﻠﺘﻨﻔﻴﺬ ‪ ،‬ﻓﻲ ﺣﺎل إﻧﺸـﺎﺋﻚ ﺗﺼـﻨﻴﻒ ﺟﺪﻳﺪ ﻓﺈن ﻫﺬا اﻟﺘﺼـﻨﻴﻒ ﺗﻠﻘﺎﺋﻴﺎ ﻳﺮث ﻣﻦ ﺗﺼـﻨﻴﻒ‬
‫‪ . any‬إذا ﻳﻌﺘﺒﺮ ‪ class any‬ﻫﻮ ‪ super class‬ﻟﺠﻤﻴﻊ اﻟﺘﺼﻨﻴﻔﺎت ‪.classes‬‬

‫ﻟﺬﻟﻚ ﻋﻨﺪ اﺷـﺘﻘﺎق ﻛﺎﺋﻦ ﻣﻦ اﻟﺘﺼـﻨﻴﻒ اﻟﺬي اﻧﺸـﺄﻧﺎه ﻓﺈﻧﻨﺎ ﺑﺎﻟﺘﺄ ﻛﻴﺪ ﺳـﻨﻼﺣﻆ وﺟﻮد دوال‬
‫ﺟﺎﻫﺰة أ ﻳﻀﺎ ﻏﻴﺮ ﺗﻠﻚ اﻟﺘﻲ ﻛﺘﺒﻨﺎﻫﺎ ‪ ،‬ﻣﺜﻞ‪.hashCode , toString , equales,…etc :‬‬

تعلم لغة الكوتلن

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

تعلم لغة الكوتلن

Uploaded by

Copyright:

Available Formats

‫ﻣﺨﺘﺼﺮ ﻟﻐﺔ‬

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

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

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

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

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

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

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

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

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

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

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

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

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

‫ﺗﺜﺒﻴﺖ ‪JAVA 8‬‬

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

‫‪var age = 12‬‬

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

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

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

‫‪var myName : String‬‬

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

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

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

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

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

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

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

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

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

fun main(args : Array<String>)

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

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

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

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

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

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

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

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

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

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

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