La declaració d'una interfície de classe comença amb la directiva del compilador @interface i finalitza amb la directiva @end (Totes les directives a Objective-C cap al compilador comencen amb "@").

@interface ComDeClasse : LaSevaSuperclasse
{
    declaracions de variables d'instància
}
declaracions de mètode
@end

La primera linia de la declaració representa el nom de la classe nova i enllaça amb la seva superclasse. La superclasse defineix la posició de la nova classe en la jerarquia d'herència, com s'ha discutit a "Herència". Si el doble punt i el nom de la superclasse s'ometeixen, la nova classe queda declarada com a classe arrel, un rival de la classe NSObject.

Seguint la primera part de la declaració de la classe, les claus contenen declaracions de les variables d'instància, les estructures de dades que són part de cada instància de la classe. Aquí hi ha una llista parcial de les variables d'instància que podria declarar-se en la classe Rectangle:

float amplada;
float alçada;
BOOL ple;
NSColor *colorPle;

Els mètodes de la classe són declarats més endavant, després les claus contenen les variables d'instànci i després el final de la declaració de la classe. Els noms dels mètodes que poden utilitzar-se pels objectes de classe, metodes de classe, van precedits per el signe més:

+ alloc;

Els mètodes que les instàncies d'una classe poden utiltizar, els mètodes d'instància es marquen amb el signe menys:

- (void) display;

Encara que no és una pràctica comunica, pots definir un mètode de classe i un mètode d'instància amb el mateix nom. Un mètode també pot tenir el mateix nom que una variable d'instància. Això és més comú, especialment si el mètode retorna el valor de la variable. Per exemple, el Cercle té un mètode radi que podria equivaldre a la variable d'instància radi.

Els mètodes retornen tipus que estan declarats utilitzant l'estàndard de la sintaxi C per repartir els paper d'un tipus i altre:

- (float) radi;

Els tipus d'arguments es declaren de la mateixa manera:

- (void) posarElRadi:(float)unRadi;

Si un tipus de retorn o argument no està declarat explícitament, s'asumeix que és del tipus per defecte per mètodes i missatges -- un id. El mètode alloc mostrat anteriorment retorna id.

Quan hi han més d'un argument, els arguments estan declarats dins el nom del mètode després dels doble punts. Els arguments trenquen la part del nom en la declaració, justament com en un missatge. Per exemple:

- (void) posarLAmplada:(float)amplada lAlçada:(float)alçada;

Els mètodes que agafen un nombre d'arguments els declara utilitzant una coma i els punts suspensius, justament com ho faria una funció:

- Agrupar:grup, ...;

Important la Interfície

El fitxer d'interfície ha d'incloure en algun modul de codi que depen de la interfície de classe -- aquest inclou algun mòdul que crea una instància de la classe, envia un missatge per invocar un mètode declarat per la classe, o menciona una variable d'instància declarada en la classe. La interfície normalment s'inclou amb la directiva #import:

#import "Rectangle.h"

Aquesta directiva és idèntica a #include, excepte que t'asegura que el mateix fitxer mai s'inclourà més d'una vegada. Per això és preferida i s'utilitza en lloc de #include en els exemples de codi en la documentació basada en Objective-C.

Per reflexar el fet que una definició de classe construeix en les definicions de classes d'herència, un fitxer d'herència comença important la interfície de la seva superclasse:

#import "LaSevaSuperclasse.h"

@interface NomClasse : LaSevaSuperclasse
{
    declaracions de variables d'instància
}
declaracions de mètodes
@end

Aquesta convenció significa que cada fitxer d'interfície inclou, indirectament, els fitxers d'interfície per totes les classes heredades. Quan un mòdul de codi importa una interfície de classe, aquest obté les interfícies per la jerarquia d'herència sencera que la classe en s'està construint.

Fixeu-vos que si aquesta és una precomp -- una capçalera precompilada -- que suporta la superclasse, en lloc d'això pots preferir importar la precomp.

Referint-se a Altres Classes

Un fitxer d'interfície declara un classe i, per importar la seva superclasse, implícitament conté declaracions per totes les classes heredades, des del NSObject per sota de la seva superclasse. Si la interfície menciona classes que no estan en la jerarquia, aquest ha d'importar-los explícitament o declarar-los amb la directiva @class:

@class Rectangle, Cercle;

Aquesta directiva simplement informa al compilador que "Rectangle" i "Cercle" són noms de classes. No importa els seus fitxers d'interfície.

Un fitxer d'interfície menciona els noms de classe quan es declaren estàticament les variables d'instància, els valors de retorn, i els arguments. Per exemple, aquesta declaració

- (void) possaElColorPrincipal: (NSColor *)unColor;

menciona la classe NSColor.

Declaracions com aquestes simplement utilitzen el nom de clase com un tipus i no depenen de cap detall de la interfície de classe (els seus mètodes i les variables d'instància), la directiva @class dona al compilador suficient sobreavís del que s'espera. Tanmateix, on la interfície d'una classe està actualment utilitzat-se (instàncies creades, missatges enviats), la interfície de la classe ha d'importar-se. Normalment, un fitxer d'interfície utilitza @class per declarar classes, i els fitxers d'implementació corresponents impoten les seves interfícies (a mida que necessitaran crear intàncies d'aquestes classes o enviar-los missatges).

La directiva @class minimitza la quantitat de codi revisat pel compilador i l'enllaçador, i per tant és la forma més simple per presentar una declaració del nom de la classe. Essent simple, evita problemes potencials que poden arribar amb l'importació de fitxers que importen parts d'altres fitxers. Per exemple, si una classe declara un variable d'instància estàticament d'una altra classe, i els seus dos fitxers d'interfície importen a l'altra, ninguna classe podrà compilar-se correctament.

El Rol de la Interfície

El propòsit del fitxer de la interfície és declarar la nova classe a altres mòduls de codi (i a altres programadors). Conté tota la informació que es necessita per treballar amb la classe (els programadors també poden apreciar una petita documentació).

• El fitxer de la interfície explica als usuaris que la classe està connectada dins la jerarquia d'herència i quines altres classes -- heredades o simplement esmentades en algun lloc de la classe -- es necessiten.
• El fitxer d'interfície també permet al compilador conneixer quines variables d'instància conté un objecte, i explica als programadors quines variables hereda de la subclasse. Encara que les variables d'instància són normalment vistes com quelcom de la implementació de la classe més que la seva interfície, tantmateix han de declarar-se en el fitxer d'interfície. Això és així perqué el compiladr ha de enterar-se de l'estructura d'un objecte en el lloc on s'utilitza, no només quan aquest està definit. Com a programador, tanmateix, pots normalment ignorar les variables d'instància de les classe que utilitzes, excepte quan defineixis una subclasse.
• Finalment, a traves de la seva llista de declaracions de mètodes, el fitxer d'interfície permet a altres mòduls coneixer quins missatges poden enviar-se a l'objecte de classe i les instàncies de la classe. Cada mètode que pot utilitzar-se fora de la definició de la calsse està declarat en el fitxer d'interfície; els mètodes que estan interns a la implementació de la classe poden ometres.