Tipi
- Per i tipi primitivi, J2ObjC ha definito typedef di stile JNI.
- Per i tipi di classe tipici, il pacchetto è preceduto da lettere maiuscole e minuscole e anteposto al nome della classe.
- Per rinominare il prefisso del pacchetto generato, consulta Prefissi pacchetto.
- Per il tipo di oggetto di base e tutte le variabili di tipo, "id" .
- Alcuni tipi di Java principali sono mappati ai tipi di base. (ad es. Da stringa a NSString)
- Per i campi dichiarati "volatili", J2ObjC ha più typedef che utilizzano tipi C11 _Atomic(...).
- Per i tipi interni, il nome della classe interna viene aggiunto al nome esterno con un trattino basso.
Tipo Java | Tipo Objective-C | Tipo volatile Objective-C |
---|---|---|
booleano | jbooleano | volatile_jboolean |
carattere | jchar | volatile_jchar |
byte | jbyte | volatile_jbyte |
video breve | Jshort | volatile_jshort |
int | Jint | volatile_jint |
Lungo | Jlong | volatile_jlong |
numero in virgola mobile | galleggiante | volatile_jfloat |
double | jdoppio | volatile_jdouble |
java.lang.Object | id | volatile_id |
variabili di tipo | id | volatile_id |
java.lang.String | NSString* | volatile_id |
java.lang.Number | Numero NS* | volatile_id |
java.lang.Cloneable | NSCopie* | volatile_id |
foo.bar.Mumble | FooBarMumble* | volatile_id |
foo.bar.Mumber$Inner | FooBarMumble_Inner* | volatile_id |
Metodi
I metodi Objective-C sono diversi dai metodi Java per due aspetti importanti. Sono sintatticamente diversi, incorporando i parametri tra i componenti del selettore di metodi. Obiettivo-C non supportano il sovraccarico come Java. Queste differenze vengono risolte incorporando nel selettore generato. Questa operazione è necessaria per evitare conflitti di nomi tra metodi Java sovraccarichi.
Esistono tre tipi di metodi Java che differiscono nell'API generata: metodi istanza, statici metodi e costruttori. I metodi di istanza si traducono in metodi di istanza Objective-C. Statica e costruttori si traducono in funzioni di stile C, ma aggiungono anche wrapper Objective-C a Offrire un'API più familiare agli sviluppatori Objective-C.
Metodi di istanza
I nomi dei metodi vengono generati come segue:
- I metodi con zero parametri non sono stati modificati
- Uno o più parametri utilizzano il seguente pattern:
<java name>With<1st param keyword>:with<2nd param keyword>:with<3rd param keyword>:
- Regole per le parole chiave dei parametri:
- Per i tipi primitivi, la parola chiave è il nome in maiuscolo della primitiva Java. (ad es. "carattere")
- Per i tipi non primitivi, la parola chiave è il nome completo del tipo con lettere maiuscole e minuscole. (ad es. "ComGoogleFoo")
- Per i tipi di array, "Array" viene aggiunto alla parola chiave del tipo di elemento.
Java di esempio
interface Foo {
void bar();
String bar(int i);
java.util.List bar(String s, long[] l);
}
Obiettivo di esempio-C
- (void)bar;
- (NSString *)barWithInt:(jint)i;
- (id<JavaUtilList>)barWithNSString:(NSString *)s
withLongArray:(IOSLongArray *)l;
Metodi statici
Viene aggiunto un metodo di classe Objective-C seguendo le stesse regole di denominazione dei metodi di istanza.
Una funzione di tipo C viene aggiunta utilizzando le seguenti regole di denominazione:
- Inizia con il selettore Objective-C generato. (ad es.
barWithInt:
) - Sostituisci i due punti con trattini bassi. (ad es.
barWithInt_
) - Anteponi il nome della classe, delimitato da un trattino basso. (ad es.
ComGoogleFoo_barWithInt_
)
Java di esempio
package com.google;
class Foo {
static boolean bar() { ... }
static double bar(int[] i) { ... }
static void bar(String s, boolean b) { ... }
}
Obiettivo di esempio-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);
Costruttori
In base alla convenzione Objective-C, viene aggiunto un metodo dell'istanza init
. Se il costruttore ha
viene utilizzata la stessa regola di denominazione dei metodi di istanza.
Vengono aggiunte tre funzioni di tipo C:
- La prima funzione accetta un oggetto appena allocato come primo parametro. Questa funzione è di solito utilizzato per le chiamate da un costruttore di sottoclassi. Segue le stesse regole di denominazione degli annunci statici di machine learning. (dove "init" è il nome del metodo)
- Vengono aggiunte due funzioni che allocano e inizializzano il nuovo oggetto. Si distinguono
in base al prefisso:
- La funzione
create_
restituirà un oggetto rilasciato automaticamente. - La funzione
new_
restituirà un oggetto conservato.
- La funzione
Java di esempio
package com.google;
class Foo {
Foo() { ... }
Foo(Object a, Object b) { ... }
}
Obiettivo di esempio-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);
Campi
Campi istanza (non statici)
Le variabili di istanza Java diventano variabili di istanza Objective-C. È lo stesso nome con una il trattino basso. Campi primitivi dichiarati "finali" sono un caso speciale e non vengono tradotti in istanza come la codifica one-hot delle variabili categoriche.
- È possibile accedere direttamente ai campi utilizzando "->" a riga di comando.
- I campi primitivi possono essere impostati direttamente.
- Le primitive finali (costanti) sono tradotte come costanti statiche. (vedi Campi statici).
- I campi non primitivi devono essere impostati utilizzando la funzione setter fornita:
ClassName_set_fieldName_(instance, value)
Java di esempio
package com.google;
class Foo {
public int myInt;
public String myString;
}
Obiettivo di esempio-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");
Campi statici
È necessario accedere alle variabili statiche utilizzando le funzioni getter e setter fornite. Queste funzioni della funzione di accesso assicurano che l'inizializzazione della classe sia avvenuta prima di accedere alla variabile.
- Accedere a un campo statico
ClassName_get_fieldName()
- Assegna un campo statico (non finale)
ClassName_set_fieldName()
- Ottieni un puntatore a un campo statico primitivo
ClassName_getRef_fieldName()
- Disponibile solo per campi non finali e non volatili.
È possibile accedere direttamente ai campi primitivi finali (costanti) perché il loro valore non dipende dall'inizializzazione della classe.
ClassName_fieldName
Java di esempio
package com.google;
class Foo {
public static final MY_FINAL_INT = 5;
public static int myInt;
public static String myString;
}
Obiettivo di esempio-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");
Enum
J2ObjC genera due tipi per ogni enum Java. Viene generato un tipo di classe Objective-C che fornisce la funzionalità completa di un'enumerazione Java. Inoltre, viene generata un'enumerazione C utilizzando la proprietà NS_ENUM del framework. Il tipo di classe Objective-C viene utilizzato da tutte le API generate. L'enum C è utile come valori costanti per un'istruzione switch o come tipo di archiviazione.
I tipi di enum generati sono denominati come segue:
- Il nome della classe Objective-C utilizza la stessa regola di una normale classe Java. (vedi la sezione Tipi).
- L'enum C viene denominata come una normale classe Java con l'aggiunta di "_Enum" suffisso.
Le costanti enum sono accessibili come campi statici.
Java di esempio
package com.google;
enum Color {
RED, GREEN, BLUE
}
Esempio di intestazione 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);