Perbedaan antara C # dan operator terner Java (? :)

Saya seorang pemula C # dan saya baru saja mengalami masalah. Ada perbedaan antara C # dan Java saat berhadapan dengan operator terner ( ? :).

Di segmen kode berikut, mengapa baris ke-4 tidak berfungsi? Kompilator menampilkan pesan kesalahan there is no implicit conversion between 'int' and 'string'. Baris ke-5 juga tidak berfungsi. Keduanya Listadalah objek, bukan?

int two = 2;
double six = 6.0;
Write(two > six ? two : six); //param: double
Write(two > six ? two : "6"); //param: not object
Write(two > six ? new List<int>() : new List<string>()); //param: not object

Namun, kode yang sama berfungsi di Java:

int two = 2;
double six = 6.0;
System.out.println(two > six ? two : six); //param: double
System.out.println(two > six ? two : "6"); //param: Object
System.out.println(two > six ? new ArrayList<Integer>()
                   : new ArrayList<String>()); //param: Object

Fitur bahasa apa di C # yang hilang? Jika ada, mengapa tidak ditambahkan?

Melihat melalui C # 5 Spesifikasi Bahasa bagian 7.14: Operator Bersyarat kita dapat melihat yang berikut:

• Jika x memiliki tipe X dan y memiliki tipe Y maka

  • Jika konversi implisit (§6.1) ada dari X ke Y, tetapi tidak dari Y ke X, maka Y adalah jenis ekspresi kondisional.

  • Jika konversi implisit (§6.1) ada dari Y ke X, tetapi tidak dari X ke Y, maka X adalah jenis ekspresi kondisional.

  • Jika tidak, tidak ada tipe ekspresi yang dapat ditentukan, dan kesalahan waktu kompilasi terjadi

Dengan kata lain: ia mencoba untuk menemukan apakah x dan y dapat dikonversi ke eachother dan jika tidak, kesalahan kompilasi terjadi. Dalam kasus kami intdan stringtidak memiliki konversi eksplisit atau implisit sehingga tidak dapat dikompilasi.

Bandingkan ini dengan Spesifikasi Bahasa Java 7 bagian 15.25: Operator Bersyarat :

• Jika operan kedua dan ketiga memiliki tipe yang sama (yang mungkin merupakan tipe null), maka itu adalah tipe ekspresi kondisional. ( TIDAK )
• Jika salah satu dari operan kedua dan ketiga adalah tipe primitif T, dan tipe yang lain adalah hasil dari penerapan konversi tinju (§5.1.7) ke T, maka tipe ekspresi kondisionalnya adalah T. ( NO )
• Jika salah satu dari operan kedua dan ketiga berjenis null dan jenis yang lain adalah jenis referensi, maka jenis ekspresi kondisional adalah jenis referensi tersebut. ( TIDAK )
• Sebaliknya, jika operan kedua dan ketiga memiliki tipe yang dapat diubah (§5.1.8) menjadi tipe numerik, maka terdapat beberapa kasus: ( NO )
• Jika tidak, operan kedua dan ketiga masing-masing memiliki tipe S1 dan S2. Misalkan T1 adalah tipe yang dihasilkan dari penerapan konversi tinju ke S1, dan biarkan T2 menjadi tipe yang dihasilkan dari penerapan konversi tinju ke S2.
  Jenis ekspresi kondisional adalah hasil dari penerapan konversi tangkapan (§5.1.10) ke lub (T1, T2) (§15.12.2.7). ( YA )

Dan, lihat bagian 15.12.2.7. Argumen Tipe Inferensi Berdasarkan Argumen Aktual, kita dapat melihat mencoba untuk menemukan nenek moyang yang sama yang akan berfungsi sebagai tipe yang digunakan untuk panggilan yang mendarat dengannya Object. Object adalah argumen yang dapat diterima sehingga panggilan tersebut akan berhasil.

Jawaban yang diberikan bagus; Saya akan menambahkan kepada mereka bahwa aturan C # ini adalah konsekuensi dari pedoman desain yang lebih umum. Ketika diminta untuk menyimpulkan jenis ekspresi dari salah satu dari beberapa pilihan, C # memilih yang terbaik dan unik dari mereka . Artinya, jika Anda memberi C # beberapa pilihan seperti "Jerapah, Mamalia, Hewan", maka C # dapat memilih yang paling umum - Hewan - atau mungkin memilih yang paling spesifik - Jerapah - bergantung pada situasinya. Tapi itu harus memilih salah satu pilihan yang diberikan . C # tidak pernah mengatakan "pilihan saya adalah antara Kucing dan Anjing, oleh karena itu saya akan menyimpulkan bahwa Hewan adalah pilihan terbaik". Itu bukan pilihan yang diberikan, jadi C # tidak bisa memilihnya.

Dalam kasus operator terner C # mencoba untuk memilih tipe yang lebih umum dari int dan string, tetapi tidak ada tipe yang lebih umum. Daripada memilih tipe yang bukan merupakan pilihan di tempat pertama, seperti objek, C # memutuskan bahwa tidak ada tipe yang dapat disimpulkan.

Saya perhatikan juga bahwa ini sesuai dengan prinsip desain C # lainnya: jika ada yang salah, beri tahu pengembang. Bahasa tidak mengatakan "Saya akan menebak apa yang Anda maksud dan mengacaukannya jika saya bisa". Bahasa mengatakan "Saya pikir Anda telah menulis sesuatu yang membingungkan di sini, dan saya akan memberitahu Anda tentang itu."

Juga, saya perhatikan bahwa C # tidak beralasan dari variabel ke nilai yang diberikan , melainkan ke arah lain. C # tidak mengatakan "Anda menugaskan ke variabel objek oleh karena itu ekspresi harus dapat diubah menjadi objek, oleh karena itu saya akan memastikan bahwa itu". Sebaliknya, C # mengatakan "ekspresi ini harus memiliki tipe, dan saya harus dapat menyimpulkan bahwa tipe tersebut kompatibel dengan objek". Karena ekspresi tidak memiliki tipe, kesalahan dihasilkan.

Mengenai bagian generik:

two > six ? new List<int>() : new List<string>()

Dalam C #, kompilator mencoba untuk mengubah bagian ekspresi kanan menjadi beberapa tipe umum; karena List<int>dan List<string>merupakan dua tipe konstruksi yang berbeda, yang satu tidak dapat dikonversi ke yang lain.

Di Java, kompilator mencoba menemukan supertipe umum daripada mengonversinya, jadi kompilasi kode melibatkan penggunaan implisit wildcard dan penghapusan tipe ;

two > six ? new ArrayList<Integer>() : new ArrayList<String>()

memiliki tipe kompilasi ArrayList<?>(sebenarnya, bisa juga ArrayList<? extends Serializable>atau ArrayList<? extends Comparable<?>>, bergantung pada konteks penggunaan, karena keduanya adalah supertipe generik umum) dan tipe waktu proses mentah ArrayList(karena ini adalah supertipe raw umum).

Misalnya (uji sendiri) ,

void test( List<?> list ) {
    System.out.println("foo");
}

void test( ArrayList<Integer> list ) { // note: can't use List<Integer> here
                                 // since both test() methods would clash after the erasure
    System.out.println("bar");
}

void test() {
    test( true ? new ArrayList<Object>() : new ArrayList<Object>() ); // foo
    test( true ? new ArrayList<Integer>() : new ArrayList<Object>() ); // foo 
    test( true ? new ArrayList<Integer>() : new ArrayList<Integer>() ); // bar
} // compiler automagically binds the correct generic QED

Baik di Java dan C # (dan sebagian besar bahasa lainnya), hasil ekspresi memiliki tipe. Dalam kasus operator terner, ada dua kemungkinan subekspresi yang dievaluasi untuk hasil dan keduanya harus memiliki jenis yang sama. Dalam kasus Java, intvariabel dapat diubah menjadi Integerdengan autoboxing. Sekarang karena keduanya Integerdan Stringmewarisi dari Object, keduanya dapat dikonversi ke jenis yang sama dengan konversi penyempitan sederhana.

Di sisi lain, di C #, an intadalah primitif dan tidak ada konversi implisit ke stringatau yang lainnya object.

Ini sangat mudah. Tidak ada konversi implisit antara string dan int. operator terner membutuhkan dua operan terakhir untuk memiliki tipe yang sama.

Mencoba:

Write(two > six ? two.ToString() : "6");