C Sharp ve Java'nın Karşılaştırılması - Comparison of C Sharp and Java

Bu makalenin birden çok sorunu var. Lütfen yardım et onu geliştir veya bu konuları konuşma sayfası. (Bu şablon mesajların nasıl ve ne zaman kaldırılacağını öğrenin) Bu makale gibi yazılır bir kılavuz veya rehber kitap. Lütfen yardım et bu makaleyi yeniden yaz bir tanımlayıcıdan tarafsız bakış açısıve tavsiye veya talimatı kaldırın. (Ocak 2016) (Bu şablon mesajını nasıl ve ne zaman kaldıracağınızı öğrenin) Bu makale çoğu okuyucunun anlayamayacağı kadar teknik olabilir. Lütfen geliştirmeye yardım et -e uzman olmayanlar için anlaşılır hale getirinteknik detayları kaldırmadan. (Ocak 2016) (Bu şablon mesajını nasıl ve ne zaman kaldıracağınızı öğrenin) Bu makale muhtemelen içerir orjinal araştırma. Lütfen onu geliştir tarafından doğrulanıyor iddia edilen ve eklenen satır içi alıntılar. Yalnızca orijinal araştırmadan oluşan ifadeler kaldırılmalıdır. (Aralık 2015) (Bu şablon mesajını nasıl ve ne zaman kaldıracağınızı öğrenin) Bu makale içerir Gelincik kelimeler: genellikle eşlik eden belirsiz ifadeler önyargılı veya doğrulanamaz bilgi. Bu tür ifadeler olmalıdır açıklığa kavuşturuldu veya kaldırıldı. (Mart 2011) (Bu şablon mesajını nasıl ve ne zaman kaldıracağınızı öğrenin)

Bu makale iki Programlama dilleri: C # ile Java. Bu makalenin odak noktası esas olarak diller ve özellikleri olsa da, böyle bir karşılaştırma zorunlu olarak dillerin bazı özelliklerini de dikkate alacaktır. platformlar ve kütüphaneler. Platformların daha ayrıntılı bir karşılaştırması için lütfen bkz. Java ve .NET platformlarının karşılaştırılması.

C # ve Java benzer dillerdir yazılan statik olarak şiddetle, ve açıkça. Her ikiside nesne odaklı ve yarıyorumlama veya çalışma zamanı tam zamanında derleme ve ikisi de küme ayracı dilleri, sevmek C ve C ++.

Türler

Bu bölüm olabilir çok uzun rahatça okumak ve gezinmek. Düşünün lütfen bölme alt makalelere içerik, yoğunlaştırma veya ekleyerek alt başlıklar. (Ekim 2014)

Birleşik tip sistemi

Her iki dil de statik olarak sınıf tabanlı nesne yönelimiyle yazılmıştır. Java'da ilkel tipler özel olmadıkları için nesne odaklı ve dilin kendisi kullanılarak tanımlanamazlar. Ayrıca referans türleriyle ortak bir atayı paylaşmazlar. Java referans türleri tümü ortak bir kök türünden türemiştir. C # birleşik tip sistemi her tür (güvenli olmayan işaretçilerin yanı sıra)^[16]) nihayetinde ortak bir kök türünden türemiştir. Sonuç olarak, tüm türler bu kök türünün yöntemlerini ve nesne tür, ilkel bile olsa tüm türler için geçerlidir int değişmezler ve delegeler. Bu, Java'nın tersine, C # 'nin referans türü olmayan kapsülleme ile nesneleri desteklemesini sağlar.

Java'da, bileşik türler referans türleriyle eş anlamlıdır; yöntemler bir tür için tanımlanamaz, aynı zamanda bir sınıf başvuru türü. C # 'da kapsülleme kavramları ve yöntemler, referans gereksiniminden ayrıştırılmıştır, böylece bir tür, bir referans türü olmadan yöntemleri ve kapsüllemeyi destekleyebilir. Yalnızca referans türleri destekler sanal yöntemler ve uzmanlaşma, ancak.

Her iki dil de birçoğunu destekler yerleşik türler referans yerine değere göre kopyalanır ve aktarılır. Java bu türleri çağırır ilkel tipler onlar çağrılırken basit tipler C # dilinde. İlkel / basit türler tipik olarak temel işlemci mimarisinden yerel desteğe sahiptir.

C # basit türleri birkaç arayüzler ve sonuç olarak birçok yöntemi doğrudan türlerin örnekleri üzerinde, değişmez değerlerde bile sunar. C # tipi isimler de yalnızca takma adlar için Ortak dil çalışması (CLR) türleri. C # System.Int64 tür, tam olarak aynı türdür uzun tip; tek fark, birincisinin kanonik .NET adı, ikincisinin ise bunun için bir C # takma adı olmasıdır.

Java, doğrudan ilkel türler üzerinde yöntemler sunmaz. Bunun yerine, ilkel değerler üzerinde çalışan yöntemler tamamlayıcı aracılığıyla sunulur ilkel sarmalayıcı sınıfları. Her biri sabit ilkel türlerden birini saran sabit bir sarmalayıcı sınıf kümesi mevcuttur. Örnek olarak, Java Uzun tip bir başvuru türü ilkel olanı saran uzun yazın. Onlar değil ancak aynı tip.

Veri tipleri

Sayısal türler

İmzalı tam sayılar

Hem Java hem de C # desteği imzalı 8, 16, 32 ve 64 bit bit genişliğine sahip tamsayılar. A olarak adlandırılan 8 bitlik tam sayı dışında, türler için aynı adı / diğer adları kullanırlar. bayt Java'da ve bir sbyte (imzalı bayt) C #.

İşaretsiz tamsayılar

C # destekler imzasız buna ek olarak imzalı tam sayı türleri. İmzasız türler bayt, ushort, uint ve ulong sırasıyla 8, 16, 32 ve 64 bit genişlikleri için. Türler üzerinde işaretsiz aritmetik işlemler de desteklenmektedir. Örneğin, iki işaretsiz tamsayı eklemek (uints) hala bir uint sonuç olarak; uzun veya işaretli bir tam sayı değil.

Java, işaretsiz tam sayı türlerine sahip değildir. Özellikle, Java'nın imzalanmamış için ilkel bir türü yoktur. bayt. Bunun yerine, Java'nın bayt tip genişletilmiş işaret Bu, ortak bir hata ve kafa karışıklığı kaynağıdır.^[17]

İmzasız tamsayılar kasıtlı olarak Java'nın dışında bırakıldı çünkü James Gosling programcıların işaretsiz aritmetiğin nasıl çalıştığını anlamayacağına inanıyordu.

Programlama dili tasarımında standart problemlerden biri, dilin o kadar karmaşık hale gelmesidir ki kimse anlayamaz. Denediğim küçük deneylerden biri insanlara C'deki işaretsiz aritmetiğin kurallarını sormaktı. C'deki işaretsiz aritmetiğin nasıl çalıştığını kimse anlamıyor. İnsanların anladığı birkaç bariz şey var ama çoğu insan bunu anlamıyor.^[9][18]

Yüksek hassasiyetli ondalık sayılar

C #, finansal ve parasal hesaplamalar için uygun olan yüksek hassasiyetli (28 ondalık basamak) ondalık aritmetik için bir türe ve değişmez gösterime sahiptir.^[19][20][21] Aksine yüzer ve çift veri türleri, 0.1 gibi ondalık kesirli sayılar tam olarak ondalık gösterimde gösterilebilir. Float ve double gösterimlerde, bu tür sayılar genellikle sonlandırmayan ikili genişletmelere sahiptir ve bu temsilleri yuvarlama hatalarına daha yatkın hale getirir.^[20]

Java böyle bir yerleşik türden yoksun olsa da, Java kitaplığı bir keyfi hassasiyet ondalık tür. Bu bir dil türü olarak kabul edilmez ve olağan aritmetik operatörleri desteklemez; daha ziyade tür yöntemleri kullanılarak manipüle edilmesi gereken bir başvuru türüdür. Rasgele boyutlu / hassas sayılar hakkında daha fazlasını görün altında.

Gelişmiş sayısal türler

Her iki dil de kitaplık tanımlı keyfi kesinlikte aritmetik rastgele boyutlu tamsayılar ve ondalık nokta hesaplamaları için türler.

Yalnızca Java, rasgele kesinlikte ondalık nokta hesaplamaları için bir veri türüne sahiptir. Yalnızca C # ile çalışmak için bir tür vardır Karışık sayılar.

Her iki dilde de, gelişmiş sayısal türlerde gerçekleştirilebilecek işlem sayısı, yerleşik olana kıyasla sınırlıdır. IEEE 754 kayan nokta türleri. Örneğin, rastgele boyut türlerinden hiçbiri kare kök veya logaritmalar.

C #, kitaplık tanımlı türlerin, özel örtük / açık dönüştürmeler ve operatör aşırı yüklemesi kullanarak mevcut türler ve işleçlerle entegre edilmesine olanak tanır. Bölümdeki örneğe bakın Kitaplık tanımlı türlerin entegrasyonu

Karakterler

Her iki dilde de yerel kömür (karakter) veri türü basit bir tür olarak. rağmen kömür tür, bit tabanlı işleçlerle kullanılabilir, bu, kömür işlemden önce bir tamsayı değerine değer. Bu nedenle, bitsel işlemin sonucu her iki dilde bir karakter değil sayısal bir türdür.

Yerleşik bileşik veri türleri

Her iki dil tedavi eder Teller gibi (değişmez ) referans türü nesneler. Her iki dilde de tür, dizeleri işlemek, ayrıştırmak, biçimlendirmek vb. İçin çeşitli yöntemler içerir. Her iki dilde de düzenli ifadeler harici bir özellik olarak kabul edilir ve ayrı sınıflarda uygulanır.

Her iki dilin kitaplıkları, farklı kültürlerdeki tarihler ve takvimlerle çalışmak için sınıflar tanımlar. Java java.util.Date değişken bir referans türüdür, oysa C # System.DateTime bir struct değer türüdür. C # ayrıca bir Zaman aralığı zaman dilimleriyle çalışmak için yazın. Her iki dil de farklı kültürlere göre tarih ve saat aritmetiğini destekler.

Kullanıcı tanımlı değer türü (yapı)

C #, programcının kullanıcı tanımlı oluşturmasına izin verir değer türleri, kullanmak yapı anahtar kelime. Sınıfların aksine ve standart ilkellerin aksine, bu tür değer türleri, referans yerine değere göre aktarılır ve atanır. Ayrıca bir nesnenin parçası olabilirler (alan olarak veya kutulu ) veya sınıf türleri için normalde var olan bellek indirmesi olmadan bir dizide saklanır.

Çünkü değer türlerinde a kavramı yoktur boş değer ve başlatma olmadan dizilerde kullanılabilir, bunlar her zaman örtük bir varsayılan kurucu yapı bellek alanını temelde sıfırlarla doldurur. Programcı yalnızca bir veya daha fazla argüman içeren ek kurucular tanımlayabilir. Değer türlerinde yok sanal yöntem tabloları ve bundan dolayı (ve sabit bellek ayak izi) dolaylı olarak mühürlenirler. Ancak, değer türleri Yapabilmek (ve sık sık uygulayın) arayüzler. Örneğin, yerleşik tamsayı türleri birkaç arayüzler.

Yerleşik ilkel türlerin yanı sıra, Java, değer türleri kavramını içermez.

Numaralandırmalar

Her iki dil de numaralandırmayı tanımlar, ancak bunlar temelde farklı şekillerde uygulanır. Bu nedenle, numaralandırmalar, kodu iki dil arasında otomatik olarak çevirmek için tasarlanmış araçların (Java'dan C # dönüştürücüler gibi) başarısız olduğu bir alandır.

C #, numaralandırmaları C'ye benzer bir şekilde, yani ilkel integral türlerinde (int, bayt, kısa, vb.) Uygulanan bit bayraklarının etrafına sarmalayıcılar olarak uygulamıştır. Bunun performans avantajları vardır ve C / C ++ derlenmiş kodla etkileşimi geliştirir, ancak daha az özellik sağlar ve C # dilinde izin verildiği gibi düşük düzeyli değer türleri doğrudan bir numaralandırma türüne dönüştürülürse hatalara yol açabilir. Bu nedenle, Sözdizimsel şeker.^[22] Buna karşılık Java, numaralandırmaları tam özellikli örnek koleksiyonu olarak uygular, daha fazla bellek gerektirir ve C / C ++ koduyla etkileşime yardımcı olmaz, ancak yansıtma ve iç davranışta ek özellikler sağlar. Her dildeki uygulama aşağıdaki tabloda açıklanmıştır.

Hem C # hem de Java'da, programcılar numaralandırmaları bir anahtar deyimi bir dizeye veya ilkel tam sayı türüne dönüştürme olmadan. Bununla birlikte, C #, case ifadesi herhangi bir kod içermediği sürece, bulunması zor hataların ortak bir nedeni olduğu için örtük düşüşe izin vermez.^[25] Fall-through, bir goto ifadesi kullanılarak açıkça bildirilmelidir.^[26]

Temsilciler, yöntem referansları

C #, nesne yönelimli yöntem işaretçileri şu şekilde uygular: delegeler. Temsilci, bir yönteme referans yakalayabilen özel bir türdür. Bu başvuru daha sonra bir temsilci türü değişkende saklanabilir veya daha sonraki çağırma için bir temsilci parametresi aracılığıyla bir yönteme aktarılabilir. C # delegates desteği kovaryans ve kontravans ve imza ile uyumlu herhangi bir statik yönteme, örnek yöntemine, anonim yönteme veya lambda ifadesi.

Delegeler, kapanışlar ve satır içi işlevlerle karıştırılmamalıdır. Kavramlar birbiriyle ilişkilidir, çünkü bir kapanış / satır içi işleve bir başvurunun yararlı olması için bir delege başvurusunda yakalanması gerekir. Ancak bir temsilci, her zaman bir satır içi işleve başvurmaz; mevcut statik veya örnek yöntemlerine de başvurabilir. Temsilciler C # temelini oluşturur Etkinlikler ama bunlarla da karıştırılmamalıdır.

Temsilciler kasıtlı olarak Java dışında bırakıldılar çünkü gereksiz ve dile zararlı oldukları düşünülüyordu ve potansiyel performans sorunları nedeniyle.^[27] Bunun yerine alternatif mekanizmalar kullanılır. sarıcı desen, istemcinin bilinen bir yöntem aracılığıyla bir veya daha fazla istemci tanımlı yönteme erişmesine izin vermesi açısından C # temsilcilerine benzeyen arayüz, böyle bir mekanizmadır.^{[kaynak belirtilmeli ]} Bir diğeri kullanımı adaptör Java tasarımcılarının savunduğu iç sınıfları kullanan nesneler, bağlı yöntem referanslarından daha iyi bir çözümdür.^[27]

Ayrıca örneğe bakın C # delegeleri ve eşdeğer Java yapıları.

Kaldırılan (null yapılabilir) türler

C #, değer / ilkel / basit türlerin özel boş türün yerel değerlerine ek olarak değer. Bir tür eklenerek kaldırılır ? tür adına son ek; bu, kullanmaya eşdeğerdir Null yapılabilir genel yazın, nerede T kaldırılacak tiptir. Dönüşümler, temel ve yükseltilmiş tür değerleri arasında dönüştürme yapmak için örtük olarak tanımlanır. Kaldırılan tip ile karşılaştırılabilir boş veya test edilebilir HasValue. Ayrıca, kaldırılmış işleçler örtük ve otomatik olarak kaldırılmamış tabanlarına göre tanımlanır; burada - bazı boolean işleçleri dışında - sonuca boş bir bağımsız değişken yayılır.

Java, bir kavram olarak tür kaldırmayı desteklemez, ancak tüm yerleşik ilkel türlerin karşılık gelen sarmalayıcı türleri vardır ve bunlar, boş referans türleri (sınıflar) olması nedeniyle değer.

Java spesifikasyonuna göre, herhangi bir girişimden vazgeçme girişimi boş başvuru, çalışma zamanında bir istisnanın, özellikle de bir NullPointerException. (Aksi takdirde referanstan vazgeçmenin bir anlamı olmaz çünkü tanımı gereği bellekte hiçbir nesneye işaret etmez.) Bu aynı zamanda kutuyu açmak bir sarmalayıcı türünde bir değişken, boş: program bir istisna atar, çünkü kutudan çıkarılacak nesne yoktur ve bu nedenle sonraki hesaplamada yer alacak kutulu bir değer yoktur.

Aşağıdaki örnek, farklı davranışı göstermektedir. C # 'de, kaldırılan * operatör, boş işlenenin değeri; Java'da, boş referansın kutusunun açılması bir istisna atar.

Yükseltilmiş C # operatörlerinin tümü yayılmak üzere tanımlanmamıştır boş koşulsuz olarak, işlenenlerden biri ise boş. Özellikle, boole operatörleri desteklemek için kaldırıldı üçlü mantık böylece empedansı korumak SQL.

Java mantıksal operatörleri üçlü mantığı desteklemez ve temel sınıf kitaplığında uygulanmaz.

Geç bağlanan (dinamik) tür

C # özellikleri a geç sınır Yansımasız dinamik çağrıyı, dinamik dillerle birlikte çalışabilirliği ve (örneğin) belge nesne modellerine geçici bağlamayı destekleyen dinamik tür. dinamik type, derleme zamanında statik / sanal yerine çalışma zamanında üye erişimini dinamik olarak çözümler. Üye arama mekanizması, bir geri dönüş mekanizması olarak geleneksel yansıma ile genişletilebilir.

İçin birkaç kullanım durumu vardır. dinamik C # yazın:

• Yansımanın daha az ayrıntılı kullanımı: dinamik tür, özellikler, yöntemler, olaylar vb. üyeler, yansıma API'sini doğrudan kullanmadan doğrudan örnek üzerinde çağrılabilir.
• Dinamik dillerle birlikte çalışabilirlik: Dinamik tür, bir hub-and-spoke Etkili üye araması için dinamik olarak türlenmiş nesneler ve ortak çalışma zamanı altyapısı uygulama desteği.
• Anında dinamik soyutlamalar oluşturma: Örneğin, dinamik bir nesne, aşağıdakiler gibi belge nesne modellerine daha basit erişim sağlayabilir. XML veya XHTML belgeler.

Java, geç bağlanan bir türü desteklemez. C # dinamik türünün kullanım durumları, Java'da farklı karşılık gelen yapılara sahiptir:

• Dinamik geç sınır için isimle önceden var olan türlerin çağrılması, yansıma kullanılmalıdır.
• Dinamik dillerle birlikte çalışabilirlik için, o dile özgü bir tür birlikte çalışabilirlik API'sinin kullanılması gerekir. Java sanal makinesi platformun üzerinde uygulanan birden fazla dinamik dil vardır, ancak nesnelerin diller arasında nasıl geçirileceğine dair ortak bir standart yoktur. Genellikle bu, bir tür yansıma veya yansıma benzeri API içerir. Java'dan JavaFX nesnelerinin nasıl kullanılacağına bir örnek olarak.^[28]
• Nesneleri tamamen çalışma zamanında oluşturmak ve onlarla etkileşim kurmak için, örneğin bir belge nesne modeli soyutlamasıyla etkileşim için, belirli bir soyutlama API'si kullanılmalıdır.

Ayrıca örneğe bakın # Dinamik dillerle birlikte çalışabilirlik.

İşaretçiler

Java, Java çalışma zamanı ortamında işaretçileri ve işaretçi aritmetiğini engeller. Java dili tasarımcıları, programcıların kodlarına hatalar koymalarını ve bunları desteklememeyi seçmelerini sağlayan ana özelliklerden birinin işaretçiler olduğunu düşündüler.^[9] Java, nesnelerin / yapıların temeldeki işletim sistemine / sistemden doğrudan aktarılmasına ve alınmasına izin vermez ve bu nedenle nesneleri / yapıları böyle belirli bir bellek düzenine, sık sık işaretçiler içeren düzenlere modellemeye ihtiyaç duymaz. Java'nın temeldeki işletim sistemiyle iletişimi, bunun yerine Java Yerel Arayüzü (JNI) temelde yatan bir işletim sistemi ile iletişim / adaptasyonun harici bir tutkal katman.

C # kullanımına izin verirken işaretçiler ve karşılık gelen işaretçi aritmetiği, C # dili tasarımcıları, nesne erişimi için katı kuralları atlamak için işaretçilerin potansiyel olarak kullanılabileceği konusunda aynı endişelere sahipti. Bu nedenle, C # varsayılan olarak işaretçileri de engeller.^[29] Ancak, birçok yerel işlevi çağırırken işaretçiler gerektiğinden, işaretçilerin açık bir güvensiz modu. İşaretçileri kullanan kod blokları veya yöntemler, güvensiz anahtar kelime işaretçileri kullanabilmek için ve derleyici, / güvensiz bu tür kodların derlenmesine izin vermek için geçiş yapın. Kullanılarak derlenen montajlar / güvensiz anahtar bu şekilde işaretlenmiştir ve yalnızca açıkça güveniliyorsa çalıştırılabilir. Bu, işaretçilerin ve işaretçi aritmetiğinin, bu nesneler için yerel bellek düzenini kullanarak işletim sisteminden veya diğer yerel API'lerden doğrudan geçmek ve almak için kullanılmasına izin verirken aynı zamanda bu tür potansiyel olarak güvenli olmayan kodu özellikle güvenilen derlemelerde izole eder.

Referans türleri

Her iki dilde Referanslar merkezi bir kavramdır. Tüm sınıf örnekleri referans olarak.

Dil sözdiziminde doğrudan belirgin olmasa da aslındaher iki dil de şu kavramını destekler: güçsüz Referanslar. Yalnızca zayıf referanslarla başvurulan bir örnek, sanki hiç başvuru yokmuş gibi çöp toplama için uygundur. Her iki dilde de bu özellik, gerçekten bir çekirdek çalışma zamanı özelliği olmasına rağmen, ilişkili kitaplıklar aracılığıyla ortaya çıkar.

Zayıf referansların yanı sıra, Java'nın yumuşak referanslar. Zayıf referanslara çok benzerler, ancak JVM, hafızaya ihtiyaç duyulana kadar yumuşak referanslı nesneleri serbest bırakmayacaktır.

Diziler ve koleksiyonlar

Diziler ve koleksiyonlar her iki dilde de öne çıkan kavramlardır.

Dizileri bildirmek ve bunlara erişmek için kullanılan sözdizimi aynıdır, tek fark C #, çok boyutlu dizileri bildirmek ve işlemek için sözdizimi eklemiştir.

Çok boyutlu diziler, bazı durumlarda artan performans nedeniyle performansı artırabilir. mahal (pürüzlü dizilerde olduğu gibi, dizinin her boyutu için bir yerine bir işaretçi özendirmesi olduğundan). Ancak, çok boyutlu bir dizideki tüm dizi öğesi erişimi, iki veya daha fazla boyut arasında çarpma / kaydırma gerektirdiğinden, bu yalnızca çok rastgele erişim senaryolarında bir avantajdır.

Diğer bir fark, çok boyutlu dizinin tamamının tek bir operatör uygulamasıyla tahsis edilebilmesidir. yenitırtıklı diziler ise her boyut için döngüler ve ayırmalar gerektirir. Bununla birlikte Java, düzenli uzunluklara sahip tırtıklı bir diziyi tahsis etmek için sözdizimsel bir yapı sağlar; döngüler ve çoklu tahsisler daha sonra sanal makine tarafından gerçekleştirilir ve kaynak seviyesinde açık olmaları gerekmez.

Her iki dilde de çeşitli sıralı ve sırasız liste türleri, haritalar / sözlükler, setler vb. İçeren kapsamlı bir koleksiyon türleri bulunur.

Java ayrıca C / C ++ sözdizimini destekler:^[38]

 // Sayılar kısa [] türünde bir nesne olduğu için geçerlidir kısa[] sayılar = yeni kısa[100]; // Geçerli, ancak açık bir kod değil çift değerler[] = yeni çift[100];

 // Sayılar kısa [] türünde bir nesne olduğu için geçerlidir kısa[] sayılar = yeni kısa[100]; // Derlenmeyecek! çift değerler[] = yeni çift[100];

İfadeler ve operatörler

Boks ve kutudan çıkarma

Her iki dil de izin verir otomatik boks ve kutudan çıkarma, yani herhangi bir ilkel tür ile karşılık gelen referans türleri arasında örtük olarak dönüştürmeye izin verirler.
C # 'da, ilkel türler, Nesne türünün alt türleridir. Java'da bu doğru değildir; herhangi bir ilkel tür ve karşılık gelen sarmalayıcı türünün, otomatik kutulama ve kutudan çıkarma dışında birbiriyle belirli bir ilişkisi yoktur. Sözdizimsel şeker aralarında değiş tokuş yapmak için. Bu, otomatik çevrim yapılmasına izin verilmeyen önceki Java sürümleriyle geriye dönük uyumluluğu korumak için bilinçli olarak yapıldı ve programcı iki ayrı tür kümesiyle çalıştı: ilkel türler ve sarmalayıcı (referans) tür hiyerarşisi.^[42]

Bu farkın aşağıdaki sonuçları vardır. Her şeyden önce, C # 'da ilkel türler, Nesnenin geçersiz kılınması gibi yöntemleri tanımlayabilir. ToString () yöntem. Java'da bu görev, ilkel sarmalayıcı sınıfları.
İkincisi, Java'da kişi doğrudan referans otomatik olarak kutuya alınmayacağı için ilkel bir değer. İfade ((Tamsayı) 42) .toString () Java'da bir tamsayıyı dizeye dönüştürürken 42.ToString () C # ile aynı işlemi gerçekleştirir. Bunun nedeni, ikincisinin ilkel değerde bir örnek çağrısı olmasıdır. 42ilki, bir nesne türünde bir örnek çağrısı iken java.lang.Integer.

Son olarak, diğer bir fark, Java'nın kutulu türleri yoğun şekilde kullanmasıdır. jenerik (görmek altında ).

İfadeler

Sözdizimi

Her iki dil de C / C ++ ailesinde "kaşlı ayraç" diller olarak kabul edilir. Genel olarak dillerin sözdizimleri çok benzer. İfade ve ifade seviyesindeki sözdizimi, C / C ++ geleneğinden gelen bariz ilhamla neredeyse aynıdır. Tür tanımlama düzeyinde (sınıflar ve arayüzler ) bazı küçük farklılıklar vardır. Java, sınıfları genişletme ve uygulama arayüzler, C # bunu yeni bir sınıf /arayüz kaynaklanıyor.

C #, Java'dan daha fazla özelliği destekler ve bu, Java'dan daha fazla anahtar sözcük ve daha fazla dilbilgisi kuralı belirten sözdiziminde bir dereceye kadar açıktır.

Anahtar kelimeler ve geriye dönük uyumluluk

Diller geliştikçe, her iki dil için de dil tasarımcıları, yeni anahtar sözcükler veya sözdizimi ile dilleri genişletmek istedikleri durumlarla karşılaştı. Özellikle yeni anahtar sözcükler mevcut kodu kaynak düzeyinde bozabilir, yani eski kod, dilin sonraki bir sürümü için bir derleyiciye sunulursa artık derlenmeyebilir. Dil tasarımcıları bu tür gerilemelerden kaçınmaya isteklidir. İki dilin tasarımcıları bu sorunu ele alırken farklı yollar izliyorlar.

Java dili tasarımcıları mümkün olduğunca yeni anahtar kelimelerden kaçınmış, bunun yerine daha önce yasal olmayan yeni sözdizimsel yapıları sunmayı veya mevcut anahtar kelimeleri yeni bağlamlarda yeniden kullanmayı tercih etmişlerdir. Bu şekilde geriye dönük uyumluluğu tehlikeye atmadılar. İlkine bir örnek, nasıl için döngü yinelenebilir türleri kabul edecek şekilde genişletildi. İkincisine bir örnek, genişler ve (özellikle) Süper Java 1.5'de jenerikler tanıtıldığında anahtar sözcükler tür sınırlarını belirlemek için yeniden kullanıldı. Bir seferde (Java 1.4) yeni bir anahtar kelime iddia etmek daha önce anahtar kelime olarak ayrılmamış olarak tanıtıldı. Bu, daha önce geçerli olan kodu geçersiz kılma potansiyeline sahipti, örneğin kullanılan kod iddia etmek tanımlayıcı olarak. Tasarımcılar bu sorunu dört aşamalı bir çözümle ele almayı seçtiler: 1) Java 1.4 veya sonraki sürümünün kullanılması gerektiğini belirten bir derleyici anahtarı tanıtımı, 2) Yalnızca işaretleme iddia etmek Java 1.4 ve üstü olarak derlerken anahtar kelime olarak, 3) Önceki (1.4 farkında olmayan kodu) geçersiz hale getirmekten kaçınmak için varsayılan olarak 1.3'e ve 4) Anahtar kelime Java 1.3 modunda kullanılıyorsa, geliştiricilere izin vermek için uyarılar yayınlayın. kodu değiştirin.

C # dili tasarımcıları, ilk sürümden bu yana birkaç yeni anahtar kelime tanıttı. Ancak, bu anahtar kelimeleri şu şekilde tanımlamak yerine küresel anahtar kelimeler olarak tanımlarlar bağlama duyarlı anahtar kelimeler. Bu, (diğerlerinin yanı sıra) kısmi ve Yol ver Anahtar sözcükler C # 2.0'da, bu sözcüklerin tanımlayıcı olarak kullanılması, bağlam göz önüne alındığında, anahtar sözcük olarak kullanım ile tanımlayıcı olarak kullanım arasında olası bir çatışma olmadığı için hala geçerlidir. Dolayısıyla, mevcut C # sözdizimi, kullanılacak dil sürümünü belirtmeden önceki herhangi bir sürüm için yazılmış kaynak koduyla tamamen geriye dönük olarak uyumludur.

değiştirmek(renk){    durum Renk.Mavi:        Konsol.Yazı çizgisi("Renk mavidir");        kırmak;    durum Renk.Koyu mavi:        Konsol.Yazı çizgisi("Renk koyu");        git durum Renk.Mavi;    // ...}

halka açık int readItem() atar java.io.IOException {    // ...}

// Küçük bir "test.txt" dosyası oluşturun, bir dize yazın,// ... ve kapatın (bir istisna olsa bile)kullanma (StreamWriter dosya = yeni StreamWriter("test.txt")){    dosya.Yazmak("Ölçek");}

Deneyin (BufferedReader br = yeni BufferedReader(yeni Dosya Okuyucusu(yol))) {    dönüş br.readLine();}

Nesne yönelimli programlama

Hem C # hem de Java sıfırdan nesne odaklı kullanan diller dinamik gönderim benzer sözdizimi ile C ++ (Sırayla C ++ türetir itibaren C ). Bununla birlikte, her iki dil de bir C veya C ++ üst kümesi değildir.

Kısmi sınıf

C #, bir sınıf tanımının, adı verilen bir özelliği kullanarak birkaç kaynak dosyaya bölünmesine izin verir. kısmi sınıflar. Her bölüm anahtar kelimeyle işaretlenmelidir kısmi. Tüm parçalar tek bir derlemenin parçası olarak derleyiciye sunulmalıdır. Parçalar, diğer parçalardan üyelere başvurabilir. Parçalar arabirimler uygulayabilir ve bir parça bir temel sınıf tanımlayabilir. Özellik, kod oluşturma senaryolarında kullanışlıdır (örneğin Kullanıcı arayüzü (UI) tasarımı), burada bir kod üreteci bir parçayı ve geliştiriciye birlikte derlenecek başka bir parçayı sağlayabilir. Böylece geliştirici, bir kod üretecinin daha sonra bu kodun üzerine yazması riski olmadan kendi parçasını düzenleyebilir. Sınıf genişletme mekanizmasının aksine, kısmi bir sınıf dairesel dependencies among its parts as they are guaranteed to be resolved at compile time. Java has no corresponding concept.

Inner and local classes

Both languages allow inner classes, where a class is defined lexically inside another class. However, in each language these inner classes have rather different semantics.

In Java, unless the inner class is declared statik, a reference to an instance of an inner class carries a reference to the outer class with it. As a result, code in the inner class has access to both the static and non-static members of the outer class. To create an instance of a non-static inner class, the instance of the embracing outer class must be named.^[49] This is done via a new yeni-operator introduced in JDK 1.3: outerClassInstance.new Outer.InnerClass(). This can be done in any class that has a reference to an instance of the outer class.

In C#, an inner class is conceptually the same as a normal class. In a sense, the outer class only acts as a namespace. Thus, code in the inner class cannot access non-static members of the outer class unless it does so through an explicit reference to an instance of the outer class. Programmers can declare the inner class özel to allow only the outer class to have any access to it.

Java provides another feature called yerel sınıflar veya anonim sınıflar, which can be defined within a method body. These are generally used to implement an interface with only one or two methods, which are typically event handlers. However, they can also be used to override virtual methods of a superclass. The methods in those local classes have access to the outer method's local variables declared final. C# satisfies the use-cases for these by providing anonymous delegeler; görmek Olay işleme for more about this.

C# also provides a feature called anonymous types/classes, but it is rather different from Java's concept with the same name. It allows the programmer to instantiate a class by providing only a set of names for the properties the class should have, and an expression to initialize each. The types of the properties are inferred from the types of those expressions. These implicitly-declared classes are derived directly from nesne.

Etkinlik

C# multicast-delegates are used with Etkinlikler. Events provide support for olay odaklı programlama and are an implementation of the gözlemci deseni. To support this there is a specific syntax to define events in classes, and operators to register, unregister or combine event handlers.

Görmek İşte for information about how events are implemented in Java.

Operator overloading and conversions

Operatör aşırı yükleme and user-defined dökümler are separate features that both aim to allow new types to become first-class citizens in the type system. By using these features in C#, types such as Karmaşık ve ondalık have been integrated so that the usual operators like addition and multiplication work with the new types. Unlike C++, C# does restrict the use of operator overloading, prohibiting it for the operators yeni, ( ), ||, &&, =, and any variations of compound statements like +=. But compound operators will call overloaded simple operators, like -= arama - ve =.^[50]

Java does not include operator overloading, nor custom conversions in order to prevent abuse of the feature and to keep the language simple.^[51]

Dizin oluşturucu

C# also includes indexers that can be considered a special case of operator overloading (like the C++ operator[]), or parameterized almak/Ayarlamak özellikleri. An indexer is a property named this[] that uses one or more parameters (indexes); the indices can be objects of any type:

myList[4] = 5;dizi isim = xmlNode.Öznitellikler["isim"];emirler = customerMap[theCustomer];

Java does not include indexers. The common Java pattern involves writing explicit getters and setters where a C# programmer would use an indexer.

Fields and initialization

Object initialization

In both C# and Java, an object's fields can be initialized either by variable initializers (expressions that can be assigned to variables where they are defined) or by inşaatçılar (special subroutines that are executed when an object is being created). In addition, Java contains instance initializers, which are anonymous blocks of code with no arguments that are run after the explicit (or implicit) call to a superclass's constructor but before the constructor is executed.

C# initializes object fields in the following order when creating an object:

1. Derived static fields
2. Derived static constructor
3. Derived instance fields
4. Base static fields
5. Base static constructor
6. Base instance fields
7. Base instance constructor
8. Derived instance constructor

Some of the above fields may not be applicable (e.g. if an object does not have static fields). Derived fields are those that are defined in the object's direct class, while temel alan is a term for the fields that are defined in one of the object's superclasses. Note that an object representation in memory contains all fields defined in its class or any of its superclasses, even, if some fields in superclasses are defined as private.

It is guaranteed that any field initializers take effect before any constructors are called, since both the instance constructor of the object's class and its superclasses are called after field initializers are called. There is, however, a potential trap in object initialization when a virtual method is called from a base constructor. The overridden method in a subclass may reference a field that is defined in the subclass, but this field may not have been initialized because the constructor of the subclass that contains field initialization is called after the constructor of its base class.

In Java, the order of initialization is as follows:

1. Invocation of another constructor (either of the object's class or of the object's superclass)
2. Instance variable initializers and instance initializers (in the order they appear in the source code)
3. The constructor body

Like in C#, a new object is created by calling a specific constructor. Within a constructor, the first statement may be an invocation of another constructor. If this is omitted, the call to the argumentless constructor of the superclass is added implicitly by the compiler. Otherwise, either another overloaded constructor of the object's class can be called explicitly, or a superclass constructor can be called. In the former case, the called constructor will again call another constructor (either of the object's class or its subclass) and the chain sooner or later ends up at the call to one of the constructors of the superclass.

After another constructor is called (that causes direct invocation of the superclass constructor, and so forth, down to the Object class), instance variables defined in the object's class are initialized. Even if there are no variable initializers explicitly defined for some variables, these variables are initialized to default values. Note that instance variables defined in superclasses are already initialized by this point, because they were initialized by a superclass constructor when it was called (either by the constructor's code or by variable initializers performed before the constructor's code or implicitly to default values). In Java, variable initializers are executed according to their textual order in the source file.

Finally, the constructor body is executed. This ensures proper order of initialization, i.e. the fields of a base class finish initialization before initialization of the fields of an object class begins.

There are two main potential traps in Java's object initialization. First, variable initializers are expressions that can contain method calls. Since methods can reference any variable defined in the class, the method called in a variable initializer can reference a variable that is defined below the variable being initialized. Since initialization order corresponds to textual order of variable definitions, such a variable would not be initialized to the value prescribed by its initializer and would contain the default value.Another potential trap is when a method that is overridden in the derived class is called in the base class constructor, which can lead to behavior the programmer would not expect when an object of the derived class is created. According to the initialization order, the body of the base class constructor is executed before variable initializers are evaluated and before the body of the derived class constructor is executed. The overridden method called from the base class constructor can, however, reference variables defined in the derived class, but these are not yet initialized to the values specified by their initializers or set in the derived class constructor. The latter issue applies to C# as well, but in a less critical form since in C# methods are not overridable by default.

Resource disposal

Both languages mainly use çöp toplama as a means of reclaiming memory resources, rather than explicit deallocation of memory. In both cases, if an object holds resources of different kinds other than memory, such as file handles, graphical resources, etc., then it must be notified explicitly when the application no longer uses it. Both C# and Java offer interfaces for such deterministic bertaraf and both C# and Java (since Java 7) feature automatic resource management statements that will automatically invoke the disposal/close methods on those interfaces.

Yöntemler

Extension methods and default methods

Using a special bu designator on the first parameter of a method, C# allows the method to act as if it were a member method of the type of the first parameter. Bu uzantı of the foreign class is purely syntactical. The extension method must be declared statik and defined within a purely static class. The method must obey any member access restriction like any other method external to the class; thus static methods cannot break object encapsulation.^[57][58] The "extension" is only active within scopes where the namespace of the static host class has been imported.

Since Java 8, Java has a similar feature called default methods, which are methods with a body declared on interfaces. As opposed to C# extension methods, Java default methods are instance methods on the interface that declare them. Definition of default methods in classes that implement the interface is optional: If the class does not define the method, the default definition is used instead.

Both the C# extension methods and the Java default methods allow a class to override the default implementation of the extension/default method, respectively. In both languages this override is achieved by defining a method on the class that should use an alternate implementation of the method.

C# scope rules defines that if a matching method is found on a class, it takes precedence over a matching extension method. In Java any class declared to implement an interface with default method is assumed to have the default methods implementions, sürece the class implements the method itself.

Partial methods

İle ilgili kısmi sınıflar C# allows partial methods to be specified within partial classes. A partial method is an intentional declaration of a method with several restrictions on the signature. The restrictions ensure that if a definition is not provided by any class part, then the method and every call to it can be safely erased.^[59] This feature allows code to provide a large number of interception points (like the şablon yöntemi GoF design pattern) without paying any runtime overhead if these extension points are not being used by another class part at compile time. Java has no corresponding concept.

Sanal yöntemler

Yöntemler in C# are non-gerçek by default, and must be declared virtual explicitly, if desired. In Java, all non-static non-private methods are virtual. Virtuality guarantees that the most recent geçersiz kılmak for the method will always be called, but incurs a certain runtime cost on invocation as these invocations cannot be normally inlined, and require an indirect call via the sanal yöntem tablosu. However, some JVM implementations, including the Oracle reference implementation, implement inlining of the most commonly called virtual methods.

Java methods are virtual by default (although they can be Mühürlü kullanarak final modifier to disallow overriding). There is no way to let türetilmiş sınıflar define a new, unrelated method with the same name.

This means that by default in Java, and only when explicitly enabled in C#, new methods may be defined in a derived class with the same name and signature as those in its base class. When the method is called on a superclass reference of such an object, the "deepest" overridden implementation of the temel sınıf ' method will be called according to the specific subclass of the object being referenced.

In some cases, when a subclass introduces a method with the same name and signature as a method already present in the temel sınıf, problems can occur. In Java, this will mean that the method in the derived class will implicitly override the method in the base class, even though that may not be the intent of the designers of either class.

To mitigate this, C# requires that if a method is intended to override an inherited method, the geçersiz kılmak keyword must be specified. Otherwise, the method will "hide" the inherited method. If the keyword is absent, compiler warning to this effect is issued, which can be silenced by specifying the yeni anahtar kelime. This avoids the problem that can arise from a base class being extended with a non-private method (i.e. an inherited part of the namespace) whose signature is already in use by a derived class. Java has a similar compiler check in the form of the @Override method annotation, but it is not compulsory, and in its absence, most compilers will not provide comment (but the method will be overridden).

Constant/immutable parameters

In Java, it is possible to prevent reassignment of a local variable or method parameter by using the final anahtar kelime. Uygulanıyor this keyword to a primitive type variable causes the variable to become immutable. However, applying final to a reference type variable only prevents that another object is assigned to it. It will not prevent the data contained by the object from being mutated. As of C#7, it is possible to prevent reassignment of a method parameter by using the içinde keyword, however this keyword cannot be used on local variables. As with Java, applying içinde to a parameter only prevents the parameter from being reassigned to a different value. It is still possible to mutate the data contained by the object.^[60]

halka açık int addOne(final int x) {    x++; // ERROR: a final variable cannot be reassigned    dönüş x;}halka açık Liste addOne(final Liste<Tamsayı> liste) {    liste.Ekle(1); // OK: it is still possible to modify a                 // final (reference type) variable    dönüş liste;}

halka açık int AddOne(içinde int x) {    x++; // ERROR: a readonly parameter cannot be reassigned    dönüş x;}halka açık Liste<int> AddOne(içinde Liste<int> liste) {    liste.Ekle(1); // OK: it is still possible to modify a                 // readonly (reference type) parameter    dönüş liste;}

Both languages do not support essential feature of sabit doğruluk var olan C /C ++, which makes a method constant.

Java defines the word "constant" arbitrarily as a statik final alan. Only these variables are capital-only variables, where the names are separated with an vurgulamak^{[kaynak belirtilmeli ]}. A parameter that is only final is not considered as a constant, although it may be so in the case of a ilkel veri türü veya bir immutable class gibi Dize.

Generator methods

Any C# method declared as returning IEnumerable, IEnumerator or the generic versions of these interfaces can be implemented using Yol ver sözdizimi. This is a form of limited, compiler-generated continuations and can drastically reduce the code needed to traverse or generate sequences, although that code is just generated by the compiler instead. The feature can also be used to implement infinite sequences, e.g., the sequence of Fibonacci sayıları.

Java does not have an equivalent feature. Instead generators are typically defined by providing a specialized implementation of a well-known collection or iterable interface, which will compute each element on demand. For such a generator to be used in a her biri için statement, it must implement interface java.lang.Iterable.

See also example Fibonacci Dizisi altında.

Explicit interface implementation

C# also has explicit interface implementation that allows a class to specifically implement methods of an arayüz, separate to its own class methods, or to provide different implementations for two methods with the same name and signature inherited from two base interfaces.

In either language, if a method (or property in C#) is specified with the same name and signature in multiple interfaces, the members will clash when a class is designed that implements those interfaces. An implementation will by default implement a common method for all of the interfaces. If separate implementations are needed (because the methods serve separate purposes, or because return values differ between the interfaces) C#'s explicit interface implementation will solve the problem, though allowing different results for the same method, depending on the current cast of the object. In Java there is no way to solve this problem other than refactoring one or more of the interfaces to avoid name clashes.^[54]

Reference (in/out) parameters

The arguments of primitive types (e.g. int, double) to a method are passed by value in Java whereas objects are passed by reference. This means that a method operates on copies of the primitives passed to it instead of on the actual variables. On the contrary, the actual objects in some cases can be changed. In the following example object String is not changed. Object of class 'a' is changed.

In C#, it is possible to enforce a reference with the ref keyword, similar to C++ and in a sense to C. This feature of C# is particularly useful when one wants to create a method that returns more than one object. In Java trying to return multiple values from a method is unsupported, unless a wrapper is used, in this case named "Ref".^[61]

sınıf PassByRefTest {    statik sınıf Referans<T> {        T val;        Referans(T val) { bu.val = val; }    }        statik geçersiz changeMe(Referans<Dize> s) {        s.val = "Değiştirildi";    }    statik geçersiz takas(Referans<Tamsayı> x, Referans<Tamsayı> y) {        int temp = x.val;        x.val = y.val;        y.val = temp;    }    halka açık statik geçersiz ana(Dize[] argümanlar) {        var a = yeni Referans(5);        var b = yeni Referans(10);        var s = yeni Referans("still unchanged");                takas(a, b);        changeMe(s);        Sistem.dışarı.println( "a = " + a.val + ", " +                            "b = " + b.val + ", " +                            "s = " + s.val );    }}

sınıf PassByRefTest {    halka açık statik geçersiz ChangeMe(dışarı dizi s)     {        s = "Değiştirildi";    }    halka açık statik geçersiz Takas(ref int x, ref int y)     {        int temp = x;        x = y;        y = temp;    }    halka açık statik geçersiz Ana(dizi[] argümanlar)     {        int a = 5;        int b = 10;        dizi s = "still unchanged";        Takas(ref a, ref b);        ChangeMe(dışarı s);        Sistem.Konsol.Yazı çizgisi("a = " + a + ", " +                                 "b = " + b + ", " +                                 "s = " + s);    }}

İstisnalar

Checked exceptions

Java supports kontrol edilen istisnalar (along with unchecked exceptions). C# only supports unchecked exceptions. Checked exceptions force the programmer to either declare the exception thrown in a method, or to catch the thrown exception using a try-catch fıkra.

Checked exceptions can encourage good programming practice, ensuring that all errors are dealt with. ancak Anders Hejlsberg, chief C# language architect, argues that they were to some extent an experiment in Java and that they have not been shown to be worthwhile except in small example programs.^[62][63]

One criticism is that checked exceptions encourage programmers to use an empty catch block (catch (Exception e) {}),^[64] which silently swallows exceptions, rather than letting the exceptions propagate to a higher-level exception-handling routine. In some cases, however, exception chaining can be applied instead, by re-throwing the exception in a wrapper exception. For example, if an object is changed to access a database instead of a file, an SQLException could be caught and re-thrown as an IOException, since the caller may not need to know the inner workings of the object.

However, not all programmers agree with this stance. James Gosling and others maintain that checked exceptions are useful, and misusing them has caused the problems. Silently catching exceptions is possible, yes, but it must be stated explicitly what to do with the exception, versus unchecked exceptions that allow doing nothing by default. It can be ignored, but code must be written explicitly to ignore it.^[65][66]

Try-catch-finally

There are also differences between the two languages in treating the try-finally Beyan. en sonunda block is always executed, even if the Deneyin block contains control-passing statements like atmak veya dönüş. In Java, this may result in unexpected behavior, if the Deneyin block is left by a dönüş statement with some value, and then the en sonunda block that is executed afterward is also left by a dönüş statement with a different value. C# resolves this problem by prohibiting any control-passing statements like dönüş veya kırmak içinde en sonunda blok.

A common reason for using try-finally blocks is to guard resource managing code, thus guaranteeing the release of precious resources in the finally block. C# features the kullanma statement as a syntactic shorthand for this common scenario, in which the Dispose() method of the object of the kullanma is always called.

A rather subtle difference is the moment a yığın izleme is created when an exception is being thrown. In Java, the stack trace is created in the moment the exception is created.

sınıf Foo {    İstisna yukarı = yeni İstisna();    int foo() atar İstisna {        atmak yukarı;    }}

The exception in the statement above will always contain the constructor's stack-trace – no matter how often foo is called.In C# on the other hand, the stack-trace is created the moment "throw" is executed.

sınıf Foo{    İstisna e = yeni İstisna();    int foo()    {        Deneyin        {            atmak e;        }        tutmak (İstisna e)        {            atmak;        }    }}

In the code above, the exception will contain the stack-trace of the first throw-line. When catching an exception, there are two options in case the exception should be rethrown: atmak will just rethrow the original exception with the original stack, while throw e would have created a new stack trace.

Finally blocks

Java allows flow of control to leave the en sonunda block of a Deneyin statement, regardless of the way it was entered. This can cause another control flow statement (such as dönüş) to be terminated mid-execution. Örneğin:

int foo() {    Deneyin {        dönüş 0;    } en sonunda {        dönüş 1;    }}

In the above code, the dönüş statement within the Deneyin block causes control to leave it, and thus en sonunda block is executed before the actual return happens. Ancak en sonunda block itself also performs a return. Thus, the original return that caused it to be entered is not executed, and the above method returns 1 rather than 0. Informally speaking, it dener to return 0 but en sonunda returns 1.

C# does not allow any statements that allow control flow to leave the en sonunda block prematurely, except for atmak. Özellikle, dönüş is not allowed at all, git is not allowed if the target label is outside the en sonunda blok ve devam et ve kırmak are not allowed if the nearest enclosing loop is outside the en sonunda blok.

Jenerikler

Nın alanında jenerik the two languages show a superficial syntactical similarity, but they have deep underlying differences.

Type erasure versus reified generics

Java'da jenerikler are a language-only construction; they are implemented only in the compiler. The generated classfiles include generic signatures only in form of metadata (allowing the compiler to compile new classes against them). The runtime has no knowledge of the generic type system; generics are not part of the JVM. Instead, generics classes and methods are transformed during compiling via a process termed tür silme. During this, the compiler replaces all generic types with their çiğ version and inserts casts/checks appropriately in client code where the type and its methods are used. The resulting byte code will contain no references to any generic types or parameters (See also Java'da jenerikler ).

The Java language specification intentionally prohibits certain uses of generics; this is necessary to allow for implementing generics through tür silme, and to allow for migration compatibility.^[67] Research into adding reified generics to the Java platform is ongoing, as part of Project Valhalla.

C# builds on support for generics from the virtual execution system, i.e., it is not just a language feature. The language is merely a front-end for cross-language generics support in the CLR. During compiling generics are verified for correctness, but code generation to uygulamak the generics are deferred to class-load time. Client code (code invoking generic methods/properties) are fully compiled and can safely assume generics to be type-safe. Bu denir şeyleşme. At runtime, when a unique set of type parameters for a generic class/method/delegate is encountered for the first time, the class loader/verifier will synthesize a concrete class descriptor and generate method implementations. During the generation of method implementations all reference types will be considered one type, as reference types can safely share the same implementations. This is merely for the purpose of uygulama kodu.Farklı referans türlerinin yine de benzersiz tür tanımlayıcıları olacaktır; yöntem tabloları yalnızca aynı kodu gösterecektir.

Aşağıdaki liste, jenerikleri yönetirken Java ve C # arasındaki bazı farklılıkları göstermektedir. Kapsamlı değildir:^[68]

Çift<Dize, Dize>[] onPairs = yeni Çift[10]; //TAMAM MI

nesne onPairs = yeni Çift<int, dizi>[10]; // TAMAM MI

halka açık sınıf Bakmak<K, V> {    halka açık V[] getEmptyValues(K anahtar) {        dönüş (V[]) yeni Nesne[0]; // TAMAM MI    }}

halka açık sınıf Bakmak<K, V genişler Kıyaslanabilir<V>> {    halka açık V[] getEmptyValues(K anahtar) {        dönüş (V[]) yeni Kıyaslanabilir[0];    }}

halka açık sınıf Bakmak<K, V> {    halka açık V[] GetEmptyValues(K anahtar) {        dönüş yeni V[0]; // TAMAM MI    }}

C #, doğrudan ilkel türler için jeneriklere izin verir. Bunun yerine Java, kutulu türlerin tür parametreleri olarak kullanılmasına izin verir (ör. listesi onun yerine listesi). Bunun bir maliyeti vardır, çünkü bu tür tüm değerlerin kullanıldıklarında kutulanması / kutudan çıkarılması gerekir ve hepsinin yığın olarak tahsis edilmesi gerekir. Bununla birlikte, genel bir tür, örneğin Java'da bir ilkel türden bir dizi türü ile özelleştirilebilir. <İnt []> listesi izin verilir.^[73]Birkaç üçüncü taraf kitaplığı, ilkel türlerin sağladığı çalışma zamanını ve bellek optimizasyonunu korumak için Java'daki temel koleksiyonları ilkel dizileri destekleyerek uyguladı.^[74]

Geçiş uyumluluğu

Java'nın tür silme tasarımı, başarmak için bir tasarım gereksinimiyle motive edildi. geçiş uyumluluğu - karıştırılmamalıdır geriye dönük uyumluluk. Özellikle, asıl gereksinim "… Java 2 platformunda sunulan Koleksiyonlar API'leri için temiz, kanıtlanabilir bir geçiş yolu olmalıdır".^[42] Bu, herhangi bir yeni genel koleksiyonun önceden var olan koleksiyon sınıflarından birini bekleyen yöntemlere geçirilebilmesi için tasarlandı.^[75]

C # jenerikleri, tam geriye dönük uyumluluk korunurken dile getirildi, ancak tam olarak korunmadı geçiş uyumluluğu: Eski kod (C # 2.0 öncesi), yeniden derleme olmadan yeni jenerik duyarlı çalışma zamanında değişmeden çalışır. Gelince geçiş uyumluluğu, genel olmayan .NET 1.x koleksiyonlarını değiştirmek yerine tamamlayan yeni genel koleksiyon sınıfları ve arabirimleri geliştirildi. Genel koleksiyon arabirimlerine ek olarak, yeni genel koleksiyon sınıfları, mümkün olduğunda genel olmayan koleksiyon arabirimlerini uygular. Bu yöntemler, koleksiyonu kullanmak için kodlanmışsa, önceden var olan (genel olmayan farkındalık) yöntemlerle yeni genel koleksiyonların kullanılmasını engeller. sınıflar.

Kovaryans ve kontravaryans

Kovaryans ve kontravaryans her iki dil tarafından desteklenmektedir. Java, tek bir genel sınıfın hem birlikte hem de kontravaryans kullanarak üyeleri bildirmesine izin veren kullanım site varyansına sahiptir. C #, genel arabirimler ve temsilciler için site tanımlama varyansına sahiptir. Varyans, doğrudan sınıflarda desteklenmez ancak varyant arabirimlerinin uygulanmasıyla desteklenir. C # ayrıca yöntemler ve temsilciler için kullanım yeri kovaryans desteğine sahiptir.

Fonksiyonel programlama

Kapanışlar

Kapanış, değişkenleri sözlü kapsamından yakalayan bir satır içi işlevdir.

C #, anonim yöntemler olarak kapatmaları destekler veya lambda ifadeleri tam özellikli kapatma anlambilim.^[79][80]

Java'da anonim iç sınıflar, Java 8 yeni standart haline gelene kadar kapanışları taklit etmenin tercih edilen yolu olarak kalacaktır. Bu daha ayrıntılı bir yapıdır. Bu yaklaşım aynı zamanda gerçek kapanışlara kıyasla bazı farklılıklar içerir, özellikle çevreleyen kapsamlardan değişkenlere daha kontrollü erişim: yalnızca nihai üyelere referans verilebilir. Ancak Java 8, mevcut kapsamı tam olarak miras alan ve aslında yeni bir kapsam sunmayan lambdalar sunar.

Bir yönteme bir başvuru daha sonra yürütülebildiğinde, yöntemin sözcüksel kapsamı içinde değişkenlere / parametrelere başvurulara sahip olduğunda ne yapılması gerektiği konusunda bir sorun ortaya çıkar. C # closures herhangi bir değişkene / parametreye kendi sözlü kapsamından erişebilir. Java'nın anonim iç sınıflarında, yalnızca sözcüksel kapsamın son üyelerine yapılan atıflara izin verilir, bu nedenle geliştiricinin hangi değişkenleri ve hangi durumda (muhtemelen kutulama gerektirdiğini) işaretlemesi gerekir.

Lambdas ve ifade ağaçları

C # ve Java'da özel bir hat içi kapanışlar aranan Lambdas. Bunlar anonim yöntemlerdir: imzaları ve gövdeleri vardır, ancak isimleri yoktur. Esas olarak diğer yöntemlere yapılan çağrılarda yerel işlev değerli argümanları belirtmek için kullanılırlar, esas olarak fonksiyonel programlama.

Java'dan farklı olarak C #, lambda işlevlerinin ifade ağaçları adı verilen özel veri yapılarını tanımlamanın bir yolu olarak kullanılmasına izin verir. Çalıştırılabilir bir işlev olarak mı yoksa bir veri yapısı olarak mı görüldükleri derleyiciye bağlıdır tür çıkarımı ve atandıkları veya atandıkları değişken veya parametre türü. Lambdalar ve ifade ağaçları, Dil ile Entegre Sorgu (LINQ).

Meta veriler

Bu bölüm genişlemeye ihtiyacı var. Yardımcı olabilirsiniz ona eklemek. (Şubat 2015)

Ön işleme, derleme ve paketleme

Ad alanları ve dosya içerikleri

C # dilinde, ad alanları içindekilere benzer C ++. Aksine paket Java'daki isimler, bir isim alanı hiçbir şekilde kaynak dosyanın konumuna bağlı değildir. Bir Java kaynak dosyası konumunun paket dizin yapısını yansıtması kesinlikle gerekli olmasa da, bu geleneksel organizasyondur.

Her iki dil de sınıfların içe aktarılmasına izin verir (ör. ithalat java.util. * Java'da), bir sınıfa yalnızca adı kullanılarak başvurulmasına izin verir. Bazen aynı ada sahip sınıflar birden çok ad alanında veya pakette bulunur. Bu tür sınıflara, tam nitelikli adlar kullanılarak veya yalnızca farklı adlara sahip seçili sınıflar içe aktarılarak başvurulabilir. Bunu yapmak için Java, tek bir sınıfın içe aktarılmasına izin verir (ör. ithalat java.util.List). C #, aşağıdaki sözdizimini kullanarak sınıfları yeni bir yerel ad altında içe aktarmaya izin verir: kullanma Konsol = System.Console. Ayrıca, sınıfların uzmanlıklarını şu şekilde içe aktarmaya da izin verir: kullanma IntList = System.Collections.Generic.List <int>.

Her iki dilde de statik içe aktarma Bir sınıftaki statik yöntemlerin / alanların bazılarının veya tamamının kısa adının kullanılmasına izin veren sözdizimi (ör. foo (bar) nerede foo () başka bir sınıftan statik olarak içe aktarılabilir). C #, bir sınıfı yalnızca statik yöntemler içerecek şekilde kısıtlayan statik bir sınıf sözdizimine sahiptir (Java'daki statik iç sınıflarla karıştırılmamalıdır). C # 3.0 tanıtıyor uzatma yöntemleri kullanıcıların bir türe statik olarak bir yöntem eklemesine izin vermek için (ör. foo.bar () nerede bar() türü üzerinde çalışan içe aktarılmış bir uzantı yöntemi olabilir foo).

Sun Microsystems Java derleyicisi, bir kaynak dosya adının içindeki tek genel sınıfla eşleşmesini gerektirirken, C # aynı dosyada birden çok genel sınıfa izin verir ve dosya adına hiçbir kısıtlama koymaz. C # 2.0 ve sonraki sürümler, bir sınıf tanımının, kısmi kaynak koddaki anahtar kelime. Java'da, genel bir sınıf her zaman kendi kaynak dosyasında olacaktır. C # 'da, kaynak kodu dosyaları ve mantıksal birim ayrımı sıkı bir şekilde ilişkili değildir.

Koşullu derleme

Java'nın aksine, C # uygular koşullu derleme kullanma Önişlemci yönergeleri. Aynı zamanda bir Koşullu nitelik yalnızca belirli bir derleme sabiti tanımlandığında çağrılan yöntemleri tanımlamak için. Bu yoldan, iddialar yöntem ile çerçeve özelliği olarak sağlanabilir Debug.Assert (), yalnızca HATA AYIKLA sabit tanımlanmıştır. 1.4 sürümünden bu yana Java, varsayılan olarak çalışma zamanında kapatılan, ancak şu şekilde etkinleştirilebilen onaylar için bir dil özelliği sağlar. -enableassertions veya -ea JVM'yi çağırırken değiştirin.

Diş açma ve eşzamansız özellikler

Her iki dil şunları içerir: Konu senkronizasyon dil sözdiziminin bir parçası olarak mekanizmalar.

C # için göreve dayalı paralellik

.NET Framework 4.0 ile, mevcut olay tabanlı zaman uyumsuz modelin yerini alacak yeni bir görev tabanlı programlama modeli tanıtıldı. API, Görev ve Görev sınıflar. Görevler oluşturulabilir ve zincirlenebilir.

Geleneksel olarak, bir döndüren her yöntem Görev ismine sonradan eklenmiş olmalıdır Asenkron.

halka açık statik sınıf SomeAsyncCode{    halka açık statik Görev<XDocument> GetContentAsync()    {        HttpClient httpClient = yeni HttpClient();        dönüş httpClient.GetStringAsync("www.contoso.com").İle devam et((görev) => {            dizi responseBodyAsText = görev.Sonuç;            dönüş XDocument.Ayrıştır(responseBodyAsText);        });    }}var t = SomeAsyncCode.GetContentAsync().İle devam et((görev) => {    var xmlDocument = görev.Sonuç;});t.Başlat();

C # 5'te, görev modeliyle çalışmayı kolaylaştırmak için bir dizi dil ve derleyici uzantıları tanıtıldı. Bu dil uzantıları, eşzamansız yöntemler ve beklemek program akışının eşzamanlı görünmesini sağlayan ifade.

halka açık statik sınıf SomeAsyncCode{    halka açık statik eşzamansız Görev<XDocument> GetContentAsync()    {        HttpClient httpClient = yeni HttpClient();        dizi responseBodyAsText = beklemek httpClient.GetStringAsync("www.contoso.com");        dönüş XDocument.Ayrıştır(responseBodyAsText);    }}var xmlDocument = beklemek SomeAsyncCode.GetContentAsync();// Görev, await ile çağrı üzerine başlatılacaktır.

Bundan Sözdizimsel şeker C # derleyicisi, geliştiricilerin düşünmesine gerek kalmadan gerekli sürekliliği yöneten bir durum makinesi oluşturur.

Java için görev tabanlı paralellik

Java, JDK 1.0'dan beri iş parçacıklarını destekler. Java, genellikle görevler olarak adlandırılan iş parçacığı çalıştırmak için çok yönlülük sunar. Bu, işlevsel bir arabirim (a java.lang.Runnable arabirim) aşağıdaki örnekte gösterildiği gibi tek bir void no-args yöntemini tanımlar:

var myThread = yeni Konu(() -> {    var threadName = Konu.currentThread().getName();    Sistem.dışarı.println("Merhaba " + threadName);});myThread.Başlat();

C # ile benzer şekilde, Java'nın iş parçacıklarıyla çalışmak için daha yüksek düzeyde bir mekanizması vardır. Yürütücüler zaman uyumsuz görevleri yürütebilir ve ayrıca bir grup alt işlemi yönetebilir. Tüm konuları Yürütme Hizmetleri örnek bir havuz. Bu Yürütme Hizmeti Örneği, Revenant görevleri için başlık altında yeniden kullanılacaktır, böylece programcının tek bir yürütücü hizmet örneğini kullanarak uygulamanın yaşam döngüsü boyunca istediği kadar eşzamanlı görevi çalıştırması mümkündür.

İlk iş parçacığı örneği, çalıştırıcıları kullanmaya benziyor:

Yürütme Hizmeti icracı = Yürütücüler.newSingleThreadExecutor();icracı.Sunmak(() -> {    var threadName = Konu.currentThread().getName();    Sistem.dışarı.println("Merhaba " + threadName);});

Yürütme Hizmeti örnek ayrıca bir Aranabilir arayüz, başka bir tek yöntem arayüzü gibi Runnable ama içerdiği yöntemin imzası Aranabilir bir değer döndürür. Bu şekilde lambda ifadesinin de bir değer döndürmesi gerekir.

halka açık statik sınıf SomeAsyncCode {    Yürütme Hizmeti icracı = Yürütücüler.newSingleThreadExecutor();    halka açık statik Gelecek<Dize> getContentAsync(){        dönüş icracı.Sunmak(() -> {                       HttpRequest httpReq = HttpRequest.newBuilder()                .uri(yeni URI("https://www.graalvm.org"))                .inşa etmek();                        dönüş HttpClient.newHttpClient()                .göndermek(httpReq, BodyHandlers.ofString())                .vücut();        });    }}var webPageResult = SomeAsyncCode.getContentAsync().almak();

Yöntemi çağırmak almak() bloklar mevcut iş parçacığı ve değeri döndürmeden önce çağrılabilir tamamlanana kadar bekler (örnekte, bir web sayfası içeriği):

Ek özellikler

Sayısal uygulamalar

Matematiksel ve finansal hesaplama alanındaki uygulamaları yeterince desteklemek için birkaç dil özelliği mevcuttur.^[87]

Java's katıfp anahtar sözcük, bir kod bölgesi için katı kayan nokta hesaplamaları sağlar. Sıkı kayan nokta hesaplamaları, bir platform hesaplamalar sırasında daha yüksek hassasiyet sunsa bile, ara sonuçların tek / ikiye dönüştürülmesi gerektiğini gerektirir. Bu, katı kayan nokta hesaplamalarının tüm platformlarda tam olarak aynı sonucu vermesini sağlar. Kesin kayan nokta olmadan, bir platform uygulaması hesaplama sırasında ara sonuçlar için daha yüksek hassasiyet kullanmakta serbesttir. C #, belirli bir donanım mimarisi için bir uygulamanın, varsa ara sonuçlar için her zaman daha yüksek bir hassasiyet kullanmasına izin verir, yani C #, programcının isteğe bağlı olarak ara sonuçları tekli / çiftin potansiyel daha düşük kesinliğini kullanmaya zorlamasına izin vermez.^[88]

Java'nın kayan nokta aritmetiği büyük ölçüde IEEE 754'e (İkili Kayan Nokta Aritmetiği için Standart) dayalı olsa da, İstisna Bayrakları ve Yönlendirilmiş Yuvarlamalar, IEEE Standard 754 tarafından zorunlu kılınan yetenekler gibi katı fp değiştiricisi kullanıldığında bile bazı özellikler desteklenmez (bkz. Java Eleştirisi, Kayan nokta aritmetiği ).

C # yerleşik bir ondalık tür sağlar,^[89] Java / C # çiftine göre daha yüksek hassasiyete (ancak daha az aralığa) sahiptir. Ondalık tür, finansal ve parasal hesaplamalar için uygun 128 bitlik bir veri türüdür. Ondalık tür, 1.0 × 10 arasında değişen değerleri temsil edebilir⁻²⁸ yaklaşık 7,9 × 10²⁸ 28-29 anlamlı basamaklı.^[90] Yapı, C # operatörü aşırı yüklemesini kullanır, böylece ondalık sayılar, diğer ilkel veri türleri gibi +, -, * ve / gibi operatörler kullanılarak işlenebilir.

BigDecimal ve BigInteger Java ile sağlanan türler, sırasıyla ondalık sayıların ve tam sayı sayılarının keyfi kesinlikte temsiline izin verir. Java standart kitaplığı, karmaşık sayılarla uğraşacak sınıflara sahip değildir.

BigInteger,^[3] ve Karmaşık^[91] C # ile sağlanan türler, sırasıyla keyfi kesinlikli tam sayıların ve karmaşık sayıların temsiline ve değiştirilmesine izin verir. Yapılar, C # operatörü aşırı yüklemesini kullanır, böylece örnekler aşağıdaki gibi operatörler kullanılarak işlenebilir. +, -, *, ve /, diğer ilkel veri türleri gibi. C # standart kitaplığı, keyfi hassasiyetli kayan nokta sayılarıyla ilgilenecek sınıflara sahip değildir (bkz. keyfi kesinlikte aritmetik için yazılım ).

C #, matematiksel uygulamalara yardımcı olabilir. kontrol ve kontrol edilmemiş için çalışma zamanı kontrolünün etkinleştirilmesine veya devre dışı bırakılmasına izin veren operatörler aritmetik taşma bir kod bölgesi için.

Dile entegre sorgu (LINQ)

C # s Dil ile Entegre Sorgu (LINQ), dil içi sorgulama yeteneklerine izin vermek için birlikte çalışmak üzere tasarlanmış bir dizi özelliktir ve C # ile Java arasında ayırt edici bir özelliktir.

LINQ aşağıdaki özelliklerden oluşur:

• Uzantı yöntemleri, mevcut arabirimlerin veya sınıfların yeni yöntemlerle genişletilmesine izin verir. Uygulamalar paylaşılabilir veya bir arayüz özel bir uygulamaya sahip olabilir.
• Lambdalar, kriterlerin işlevsel bir şekilde ifade edilmesine izin verir.
• İfade ağaçları, belirli bir uygulamanın bir lambdayı bir soyut sözdizimi ağacı yürütülebilir bir blok yerine. Bu, ölçütleri farklı bir dilde temsil etmek için uygulamalar tarafından kullanılabilir, örn. şeklinde SQL nerede cümlesi olduğu gibi ör. Linq, LINQ to SQL.
• Anonim türler ve tür çıkarımı, bir sorgunun sonuç türü yakalama ve onunla çalışmayı destekler. Bir sorgu, adlandırılamayan bir sonuç türüne yol açabilecek sorgu kaynakları üzerinden hem birleştirilebilir hem de projelendirilebilir.
• Tanıdık bir sözdizimini desteklemek için sorgu ifadeleri SQL kullanıcılar.
• Null yapılabilir (kaldırılmış) türler, ör. Null yapılabilir türleri destekleyen sorgu sağlayıcılarıyla daha iyi eşleşmeye izin verir. SQL.

Yerel birlikte çalışabilirlik

Java Yerel Arayüzü (JNI) özelliği, Java programlarının Java dışı kodu aramasına olanak tanır. Bununla birlikte, JNI, çağrılan kodun çeşitli kurallara uymasını gerektirir ve kullanılan türlere ve adlara kısıtlamalar getirir. Bu, eski kod ve Java arasında genellikle fazladan bir uyarlama katmanına ihtiyaç duyulduğu anlamına gelir. Bu uyarlama kodu Java dışı bir dilde, genellikle C veya C ++ ile kodlanmalıdır. Java Yerel Erişimi (JNA), yalnızca Java kodu yazmayı gerektiren, ancak bir performans maliyeti ile gelen yerel kodun daha kolay çağrılmasını sağlar.

Ayrıca üçüncü taraf kütüphaneler Java sağlayın-Bileşen Nesne Modeli (COM) köprüleme, ör. JACOB (Bedava ) ve COM için J-Integra (tescilli ).

.NET Platform Çağrısı (P / Çağır ), C #’dan Microsoft’un terimlerine göre çağrılara izin vererek aynı yeteneği sunar.yönetilen kod. Metadata öznitelikleri aracılığıyla programcı, parametrelerin ve sonuçların tam olarak nasıl olduğunu kontrol edebilir. sıralı böylece Java'daki eşdeğer JNI tarafından ihtiyaç duyulan harici tutkal kodundan kaçınılır. P / Invoke, prosedürel API'lere (Win32 veya POSIX gibi) neredeyse tam erişime izin verir, ancak C ++ sınıf kitaplıklarına sınırlı erişim sağlar.

Ayrıca .NET Framework, COM bileşenlerine birinci sınıf .NET nesneleri gibi erişime izin veren bir .NET-COM köprüsü sağlar.

C # ayrıca programcının normal tip kontrolünü ve diğer güvenlik özelliklerini devre dışı bırakmasına izin verir. CLR, daha sonra kullanımını etkinleştirir işaretçi değişkenleri. Bu özelliği kullanırken, programcı kodu kullanarak kodu işaretlemelidir. güvensiz anahtar kelime. JNI, P / Invoke ve "güvenli olmayan" kod aynı derecede riskli özelliklerdir ve olası güvenlik açıklarını ve uygulama kararsızlığını ortaya çıkarır. Güvenli olmayan, yönetilen kodun P / Invoke veya JNI'ye göre bir avantajı, programcının, başka türlü yönetilmeyen koda çağrı yapılmasını gerektirecek bazı görevleri gerçekleştirmek için tanıdık C # ortamında çalışmaya devam etmesine izin vermesidir. Güvenli olmayan kodu kullanan bir derleme (program veya kitaplık) özel bir anahtarla derlenmeli ve bu şekilde işaretlenmelidir. Bu, çalışma zamanı ortamlarının zararlı olabilecek kodları çalıştırmadan önce özel önlemler almasını sağlar.

Çalışma zamanı ortamları

Java (programlama dili), Java platformunda şu yolla yürütülecek şekilde tasarlanmıştır: Java Runtime Environment (JRE). Java platformu şunları içerir: Java sanal makinesi (JVM) ve ortak bir kitaplık kümesi. JRE, orijinal olarak, bir seçenek olarak nihai derleme ile yorumlanmış yürütmeyi desteklemek için tasarlanmıştır. Çoğu JRE ortamı, muhtemelen aşağıdakilerle birlikte tamamen veya en azından kısmen derlenmiş programları yürütür. uyarlanabilir optimizasyon. Java derleyicisi, Java bayt kodu. Yürütmenin ardından, bayt kodu Java çalışma zamanı tarafından yüklenir ve ya doğrudan yorumlanır ya da makine talimatlarına göre derlenir ve ardından çalıştırılır.

C #, Ortak dil çalışması (CLR). CLR, tamamen derlenmiş kodu yürütmek için tasarlanmıştır. C # derleyicisi, Ortak Ara Dil Talimatlar. Yürütmenin ardından çalışma zamanı bu kodu yükler ve hedef mimarideki makine talimatlarını derler.

Örnekler

Giriş çıkış

Her iki dili kullanarak metnin bir dosyadan diğerine her seferinde bir satırın nasıl kopyalanacağını gösteren örnek.

ithalat java.nio.file. *;sınıf FileIOTest {    halka açık statik geçersiz ana(Dize[] argümanlar) atar İstisna {        var çizgiler = Dosyalar.readAllLines(Yollar.almak("input.txt"));        Dosyalar.yazmak(Yollar.almak("output.txt"), çizgiler);    }}

kullanma System.IO;sınıf FileIOTest{    halka açık statik geçersiz Ana(dizi[] argümanlar)    {        var çizgiler = Dosya.ReadLines("input.txt");        Dosya.WriteAllLines("output.txt", çizgiler);    }}

Kitaplık tanımlı türlerin entegrasyonu

C #, kütüphane tanımlı türlerin, aşağıdaki örnekte gösterildiği gibi özel örtük / açık dönüştürmeleri ve operatör aşırı yüklemesini kullanarak mevcut türler ve işleçlerle entegre olmasına izin verir:

var Büyük sayı =    yeni BigInteger("123456789012345678901234567890");var Cevap = Büyük sayı.çarpmak(yeni BigInteger("42"));var Meydan = Büyük sayı.çarpmak(Büyük sayı);var toplam = Büyük sayı.Ekle(Büyük sayı);

var Büyük sayı =    BigInteger.Ayrıştır("123456789012345678901234567890");var Cevap = Büyük sayı*42;var Meydan = Büyük sayı*Büyük sayı;var toplam = Büyük sayı + Büyük sayı;

C # delegeleri ve eşdeğer Java yapıları

    // bir hedef sınıf    sınıf Hedef {        halka açık Boole targetMethod(Dize arg) {            // bir şey yap            dönüş doğru;        }    }    // kullanım    geçersiz bir şey yap() {        // hedef yöntemle bir hedef oluşturun        var hedef = yeni Hedef();        // yöntem referansını yakala        Fonksiyon<Dize, Boole> ivk = hedef::targetMethod;        // başvurulan yöntemi çağırır        Boole sonuç = ivk.uygulamak("argüman dizesi");    }

    // bir hedef sınıf    sınıf Hedef    {        halka açık bool TargetMethod(dizi arg)        {            // bir şey yap            dönüş doğru;        }    }    // kullanım    geçersiz Bir şey yap()    {        // hedef yöntemle bir hedef oluşturun        var hedef = yeni Hedef();        // daha sonraki çağrı için temsilciyi yakalayın        Func<dizi, bool> dlg = hedef.TargetMethod;        // temsilciyi çağır        bool sonuç = dlg("argüman dizesi");    }

Tip kaldırma

var a = İsteğe bağlı.nın-nin(42);var b = İsteğe bağlı.boş();// orElse (0), b'nin değeri null ise 0 döndürürvar c = a.almak() * b.orElse(0);

int? a = 42;int? b = boş;// c boş değeri alacak// çünkü * kaldırılmış ve işlenenlerden biri boşint? c = a * b;

Dinamik dillerle birlikte çalışabilirlik

Bu örnek, Java ve C # 'nin başka bir programlama dilinde uygulanan bir sınıf örneğini oluşturmak ve çağırmak için nasıl kullanılabileceğini gösterir. "Deepthought" sınıfı, Ruby programlama dili ve iki giriş değerini çarpan basit bir hesap makinesini temsil eder (a ve b) ne zaman Hesaplamak yöntem çağrılır. Geleneksel yönteme ek olarak, Java'da GraalVM, uygulanan herhangi bir programlama dilini çalıştırabilen sanal bir makine.

Bağlam çok dilli = Bağlam.newBuilder().allowAllAccess(doğru).inşa etmek();// RubyDeğer rubyArray = çok dilli.değerlendirme("yakut", "[1,2,42,4]");int RubyResult = rubyArray.getArrayElement(2).asInt();// PythonDeğer pythonArray = bağlam.değerlendirme("python", "[1,2,42,4]");int pythonResult = pythonArray.getArrayElement(2).asInt();// JavaScriptDeğer jsArray = çok dilli.değerlendirme("js", "[1,2,42,4]");int jsResult = jsArray.getArrayElement(2).asInt();// RDeğer rArray = çok dilli.değerlendirme("R", "c (1,2,42,4)");int rSonuç = rArray.getArrayElement(2).asInt();// LLVM (bu durumda C, ancak C ++, Go, Basic vb. Olabilir ...)Kaynak kaynak = Kaynak.newBuilder("llvm", yeni Dosya("C_Program.bc")).inşa etmek();Değer cpart = çok dilli.değerlendirme(kaynak);cpart.getMember("ana").yürütmek();

// motoru başlatvar çağrılabilir = yeni ScriptEngineManager().getEngineByName("jruby");var RubyFile = yeni Dosya Okuyucusu("Deepthought.rb");motor.değerlendirme(fr);

// motoru başlatvar Çalışma süresi = ScriptRuntime.CreateFromConfiguration();dinamik küreseller = Çalışma süresi.Küresel;Çalışma süresi.ExecuteFile("Deepthought.rb");

// "Derin Düşünce" hesap makinesinin yeni bir örneğini oluşturunvar hesaplamak = küreseller.Derin Düşünce.@yeni();// hesap makinesi giriş değerlerini ayarlahesaplamak.a = 6;hesaplamak.b = 7;// sonucu hesaplavar Cevap = hesaplamak.Hesaplamak();

// "Derin Düşünce" hesap makinesinin yeni bir örneğini oluşturunvar calcClass = motor.değerlendirme("Derin Düşünce");var hesaplamak = çağrılabilir.invokeMethod(calcClass, "yeni");// hesap makinesi giriş değerlerini ayarlaçağrılabilir.invokeMethod(hesaplamak, "a =", 6);çağrılabilir.invokeMethod(hesaplamak, "b =", 7);// sonucu hesaplavar Cevap = çağrılabilir.invokeMethod(hesaplamak, "Hesaplamak");

Fibonacci Dizisi

Bu örnek, Fibonacci Dizisi iki dil kullanılarak uygulanabilir. C # sürümü, C # avantajını kullanır jeneratör yöntemleri. Java sürümü şu avantajlardan yararlanır: Akış arayüz ve yöntem referansları. Hem Java hem de C # örneklerinde K&R tarzı sınıfların, yöntemlerin ve ifadelerin kod biçimlendirmesi için.

// Fibonacci dizisiAkış.oluşturmak(yeni Tedarikçi<Tamsayı>() {    int a = 0;    int b = 1;    halka açık Tamsayı almak() {        int temp = a;        a = b;        b = a + temp;        dönüş temp;    }}).limit(10).her biri için(Sistem.dışarı::println);

// Fibonacci dizisihalka açık IEnumerable<int> Fibonacci() {    int a = 0;    int b = 1;    süre (doğru)     {        Yol ver dönüş a;        (a, b) = (b, a + b);    }}

// ilk 10 Fibonacci numarasını yazdırınher biri için (var o içinde Fibonacci().Al(10)) {    Konsol.Yazı çizgisi(o);}

kayıt Çift(int x, int y);Akış.yinelemek(yeni Çift(0,1), p -> yeni Çift(p.y(), p.x() + p.y()))    .limit(10)    .harita(p -> p.x())    .her biri için(Sistem.dışarı::println);

Ayrıca bakınız

• C # ve VB.NET karşılaştırması
• Java ve C ++ Karşılaştırması
• Java ve .NET platformlarının karşılaştırılması
• Java programlama dili

Referanslar

Dış bağlantılar

• Moving to C# and the .NET Framework -de MSDN
• C# and Java: Comparing Programming Languages -de MSDN
• Java vs. C# – Code for Code Comparison
• Nine Language Performance Round-up
• Microsoft Geliştirici Ağı (MSDN): The C# Programming Language for Java Developers
• Standard ECMA-334 C# Language specification
• Java Language Specification (Sun)
• The State of C#: Is It Still a Viable Language?