Quelles sont les principales différences entre C # et Java?

Je veux juste clarifier une chose. Ce n'est pas une question sur laquelle on est meilleur, cette partie que je laisse à quelqu'un d'autre pour en discuter. Je m'en fiche. On m'a posé cette question lors de mon entretien d'embauche et j'ai pensé qu'il pourrait être utile d'en apprendre un peu plus.

Ce sont ceux que je pourrais trouver:

• Java est "indépendant de la plate-forme". Eh bien, de nos jours, on pourrait dire qu'il y a le projet Mono , donc C # pourrait aussi être considéré, mais je pense que c'est un peu exagéré. Pourquoi? Eh bien, lorsqu'une nouvelle version de Java est terminée, elle est simultanément disponible sur toutes les plates-formes qu'elle prend en charge, en revanche combien de fonctionnalités de C # 3.0 manquent encore dans l'implémentation Mono? Ou est-ce vraiment CLR vs JRE que nous devrions comparer ici?
• Java ne prend pas en charge les événements et les délégués. Pour autant que je sache.
• En Java, toutes les méthodes sont virtuelles
• Outils de développement: je crois qu'il n'y a pas encore un tel outil que Visual Studio. Surtout si vous avez travaillé avec des éditions en équipe, vous comprendrez ce que je veux dire.

Veuillez en ajouter d'autres que vous jugez pertinentes.

Mise à jour: Je viens de penser, Java n'a pas quelque chose comme des attributs personnalisés sur les classes, les méthodes, etc. Ou est-ce le cas?

Comparaison de Java 7 et C # 3

(Certaines fonctionnalités de Java 7 ne sont pas mentionnées ici, mais l' usingavantage de toutes les versions de C # sur Java 1-6 a été supprimé.)

Tout votre résumé n'est pas correct:

• En Java, les méthodes sont virtuelles par défaut mais vous pouvez les rendre définitives. (En C #, ils sont scellés par défaut, mais vous pouvez les rendre virtuels.)
• Il existe de nombreux IDE pour Java, à la fois gratuits (par exemple Eclipse, Netbeans) et commerciaux (par exemple IntelliJ IDEA)

Au-delà de cela (et ce qui est déjà dans votre résumé):

• Les génériques sont complètement différents entre les deux; Les génériques Java ne sont qu'une «astuce» à la compilation (mais utile à cela). En C # et .NET, les génériques sont également conservés au moment de l'exécution et fonctionnent pour les types de valeur ainsi que les types de référence, en conservant l'efficacité appropriée (par exemple, un List<byte>comme byte[]support, plutôt qu'un tableau d'octets encadrés).
• C # n'a pas vérifié les exceptions
• Java ne permet pas la création de types de valeurs définis par l'utilisateur
• Java n'a pas d'opérateur et de surcharge de conversion
• Java n'a pas de blocs d'itérateurs pour une implémentation simple des itérateurs
• Java n'a rien de tel que LINQ
• En partie en raison de l'absence de délégués, Java n'a rien à voir avec les méthodes anonymes et les expressions lambda. Les classes internes anonymes remplissent généralement ces rôles, mais de manière clouée.
• Java n'a pas d'arbres d'expression
• C # n'a pas de classes internes anonymes
• C # n'a pas du tout les classes internes de Java, en fait - toutes les classes imbriquées en C # sont comme les classes imbriquées statiques de Java
• Java n'a pas de classes statiques (qui n'ont pas de constructeurs d'instances et ne peuvent pas être utilisées pour des variables, des paramètres, etc.)
• Java n'a pas d'équivalent aux types anonymes C # 3.0
• Java n'a pas de variables locales implicitement typées
• Java n'a pas de méthodes d'extension
• Java n'a pas d'expressions d'initialisation d'objet et de collection
• Les modificateurs d'accès sont quelque peu différents - en Java, il n'y a (actuellement) aucun équivalent direct d'un assemblage, donc aucune idée de visibilité "interne"; en C # il n'y a pas d'équivalent à la visibilité "par défaut" en Java qui prend en compte l'espace de nom (et l'héritage)
• L'ordre d'initialisation en Java et C # est subtilement différent (C # exécute les initialiseurs de variables avant l'appel chaîné au constructeur du type de base)
• Java n'a pas de propriétés dans le cadre du langage; ils sont une convention de méthodes get / set / is
• Java n'a pas l'équivalent du code "dangereux"
• L'interopérabilité est plus facile en C # (et .NET en général) que JNI de Java
• Java et C # ont des idées quelque peu différentes des énumérations. Les Java sont beaucoup plus orientés objet.
• Java n'a pas de directives de préprocesseur (#define, #if etc en C #).
• Java n'a pas d'équivalent de C # refet outpour passer des paramètres par référence
• Java n'a pas d'équivalent de types partiels
• Les interfaces C # ne peuvent pas déclarer de champs
• Java n'a pas de types entiers non signés
• Java ne prend pas en charge le langage pour un type décimal. (java.math.BigDecimal fournit quelque chose comme System.Decimal - avec des différences - mais il n'y a pas de support de langue)
• Java n'a pas d'équivalent de types de valeur nullable
• La boxe en Java utilise des types de référence prédéfinis (mais "normaux") avec des opérations particulières sur eux. La boxe en C # et .NET est une affaire plus transparente, avec un type de référence créé pour la boxe par le CLR pour tout type de valeur.

Ce n'est pas exhaustif, mais il couvre tout ce que je peux penser de manière autonome.

Ce qui suit est une grande référence en profondeur par Dare Obasanjo sur les différences entre C # et Java. Je me retrouve toujours à me référer à cet article lorsque je bascule entre les deux.

http://www.25hoursaday.com/CsharpVsJava.html

C # a des propriétés automatiques incroyablement pratiques et elles aident également à garder votre code plus propre, du moins lorsque vous n'avez pas de logique personnalisée dans vos getters et setters.

Caractéristiques de C # absent en Java • C # comprend plus de types primitifs et la fonctionnalité pour intercepter les exceptions arithmétiques.

• Comprend un grand nombre de fonctionnalités de notation sur Java, dont beaucoup, telles que la surcharge des opérateurs et les transformations définies par l'utilisateur, sont déjà familières à la grande communauté des programmeurs C ++.

• La gestion des événements est un «citoyen de première classe» - elle fait partie du langage lui-même.

• Permet la définition de "structures", qui sont similaires aux classes mais peuvent être allouées sur la pile (contrairement aux instances de classes en C # et Java).

• C # implémente des propriétés dans le cadre de la syntaxe du langage.

• C # permet aux instructions switch de fonctionner sur les chaînes.

• C # permet des méthodes anonymes fournissant une fonctionnalité de fermeture.

• C # permet à l'itérateur qui utilise des co-routines via un mot-clé de rendement de style fonctionnel.

• C # prend en charge les paramètres de sortie, aidant au retour de plusieurs valeurs, une fonctionnalité partagée par C ++ et SQL.

• C # a la capacité d'alias les espaces de noms.

• C # a "Implicit Member Implementation" qui permet à une classe d'implémenter spécifiquement les méthodes d'une interface, distinctes de ses propres méthodes de classe. Cela lui permet également d'implémenter deux interfaces différentes qui se trouvent avoir une méthode du même nom. Les méthodes d'une interface n'ont pas besoin d'être publiques; ils ne peuvent être rendus accessibles que via cette interface.

• C # assure l'intégration avec COM.

• Suivant l'exemple de C et C ++, C # autorise l'appel par référence pour les types primitifs et de référence.

Fonctionnalités de Java absent en C #

• Le mot clé strictfp de Java garantit que le résultat des opérations en virgule flottante reste le même sur toutes les plateformes.

• Java prend en charge les exceptions vérifiées pour une meilleure application du recouvrement et de la gestion des erreurs.

Une autre bonne ressource est http://www.javacamp.org/javavscsharp/ Ce site énumère de nombreux exemples qui illustrent presque toutes les différences entre ces deux langages de programmation.

À propos des attributs, Java a des annotations, qui fonctionnent presque de la même manière.

Génériques:

Avec les génériques Java, vous n'obtenez en fait aucune de l'efficacité d'exécution que vous obtenez avec .NET car lorsque vous compilez une classe générique en Java, le compilateur supprime le paramètre type et remplace Object partout. Par exemple, si vous avez une Foo<T>classe, le compilateur java génère du code d'octet comme s'il étaitFoo<Object> . Cela signifie que le casting et la boxe / unboxing devront être effectués en arrière-plan.

Je joue avec Java / C # depuis un certain temps maintenant et, à mon avis, les principales différences au niveau du langage sont, comme vous l'avez souligné, les délégués.

Veuillez parcourir le lien ci-dessous msdn.microsoft.com/en-us/library/ms836794.aspx Il couvre à la fois la similitude et la différence entre C # et java