Adakah ini pepijat di Jawa?

Baru-baru ini, saya ingin mencipta semula fleksibiliti console.log dalam Java, jadi saya memutuskan untuk menulis fungsi cetakan generik yang boleh menerima berbilang argumen dan mencetaknya dipisahkan koma, sama seperti console.log masuk JavaScript atau TypeScript. Hasilnya? Saya ditinggalkan dengan lebih banyak soalan daripada jawapan. Biar saya membimbing anda melaluinya.

Kod Java

Saya bermula dengan menulis fungsi generik ringkas dalam Java yang mengambil vararg jenis T dan mencetaknya, memisahkan nilai dengan koma:

public class Main {
    public static void main(String[] args) {
        Main.print(1, "4", new ArrayList<>());
        // Expected type issues, but it ran without any problem!
    }

    private static <T> void print(T... args) {
        System.out.println(Arrays.toString(args));
    }
}

Saya menjangkakan penaipan Java yang ketat akan memberi amaran kepada saya atau menimbulkan ralat apabila saya melepasi jenis campuran—Integer, String dan ArrayList—tetapi tidak. Kod disusun dan berjalan dengan baik, mencetak [1, 4, []] tanpa sebarang aduan.

Ini membuatkan saya terperanjat kerana, sebagai seseorang yang juga bekerja dengan TypeScript, ini terasa tidak menyenangkan. Bukankah Java sepatutnya menangkap jenis ketidakkonsistenan ini?

Mencubanya dalam TypeScript

Sememangnya, saya beralih kepada TypeScript untuk melihat cara ia mengendalikan perkara ini. Saya menulis fungsi yang sama dalam TypeScript:

function print<T>(...args: T[]) {
  console.log(args.join(","));
}

print(1, "4", []);
// TS warns (which makes sense):
// Argument of type 'string' is not assignable to parameter of type 'number'.

Seperti yang dijangkakan, TypeScript memberikan amaran! Memandangkan TypeScript menyimpulkan jenis T sebagai nombor daripada argumen pertama (1), ia menandakan argumen kedua dan ketiga ("4" dan []) sebagai tidak sah. Tingkah laku ini masuk akal kerana TypeScript menguatkuasakan jenis yang konsisten untuk fungsi generik.

Jadi, Adakah Ini Bug di Jawa?

Tidak semestinya. Apa yang berlaku di sini ialah sistem jenis Java berkelakuan berbeza disebabkan oleh pemadaman jenis. Di Java, maklumat jenis generik dipadamkan semasa runtime, bermakna apabila anda menghantar jenis yang berbeza kepada T... args, Java tidak akan menguatkuasakan bahawa semua argumen adalah daripada jenis yang sama. Ia hanya menganggap input sebagai objek.

TypeScript, sebaliknya, mengekalkan pemeriksaan ketat pada kedua-dua penyusunan dan masa jalan, memastikan semua argumen sepadan dengan jenis yang disimpulkan atau diisytiharkan.

Kesimpulan

Pengalaman ini membuatkan saya terfikir: patutkah Java menguatkuasakan semakan jenis yang lebih ketat seperti TypeScript lakukan? Atau adakah fleksibiliti ini merupakan bahagian yang disengajakan dalam reka bentuk Java?

Apa pendapat anda? Pernahkah anda menemui kebiasaan yang sama semasa bertukar antara Java dan TypeScript? Saya ingin mendengar pendapat anda dalam ulasan!

Atas ialah kandungan terperinci Adakah ini pepijat di Jawa?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!