Jeu des 7 différences avec le C# (1 question, 1 troll) - Page 1

Il y a longtemps que je n'ai pas fait de JAVA, et je me demandais :
Est ce qu'il faut déclarer un double comme en C# : double foo = new double();
Pour le JAVA je ne sais plus, mais parfois, je trouve que le C#, c'est de la programmation objet "extrême".
Pas besoin de m'expliquer pourquoi c'est comme ça, je le sais, et je trouve ça très bien, mais je trouve le sujet intéressant, et cette notation très caractéristique d'une volonté "jusqu'au boutiste".
La vraie question étant : qui est le plus extrémiste de la POO des deux?

C'est pas propre au fonctionnement du GC qui réclame que tu déclares explicitement tes réservations mémoire pour chaque variable utilisée ?

Kochise

("double foo = 1.0;" est tout à fait valide en C#)

GUNNM (./1) :
double foo = new double();

C'est quoi ce truc de malade ?!?
Rappelez-moi de ne jamais faire de C#

@iwannabeamaki > Topic killer!
Folco > Tu aurais tord, tu commences et après tu peux plus t'en empecher tellement c'est intuitif. Rien à voir avec le "patch objet" du C.

./2 > Non, rien à voir (Le seul moment où tu es *obligé* d'assigner une variable c'est dans les fonctions: écrire avant de lire)
En fait, le GC ne te réclame rien du tout, vu qu'il est là pour tout faire tout seul… Par contre ça ne t'interdit pas de travailler avec si tu veux mieux contrôler ce qu'il fait.
./3 > (Et encore l'assignation n'est pas forcément nécessaire…)

GUNNM (./1) :
Est ce qu'il faut déclarer un double comme en C# : double foo = new double();

C'est plutôt ce qu'il ne faut pas faire.
Et pour répondre à ta « vraie » question, il n'y a pas de « plus extrêmiste ». Le C# a été très largement inspiré du Java, tout en prenant de bonnes idées venant d'ailleurs (C++, COM, VB, Delphi, …). Tout au plus le C# est plus complet et plus consistant dans ses choix, mais le Java reprend petit à petit les mêmes fonctionnalités en plus ou moins bien. (par exemple pour les types génériques c'est clairement en moins bien…)

Ce qu'il ne faut pas faire?! Pourquoi pas ... même si je l'ai vus un peu partout, livres et msdn. Mais dis nous pourquoi tu dis ça.

(par exemple pour les types génériques c'est clairement en moins bien…)

Comme l'exemple que je viens de donner, ou pour d'autres raisons?

D'abord, parce que new double() == 0.
Ensuite parce qu'initialiser une variable à sa valeur par défaut ne sert a rien.
Alors on écrit « double d; » ou « double d = 10; », et on évite tant que possible « double d = 0; ». Ecrire le = 0 clarifie éventuellement le code (par exemple si beaucoup de paramètres d'une simulation sont définis à la suite), mais les types sont toujours initialisés à 0 à l'allocation, donc par conséquent, tous les champs sont initialisés à 0…
Et puis ce n'est pas parce qu'on te permet (ce qui est tout à fait sensé) d'écrire « new double() » que tu dois absolument le faire… Tu ne vas pas écrire « int i = new int(); » à chaque fois aussi quand même ?

GUNNM (./7) :
Comme l'exemple que je viens de donner, ou pour d'autres raisons?

En fait… ça n'a aucun rapport
Et puis de nos jour je sais que le Java (version 1.7 ?) gère l'autoboxing dans certains cas, donc tu peux peut-être écrire « double d = new Double(); »

D'abord, parce que new double() == 0.

Et alors? C'est pas du natif et quand bien même, il n'y a pas faute.

Tu ne vas pas écrire « int i = new int(); » à chaque fois aussi quand même ?

Ben si, aussi. Tu déclares les doubles différemment des int toi? Il me semble que c'est ce qui est préconisé par Ms. J'ai la flemme de chercher sur MSDN, préférant troller, mais la prochaine fois que je vois ça sur MSDN je le posterais ici. Je me demande quand même si ce n'est pas tout simplement la bonne façon de faire, puisque c'est celle que le compilateur comprendra, car c'est la plus prévisible.

et on évite tant que possible « double d = 0; »

Je n'ai jamais dis ça, mais ça ne me parait pas plus bête que « double d = 1.0; ».

GUNNM (./7) :
Comme l'exemple que je viens de donner, ou pour d'autres raisons?

En fait… ça n'a aucun rapport

Pourquoi considères-tu que Java reprend les idées du C# sur les types génériques? Ça éveille ma curiosité. Je savais que JAVA reprenais aussi des bonnes idées du C#, et ils ont raison, c'est de bonne guerre.Pour la surcharge? Je ne suis pas au faît du JAVA.

Java (version 1.7 ?) gère l'autoboxing

Ca existe chez MS en VBA depuis 10 ans et c'est pénible. Tu tapes le nom d'une variable, et il le corrige à la volée. C'est sympas 10 minutes et puis c'est vite chiant.

GUNNM (./9) :

Java (version 1.7 ?) gère l'autoboxing

Ca existe chez MS en VBA depuis 10 ans et c'est pénible. Tu tapes le nom d'une variable, et il le corrige à la volée. C'est sympas 10 minutes et puis c'est vite chiant.

Euuuh il a parlé d'autoboxing (qui est une spécificité du langage), pas d'autocomplétion (qui est une spécificité de l'IDE qui n'a pas grand chose à voir).

Je rappelle au passage que new double() ne fait ni boxing, ni allocation sur le tas managé.

"object o=1.0;" fait de l'autoboxing, par contre.

En gros, "double d = new double();" en C# est l'équivalent de "double d = double();" en C++: Tout le monde utilise zéro à la place. Pourquoi pas écrire "double d = default(double);" pendant que vous y êtes?

C'est pas pareil. Contrairement au constructeur des types valeur qui sont d'un intérêt discutable, le mot-clé "default" est très utile pour initialiser une valeur dont on ne connait pas le type, dans une classe générique.

Je sais. Mais hors d'un type générique, l'intérêt est tout aussi limité.

Alors la comparaison est stupide, puisqu'il n'y a aucun contexte (à ma connaissance) où le constructeur double est utile ^^

En effet, puisque le type double est un type natif .NET (au même titre que float, [u]long, [u]int, [s]byte et char), donc cette instruction peut être directement utilisée…
Au passage, l'appel d'un constructeur par défaut sur un type valeur correspond à l'instruction initobj, et en aucun cas à l'exécution d'un code « personnalisé ». C'est à priori aussi l'instruction utilisée par default(T) en C#. (Puis tiens en fait c'est confirmé par les commentaires en bas de la page c'est encore mieux :] )

GoldenCrystal (./8) :
Et puis de nos jour je sais que le Java (version 1.7 ?) gère l'autoboxing dans certains cas

Depuis le 1.5

Ah c'est si vieux que ça ? (À vrai dire mon hésitation était plutôt entre 1.6 et 1.7 )
J'avais souvenir d'avoir fait un peu de Java 5 (ou alors était-ce du Java 4 ? ) il y a longtemps et que ça m'avait brisé les couilles de pas pouvoir caser des int dans des Vector… Cela dit, l'autoboxing ne doit pas fonctionner vers ou à partir du type Object directement, ce qui pourrait expliquer des choses

http://download.oracle.com/javase/1.5.0/docs/relnotes/features.html

Autoboxing avec un Object ? Ça donne quoi en pratique ?

(Java 7 n'est pas sorti, hein )

(Ouais bon il est en développement soit, mais je ne fais pas de Java alors ça me passe au dessus de la tête. En fait il me semblait avoir vu une installation de Java 1.7 sur mon Windows, mais à vrai dire je ne regarde jamais vraiment ce qui s'installe. En général je finis par mettre à jour simplement parce que l'icône de merde qui squatte ma barre des tâches me tape sur le système à chaque démarrage.)
Sinon je voulais dire que tu ne dois pas pouvoir faire int i = 1; Object o = i;Alors que que int i = 1; Integer I = i; doit fonctionner… Ça doit être ça non ?
(Sinon je ne sais plus comment ça aurait pu me briser autant les couilles… Peut-être était-ce du Java 4 (De toutes façons on n'utilisait pas encore les types génériques alors l'un ou l'autre…))

Je ne crois pas que ta v1 fonctionne, effectivement. Mais je trouve que c'est une drôle d'idée !

(pas de problème pour JAVA 7, je faisais la remarque, c'est tout )

SimpleName()) ; System.out.println(o2+o2.getClass().getSimpleName()) ; } }

Ah, ben si, même ta v1 fonctionne en fait (j'ai testé en 1.6, en 1.5 je ne sais pas)public class GC
{
   public static void main( String[] args )
   {
      int i= 42 ;
      Object o= i ;
      Object o2= 0x42 ;

      System.out.println(i) ;
      System.out.println(o+o.getClass().get

42
42Integer
66Integer

./20 > Bah, c'est ce qui te permet en C# d'appeler une fonction comme ça:Console.WriteLine("Int32 Value: {0}, Double Value: {1}, String Value: \"{2}\"", 1234, 0.5, "Blabla")
Ou bien de faire un appel dynamiqueinternal T CreateT(float x, float y, float w, float h) { return Activator.CreateInstance(typeof(T), this, x, y, w, h) as T; } // PS: C'est équivalent à Activator.CreateInstance(typeof(T), new object[] { this, x, y, w, h })Alors certes c'est « crade » à cause du boxing et du tableau créé implicitement pour une utilisation unique, mais au moins c'est clair et lisible. (Puis pour le second exemple c'est lent à cause de l'introspection, mais il y a évidemment d'autres moyens efficaces de faire la même chose… )
./21 > Ben du coup… je devais être configuré en Java 4…

OK merci.

(ou 1.2 )

Bah moi j'ai appris en 1.2 et je n'en ai pas fait depuis, alors