Documentation de référence sur la traduction

Types

  • Pour les types primitifs, J2ObjC a défini des typesdefdefs.
  • Pour les types de classes classiques, le package est précédé d'un camel case et son nom est précédé du nom de la classe.
  • Pour le type d'objet de base et toutes les variables de type, "id" est utilisé.
  • Quelques types principaux de Java sont mappés à des types de base. (par exemple, Chaîne à NSString)
  • Pour les champs "volatils", J2ObjC comporte davantage de types qui utilisent les types C11 _Atomic(...).
  • Pour les types internes, le nom de la classe interne est ajouté au nom externe avec un trait de soulignement.
Type Java Type Objective-C Type volatile Objective-C
booléen booléen volatile_jboolean
car. Jchar volatile_jchar
octet octet volatile_joctet
court jshort volatile_jshort
int Jint volatil_jint
long jlong volatile_jlong
float Jfloat volatile_jfloat
double jdouble volatile_jdouble
java.lang.Object id volatile_id
variables de type id volatile_id
java.lang.String NSString* volatile_id
java.lang.Number NSNumber* volatile_id
java.lang.Cloneable NSCopying* volatile_id
foo.bar.coucou FooBarMumble* volatile_id
foo.bar.Mumber$Inner FooBarMumble_Inner* volatile_id

Méthodes

Les méthodes Objective-C diffèrent des méthodes Java de deux manières importantes. D'un point de vue syntaxique, ils intègrent les paramètres entre les composants du sélecteur de méthode. Comme Java, les méthodes Objective-C ne sont pas compatibles avec la surcharge. Ces problèmes sont résolus en intégrant les types de paramètres dans le sélecteur généré. Cela est nécessaire pour éviter les conflits de noms entre les méthodes Java surchargées.

L'API générée comporte trois types de méthodes Java: les méthodes d'instance, les méthodes statiques et les constructeurs. Les méthodes d'instance se traduisent en méthodes d'instance Objective-C. Les méthodes et constructeurs statiques se traduisent en fonctions de type C, mais ajoutent également des wrappers Objective-C pour fournir une API plus connue aux développeurs.

Méthodes des instances

Les noms de méthodes sont générés comme suit:

  • Aucune méthode de paramètre n'est modifiée
  • Un ou plusieurs paramètres utilisent le modèle suivant :
    • <java name>With<1st param keyword>:with<2nd param keyword>:with<3rd param keyword>:
  • Règles relatives aux mots clés des paramètres :
    • Pour les types primitifs, le mot clé est le nom en majuscules de la primitive Java. (par exemple, "Char")
    • Pour les types non primitifs, le mot clé correspond au nom complet du type camel case. (par exemple, "ComGoogleFoo")
    • Pour les types "Tableau", "Tableau" est ajouté au mot clé du type d'élément.
Exemple de code Java
interface Foo {
  void bar();
  String bar(int i);
  java.util.List bar(String s, long[] l);
}
Exemple Objective-C
- (void)bar;

- (NSString *)barWithInt:(jint)i;

- (id<JavaUtilList>)barWithNSString:(NSString *)s
                      withLongArray:(IOSLongArray *)l;

Méthodes statiques

Une méthode de classe Objective-C est ajoutée suivant les mêmes règles de dénomination que les méthodes d'instance.

Une fonction de style C est ajoutée à l'aide des règles de dénomination suivantes:

  • Commencez avec le sélecteur Objective-C généré. (par exemple, barWithInt:)
  • Remplacez les deux-points par des traits de soulignement. (par exemple, barWithInt_)
  • Ajoutez un trait de soulignement au début du nom de la classe. (par exemple, ComGoogleFoo_barWithInt_)
Exemple de code Java
package com.google;
class Foo {
  static boolean bar() { ... }
  static double bar(int[] i) { ... }
  static void bar(String s, boolean b) { ... }
}
Exemple Objective-C
@interface Foo : NSObject

+ (jboolean)bar;

+ (jdouble)barWithIntArray:(IOSIntArray *)i;

+ (void)barWithNSString:(NSString *)s
            withBoolean:(jboolean)b;

@end

FOUNDATION_EXPORT jboolean ComGoogleFoo_bar();

FOUNDATION_EXPORT jdouble ComGoogleFoo_barWithIntArray_(IOSIntArray *i);

FOUNDATION_EXPORT void ComGoogleFoo_barWithNSString_withBoolean_(NSString *s, jboolean b);

Constructeurs

Conformément à la convention Objective-C, une méthode d'instance init est ajoutée. Si le constructeur comporte des paramètres, la même règle de dénomination que les méthodes d'instance est utilisée.

Trois fonctions de style C sont ajoutées:

  • La première fonction accepte un objet nouvellement alloué comme premier paramètre. Cette fonction est généralement utilisée pour les appels provenant d'un constructeur de sous-classe. Cela suit les mêmes règles de dénomination que les méthodes statiques. (où "init" est le nom de la méthode)
  • Deux fonctions sont ajoutées pour allouer et initialiser le nouvel objet. Ils se distinguent par leur préfixe :
    • La fonction create_ renvoie un objet libéré automatiquement.
    • La fonction new_ renvoie un objet conservé.
Exemple de code Java
package com.google;
class Foo {
  Foo() { ... }
  Foo(Object a, Object b) { ... }
}
Exemple Objective-C
@interface ComGoogleFoo : NSObject

- (instancetype)init;

- (instancetype)initWithId:(id)a
                    withId:(id)b;

@end

FOUNDATION_EXPORT void ComGoogleFoo_init(ComGoogleFoo *self);

FOUNDATION_EXPORT ComGoogleFoo *new_ComGoogleFoo_init() NS_RETURNS_RETAINED;

FOUNDATION_EXPORT ComGoogleFoo *create_ComGoogleFoo_init();

FOUNDATION_EXPORT void ComGoogleFoo_initWithId_withId_(ComGoogleFoo *self, id a, id b);

FOUNDATION_EXPORT ComGoogleFoo *new_ComGoogleFoo_initWithId_withId_(id a, id b) NS_RETURNS_RETAINED;

FOUNDATION_EXPORT ComGoogleFoo *create_ComGoogleFoo_initWithId_withId_(id a, id b);

Champs

Champs d'instance (non statiques)

Les variables d'instance Java deviennent des variables d'instance Objective-C. Le nom est identique avec un trait de soulignement à la fin. Les champs primitifs déclarés "final" sont un cas particulier et ne sont pas traduits en variables d'instance.

  • Vous pouvez accéder directement aux champs à l'aide de la syntaxe "->".
  • Les champs primitifs peuvent être définis directement.
    • Les primitives finales sont considérées comme des constantes statiques. (voir Champs statiques).
  • Les champs non primitifs doivent être définis à l'aide de la fonction setter fournie :
    • ClassName_set_fieldName_(instance, value)
Exemple de code Java
package com.google;
class Foo {
  public int myInt;
  public String myString;
}
Exemple Objective-C
Foo *foo = [[Foo alloc] init];

// Access a primitive field.
i = foo->myInt_;

// Set a primitive field.
foo->myInt_ = 5;

// Access a non-primitive field.
NSString *s = foo->myString_;

// Set a non-primitive field.
ComGoogleFoo_set_myString_(foo, @"bar");

Champs statiques

Les variables statiques doivent être accessibles à l'aide des fonctions getter et setter fournies. Ces fonctions d'accesseur garantissent l'initialisation de la classe avant l'accès à la variable.

  • Accéder à un champ statique
    • ClassName_get_fieldName()
  • Attribuez un champ statique (non final)
    • ClassName_set_fieldName()
  • Obtenir un pointeur sur un champ statique primitif
    • ClassName_getRef_fieldName()
    • Disponible uniquement pour les champs non finaux et non volatiles.

L'accès direct aux champs primitifs finaux (constants) est sécurisé, car leur valeur ne dépend pas de l'initialisation de la classe.

  • ClassName_fieldName
Exemple de code Java
package com.google;
class Foo {
  public static final MY_FINAL_INT = 5;
  public static int myInt;
  public static String myString;
}
Exemple Objective-C
// Access a primitive constant field.
jint i = ComGoogleFoo_MY_FINAL_INT;   // No class initialization
i = ComGoogleFoo_get_MY_FINAL_INT();  // Class initialization

// Access a primitive field.
i = ComGoogleFoo_get_myInt();

// Set a primitive field.
ComGoogleFoo_set_myInt(5);

// Access a non-primitive field.
NSString *s = ComGoogleFoo_get_myString();

// Set a non-primitive field.
ComGoogleFoo_set_myString(@"bar");

Enums

J2ObjC génère deux types pour chaque énumération Java. Un type de classe Objective-C est généré et fournit toutes les fonctionnalités d'une énumération Java. De plus, une énumération C est générée à l'aide de la macro NS_ENUM du framework Foundation. Le type de classe Objective-C est utilisé par toutes les API générées. L'énumération C est utile comme valeurs constantes pour une instruction switch ou comme type de stockage.

Les types d'énumération générés sont nommés comme suit:

  • La classe Objective-C est nommée à l'aide de la même règle qu'une classe Java classique. (voir la section Types).
  • L'énumération C est nommée en tant que classe Java standard avec un suffixe "_Enum".

Les constantes d'énumération sont accessibles comme des champs statiques.

Exemple de code Java
package com.google;
enum Color {
  RED, GREEN, BLUE
}
Exemple d'en-tête Objective-C
typedef NS_ENUM(NSUInteger, ComGoogleColor_Enum) {
  ComGoogleColor_Enum_RED = 0;
  ComGoogleColor_Enum_GREEN = 1;
  ComGoogleColor_Enum_BLUE = 2;
};

@interface ComGoogleColor : JavaLangEnum < NSCopying >
+ (IOSObjectArray *)values;
+ (ComGoogleColor *)valueOfWithNSString:(NSString *)name;
@end

inline ComGoogleColor *ComGoogleColor_get_RED();
inline ComGoogleColor *ComGoogleColor_get_GREEN();
inline ComGoogleColor *ComGoogleColor_get_BLUE();

// Provides conversion from ComGoogleColor_Enum values.
FOUNDATION_EXPORT ComGoogleColor *ComGoogleColor_fromOrdinal(NSUInteger ordinal);