Documentation de référence sur la traduction

Types

  • Pour les types primitifs, J2ObjC a défini des typesdefs de style JNI.
  • Pour les types de classes classiques, le package est en Camel Case ("casse de chameau") et 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 Java principaux sont mappés aux types de fondation. (par exemple, chaîne en NSString)
  • Pour les champs déclarés comme "volatils", J2ObjC dispose d'un plus grand nombre de définitions de type utilisant les types C11 _Atomic(...).
  • Pour les types internes, le nom de la classe interne est ajouté par un trait de soulignement au nom externe.
Type Java Type Objective-C Type volatile Objective-C
booléen jbooléen volatile_jboolean
car. Jchar volatile_jchar
octet Joctet volatile_jbyte
court jshort volatile_jshort
int jint volatile_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 NSCopy* volatile_id
foo.bar.Mumble FooBarMumble* volatile_id
foo.bar.Mumber$Inner FooBarMumble_Inner* volatile_id

Méthodes

Les méthodes Objective-C diffèrent des méthodes Java sur deux points essentiels. La syntaxe est la suivante : différent, en intégrant les paramètres entre les composants du sélecteur de méthode. Objectif C ne sont pas compatibles avec la surcharge, contrairement à Java. Ces différences sont résolues en intégrant types de paramètres dans le sélecteur généré. Cela est nécessaire pour éviter des conflits de noms entre méthodes Java surchargées.

Il existe trois types de méthodes Java qui diffèrent dans leur API générée: les méthodes d'instance, les méthodes statiques les méthodes et les constructeurs. Les méthodes d'instance se traduisent par des méthodes d'instance Objective-C. Statique les méthodes et constructeurs se traduisent en fonctions de style C, mais ajoutent également des wrappers Objective-C aux fournir une API plus familière aux développeurs Objective-C.

Méthodes des instances

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

  • Les méthodes sans paramètre restent inchangées
  • Un ou plusieurs paramètres utilisent le format suivant: <ph type="x-smartling-placeholder">
      </ph>
    • <java name>With<1st param keyword>:with<2nd param keyword>:with<3rd param keyword>:
  • Règles concernant les mots clés de paramètres: <ph type="x-smartling-placeholder">
      </ph>
    • Pour les types primitifs, le mot clé correspond au nom en majuscules de la primitive Java. (par exemple, "Caractère")
    • Pour les types non primitifs, le mot clé correspond au nom de type complet en Camel Case ("casse de chameau"). (par exemple, "ComGoogleFoo")
    • Pour les types ARRAY, "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 en suivant les mêmes règles de dénomination que les méthodes d'instance.

Une fonction de style C est ajoutée en utilisant les règles de dénomination suivantes:

  • Commencez par le sélecteur Objective-C généré. (par exemple, barWithInt:)
  • Remplacez les deux-points par des traits de soulignement. (par exemple, barWithInt_)
  • Ajoutez le nom de la classe en préfixe, délimité par un trait de soulignement. (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 possède , 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é pour appeler à partir d'un constructeur de sous-classe. Les règles de dénomination sont les mêmes que pour les méthodes. (où "init" est le nom de la méthode)
  • Deux fonctions sont ajoutées pour allouer et initialiser le nouvel objet. On les distingue par leur préfixe: <ph type="x-smartling-placeholder">
      </ph>
    • 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, suivi d'un trait de soulignement. Champs primitifs déclarés "final" constituent un cas particulier et ne sont pas traduits variables.

  • Les champs sont directement accessibles en utilisant "->" syntaxe.
  • Les champs primitifs peuvent être définis directement.
    • Les primitives finales (constantes) sont traduites comme des constantes statiques. (voir Champs statiques).
  • Les champs non primitifs doivent être définis à l'aide de la fonction setter fournie: <ph type="x-smartling-placeholder">
      </ph>
    • 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

Vous devez accéder aux variables statiques à l'aide des fonctions getter et setter fournies. Ces fonctions d'accesseur garantissent que la classe a été initialisée avant l'accès à la variable.

  • Accéder à un champ statique <ph type="x-smartling-placeholder">
      </ph>
    • ClassName_get_fieldName()
  • Attribuer un champ statique (non final) <ph type="x-smartling-placeholder">
      </ph>
    • ClassName_set_fieldName()
  • Obtenir un pointeur vers un champ statique primitif <ph type="x-smartling-placeholder">
      </ph>
    • ClassName_getRef_fieldName()
    • Disponible uniquement pour les champs non finaux et non volatiles.

Les champs primitifs finaux (constants) sont directement accessibles en toute sécurité, 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é, toutes les fonctionnalités d'une énumération Java. De plus, une énumération C est générée à l'aide de la clé NS_ENUM du framework. Le type de classe Objective-C est utilisé par toutes les API générées. L'énumération C est utiles 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 standard. (voir Types).
  • L'énumération C est nommée comme une classe Java standard avec la mention "_Enum" ajoutée .

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);