Fondamentalement, je crois que le Java concepteurs fait une erreur quand ils ont conçu la langue, et il est trop tard pour le corriger en raison de la compatibilité des enjeux. Oui, elle peut conduire à de très trompeur code. Oui, vous devriez éviter. Oui, vous devriez assurez-vous que votre IDE est configuré de manière à la traiter comme une erreur, de l'OMI. Si jamais vous la conception d'un langage de vous-même, l'ours à l'esprit, comme un exemple du genre de chose à ne pas faire :)
Juste pour répondre à DJClayworth point, voici ce qui est autorisé en C#:
public class Foo
{
public static void Bar()
{
}
}
public class Abc
{
public void Test()
{
// Static methods in the same class and base classes
// (and outer classes) are available, with no
// qualification
Def();
// Static methods in other classes are available via
// the class name
Foo.Bar();
Abc abc = new Abc();
// This would *not* be legal. It being legal has no benefit,
// and just allows misleading code
// abc.Def();
}
public static void Def()
{
}
}
Pourquoi dois-je pense que c'est trompeur? Parce que si je regarde le code someVariable.SomeMethod() - je m'attendre à l'utilisation de la valeur de someVariable. Si SomeMethod() est une méthode statique, que l'attente est invalide; le code est tromper moi. Comment peut éventuellement être une bonne chose?
Bizarrement assez, Java ne vous laissent pas utiliser potentiellement variable non initialisée à l'appel d'une méthode statique, malgré le fait que la seule information dont il va utiliser est le type déclaré de la variable. C'est incohérent et inutile mess. Pourquoi permet-il?
EDIT: Cette modification est une réponse à Clayton réponse, qui prétend qu'il permet à l'héritage pour les méthodes statiques. Il n'a pas. Les méthodes statiques ne sont pas polymorphes. Voici une courte mais complète du programme est de démontrer que:
class Base
{
static void foo()
{
System.out.println("Base.foo()");
}
}
class Derived extends Base
{
static void foo()
{
System.out.println("Derived.foo()");
}
}
public class Test
{
public static void main(String[] args)
{
Base b = new Derived();
b.foo(); // Prints "Base.foo()"
b = null;
b.foo(); // Still prints "Base.foo()"
}
}
Comme vous pouvez le voir, le temps d'exécution de la valeur de b est complètement ignoré.
