สวัสดีนักเรียน JavaRush ก่อนที่คุณจะซึมซับ Java โดยสมบูรณ์ ฉันอยากจะขยายขอบเขตของคุณและดึงความสนใจไปที่ ภาษา Kotlin ที่ได้รับความนิยมมากขึ้นเรื่อย ๆ !
Kotlin เป็นภาษาที่ค่อนข้างใหม่ซึ่งพัฒนาโดยJetBrains ใช่ ใช่ บริษัทเดียวกับที่พัฒนา IDE ที่เราชื่นชอบ: IntelliJ IDEA Kotlin เป็นภาษา JVM และเข้ากันได้กับ Java อย่างสมบูรณ์นั่นคือจากโค้ด Kotlin คุณสามารถเข้าถึงไลบรารี Java ที่คุ้นเคยได้อย่างง่ายดาย แล้วไลบรารีล่ะ: คลาส Kotlin และ Java สามารถอยู่ร่วมกันในแพ็คเกจเดียวได้! Kotlin ได้รับความนิยมอย่างมากในชุมชนการเขียนโปรแกรมจน Google ยอมรับว่าเป็นภาษาสำหรับการพัฒนาอย่างเป็นทางการสำหรับ Android และเมื่อเร็ว ๆ นี้ Kotlin ก็เริ่มได้รับความนิยมในโครงการระดับองค์กร ในบทความนี้ ฉันอยากจะยกตัวอย่างเปรียบเทียบของโค้ดที่เขียนด้วย Kotlin และ Java และสรุปบางส่วน ไป! มาเริ่มกันตามปกติด้วย "Hello World"
// Java
public class Application {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
// Kotlin
class Application
fun main(vararg args: String) {
println("Hello World!")
}
เมื่อดูตัวอย่าง Kotlin เราจะสังเกตสิ่งต่อไปนี้ได้ทันที:
- ไม่จำเป็นต้องเขียนอัฒภาคที่ท้ายบรรทัด
- วิธีการทั้งหมดอธิบายด้วย คำสำคัญfun ;
- หากต้องการพิมพ์บรรทัด เพียงคำเดียวก็เพียงพอแล้ว - println() !
// Java (до 10)
final Application application = new Application();
// Kotlin
val application = Application()
ความแตกต่างของ Kotlin:
- ไม่จำเป็นต้องประกาศประเภทของตัวแปรหากชัดเจนจากอินสแตนซ์
- แทนที่จะเป็นประเภทตัวแปร - val (ไม่เปลี่ยนรูป) หรือvar (เปลี่ยนแปลงได้)
- คุณไม่จำเป็นต้องเขียนคีย์เวิร์ด ใหม่เพื่อสร้างอินสแตนซ์!
// Java
public int sum(int a, int b) {
return (a + b);
}
// Kotlin
fun sum(a: Int, b: Int): Int {
return (a + b)
}
ความแตกต่างของ Kotlin:
- หากจำเป็นต้องส่งคืนบางสิ่งจากวิธีการ “ : Int ” จะถูกเพิ่มในลายเซ็น โดยที่Intคือประเภทการส่งคืน
- คำอธิบายของพารามิเตอร์วิธีการ: อันดับแรกชื่อตัวแปรแล้วชนิด;
- เนื่องจากเนื้อหาของวิธีการมีเพียงบรรทัดเดียว คุณจึงสามารถละเว้นการ return :
fun sum(a: Int, b: Int): Int = (a+b)
// Java
public int sum(int a, int b) {
int result = (a + b);
System.out.printf("Сумма %d и %d равна %d\n", a, b, result);
return result;
}
// Kotlin
fun sum(a: Int, b: Int): Int {
val result = (a + b)
println("Сумма $a и $b равна $result")
return result
}
Kotlin รองรับการแก้ไขสตริง เพียงใช้สัญลักษณ์ "$" ที่จุดเริ่มต้นของตัวแปร สัญลักษณ์นี้ช่วยปรับปรุงความสะอาดและความสามารถในการอ่านโค้ดได้อย่างมาก การเปรียบเทียบอินสแตนซ์
// Java
object1.equals(object2)
// Kotlin
object1 == object2
ใน Kotlin การเปรียบเทียบ " ==
" สำหรับประเภทวัตถุจะถูกแปลเป็นequals
! และเพื่อเปรียบเทียบลิงก์ " ===
" จะถูกใช้ ข้อยกเว้น
// Java
public List<String> getFileContent(String file) throws IOException {
Path path = Paths.get(file);
return Files.readAllLines(path);
}
// Kotlin
fun getFileContent(file: String): List<String> {
val path = Paths.get(file)
return Files.readAllLines(path)
}
ไม่มี ข้อยกเว้นที่ตรวจสอบ ใน Kotlin ตอนนี้คุณไม่จำเป็นต้องส่งข้อยกเว้นอย่างไม่มีที่สิ้นสุดผ่านแอปพลิ try-catch
เค ชันทั้งหมดหรือสร้างข้อยกเว้นหลายระดับ ความปลอดภัยที่เป็นโมฆะ
// Java
public class Data {
String value;
String render() {
if (value == null) {
return "Value: undefined";
} else {
return "Value:" + value.toUpperCase();
}
}
}
// Kotlin
class Data {
var value: String? = null
fun render(): String =
"Value: ${value?.toUpperCase() ?: "undefined"}"
}
Kotlin ดูแลปัญหา NPE และแนะนำข้อกำหนดหลายประการ:
- ฟิลด์คลาสและตัวแปรทั้งหมดจะต้องเริ่มต้นได้
- คุณสามารถเขียน “null” ในช่องหรือตัวแปรได้ แต่คุณต้องระบุอย่างชัดเจนว่าตัวแปรของคุณเป็น Nullable (เขียนเครื่องหมาย “?”)
- ตัวดำเนินการ Elvis "?:" ทำงานดังนี้: หากมี Null ทางด้านซ้าย ให้เอาสิ่งที่อยู่ทางขวา ในกรณีตัวอย่างของเรา เมื่อ ไม่ได้เตรียมใช้งานตัวแปร ค่าระบบจะใช้ค่า " undefinition "
// Java
public class Data {
private String value;
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
}
class App {
void execute() {
Data data = new Data()
data.setValue("Foo")
}
}
// Kotlin
class Data {
var value: String = ""
}
class App {
fun execute() {
val data = Data()
data.value = "Foo" // Под капотом выполнится data.set("Foo")
}
}
ใน Kotlin แค่อธิบาย field ก็พอเพียงเท่านั้น มันมี getters และ setters โดยนัยอยู่แล้ว (hello lombok ) ซึ่งสามารถแทนที่ได้ตลอดเวลาหากต้องการ ในเวลาเดียวกัน เราอ่านและแก้ไขค่าของฟิลด์โดยการเข้าถึงโดยตรง และภายใต้ประทุนนั้นเรียกget()|set()
ว่า รอบ
// Java
void example() {
for(int i = 1; i <= 10; i++) {
System.out.println(i);
}
for(String line : "a,b,c".split(",")) {
System.out.println(line);
}
}
// Kotlin
fun example() {
for(i in 1..10) {
println(i)
}
for(line in "a,b,c".split(",")) {
println(line)
}
}
Kotlin ได้จัดเตรียมไวยากรณ์ที่สะดวกและสม่ำเสมอสำหรับลำดับการเคลื่อนที่: คุณเพียงใช้ตัวแปรทางด้านซ้าย ลำดับ ทางด้านขวาและคีย์เวิร์ด “ ใน ” ในระหว่างนั้น ประเภทจะถูกกำหนดโดยอัตโนมัติโดยเนื้อหา ซิงเกิลตัน
// Java
public class Singleton {
private static Singleton ourInstance = new Singleton();
public static Singleton getInstance() {
return ourInstance;
}
private Singleton() {
}
}
class App {
void execute() {
Singleton singleton = Singleton.getInstance()
}
}
// Kotlin
object Singleton {}
class App {
fun execute() {
val singleton = Singleton
}
}
รูปแบบ “ singler ” ที่คุ้นเคยนั้นถูกใช้ค่อนข้างบ่อยในทางปฏิบัติ ดังนั้น Kotlin จึงตัดสินใจสร้างคำหลักแยกต่างหาก “ object ” ซึ่งเขียนแทน “ class ” และหมายความว่าคลาสนั้นเป็น singleton เมื่อใช้แล้ว คุณจะไม่ได้ ต้องเรียก Constructor หรือวิธีอื่นใด! พารามิเตอร์วิธีการตั้งชื่อและค่าเริ่มต้น
// Java
void setStatus(String code) {
setStatus(code, "");
}
void setStatus(String code, String desc) {
this.code = code;
this.desc = desc;
}
// Kotlin
fun setStatus(code: String, desc: String = "") {
this.code = code;
this.desc = desc;
}
fun execute() {
setStatus("200")
setStatus(code = "200", desc = "Ok")
}
มันเกิดขึ้นที่ไม่จำเป็นต้องใช้พารามิเตอร์ทั้งหมดในเมธอดหรือคอนสตรัคเตอร์ และใน Java เราคุ้นเคยกับการสร้างชุดของเมธอดหรือคอนสตรัคเตอร์สำหรับการรวมกันของพารามิเตอร์ที่เป็นไปได้ทั้งหมด พารามิเตอร์เริ่มต้นได้รับการแนะนำใน Kotlin ซึ่งช่วยให้คุณสามารถประกาศ 1 วิธีและส่งชุดพารามิเตอร์ที่ต้องการไปให้ขึ้นอยู่กับสถานการณ์ สตรีม
// Java
String getFirst(List<String> strings, String alpha) {
return strings.stream()
.filter(x -> x.startsWith(alpha))
.findFirst()
.orElse("");
}
// Kotlin
fun getFirst(strings: List<String>, alpha: String): String {
return strings.first { it.startsWith(alpha) }
}
การเปิดตัวสตรีมใน Java 8 ได้กลายเป็นฟังก์ชันการทำงานที่สำคัญเมื่อทำงานกับคอลเลกชัน ใน Kotlin สตรีมได้รับความสะดวกและใช้งานได้มากขึ้น: แต่ละคอลเลกชันมีชุดวิธีที่สะดวกและใช้บ่อยในการทำงานกับข้อมูลอยู่แล้ว นอกจากนี้ ให้สังเกตนิพจน์แลมบ์ดาภายในเมธอดแรก: หากลิเทอรัลของฟังก์ชันมีพารามิเตอร์เพียงตัวเดียว การประกาศก็สามารถลบออกได้ (พร้อมกับ ->) และเรียก มันว่า ถึงเวลาสรุปแล้ว... ฉันสาธิตฟังก์ชันพื้นฐานเพียงเล็กน้อยเท่านั้น แต่ฉันแน่ใจว่าคุณอยากลองใช้ Kotlin อยู่แล้ว! จากประสบการณ์ของฉัน ฉันสามารถสรุปได้ดังต่อไปนี้:
- เป็นเรื่องง่ายมากสำหรับนักพัฒนา Java ที่จะเชี่ยวชาญไวยากรณ์ Kotlin และเริ่มเขียนโค้ด
- Kotlin เข้ากันได้กับ Java อย่างสมบูรณ์ และคุณสามารถลองใช้กับโปรเจ็กต์ที่มีอยู่แล้วได้ เช่น ในการทดสอบ
- โค้ด Kotlin นั้นสะอาดกว่าและอ่านง่ายกว่า คุณ ไม่ จำเป็นต้องเขียน Boilerplateมากมาย
- IDEA มีตัวแปลง Java เป็น Kotlin อัตโนมัติ คุณสามารถใช้โค้ด Java สำเร็จรูปและแปลงเป็น Kotlin โดยอัตโนมัติ
- จำเป็นต้องเขียนโปรเจ็กต์ใหม่ด้วย Kotlin เพราะจากมุมมองของโครงสร้างพื้นฐานมันเป็น Java เดียวกัน แต่ในแง่ของการใช้งานมันดีกว่าและสะดวกกว่า!
GO TO FULL VERSION