L'équivalent de #define en Java?

Comme d'autres l'ont dit, il n'y a pas une telle chose comme #define/#ifdef en Java. Mais en ce qui concerne le problème d'avoir en option des bibliothèques externes, ce qui vous permettrait d'utiliser, le cas échéant, et de ne pas l'utiliser si ce n', à l'aide des classes de proxy peut être une option (si la bibliothèque d'interfaces ne sont pas trop gros).

J'ai dû le faire une fois pour le système Mac OS X d'extensions spécifiques pour AWT/Swing (qui se trouve dans com.apple.eawt.*). Les classes sont, bien sûr, que sur le chemin de classe si l'application est en cours d'exécution sur Mac OS. Pour être en mesure de les utiliser, mais permettent toujours de la même application pour être utilisé sur d'autres plates-formes, j'ai écrit simple des classes proxy, qui vient d'offrir les mêmes méthodes que l'original EAWT classes. En interne, les proxy utilisé une partie de la réflexion afin de déterminer si, en réalité, les classes ont été sur le chemin de classe et permettrait de passer à travers tous les appels de méthode. À l'aide de la java.lang.de réfléchir.Proxy de classe, vous pouvez même créer et de faire passer des objets d'un type défini dans la bibliothèque externe, sans l'avoir disponible au moment de la compilation.

Par exemple, le proxy pour com.apple.eawt.ApplicationListener ressemblait à ceci:

public class ApplicationListener {
private static Class<?> nativeClass;
static Class<?> getNativeClass() {
try {
if (ApplicationListener.nativeClass == null) {
ApplicationListener.nativeClass = Class.forName("com.apple.eawt.ApplicationListener");
}
return ApplicationListener.nativeClass;
} catch (ClassNotFoundException ex) {
throw new RuntimeException("This system does not support the Apple EAWT!", ex);
}
}
private Object nativeObject;
public ApplicationListener() {
Class<?> nativeClass = ApplicationListener.getNativeClass();
this.nativeObject = Proxy.newProxyInstance(nativeClass.getClassLoader(), new Class<?>[] {
nativeClass
}, new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
ApplicationEvent event = new ApplicationEvent(args[0]);
if (methodName.equals("handleReOpenApplication")) {
ApplicationListener.this.handleReOpenApplication(event);
} else if (methodName.equals("handleQuit")) {
ApplicationListener.this.handleQuit(event);
} else if (methodName.equals("handlePrintFile")) {
ApplicationListener.this.handlePrintFile(event);
} else if (methodName.equals("handlePreferences")) {
ApplicationListener.this.handlePreferences(event);
} else if (methodName.equals("handleOpenFile")) {
ApplicationListener.this.handleOpenFile(event);
} else if (methodName.equals("handleOpenApplication")) {
ApplicationListener.this.handleOpenApplication(event);
} else if (methodName.equals("handleAbout")) {
ApplicationListener.this.handleAbout(event);
}
return null;
}
});
}
Object getNativeObject() {
return this.nativeObject;
}
//followed by abstract definitions of all handle...(ApplicationEvent) methods
}

Tout cela n'a de sens que si vous avez juste besoin d'un peu de classes à partir d'une bibliothèque externe, parce que vous avez à faire tout par la réflexion au moment de l'exécution. Pour les grandes bibliothèques, vous avez probablement besoin d'un peu de manière à automatiser la génération de la procuration. Mais alors, si vous êtes vraiment à qui dépend d'un grand bibliothèque externe, vous devez juste besoin d'elle au moment de la compilation.

Commentaire par Peter Lawrey: (Désolé pour le modifier, il est très difficile de mettre le code dans un commentaire)

L'exemple suivant est générique par la méthode de sorte que vous n'avez pas besoin de connaître toutes les modalités. Vous pouvez aussi faire de ce générique en classe si vous avez seulement besoin d'un InvocationHandler classe codé de manière à couvrir tous les cas.

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
ApplicationEvent event = new ApplicationEvent(args[0]);
Method method = ApplicationListener.class.getMethod(methodName, ApplicationEvent.class);
return method.invoke(ApplicationListener.this, event);
}

OriginalL'auteur Simon Lehmann

En Java, on pourrait utiliser une variété d'approches pour atteindre le même résultat:

• L'Injection De Dépendance

• Les Annotations

• La réflexion

La Java façon est de mettre un comportement qui varie dans un ensemble de classes distinctes l'une abstraction par une interface, puis branchez la classe requise au moment de l'exécution. Voir aussi:

• Modèle de fabrique

• Le générateur de modèle

• Modèle de stratégie

OriginalL'auteur Vlad Gudim

Utiliser un constant:

Cette semaine, nous avons créer des constantes
qui ont tous les avantages de l'utilisation de
le préprocesseur C installations de
définir des constantes de compilation et
conditionnellement code compilé.

Java a réussi à se débarrasser de l'ensemble de la
notion d'un texte de préprocesseur (si
vous prenez Java comme un "descendant" de
C/C++). Nous pouvons, toutefois, obtenir les meilleures
les avantages d'au moins une partie de la C
préprocesseur fonctionnalités en Java:
et les constantes de compilation conditionnelle.

OriginalL'auteur Andrew Hare

"pour minimiser ma taille de l'exécutable"

Qu'entendez-vous par "la taille de l'exécutable"?

Si vous voulez dire la quantité de code chargé lors de l'exécution, puis vous pouvez conditionnellement classes de charge par le chargeur de classe. Si vous distribuez votre code alternatif n'importe quoi, mais c'est seulement chargé si la bibliothèque qu'il représente est manquant. Vous pouvez utiliser un Adaptateur (ou similaire) pour encapsuler l'API, de faire en sorte que presque tout votre code est exactement le même de toute façon, et l'une des deux classes wrapper est chargé en fonction de votre cas. La sécurité de Java SPI peut vous donner quelques idées de la façon dont cela peut être structuré et mis en œuvre.

Si tu parles de la taille de votre .fichier jar, vous pouvez le faire ci-dessus, mais parlez-en à vos développeurs comment dépouiller de l'inutile classes du pot, dans le cas où ils savent qu'ils ne vont pas être nécessaire.

OriginalL'auteur Steve Jessop

En fonction de ce que vous faites (pas assez d'informations), vous pourriez faire quelque chose comme ceci:

interface Foo
{
void foo();
}
class FakeFoo
implements Foo
{
public void foo()
{
//do nothing
}
}
class RealFoo
{
public void foo()
{
//do something
}
}

et de fournir ensuite une classe abstraite de l'instanciation:

class FooFactory
{
public static Foo makeFoo()
{
final String   name;
final FooClass fooClass;
final Foo      foo;
name     = System.getProperty("foo.class");
fooClass = Class.forName(name);
foo      = (Foo)fooClass.newInstance();
return (foo);
}
}

Puis exécuter java avec -Dfoo.nom=RealFoo|FakeFoo

Ignoré la gestion des exceptions dans le makeFoo méthode et vous pouvez le faire par d'autres moyens... mais l'idée est la même.

De cette façon, vous compilez les deux versions de l'Foo sous-classes et de permettre au développeur de choisir lors de l'exécution qu'ils souhaitent utiliser.

OriginalL'auteur TofuBeer

S'il permet d'avoir un regard sur j2me polonais ou En utilisant les directives de préprocesseur dans BlackBerry JDE plugin pour eclipse?

c'est pour les mobiles app, mais cela peut être réutilisé non ?

OriginalL'auteur RzR