Bài báo
Bắt đầu
Bắt đầu học
JavaRush /Blog Java /Random-VI /KotlinRush: tiếp tục viết bằng Java có hợp lý không?
NikEy
Mức độ
Новосибирск

KotlinRush: tiếp tục viết bằng Java có hợp lý không?

Xuất bản trong nhóm
Xin chào, sinh viên JavaRush, trước khi bạn hoàn toàn say mê Java, tôi muốn mở rộng tầm nhìn của bạn và thu hút sự chú ý đến ngôn ngữ Kotlin ngày càng phổ biến !
KotlinRush: tiếp tục viết bằng Java có hợp lý không? - 1
Kotlin là một ngôn ngữ khá trẻ được phát triển bởi JetBrains . Vâng, vâng, chính công ty đã phát triển IDE yêu thích của chúng tôi: IntelliJ IDEA. Kotlin là một ngôn ngữ JVM và hoàn toàn tương thích với Java , tức là từ mã Kotlin bạn có thể dễ dàng truy cập vào các thư viện Java quen thuộc.Còn các thư viện: Các lớp Kotlin và Java có thể cùng tồn tại trong một gói! Kotlin nổi tiếng với cộng đồng lập trình đến mức Google công nhận nó là ngôn ngữ phát triển chính thức cho Android và gần đây Kotlin đã bắt đầu trở nên phổ biến trong các dự án doanh nghiệp. Trong bài viết này, tôi muốn đưa ra một số ví dụ so sánh về mã viết bằng Kotlin và Java và rút ra một số kết luận. Đi! Hãy bắt đầu như thường lệ với "Xin chào thế giới" 
// 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!")
}
Nhìn vào ví dụ về Kotlin, chúng ta có thể nhận thấy ngay những điều sau:
  • không cần viết dấu chấm phẩy ở cuối dòng;
  • tất cả các phương pháp được mô tả bằng từ khóa fun ;
  • Để in một dòng, chỉ cần một từ là đủ - println() !
Tạo một phiên bản 
// Java (до 10)
final Application application = new Application();
// Kotlin
val application = Application()
Sự khác biệt của Kotlin:
  • không cần phải khai báo loại biến nếu nó rõ ràng trong thể hiện;
  • thay vì loại biến - val (không thay đổi) hoặc var (có thể thay đổi);
  • Bạn không cần phải viết từ khóa mới để tạo một phiên bản !
Mô tả các phương pháp 
// Java
public int sum(int a, int b) {
    return (a + b);
}
// Kotlin
fun sum(a: Int, b: Int): Int {
return (a + b)
}
Java-университет
Sự khác biệt của Kotlin:
  • nếu một cái gì đó cần được trả về từ một phương thức, “ : Int ” sẽ được thêm vào chữ ký, trong đó Int là kiểu trả về;
  • mô tả các tham số của phương thức: đầu tiên là tên biến, sau đó là loại;
  • vì phần thân phương thức chỉ bao gồm một dòng nên bạn có thể bỏ qua return :
    fun sum(a: Int, b: Int): Int = (a+b)
Đầu ra chuỗi được định dạng 
// 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 hỗ trợ nội suy chuỗi, chỉ cần sử dụng ký hiệu "$" ở đầu biến. Ký hiệu này cải thiện đáng kể độ rõ ràng và khả năng đọc của mã. So sánh các trường hợp 
// Java
object1.equals(object2)
// Kotlin
object1 == object2
Trong Kotlin, sự so sánh " ==" của các loại đối tượng được dịch sang equals! Và để so sánh các liên kết, " ===" được sử dụng. Ngoại lệ 
// 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)
}
Không có ngoại lệ nào được kiểm tra trong Kotlin ; giờ đây bạn không cần phải liên tục đưa ra ngoại lệ trong toàn bộ ứng dụng hoặc tạo ngoại lệ nhiều cấp độ try-catch. Không an toàn 
// 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 đã giải quyết vấn đề NPE và đưa ra một số yêu cầu:
  • tất cả các trường và biến của lớp phải được khởi tạo;
  • Bạn có thể viết “null” trong một trường hoặc biến, nhưng sau đó bạn phải nói rõ ràng rằng biến của bạn là Nullable (viết dấu “?”);
  • Toán tử Elvis "?:" hoạt động như thế này: nếu có Null ở bên trái, hãy lấy những gì ở bên phải. Trong trường hợp ví dụ của chúng tôi, khi biến giá trị không được khởi tạo, giá trị “ không xác định ” sẽ được lấy.
Các trường lớp và quyền truy cập vào chúng 
// 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")
     }
}
Trong Kotlin, chỉ cần mô tả một trường là đủ: nó đã có các getters và setters ngầm định (xin chào lombok ), có thể được ghi đè bất cứ lúc nào nếu muốn. Đồng thời, chúng tôi đọc và sửa đổi giá trị của trường chỉ bằng cách truy cập trực tiếp vào nó và dưới mui xe, nó được gọi là get()|set(). Chu kỳ 
// 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 đã cung cấp một cú pháp thuận tiện và thống nhất để duyệt trình tự: bạn chỉ cần sử dụng một biến ở bên trái , một biến ở bên phải và từ khóa “ in ” ở giữa, loại được xác định tự động bởi nội dung. Singleton 
// 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
    }
}
Mẫu “ singler ” quen thuộc được sử dụng khá thường xuyên trong thực tế, nên Kotlin quyết định tạo một từ khóa riêng “ object ”, viết thay cho “ class ” và có nghĩa là lớp đó là một singleton; khi sử dụng, bạn thậm chí không cần gọi hàm tạo hoặc bất kỳ phương thức nào khác! Các tham số phương thức được đặt tên và giá trị mặc định 
// 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")
}
Điều xảy ra là không phải tất cả các tham số trong một phương thức hoặc hàm tạo đều phải được yêu cầu và trong Java, chúng ta đã quen với việc tạo một tập hợp các phương thức hoặc hàm tạo cho mọi tổ hợp tham số có thể có. Các tham số mặc định đã được đưa vào Kotlin, cho phép bạn khai báo 1 phương thức và truyền bộ tham số bắt buộc cho phương thức đó tùy theo tình huống. Dòng 
// 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) }
}
Việc giới thiệu luồng trong Java 8 đã trở thành một chức năng không thể thiếu khi làm việc với các bộ sưu tập. Trong Kotlin, các luồng thậm chí còn trở nên thuận tiện và hữu dụng hơn: mỗi bộ sưu tập đã có sẵn một tập hợp các phương thức thuận tiện và được sử dụng thường xuyên để làm việc với dữ liệu. Ngoài ra, hãy chú ý biểu thức lambda bên trong phương thức đầu tiên: nếu một hằng hàm có chính xác một tham số thì phần khai báo của nó có thể bị loại bỏ (cùng với dấu ->) và được gọi là  it . Đã đến lúc kết thúc... Tôi chỉ trình bày một phần nhỏ, cơ bản của chức năng, nhưng tôi chắc chắn rằng bạn đã muốn dùng thử Kotlin! Từ kinh nghiệm của mình, tôi có thể rút ra kết luận sau:
  • Nhà phát triển Java rất dễ dàng nắm vững cú pháp Kotlin và bắt đầu viết mã;
  • Kotlin hoàn toàn tương thích với Java và bạn đã có thể dùng thử nó trong các dự án hiện có của mình, chẳng hạn như trong các thử nghiệm;
  • Mã Kotlin sạch hơn và dễ đọc hơn, bạn không cần phải viết nhiều bản mẫu ;
  • IDEA có trình chuyển đổi Java sang Kotlin tự động, bạn có thể lấy mã Java làm sẵn và tự động chuyển đổi nó thành Kotlin;
  • một dự án mới cần phải được viết bằng Kotlin, vì từ quan điểm cơ sở hạ tầng, nó giống với Java, nhưng về mặt sử dụng thì nó tốt hơn và thuận tiện hơn!
Nếu bạn thích bài viết này và nhìn chung có liên quan đến một tài nguyên về Java, tôi có thể tiếp tục viết về trải nghiệm sử dụng Kotlin trong một dự án doanh nghiệp thực sự. Liên kết hữu ích:
Bình luận
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION