บทช่วยสอนการเขียนโปรแกรม Kotlin

ประวัติความเป็นมาของคอตลิน

สถานที่สำคัญทางประวัติศาสตร์ของ Kotlin มีดังนี้

เหตุผลในการใช้ Kotlin

นี่คือเหตุผลสำคัญบางประการที่ทำให้ Kotlin ถูกใช้อย่างกว้างขวาง:

• Kotlin เป็นภาษาที่พิมพ์แบบคงที่ซึ่งอ่านและเขียนได้ง่ายมาก
• โปรแกรม Kotlin ไม่จำเป็นต้องมีเครื่องหมายเซมิโคลอนในโปรแกรม ซึ่งทำให้โค้ดง่ายและอ่านง่ายขึ้น
• ภาษานี้อนุญาตให้มีการแลกเปลี่ยนและใช้ข้อมูลจาก Java ในรูปแบบต่างๆ นอกจากนี้, Java และโค้ด Kotlin สามารถอยู่ร่วมกันในโปรเจ็กต์เดียวกันได้
• ระบบประเภทของ Kotlin มีวัตถุประสงค์เพื่อกำจัด NullPointerException ออกจากโค้ด
• ใช้เวลาน้อยลงในการเขียนโค้ดใหม่ใน Kotlin ง่ายยิ่งขึ้นในการปรับใช้โค้ด kotlin และดูแลรักษาตามขนาดที่ต้องการ

คุณสมบัติของ Kotlin

ต่อไปนี้เป็นคุณลักษณะบางประการของ Kotlin ที่จะทำให้คุณมั่นใจในเส้นทางความก้าวหน้าของภาษาการเขียนโปรแกรม

การเข้ารหัสแบบตัดแต่ง:

Kotlin เป็นภาษาการเขียนโปรแกรมแบบ OOP ซึ่งสามารถตัดบรรทัดโค้ดได้สูงสุดถึง 40% ซึ่งทำให้ Kotlin เป็นตัวเลือกในอุดมคติสำหรับซอฟต์แวร์หรือการพัฒนาเว็บ

โอเพ่นซอร์ส:

คอตลินสำหรับ Android ใช้ JVM และผสมผสานคุณสมบัติของ OOP และการเขียนโปรแกรมเชิงฟังก์ชัน

การรวบรวมอย่างรวดเร็ว:

การคอมไพล์โค้ดเป็นเรื่องง่ายเมื่อทำงานกับ Kotlin ซึ่งส่งผลให้ประสิทธิภาพการพัฒนา Android ดีขึ้น และยังจะอธิบายด้วยว่าสามารถใช้ฟังก์ชันข้อมูลประเภทใดในโค้ดทั้งหมดได้

ฟังก์ชั่นส่วนขยาย:

Kotlin สามารถรองรับฟังก์ชันส่วนขยายต่างๆ ได้โดยไม่ต้องทำการเปลี่ยนแปลงโค้ดใดๆ ช่วยทำให้โค้ดที่มีอยู่น่าสนใจและสวยงามยิ่งขึ้นสำหรับนักพัฒนา

ตัวอย่างเช่น:

Fun String.removeFirstLastChar():
String = this.substring(1, this.length -1)

รหัสนี้จะช่วยในการตัดแต่งอักขระตัวแรกและตัวสุดท้ายของสตริง เราสามารถใช้เป็น:

Val string1 = "Today ">is cloudy."
Val string2 = string1.removeFirstLastChar()

ความปลอดภัยที่เป็นศูนย์:

ใน Kotlin ระบบจะแยกความแตกต่างระหว่างการอ้างอิงที่เป็นโมฆะ และไม่ใช่การอ้างอิงที่เป็นโมฆะ ดังที่แสดงในตัวอย่าง Kotlin ด้านล่าง

ตัวอย่างเช่น ตัวแปร String ไม่สามารถเก็บค่าว่างได้:

Var string1: String = "Today ">is Sunday"
String1 = null  // compilation error
To permit null, we can adjoin the nullable variable :
Var string2: String? = "Today ">is Sunday"
String2 = null
print(string2)

ทำงานร่วมกันได้:

รหัส Kotlin สามารถใช้ได้โดย Javaและ Java รหัสสามารถใช้กับ Kotlin ดังนั้นหากคุณมีความรู้เกี่ยวกับ OOP การเขียนโปรแกรมก็ง่ายที่จะเปลี่ยนไปใช้การพัฒนาของ Kotlin นอกจากนี้หากมีบางแอปพลิเคชันเขียนมาด้วย Javaจากนั้นจึงจะสามารถนำไปใช้กับสภาพแวดล้อมของ Kotlin ได้

เครื่องมือที่แข็งแกร่ง:

Like Java, รหัส Kotlin ยังสามารถเขียนโดยใช้ IDE หรือใช้อินเทอร์เฟซบรรทัดคำสั่ง ง่ายต่อการทำงานกับ IDE และข้อผิดพลาดทางไวยากรณ์ก็ลดลงอย่างมากเช่นกัน ในเวลาเดียวกัน เมื่อคุณทำงานกับอินเทอร์เฟซบรรทัดคำสั่ง โค้ดจะต้องได้รับการคอมไพล์ก่อน

สมาร์ทแคสต์:

โดยทั่วไปแล้ว การหล่ออัจฉริยะจะช่วยลดต้นทุนแอปพลิเคชัน และปรับปรุงความเร็วหรือประสิทธิภาพ มันทำงานเกี่ยวกับการจัดการประสิทธิภาพของโค้ดโดยใช้การหล่อประเภทหรือค่าที่ไม่เปลี่ยนรูป

ตัวอย่างเช่น หากมีการระบุสตริง ก็จะมีความยาวและจำนวนและสามารถพบได้โดยใช้ฟังก์ชัน Smart Cast:

Val string1: Any = "Today ">is Monday"
when(string1)
{
is String  -> string1.length
Is Int -> string1.inc()
}

ต้นทุนการรับเลี้ยงบุตรบุญธรรมต่ำ:

Kotlin เป็นที่ต้องการขององค์กรต่างๆ เนื่องจากสูญเสียต้นทุนในการนำไปใช้ สิ่งสำคัญที่สุดคือนักพัฒนาสามารถเรียนรู้ได้ง่ายโดยเฉพาะผู้ที่มีพื้นฐานด้านการเขียนโปรแกรม

การตั้งค่าสภาพแวดล้อม Kotlin

ต่อไปนี้เป็นขั้นตอนที่ช่วยคุณในการตั้งค่าสภาพแวดล้อมการทำงานโดยการติดตั้ง Kotlin

ขั้นตอนที่ 1) ติดตั้ง Java

ดังที่เราได้กล่าวไปแล้วก่อนหน้านี้ว่า Kotlin มีพื้นฐานมาจาก Javaดังนั้นคุณต้องติดตั้ง Java ครั้งแรกเมื่อวางแผนที่จะนำ Kotlin มาใช้ อ้างอิงของเรา Java สอนการติดตั้ง.

ขั้นตอนที่ 2) ติดตั้ง Java IDEs

โชคดีที่มีหลายรายการ Java IDEs ให้เลือก เราได้ให้ลิงก์ดาวน์โหลดไว้ที่นี่เพื่อทำให้ทุกอย่างง่ายขึ้นสำหรับคุณ

• เมื่อต้องการดาวน์โหลด Eclipse, คลิกที่นี่.
• เมื่อต้องการดาวน์โหลด NetBeans, คลิกที่นี่.
• หากต้องการดาวน์โหลด IntelliJ คลิกที่นี่.

ในบทช่วยสอน Kotlin นี้ เราจะใช้ Eclipse.

ขั้นตอนที่ 3) ติดตั้ง Kotlin

สำหรับการติดตั้ง Kotlin ใน Eclipseให้ไปที่ส่วนช่วยเหลือใน Eclipse และคลิกที่ Eclipse ตัวเลือกตลาด

ตอนนี้พิมพ์คำค้นหา Kotlin ลงในกล่องค้นหา คลิกที่ตัวเลือก Go เพื่อแสดงรายการปลั๊กอิน คุณจะได้รับลิงก์ปลั๊กอิน Kotlin คุณต้องติดตั้งปลั๊กอินจากลิงก์ที่ระบุ

กรุณารีสตาร์ท Eclipse IDE, เมื่อติดตั้งเสร็จแล้ว. คุณจะพบไอคอนทางลัดที่มุมขวาบนของ Eclipse ไอดี เป็นวิธีการเข้าถึงที่รวดเร็ว

อีกวิธีในการเข้าถึง Kotlin Eclipse IDE คือไปที่ Windowsมุมมอง เปิดมุมมอง จากนั้นเลือกตัวเลือกอื่นๆ ที่นี่ คุณสามารถตรวจสอบรายการปลั๊กอินที่ติดตั้งในภายหลังได้ ดังแสดงด้านล่าง

เมื่อคุณตรวจสอบการติดตั้ง Kotlin แล้ว ให้เราสร้างโปรแกรม Kotlin แรกในขั้นตอนถัดไป

ขั้นตอนที่ 4) โปรแกรม Kotlin แรก

เริ่มต้นด้วยโครงการ Kotlin แรกของคุณ จากเมนูไฟล์ ให้เลือกตัวเลือกใหม่ จากนั้นเลือกตัวเลือกอื่นๆ และเริ่มต้นด้วยโปรเจ็กต์ Kotlin ใหม่จากรายการ

ตอนนี้ คุณต้องกำหนดชื่อสำหรับโปรเจ็กต์ และคุณก็พร้อมที่จะทำงานกับ Kotlin แล้ว

ด้วยขั้นตอนง่ายๆ เหล่านี้ การดาวน์โหลดจึงเป็นเรื่องง่าย Eclipse และ Kotlin บนระบบของคุณและเขียนโปรแกรม Kotlin แรกของคุณทันที

Archiการสอนของ Kotlin

สถาปัตยกรรมที่สร้างขึ้นอย่างดีมีความสำคัญต่อการขยายคุณสมบัติและตอบสนองความคาดหวังของฐานผู้ใช้ปลายทาง Kotlin มีสถาปัตยกรรมเฉพาะตัวที่จัดสรรหน่วยความจำและให้ผลลัพธ์ที่มีคุณภาพสำหรับนักพัฒนาและผู้ใช้ปลายทาง

โครูทีนและคลาสของ Kotlin ออกแบบแกนหลักในลักษณะที่จะสร้างโค้ดสำเร็จรูปน้อยลง เพิ่มประสิทธิภาพ และเสริมประสิทธิภาพ มีสถานการณ์ต่างๆ มากมายที่คอมไพเลอร์ Kotlin สามารถตอบสนองได้แตกต่างกัน โดยเฉพาะอย่างยิ่งเมื่อคอมไพเลอร์กำหนดภาษาต่างๆ

จากไดอะแกรมสถาปัตยกรรม จะเห็นได้ชัดว่าการดำเนินการโค้ดเสร็จสิ้นในสามขั้นตอนง่ายๆ

1. ในขั้นตอนแรก ไฟล์ “.kt” หรือ kotlin จะถูกเพิ่มลงในคอมไพเลอร์
2. ในขั้นตอนที่สอง คอมไพเลอร์ Kotlin จะแปลงโค้ดเป็นโค้ดไบต์
3. ในขั้นตอนที่สาม ใส่ bytecode ลงไป Java เครื่องเสมือน และดำเนินการโดย JVM

เมื่อไฟล์ที่เข้ารหัสแบบไบต์คู่หนึ่งทำงานบน JVM ไฟล์เหล่านั้นจะจุดประกายการสื่อสารระหว่างกัน ซึ่งเป็นสาเหตุที่ฟีเจอร์ใน Kotlin เรียกว่าการทำงานร่วมกันสำหรับ Java OOK Birth

การเกิดขึ้นของ Kotlin ถึง Javaสคริปต์เกิดขึ้นเมื่อ Kotlin กำหนดเป้าหมาย Javaต้นฉบับ

เมื่อราคาของ Javaเลือกเป้าหมายของสคริปต์แล้ว โค้ด Kotlin ใดๆ ที่เป็นส่วนหนึ่งของไลบรารีที่ทำงานร่วมกับ Kotlin จะถูกปล่อยออกมาด้วย Javaสคริปต์ อย่างไรก็ตาม Java ไม่รวม Development Kit (JDK) หรือไลบรารี Java ใด ๆ ที่ใช้

ไฟล์ที่ไม่ใช่ Kotlin จะไม่ถูกนำมาพิจารณาในระหว่างการดำเนินการดังกล่าว ขณะกำหนดเป้าหมาย Javaไฟล์สคริปต์ .kt จะถูกแปลงเป็น ES5.1 โดยคอมไพเลอร์ Kotlin เพื่อสร้างโค้ดที่สอดคล้องกันสำหรับ Javaสคริปต์ คอมไพเลอร์ Kotlin พยายามให้เอาต์พุตมีขนาดที่เหมาะสมที่สุด การทำงานร่วมกันได้กับโมดูลที่มีอยู่ ฟังก์ชันการทำงานเดียวกันกับไลบรารีมาตรฐาน และเอาต์พุตที่เป็น Javaสามารถอ่านสคริปต์ได้

จากการสนทนาเป็นที่ชัดเจนว่า Kotlin Compilers สามารถสร้างโค้ดที่มีประสิทธิภาพ มีความสามารถ และเป็นอิสระมากขึ้น ซึ่งส่งผลให้ผลิตภัณฑ์ซอฟต์แวร์มีประสิทธิภาพสูงต่อไป

ตัวแปร Kotlin

ตัวแปรใช้ในการจัดเก็บข้อมูลที่จะจัดการและอ้างอิงในโปรแกรม โดยพื้นฐานแล้วมันเป็นหน่วยเก็บข้อมูลและการติดป้ายกำกับเพื่อรอนามแฝงที่อธิบายเพื่อให้โปรแกรมอ่านง่ายและเข้าใจง่าย กล่าวอีกนัยหนึ่ง เราสามารถพูดได้ว่าตัวแปรคือคอนเทนเนอร์ในการรวบรวมข้อมูล

ใน Kotlin ตัวแปรทั้งหมดควรได้รับการประกาศ อย่างไรก็ตาม หากไม่ได้ประกาศตัวแปรใด ๆ ก็จะปรากฎข้อผิดพลาดทางไวยากรณ์ นอกจากนี้ การประกาศตัวแปรจะกำหนดประเภทของข้อมูลที่เราจะอนุญาตให้จัดเก็บในตัวแปร ใน Kotlin เราสามารถกำหนดตัวแปรได้โดยใช้คีย์เวิร์ด val และ var นี่คือไวยากรณ์ของการประกาศตัวแปรใน Kotlin:

Var day = "Monday"
Var number = 3

ที่นี่เราได้ประกาศวันตัวแปรท้องถิ่นที่มีค่าเป็น “Monday' และมีประเภทเป็น String และหมายเลขตัวแปรท้องถิ่นอื่นที่มีค่าเป็น 3 และมีประเภทเป็น Int เนื่องจากในที่นี้ตัวอักษรเป็นจำนวนเต็มประเภทที่เป็น 3

โดยทั่วไปตัวแปรในพื้นที่จะถูกประกาศและกำหนดค่าเริ่มต้นพร้อมกัน เราสามารถดำเนินการบางอย่างได้ในขณะกำหนดค่าเริ่มต้นตัวแปร Kotlin

เราสามารถดำเนินการกับตัวแปรที่มีชนิดข้อมูลเดียวกันได้ เช่น num1 และ num2 ต่างก็มีชนิดข้อมูลเดียวกันคือ Int ในขณะที่ day มีชนิดข้อมูลเป็นสตริง ดังนั้นระบบจะแสดงข้อผิดพลาด นี่คือเทคนิคอีกวิธีหนึ่งในการกำหนดตัวแปรใน Kotlin

var day : String = "GURU99"
var num : Int = 100

มาดูกันว่าคีย์เวิร์ด var และ val แตกต่างกันอย่างไร

วาร์ :

Var เปรียบเสมือนตัวแปรทั่วไปที่ใช้ในภาษาการเขียนโปรแกรมใดๆ ที่สามารถนำไปใช้ได้หลายครั้งในโปรแกรมเดียว นอกจากนี้คุณสามารถเปลี่ยนค่าได้ตลอดเวลาในโปรแกรม ดังนั้นจึงเรียกว่าตัวแปรที่ไม่แน่นอน

นี่คือตัวอย่างของตัวแปรที่ไม่แน่นอนใน Kotlin:

var num1 = 10
Var num2 = 20
Num1 = 20
print(num1 + num2) // output : 40

ที่นี่ค่าของ num1 ที่เป็น 20 จะถูกเขียนทับด้วยค่าก่อนหน้าของ num1 ที่เป็น 10 ดังนั้นเอาต์พุตของ num1 + num2 จึงเป็น 40 แทนที่จะเป็น 30

ค่า:

Val เป็นเหมือนตัวแปรคงที่ และคุณไม่สามารถเปลี่ยนค่าของตัวแปรนี้ในภายหลังในโปรแกรมได้ ซึ่งตัวแปรทั้งสองไม่สามารถกำหนดได้หลายครั้งในโปรแกรมเดียว และสามารถใช้ได้เพียงครั้งเดียวในโปรแกรมใดโปรแกรมหนึ่งเท่านั้น ดังนั้น จึงเรียกว่าตัวแปรที่ไม่เปลี่ยนแปลงได้

นี่คือตัวอย่างโปรแกรม Kotlin ของตัวแปรที่ไม่เปลี่ยนรูปใน Kotlin:

Val num1 = 10
Var num2 = 20

ในที่นี้ ค่าของ num1 ที่เป็น 10 ไม่สามารถเขียนทับด้วยค่าใหม่ของ num1 ที่เป็น 20 ได้ เนื่องจากเป็นประเภท val ที่เป็นค่าคงที่ ดังนั้นเอาต์พุตจึงเป็น 30 แทนที่จะเป็น 40

หมายเหตุ: ใน Kotlin ตัวแปรที่ไม่เปลี่ยนรูปเป็นที่ต้องการมากกว่าตัวแปรที่ไม่แน่นอน

ชนิดข้อมูลใน Kotlin

ประเภทข้อมูลคือชุดของค่าที่เกี่ยวข้องและอธิบายการดำเนินการที่สามารถดำเนินการกับค่าเหล่านั้นได้ เช่นเดียวกับภาษาการเขียนโปรแกรมอื่น ๆ Kotlin ยังมีชุดประเภทข้อมูลที่กำหนดไว้ล่วงหน้า เช่น Int, Boolean, Char Doubleฯลฯ

ใน Kotlin ข้อมูลทุกประเภทจะถือเป็นออบเจ็กต์

ในบทช่วยสอนพื้นฐานของ Kotlin นี้ เราจะมาเจาะลึกประเภทข้อมูลที่กำหนดไว้ล่วงหน้าที่ใช้ใน Kotlin กัน

Numbers :

Kotlin ให้บริการชุดประเภทข้อมูลในตัวที่เรียกว่าตัวเลข ซึ่งแบ่งย่อยเป็นจำนวนเต็มและจุดลอยตัว Numbers.

จำนวนเต็ม :

เลขจำนวนเต็ม คือ หมวดหมู่ของตัวเลขที่มี 4 ประเภท ดังนี้

จุดลอยตัว Numbers :

จุดลอยตัว Numbers เป็นตัวเลขที่ไม่ใช่จำนวนเต็มซึ่งมีค่าทศนิยมบางค่า

ลอย: ลอยเป็นค่าจุดลอยตัวที่มีความแม่นยำเดียว 32 บิต

ตัวอย่าง: var: ลอย x = 3.25600

Double: Double เป็นค่าจุดลอยตัวความแม่นยำแบบ 64 บิต

ตัวอย่าง: var: Double ย = 2456.345587

บูลีน :

ชนิดข้อมูล Booleans ใน Kotlin มีความสำคัญในการแสดงค่าตรรกะ มีเพียงสองค่าที่เป็นไปได้ในบูลีนเท่านั้นที่เป็นจริงหรือเท็จ

ตัวอย่างเช่น: วันวาล = จริง

วาล day2 = เท็จ

ตัวอักษร:

อักขระใน Kotlin จะแสดงโดยใช้คีย์เวิร์ดที่เรียกว่า char ใน Kotlin เครื่องหมายคำพูดเดี่ยวจะแสดงการประกาศ char ใน Java บางครั้ง char จะถูกใช้เป็นตัวเลข ซึ่งไม่สามารถใช้ได้ใน Kotlin

ตัวอย่างเช่น:

val onechar = 'x'
print(onechar) //  output : x
Val onedigit = '7'
print(onedigit) // output : 7

การแปลงประเภท Kotlin หรือการหล่อประเภท Kotlin

การแปลงประเภทเป็นขั้นตอนของการแปลงตัวแปรข้อมูลประเภทหนึ่งไปเป็นตัวแปรประเภทข้อมูลอื่น มีขนาดใหญ่มากหรือที่เรียกว่า Type Casting

อย่างโดดเด่นใน Javaรองรับการแปลงประเภทโดยนัยหรือประเภทโดยนัยของการพิมพ์ประเภทข้อมูลที่เล็กลงเป็นประเภทข้อมูลที่ใหญ่กว่า

For Example : int abc = 15;
Long bcd = abc; // compiles successfully

อย่างไรก็ตาม ใน kotlin การแปลงประเภทข้อมูลที่เล็กกว่าไปเป็นประเภทข้อมูลที่ใหญ่กว่าโดยนัยนั้นไม่ได้รับการสนับสนุนเลย เนื่องจากประเภทข้อมูล int ไม่สามารถแปลงเป็นประเภทข้อมูลที่ยาวโดยปริยายได้

For Example : var abc = 15
Val bcd : Long = abc // error

อย่างไรก็ตาม ใน Kotlin การแปลงประเภทจะดำเนินการอย่างชัดเจน คำแนะนำเกี่ยวกับฟังก์ชันตัวช่วยที่แนะนำการแปลงตัวแปรประเภทข้อมูลหนึ่งไปยังอีกตัวแปรหนึ่งมีดังนี้

มีฟังก์ชันตัวช่วยบางอย่างซึ่งมีอยู่แล้วสำหรับการแปลงประเภทข้อมูลหนึ่งไปเป็นอีกประเภทหนึ่ง:

ถึงInt()

เป็นไบต์()

ถึงสั้น()

toChar()

ไปอีกนาน()

ลอย()

ไปยังDouble()

For Example : var abc = 15
Val bcd : Long = abc.toLong() // compiles successfully

คอตลิน Operaโปร

Operators คืออักขระหรือสัญลักษณ์ที่สำคัญและพิเศษซึ่งรับรองการดำเนินการในตัวดำเนินการที่มีตัวแปรและค่า ใน Kotlin มีชุดตัวดำเนินการที่ใช้ในการดำเนินการต่างๆ เช่น การดำเนินการทางคณิตศาสตร์ การดำเนินการกำหนดค่า การดำเนินการเปรียบเทียบ เป็นต้น

คณิตศาสตร์ Operaทอร์ :

ตัวดำเนินการทางคณิตศาสตร์ใช้สำหรับการบวกและการลบtracการคูณ การหาร และค่าสัมบูรณ์

ตัวอย่างเช่น:

var x = 10
var y = 20
var z = ( ( x + y ) * ( x + y ) ) / 2     

ผลลัพธ์ของโค้ดต่อไปนี้คือ 45

การเปรียบเทียบ Operaทอร์ :

ตัวดำเนินการเปรียบเทียบใช้ในการเปรียบเทียบค่า 2 ค่า 2 ตัวแปร หรือ 2 ตัวเลข ใช้กับสัญลักษณ์มากกว่า ( > ) สัญลักษณ์น้อยกว่า ( < ) และสัญลักษณ์เท่ากับ ( == ) สัญลักษณ์ไม่เท่ากับ ( != ) สัญลักษณ์มากกว่าเท่ากับ ( >= ) สัญลักษณ์น้อยกว่าเท่ากับ ( <= ) โดยผลลัพธ์จะเป็นจริงหรือเท็จเสมอ

ตัวอย่างเช่น:

var x = 10
Var y =20
Var z = x < y // Output : true
Var w = x > y // Output : false
Var m = x == y // Output : false

การมอบหมาย Operaทอร์ :

การมอบหมาย Operators ใช้เพื่อกำหนดค่าที่ดำเนินการทางคณิตศาสตร์ ใช้ร่วมกับสัญลักษณ์เช่น +=, -=, *=, /=, %=

ตัวอย่างเช่น:

var x = 10
var y = 20
var x + = y // Output : 30
Var y - = x // Output : 10
Var x * = y // Output : 200

เพิ่มขึ้นและลดลง Operaทอร์ :

ตัวดำเนินการเพิ่มและลดค่าใช้เพื่อเพิ่มและลดค่าของตัวแปรหรือตัวเลข โดยใช้สัญลักษณ์เช่น ++ และ —

การเพิ่มขึ้นและการลดลงมีสองประเภท ได้แก่ การเพิ่มขึ้นล่วงหน้า ++a, การเพิ่มขึ้นหลัง a++, การลดลงก่อน –b, หลังการลดลง b–

ตัวอย่างเช่น:

var a = 10
var b = 20
var c = a++ // Output: 11
var d = b— //Output : 19     

อาร์เรย์ Kotlin

อาร์เรย์เป็นชุดของประเภทข้อมูลที่เป็นเนื้อเดียวกันและเป็นหนึ่งในประเภทข้อมูลพื้นฐานที่สุดซึ่งใช้ในการจัดเก็บข้อมูลประเภทเดียวกันในตำแหน่งหน่วยความจำที่อยู่ติดกัน อาร์เรย์มีความสำคัญสำหรับการจัดระเบียบข้อมูลในภาษาการเขียนโปรแกรมใดๆ ก็ตาม ดังนั้นข้อมูลจำนวนมากที่จัดเก็บไว้ในที่เดียวจึงง่ายต่อการค้นหาหรือจัดเรียง

ใน Kotlin อาร์เรย์เป็นการทำงานร่วมกันที่ไม่แน่นอนของประเภทข้อมูลเดียวกันแทนที่จะเป็นประเภทข้อมูลดั้งเดิม

นี่คือคุณสมบัติบางอย่างของอาร์เรย์ใน Kotlin

• ขนาดของอาร์เรย์ไม่สามารถเปลี่ยนแปลงได้เมื่อประกาศแล้ว
• อาร์เรย์ใน Kotlin นั้นไม่แน่นอน
• อาร์เรย์จะถูกจัดเก็บไว้ในตำแหน่งหน่วยความจำที่อยู่ติดกัน
• อาร์เรย์สามารถเข้าถึงได้ด้วยความช่วยเหลือของดัชนี เช่น a[1], a[2], et – cetera
• ดัชนีของอาร์เรย์เริ่มต้นด้วยศูนย์ที่เป็น [0]

ใน Kotlin คุณสามารถกำหนดอาร์เรย์ได้สองวิธี

โดยใช้ฟังก์ชัน arrayOf() :

ใน Kotlin มีการใช้งานฟังก์ชั่นห้องสมุดเป็นหลัก ฟังก์ชันไลบรารีหนึ่งดังกล่าวคือฟังก์ชัน arrayOf() ซึ่งใช้ในการกำหนดอาร์เรย์โดยส่งค่าของตัวแปรไปยังฟังก์ชัน

ตัวอย่างเช่น: การประกาศประเภทโดยนัยของอาร์เรย์โดยใช้ฟังก์ชัน arrayOf()

val x = arrayOf(1,2,3,4,5,6,7,8,9)

ตัวอย่างเช่น: พิมพ์การประกาศอาร์เรย์อย่างชัดเจนโดยใช้ฟังก์ชัน arrayOf()

Val y = arrayOf<Int>(1,2,3,4,5,6,7,8,9)

โดยใช้ Array Constructor:

ใน Kotlin มีคลาสชื่อ Array ดังนั้นจึงเป็นไปได้ที่จะใช้อาร์เรย์ของตัวสร้างเพื่อสร้างอาร์เรย์ อาร์เรย์ในตัวสร้างมีพารามิเตอร์หลักสองตัว

ดัชนีของอาร์เรย์ใน Kotlin คืออะไร?

ฟังก์ชันที่ดัชนีอาร์เรย์สามารถส่งกลับค่าเริ่มต้นของดัชนีได้

ตัวอย่างเช่น:

val abc = Array(7 , { i -> i*1})

ที่นี่ ค่าของอาร์เรย์คือ 7 และนิพจน์แลมบ์ดาใช้เพื่อเริ่มต้นค่าขององค์ประกอบ

นอกจากนี้ยังมีวิธีการต่างๆ ในการเข้าถึงและแก้ไขอาร์เรย์โดยใช้ฟังก์ชันบางอย่าง ดังนั้นจึงมีฟังก์ชันสมาชิกสองตัวคือ get() และ set() ซึ่งใช้เพื่อเข้าถึงอ็อบเจ็กต์ของคลาสอาร์เรย์

ตัวอย่างเช่น:

val x = arrayOf(10,20,30,40,50,60,70,80,90)
val y = x.get(0) // Output 10

ที่นี่เอาต์พุตคือ 10 เนื่องจากค่าที่ดัชนี 0 ของอาร์เรย์คือ 10

หมายเหตุ : get() รับเพียงค่าเดียวเท่านั้น

ตัวอย่างเช่น:

val x = arrayOf(10,20,30,40,50,60,70.80.90)
val y = x.set(2, 3) //

เอาท์พุต : 30 40

ที่นี่เอาต์พุตคือ 30 และ 40 เนื่องจากค่าที่ดัชนี 2 ของอาร์เรย์คือ 30 และที่ดัชนี 3 คือ 40

หมายเหตุ: set() รับค่าหลายค่าของอาร์เรย์

สตริง Kotlin

สตริงเป็นชนิดข้อมูลพื้นฐานในภาษาการเขียนโปรแกรมใดๆ สตริงคืออะไรนอกจากลำดับของอักขระ คลาส String แสดงถึงสตริงอักขระ ใน Kotlin สตริงทั้งหมดเป็นอ็อบเจ็กต์ของคลาส String ซึ่งหมายความว่าสตริงตัวอักษรจะถูกนำไปใช้เป็นอินสแตนซ์ของคลาส

ไวยากรณ์:

 Val myString = "Hey there!"

คอตลิน คอลเลคชั่น

คอลเลกชันประกอบด้วยวัตถุหลายประเภทที่คล้ายกัน และวัตถุเหล่านี้ในคอลเลกชันเรียกว่าองค์ประกอบหรือรายการ คอลเลกชันสามารถช่วยจัดเก็บ ดึงข้อมูล จัดการ และรวบรวมข้อมูลได้

ประเภทของคอลเลกชัน:

คอลเลกชันที่ไม่เปลี่ยนรูป

คอลเลกชันประเภทนี้รองรับฟังก์ชันแบบอ่านอย่างเดียว ไม่มีใครสามารถปรับเปลี่ยนองค์ประกอบได้

วิธีการรวมถึง:

• รายการ – listOf() และ listOf -
• ชุด – setOf()
• แผนที่ – mapOf()

คอลเลกชันที่ไม่แน่นอน

รองรับทั้งฟังก์ชั่นการอ่านและเขียน

วิธีการต่างๆ ได้แก่

• รายการ – mutableListOf(),arrayListOf() และ ArrayList
• ชุด – mutableSetOf(), hashSetOf()
• แผนที่ – mutableMapOf(), hashMapOf() และ HashMap

ฟังก์ชัน Kotlin

ฟังก์ชั่นในภาษาการเขียนโปรแกรมคือกลุ่มของข้อความที่คล้ายกันซึ่งถูกกำหนดให้ทำงานเฉพาะอย่าง ฟังก์ชันต่างๆ ช่วยให้โปรแกรมสามารถแยกออกเป็นบล็อคโค้ดเล็กๆ ต่างๆ ได้ การแบ่งโค้ดนี้ช่วยเพิ่มความสามารถในการอ่านโค้ด การนำโค้ดกลับมาใช้ใหม่ได้ และทำให้โปรแกรมจัดการได้ง่าย

เนื่องจาก Kotlin เป็นที่รู้จักในฐานะภาษาที่พิมพ์แบบคงที่ ในที่นี้คีย์เวิร์ด 'fun' ใช้เพื่อประกาศฟังก์ชัน ใน Kotlin มีฟังก์ชันสองประเภทซึ่งขึ้นอยู่กับความพร้อมใช้งานในไลบรารีมาตรฐานหรือคำจำกัดความของผู้ใช้เท่านั้น พวกเขาคือ:

• ฟังก์ชั่นไลบรารีมาตรฐาน
• ฟังก์ชันที่ผู้ใช้กำหนด

ตอนนี้เรามาพูดคุยกันโดยละเอียดด้วยตัวอย่างโค้ด Kotlin

ฟังก์ชั่นไลบรารีมาตรฐาน

เป็นฟังก์ชันไลบรารีในตัวที่สามารถกำหนดโดยปริยายและพร้อมใช้งานได้

ตัวอย่างที่ 2:

fun main(args: Array<String>){  
var number = 9  
var result = Math.sqrt(number.toDouble())  
print("$result")  
}  

Output:

3.0

sqrt() เป็นฟังก์ชันที่กำหนดไว้ในไลบรารีซึ่งจะคืนค่ารากที่สองของตัวเลข

ฟังก์ชัน print() พิมพ์ข้อความไปยังเอาต์พุตสตรีมมาตรฐาน

ฟังก์ชันที่ผู้ใช้กำหนด

ตามชื่อที่แนะนำ ฟังก์ชันเหล่านี้มักจะสร้างขึ้นโดยผู้ใช้ และสามารถใช้สำหรับการเขียนโปรแกรมขั้นสูงได้

ที่นี่ ฟังก์ชันต่างๆ ได้รับการประกาศโดยใช้คีย์เวิร์ด 'fun'

ตัวอย่างที่ 3:

fun functionName(){
//body of the code
}

ที่นี่เราเรียกใช้ฟังก์ชันเพื่อเรียกใช้โค้ดภายในร่างกาย functionName()

ตัวอย่างฟังก์ชัน Kotlin:

fun main(args: Array<String>){  
    sum()  
    print("code after sum")  
}  
fun sum(){  
    var num1 =8  
    var num2 = 9  
    println("sum = "+(num1+num2))  
}  

Output:

ผลรวม = 17

รหัสหลังผลรวม

การจัดการข้อยกเว้นใน Kotlin

ข้อยกเว้นในการเขียนโปรแกรมถูกกำหนดให้เป็นปัญหารันไทม์ซึ่งเกิดขึ้นในโปรแกรม นำไปสู่การยุติ ปัญหานี้อาจเกิดขึ้นได้เนื่องจากพื้นที่หน่วยความจำน้อย อาร์เรย์ไม่อยู่ในพันธะ เงื่อนไขเช่นการหารด้วยศูนย์ เพื่อลดปัญหาประเภทนี้ในการเรียกใช้โค้ด จึงมีการใช้การจัดการข้อยกเว้น

การจัดการข้อยกเว้นถูกกำหนดให้เป็นเทคนิคที่จัดการกับปัญหารันไทม์และยังรักษาโฟลว์ของโปรแกรมระหว่างการดำเนินการอีกด้วย

Kotlin ใช้นิพจน์ 'throw' เพื่อโยนวัตถุข้อยกเว้น ที่นี่คลาสยกเว้นทั้งหมดเป็นทายาทของคลาส Throwable

โยน MyException (“ โยนข้อยกเว้น”)

มีข้อยกเว้นสี่ประเภทในการจัดการข้อยกเว้น พวกเขาคือ:

• ลอง - บล็อกนี้มีคำสั่งที่อาจสร้างข้อยกเว้น ตามด้วย catch หรือท้ายที่สุดหรือทั้งสองอย่างเสมอ
• catch - จับข้อยกเว้นที่ส่งมาจากบล็อก try
• ในที่สุด – มันจะตรวจสอบเสมอว่ามีการจัดการข้อยกเว้นหรือไม่
• โยน - ใช้เพื่อโยนข้อยกเว้นอย่างชัดเจน

ลองจับ:

ในบล็อก try-catch ในการจัดการข้อยกเว้น try block ล้อมรอบโค้ด ซึ่งอาจส่งข้อยกเว้นและ catch block จะจับนิพจน์และจัดการมัน

ไวยากรณ์ของ try catch block:

try{    
//code with exception    
}catch(e: SomeException){  
//code handling exception  
}    

ไวยากรณ์ของ try with ในที่สุดบล็อก

try{    
//code with exception    
}finally{  
// code finally block  
}   

สุดท้าย:

ใน Kolin ในที่สุด block จะตรวจสอบเสมอว่าข้อยกเว้นได้รับการจัดการหรือไม่ ทำให้เป็นคำสั่งที่สำคัญมากเกี่ยวกับการจัดการข้อยกเว้น

ตัวอย่างที่ 4:

ในข้อมูลโค้ดนี้ มีข้อยกเว้นเกิดขึ้น และได้รับการจัดการ

fun main (args: Array<String>){  
    try {  	
        val data =  9/ 0  
        println(data)  
    } catch (e: ArithmeticException) {  
        println(e)  
    } finally {  
        println("">finally block executes")  
    }  
    println("write next code")  
}  

Output:

java.lang.ArithmeticException: / by zero
finally block executes
write next code

โยน:

Throw block ทำให้เกิดข้อยกเว้นที่ชัดเจน นอกจากนี้ยังใช้เพื่อส่งข้อยกเว้นแบบกำหนดเอง

ไวยากรณ์:

Throw SomeException()

Throw SomeException()

ตัวอย่าง:

fun main(args: Array<String>) {
    try{
        println("Exception ">is not thrown yet")
        throw Exception("Everything ">is not well")
        println("Exception ">is thrown")
    }
    catch(e: Exception){
        println(e)

    }
    finally{
        println("You can't ignore me")
    }
}

Output:

Kotlin Null ความปลอดภัย

ประเภทของระบบที่รองรับ Kotlin จะมีความแตกต่างอย่างมากระหว่างการอ้างอิงที่สามารถนำการอ้างอิงที่เป็นโมฆะได้ และประเภทของระบบที่สนับสนุน Kotlin นั้นไม่สามารถมีการอ้างอิงที่เป็นโมฆะได้ Kotlin เป็นภาษาความปลอดภัยแบบ null ที่มุ่งกำจัดข้อยกเว้นของตัวชี้ null หรือการอ้างอิง null จากโค้ด ซึ่งจงใจรู้จักกันในชื่อ A Billไอออนดอลลาร์ผิดพลาด

สิ่งกีดขวางที่ธรรมดาที่สุดของหลาย ๆ คน การเขียนโปรแกรมภาษา คือในขณะที่เข้าถึงสมาชิกของการอ้างอิง null ผลลัพธ์ที่ได้คือ NullPointerException ซึ่งอาจเป็นเพราะตัวดำเนินการ !! หรือคอนสตรัคเตอร์นี้ถูกใช้ในที่อื่นแล้วส่งผ่านไปยังจุดโค้ดอื่น คุณสมบัติ nullable ต้องได้รับการยืนยันสำหรับการตรวจสอบ null ทุกครั้งก่อนที่จะใช้งาน

ใน Kotlin ระบบจะแยกความแตกต่างระหว่างการอ้างอิงที่เป็นโมฆะ และไม่ใช่การอ้างอิงที่เป็นโมฆะ

ตัวอย่างเช่น ตัวแปร String ไม่สามารถเก็บค่าว่างได้:

ตัวอย่างที่ 5:

fun main(args: Array<String>){
    var x: String = "GURU99 ">is the only place where you will get maximum technical content!" // Not Null by default
    println("x ">is : $x")
    // You cannot assign null variable to not-nullable variables 
    // a=null // it will give compilation error
    var y: String? = "Thanks ">for visiting GURU99" 
// Nullable Variable
    println("y ">is : $y")
    y = null
    println("y ">is : $y")
}

Output:

Kotlin OOP

แนวทางการเขียนโปรแกรมเชิงวัตถุช่วยให้สามารถแบ่งโค้ดย่อยๆ ออกเป็นบล็อกโค้ดที่เล็กลงได้โดยการสร้างวัตถุ วัตถุเหล่านี้มีลักษณะร่วมกันสองประการ ได้แก่ สถานะและพฤติกรรม

นี่คือองค์ประกอบ OOP บางส่วนที่เราจะหารือกับตัวอย่างโค้ด Kotlin:

• คลาสและวัตถุ
• ตัวสร้าง
• มรดก
• abstracคลาส t

ชั้นเรียนใน Kotlin

ขั้นแรกก่อนที่จะสร้างวัตถุ เราจำเป็นต้องกำหนดคลาสที่เรียกว่าพิมพ์เขียวสำหรับวัตถุ

ไวยากรณ์:

class ClassName {
    // property
    // member function
    ... .. ...
}

วัตถุใน Kotlin

ในขณะที่กำหนดคลาส เราจะกำหนดเฉพาะข้อกำหนดสำหรับอ็อบเจ็กต์เท่านั้น โดยไม่มีการจัดสรรพารามิเตอร์อื่น เช่น หน่วยความจำหรือที่เก็บข้อมูล

ไวยากรณ์:

var obj1 = ClassName()

ช่างก่อสร้างใน Kotlin

Constructor เป็นวิธีการเริ่มต้นคุณสมบัติคลาส มันเป็นฟังก์ชันสมาชิกที่เรียกว่าเมื่อมีการสร้างอินสแตนซ์ของวัตถุ แต่ใน Kotlin มันทำงานแตกต่างออกไป

Kotlin มี Constructor อยู่ 2 ประเภท:

ตัวสร้างหลัก: วิธีที่ปรับให้เหมาะสมในการเริ่มต้นคลาส

ไวยากรณ์:

class myClass(valname: String,varid: Int) {  
    // class body  
}  

ตัวสร้างรอง: ช่วยเพิ่มตรรกะการเริ่มต้น

มรดก Kotlin

การสืบทอดเกิดขึ้นเมื่อคุณสมบัติบางอย่างของคลาสพาเรนต์ได้มาโดยคลาสลูก อนุญาตให้สืบทอดได้เมื่อคลาสตั้งแต่สองคลาสขึ้นไปมีคุณสมบัติเหมือนกัน

ไวยากรณ์:

open class ParentClass(primary_construct){
    // common code
  }class ChildClass(primary_construct): ParentClass(primary_construct_initializ){
    // ChildClass specific behaviours
  }

abstracคลาส t ใน Kotlin

กล้ามท้องtracคลาส t คือคลาสที่ไม่สามารถสร้างอินสแตนซ์ได้ แต่เราสามารถสืบทอดคลาสย่อยจากคลาสนี้ได้ 'abstracคำหลัก 't' ใช้สำหรับประกาศค่าสัมบูรณ์tracคลาส t

ตัวอย่างที่ 6:

  open class humanbeings { 
    open fun Eat() { 
        println("All Human being Eat") 
    } 
} 
abstract class Animal : humanbeings() { 
    override abstract fun Eat() 
} 
class Cat: Animal(){ 
    override fun Eat() { 
        println("Cats also loves eating") 
    } 
} 
fun main(args: Array<String>){ 
    val lt = humanbeings() 
    lt.Eat() 
    val d = Cat() 
    d.Eat() 
} 

Output:

ปัจจุบันและอนาคตของ Kotlin

ปัจจุบัน:

• หลายๆบริษัทชอบ Netflix, Pinterest และ Corda ใช้ Kotlin เพื่อสร้างสิ่งที่ทรงพลัง Android ปพลิเคชัน
• ในช่วงเวลาสั้นๆ หนึ่งปีระหว่างปี 2016 ถึง 2017 Kotlin ได้รับความนิยมอย่างสูงด้วยฟีเจอร์การเขียนโปรแกรมที่น่าทึ่ง
• ใน 2017, Google ประกาศให้ Kotlin เป็นภาษาโปรแกรมอย่างเป็นทางการสำหรับการพัฒนาแอปพลิเคชันแอนดรอยด์
• คุณสามารถเปลี่ยนได้อย่างรวดเร็ว Java โค้ดที่ใช้ Kotlin สามารถทำงานร่วมกันได้ 100% Java และ Android.

อนาคต:

• การพัฒนาเกมข้ามแพลตฟอร์ม
• การพัฒนาแอพมือถือข้ามแพลตฟอร์ม
• การเขียนสคริปต์ฝั่งบริการและไมโครเซอร์วิส
• การเรียนรู้เครื่อง & การวิเคราะห์ข้อมูล

คำถามที่พบบ่อย