iOS Введение в Objective-C

iOS Xcode Objective-C iPhone iPad iPod

среда, 18 июля 2012 г.

Введение в Objective-C.

Для начала рассмотрим простейший пример простейшей программы на Objective-C.

Исходный код файла program.m

// Это однострочный комментарий.

/*
Это многострочный комментарий.
*/

@interface Fraction: NSObject

— (void) setNumerator: (int) n;

— (void) setDenominator: (int) d;

NSLog (@»%i/%i», numerator, denominator);

— (void) setNumerator: (int) n

— (void) setDenominator: (int) d

int main (int argc, const char * argv[])

NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

Fraction *myFraction = [[Fraction alloc] init];

[myFraction setNumerator: 1];

[myFraction setDenominator: 3];

NSLog (@»Значение дроби: i%/i%», [myFraction numeratror], [myFraction denominator]);

[pool drain];
return 0;

Данная программа логически разделена на 3 части:

@interface
@implimentation
@program

Каждая из этих секций является частью любой программы, написанной на языке Objectine-C. Каждая секция обычно помещается для удобства в отдельный файл (@interface помещается в файл my_class.h, @implimentation помещается в файл my_class.m, а @program помещается в файл main.m), но для простоты понимания работы всей программы вы можете держать их в одном файле, как сделано в нашем примере.

Приведем примеры записи комментариев в Objective-C.
В Objective-C существует 2 вида комментариев.

// Это однострочный комментарий. Он используется краткого для комментирования программы.

/*
Это многострочный комментарий. Он служит для подробного комментирования программы.
В отличии от однострочного комментария, его текст может быть очень длинным и размещаться на нескольких строчках.
Комментарии не могут быть вложенными друг в друга.
*/

Импортирование кода из одного файла в другой.

/*
#import указывает компилятору, что нужно импортировать и включить информацию из файла так, как если бы вы ввели её в этом месте вручную. Импорт файла Foundation.h выполняется потому, что он содержит классы и функции, используемые в этой программе.
Оператор #import импортирует исходный код из заголовочных файлов, имеющих расширение .h

#import «metric.h»
#import

Если заключить имя импортируемого файла в кавычки, то компилятор будет искать файл в локальных папках.
Если заключить имя импортируемого файла в треугольные скобки, то компилятор будет искать файл в только в специальной системной папке header-файлов, но в текущей папке поиск выполняться не будет.
*/

// Описание классов для создания объектов.

//—- @interface section —-

/*
@interface — это область кода вашей программы, предназначенная для описания характеристик — атрибутов и перечня названий методов — функций, которыми будут обладать все созданные объекты данного класса.
*/

/*
В общем виде секция @interface имеет следующий формат записи:

@interface Имя-Нового-Класса-Объектов: Имя-Родительского-Класса-Объектов-от-которого-будут-унаследованы-все-имеющиеся-у-него-свойства-характеристики-и-методы
<
внутри данных фигурных скобок происходит объявление атрибутов-характеристик;
>

под скобками идет объявление методов;

Обычно принято начинать названия классов с заглавной буквы для того, чтобы программистам было легче отличать названия классов от других типов переменных, хотя это не обязательно.
*/

/*
Имя нового класса — Fraction, его родительский класс NSObject, от которого новый класс автоматически наследует все свойства и методы.
Класс NSObject определен в файле NSObject.h, который автоматически включается в программу в результате импорта файла Foundation.h благодаря инструкции импорта #import , написанной выше.
*/

/*
@interface внутри фигурных скобок указывает какие типы данных содержатся в классе Fraction и имена этих типов данных. Каждый вновь созданный объект получит свои личные экземпляры этих данных.
*/

@interface Fraction: NSObject
<
int numerator;
int denominator;
>

/*
Для изменения данных в переменных, описанных внутри фигурных скобок, задается набор методов.

Знак минус (-) указывает компилятору Objective-C, что данный метод является методом, который будет использоваться непосредственно только объектами-экземплярами данного класса. Метод объекта-экземпляра класса выполняет определенную операцию только для своего определенного объекта-экземпляра класса. Метод объекта-экземпляра не может вызываться без предварительного создания самого объекта.

Знак плюс (+) указывает на метод класса, который выполняет определенную операцию над самим классом, например, создает новый экземпляр данного класса, как метод new. Метод класса может вызываться в любой момент без предварительного создания объекта.

Метод объекта-экземпляря (-) всегда может выполнять непосредственный доступ к переменным своего экземпляра. Однако, это не может делать метод класса (+), поскольку он применяется только к самому классу, а не к экземплярам этого класса.

Все переменные экземпляров класса скрыты от доступа извне и вне методов данного конкретного объекта недоступны.

При написании метода после знака плюс (+) или минус (-) необходимо в круглых скобках указать какой тип значения он будет возвращать в результате своего выполнения ( например -(int) ). Данное значение можно будет записать в переменную соответствующего типа. Если метод не будет возвращать какое-либо значение с помощью оператора return, то указывается тип значения (void).

Указывать тип возвращаемого значения для методов не обязательно, но для удобства понимания программистом программы рекомендуется это делать.
Если тип возвращаемого значения не будет указан, то по умолчанию будет возвращаться значение с типом (id)

Методу могут передаваться параметры — аргументы, которые прописываются после двоеточия (например -(int) myMethod: (int) value; ). Тип принимаемого методом аргумента указывается в скобках. В конце метода ставится точка с запятой.
*/

Синтаксис объявления метода.

— (void) setNumerator : (int) n;
тип возвращаемый имя метода передается тип имя
метода тип аргумент аргумента аргумента

/*
Метод без двоеточия указывает на то, что этому методу не передаются никакие аргументы.
*/

/*
Примеры методов в Objective-C.
*/

— (void) print;
— (void) setNumerator: (int) n;
— (void) setDenominator: (int) d;
— (int) numerator;
— (int) denominator;

//—- @implimentation section —-

/*
@implimentation — это область кода вашей программы, предназначенная для подробного описания кода методов — функций, которыми будут обладать все созданные объекты данного класса.
*/

/*
В общем виде секция @implimentation имеет следующий формат:

@implimentation Имя-Нового-Класса
определение методов;
@end;

Имя-Нового-Класса — это то же самое имя, которое использовалось для данного класса в секции @interface. Так же повторно через двоеточие здесь можно указать имя родительского класса, хотя это не обязательно и обычно не делается.

Аналогично секции @interface определение каждого метода начинается с указания типа метода (для класса со знаком + или экземпляра со знаком -), типа возвращаемого методом значения (наприммер (void)), а так же типа и имен принимаемых методом аргументов, но вместо завершения строки символом точка с запятой следует код метода, заключенный в фигурные скобки.
* /

— (void) print
<
NSLog (@»%i/%i», numerator, denominator);
>

/*
Для установки значений переменных, используемых внутри объекта класса используются специально созданные методы-установщики. Без них значение переменных, содержащихся внутри объекта экземпляра класса извне изменить нельзя.
*/

— (void) setNumerator: (int) n
<
numerator = n;
>

— (void) setDenominator: (int) d
<
denominator = d;
>

/*
Для получения данных, хранящихся в каждом объекте-экземпляре класса, используются особые методы-получатели для вывода данных. Имена методов и переменных экземпляра, к которым они выполняют доступ, совпадают. Это распространенная практика.
*/

— (int) numerator
<
return numerator;
>

— (int) denominator
<
return denominator;
>

//—- @program section —-

/*
Секция @program содержит код, в которой будут непосредственно создаваться и работать экземпляры объектов, созданные на основе классов, описанных в секциях @interface и @implimentation. Эта секция содержит код предназначенный для непосредственного решения конкретной задачи, которая может включать много файлов.
*/

/*
Следующая строка указывает, что программа имеет имя main. Это специально имя, которое указывает, где должно начаться выполнение программы. Зарезервированное слово int, которое поставлено перед main, указывает тип значения, которое возвращает функция main. Внутри круглых скобок располагаются аргументы командной строки.
Наличие процедуры main является обязательным в любой программе, поскольку каждая программа в Objective-C начинается именно с неё.
*/

int main (int argc, const char * argv[])
<

/*
Между открывающей и закрывающей фигурной скобкой размещается тело программы main.
*/

/*
Все операторы программы в Objective-C должны заканчиваться символом «точка с запятой» (;).
*/

/*
NSAutoreleasePool резервирует пространство в оперативной памяти компьютера для так называемого автоматически высвобождаемого пула (autorelease pool).
*/

NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

// Весь ваш код начинается с этого места.

/*
Процедура (функция) NSLog — это функция библиотеки Objective-C, которая предназначена для вывода на экран сообщений в виде даты и времени выполнения программы, имени программы, некоторых других числовых данных, после которых идет ваше личное текстовое сообщение.
Символ @, стоящий непосредственно перед вашим сообщением, заключенным в кавычки, указывает что данная строка является объектом-константой типа NSString.
*/

NSLog (@»Данное сообщение используется для отладки программы. Оно будет выведено в консоль отладчика.»);

/*
Особое сочетание \n используется как символ новой строки. Этот символ в программе указывает системе, что после него надо перейти на новую строку. Все символы, которые выводятся после символа \n, появятся на следующей строке ввода.
*/

NSLog (@»Это сообщение расположится на первой сткроке.\nЭто сообщение окажется на второй строке.\nА это на третьей.»);

/*
С помощью NSLog можно выводить на экран не только простые фразы, но и значения переменных или результаты вычисления.
*/

/*
Сначала мы зададим переменную, в которой будем хранить результат сложения двух чисел. Переменные можно использовать для хранения чисел, символов и ссылок на объекты, хранящиеся в оперативной памяти компьютера.
Имена переменных обязательно должны начинаться только с буквы или символа подчеркивания (_). Затем может идти любое сочетание прописных и строчных букв, символов подчеркивания и цифр от 0 до 9. Все остальные символы в названиях переменных недопустимы.
Зарезервированное слово int указывает, что в переменной sum будут находится данные типа integer, то есть только целые числа без цифр после десятичной точки, такие как: 2, 5, -15 и 0.
Зарезервированные слова, такие как int, имеющие определенный смысл для языка программирования Objective-C, нельзя использовать в качестве имен переменных.
Имена переменных и объектов-экземпляров класса рекомендуется начинать со строчной буквы.
Продуманные имена переменных, классов и методов могут намного упростить понимание программы программистом.
*/

/*
Результат от сложения двух чисел сохраняется в переменной sum.
*/

/*
Ниже вызов процедуры (функции) NSLog теперь содержит 2 аргумента, разделенных запятой.
Первый аргумент при обращении к NSLog — это всегда символьная строка, заключенная в кавычки, которая должна быть выведена на экран. Иногда в данную строку требуется подставлять значения определенных переменных для того, чтобы можно было следить за ходом выполнения вашей программы.
В данном случае требуется вывести на экран значение переменной sum.
Поскольку типом переменной sum указан int, то мы используем для подстановки символ %i.
Символ %i — это специальный символ, который указывает на тип подставляемого в строку значения.
*/

NSLog (@»Сумма 10 и 5 равна %i», sum);

/*
Однотипные переменные можно задавать подряд, разделяя их запятой, указав их общий тип лишь 1 раз.
*/

int value1, value2, total;

value1 = 20;
value2 = 30;
total = value1 + value2;

/*
При вызове процедуры (функции) NSLog в выводимую на экран строку можно подставлять значения сразу нескольких переменных. Значения переменных будут подставляться в строку в согласно порядку их следования после запятой.
*/

NSLog (@»Сумма %i и %i равна %i», value1, value2, total);

/*
Так же NSLog позволяет производить вычисление итогового значения переменных внутри нее самой.
*/

int result;
result = 1;
NSLog (@»Результат сложения 1 и 2 равен %i», result + 2);

/*
Выравнивание целых чисел в столбик по правому краю.
*/

int a = 1;
int b = 5;
int с = 10;
NSLog (@»%2i», a);
NSLog (@»%2i», b);
NSLog (@»%2i», с);

/*
Результат будет выведен в столбик с выравниванием по правому краю.
1
5
10
*/

/*
Если перед описателем ширины поля поставлен знак минус, то это поле выводится с выравниванием по левому краю.
*/

/*
Результат будет выведен в столбик с выравниванием по левому краю.
1
5
10
*/

/*
Создание объекта — экземпляра класса.
*/

/*
Для начала создадим переменную myFraction, в которой будет хранится объект — экземпляр класса Fraction.
Звездочка (*) перед myFraction является обязательным элементом. Она означает, что переменная myFraction является ссылкой на область оперативной памяти компьютера, в которой будет содержаться созданный объект. Грубо говоря, если мы создаем новый объект экземпляр класса, то перед названием переменной обязательно ставим символ звездочка (*).
*/

/*
После того, как задана переменная, необходимо создать сам объект с помощью команды выделения под него оперативной памяти alloc.
alloc — это сокращение от allocate (выделить). Данный метод наш объект автоматически унаследовал от родительского класс NSObject, который мы указали для класса Fraction в секции @interface.
*/

myFraction = [Fraction alloc];

/*
После того, как под объект была выделена оперативная память компьютера необходимо его инициализировать с помощью метода init, который так же был автоматически унаследован от родительского класса NSObject.
*/

myFraction = [myFraction init];

/*
Последовательность выделения памяти под объект и его последующая инициализация выполняются в Objective-C так часто, что два метода обычно объединяются в цепочку вызов.

Fraction *myFraction = [[Fraction alloc] init];

В цепочке вызовов методов данного объекта сначала выполняется метод во внутренних квадратных скобках, а затем во внешних.

Метод new объединяет в себе методы alloc и init.

Fraction *myFraction = [Fraction new];

Но обычно применяется двухшаговый способ выделения памяти и инициализации объекта.
*/

/*
Установка значений атрибутов данного объекта с помощью имеющихся у него методов.
*/

[myFraction setNumerator: 1];
[myFraction setDenominator: 3];

/*
Вывод на экран дроби с помощью имеющегося у объекта метода print.
*/

/*
Дробь так же может выводиться на экран с помощью методов-получателей, получающих значения атрибутов, хранящихся в созданном объекте.
*/

NSLog (@»Значение дроби: i%/i%», [myFraction numeratror], [myFraction denominator]);

/*
После завершения всех работ с данным объектом обязательно необходимо освободить занимаемую им оперативную память компьютера с помощью метода release, который был автоматически унаследован от родительского класса NSObject.
Это критически важная часть в практике программирования на языке Objective-C. При создании каждого нового объекта вы запрашиваете память, выделяемую для объекта. Закончив работу с объектом, вы обязаны освободить эту память. Если не освобождать оперативную память, то это может привести к сбою вашей программы. Однако освобождать память вы должны только для объектов, которые создали сами.
*/

// Весь ваш код заканчивается здесь.

/*
Прежде чем выполнить выход из программы, вы должны освободить выделенный пул памяти (autorelease pool) и связанные с ним объекты.
*/

/*
С помощью оператора return осуществляется завершение программы main. Оператор return возвращает значение состояния, равное 0, которое указывает на нормальное завершение программы. В случае успешного завершения программы в окне отладчика Debug Console будет выведено сообщение: «The Debugger has exited with status 0». Любое ненулевое возвращаемое значение будет означать, что возникла проблема, например, программа не смогла найти нужный файл.
*/

Разделение файлов объявлений (@interface) и определений (@implimentation)

Файл объявлений (@interface) Fraction.h

@interface Fraction: NSObject
<
int numerator;
ind denominator;
>
— (void) print;
— (void) setNumerator: (int) n;
— (void) setDenominator: (int) d;
— (int) numerator;
— (int) denominator;
— (double) convertToNum;
@end;

Файл определений (@implimentation) Fraction.m

/*
В файл определений Fraction.m импортируется только заголовок из файла Fraction.h.
Импортируемый файл заключается в кавычки, а не в угловые скобки. Кавычки используются для локальных файлов, создаваемых вами (вместо системных).
*/

— (void) print
<
NSLog (@»%i/%i», numerator, denominator);
>

— (void) setNumerator: (int) n
<
numerator = n;
>

— (void) setDenominator: (int) d
<
denominator = d;
>

— (int) numerator
<
return numerator;
>

— (int) denominator
<
return denominator;
>

— (double) convertToNum
<
if (denominator != 0)
<
return (double) numerator / denominator;
>
else
<
return 1.0;
>
>

Файл тела программы FractionProgram.m

/*
В файл теле программы импортируется только заголовок из файла Fraction.h.
Импортируемый файл заключается в кавычки, а не в угловые скобки. Кавычки используются для локальных файлов, создаваемых вами (вместо системных).
*/

int main (int argc, char *argv[])
<
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
Fraction *myFraction = [[Fraction alloc] init];

[myFraction setNumerator: 1];
[myFraction setDenominator: 3];
[myFraction print];

[pool drain];
return 0;
>

Синтезирование методов установщиков и получателей данных для переменных.

/*
@synthesize автоматически создает стандартные методы-установщики и методы-получатели для переменных, определенных в секции @interface, позволяющие записывать данные в переменные и выводить их.
*/

@interface Fraction: NSObject
<
int numerator;
int denominator;
>

@property numerator, denominator;

@synthesize numerator;
@synthesize denominator;

Доступ к свойствам объекта с помощью оператора точка (.)

myFraction.numerator; // эквивалентен [myFarction numerator];
myFraction.numerator = 1; // эквивалентен [myFarction setNumerator: 1];

Передача методам нескольких аргументов

@interface Fraction: NSObject
<
int numerator;
int denominator;
>

-(void) setTo: (int) n over: (int) d;

-(void) setTo: (int) n over: (int) d
<
numerator = n;
denominator = d;
>

int main (int argc, char *argv[])
<
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
Fraction *myFraction = [[Fraction alloc] init];

[myFraction setTo: 1 over: 3];

[pool drain];
return 0;
>

Методы без аргументов.

При создании имени метода имена аргументов не являются обязательными, хотя использование имен аргументов повышает удобство понимания программы программистом.
При работе с методом без имен аргументов в качестве разделителя аргументов используется просто двоеточие (:).
-(int) set: (int) n: (int) m;
[myFraction set 1 : 3];

Передача объектов в качестве аргументов.

@interface Fraction: NSObject
<
int numerator;
int denominator;
>

-(void) setTo: (int) n over: (int) d;
-(void) add: (Fraction *) f;

-(void) setTo: (int) n over: (int) d
<
numerator = n;
denominator = d;
>

-(void) add: (Fraction *) f
<
numerator = numerator + f.denominator;
denominator = denominator + f.numerator;
>

int main (int argc, char *argv[])
<
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
Fraction *myFraction1 = [[Fraction alloc] init];
Fraction *myFraction2 = [[Fraction alloc] init];

[myFraction1 setTo: 1 over: 3];
[myFraction2 setTo: 5 over: 7];

[myFraction1 add: myFraction2];

[myFraction1 release];
[myFraction2 release];

[pool drain];
return 0;
>

Локальные переменные.

Локальные переменные создаются внутри методов, как часть функции. У каждого объекта получаются независимые от других объектов локальные переменные.

@implimentation Fraction
-(void) reduce
<
int u = nemerator;
int v = denominator;
int temp;
NSLog (@»Это локальные переменные: %i, %i. Они являются индивидуальными для каждого объекта-экземпляра.», u, v);
>
@end;

Аргументы, передаваемые методам, так же являются локальными переменными, используемыми внутри функции.

-(void) calculate: (double) x
<
x = x * 2;
>

Сохранение значения переменной при повторных вызовах одного и того же метода. Ключевое слово static.

Чтобы локальная переменная внутри функции сохраняла свое значение поместите ключевое слово static перед объявление переменной.

Статические переменные инициализируются только один раз, в начале выполнения программы, и сохраняют свои значения неизменными при нескольких вызовах метода.

-(void) showPage
<
static int pageCount = 0;
pageCount++;
>

Доступ к статическим и локальным переменным может выполняться только из метода объекта, в котором они определены. Чтобы сделать эти переменные доступными другим методам вне метода объекта, нужно объявить их вне объявления любого метода (обычно это делают в начале файла @implimentation). После этого любой метод объекта-экземпляра или класса сможет выполнить доступ к этим переменным.

static int pageCount;

@implimentation Printer
.
@end;

Ключевое слово self

Вы можете использовать ключевое слово self для ссылки на объект, который в данный момент является выполняющим текущий метод.

-(void) add: (Fraction *) f
<
[self reduce];
>

То есть в данном случае запустится метод самого объекта, как если бы было написано: [[myFraction add] reduce];

Выделение памяти и возврат объектов после выполнения метода.

-(Fraction *) add: (Fraction *) f
<
Fraction *result = [[Fraction alloc] init];

int resultNum, resultDenom;
resultNum = numerator * f.denominator + denominator * f.numerator;
resultDenom = denominator * f.denominator;

[result setTo: resultNum over: resultDenom];
[result reduce];

Данный метод принимает объект, производит с ним какие-либо действия и в итоге возвращает обратно измененный объект или другой созданный объект.

В примере занимаемая объектом result память, которая была выделена внутри метода add, не освобождается. Вы не можете освободить ее из метода add, поскольку данный объект необходим для дальнейшей работы программы. Поэтому пользователь обязан знать, что возвращаемый объект является новым экземпляром и должен быть в дальнейшем освобожден из памяти после его использования в программе. Это можно указать в соответствующей документации.

Fraction *resultFraction;
resultFraction = [myfraction add: someFraction];
[resultFruction release];

Во избежания утечек памяти лучше избегать использование вложенных методов вида [[aFraction add: bFraction] print];

Наследование.

Дочерний класс имеет доступ ко всем свойствам и методам родительского класса, как будто они были определены в нем самом.

ClassB наследует все свойства и методы ClassA. Каждый объект-экземпляр класса будет получать свои собственные переменные экземпляра, даже если они наследуются.

Наследование часто используется для расширения базового родительского класса. В новый класс лишь добавляются новые свойства и методы, отсутствующие в родительском классе.

Замещение методов родительского класса.

Для замены метода родительского класса в дочернем классе нужно просто в дочернем классе повторно определить метод метод с тем же именем, что в родительском классе, но уже со своим функционалом. Новый метод должени иметь тот же тип возвращаемого значения и принимать такое же число аргументов того же типа, как метод, который вы замещаете.

Замещение метода dealloc и ключевое слово super.

При замещении метода dealloc вы должны проследить, чтобы была освобождена память, занимаемая не только вашими переменными объекта-экземпляра класса, но и всеми унаследованными переменными. Для этого существует специальное слово super, которое обозначает родительский класс.
Выражение [super release]; при использовании внутри метода вызывает метода release, который был определен или унаследован в родительском классе.
Таки образом замещение родительского метода dealloc внутри класса наследника производится следующим образом:

. Ваш код .
. Ваш код .
. Ваш код .

При наследовании вы не можете удалять методы или переменные родительского класса. Вы только можете добавлять переменные в дочерний класс, а методы только добавлять или замещать.

Полиморфизм — использование методов с одинаковыми именами для разных классов. Таким образом у разных классов могут независимые методы и переменные с одинаковыми названиями.

Методы для работы с динамическими типами (id).

Вопрос или действие
Метод

Является ли данный объект членом объекта-класса или дочернего класса?
-(BOOL) isKindOfClass: объект-класс

Является ли данный объект членом объекта-класса?-(BOOL) isMemberOfClass: объект-класс
[myFract isMemberOfClass: [Fraction class]];

Может ли данный объект отвечать на метод, указанный селектором?
-(BOOL) respondsToSelector: селектор

Могут ли экземпляры данного класса отвечать на селектор?
+(BOOL) instancesRespondToSelector: объект-класс
[Fraction instancesRespondToSelector: @selector (setTo: over:)];

Является ли данный объект подклассом указанного класса?
+(BOOL) isSubclassOfClass: объект-класс

Применение метода, указанного селектором.
-(id) performSelector: селектор

Применение метода, указанного селектором, c передачей аргумента типа объект.
-(id) performSelector: селектор withObject: объект

Применение метода, указанного селектором, c передачей аргументов типа объект1 и объект2.
-(id) performSelector: селектор withObject: объект1 withObject: объект2

if ([obj1 class] == [obj2 class])

Категории.

Категории предназначены для внесения новых методов в уже имеющийся класс в том случае, если вам недоступен для изменения исходный файл с кодом данного класса.

Для добавления новых методов вы можете создать новые файлы, куда поместите новые категории методов для данного класса.

@interface Fraction (MathOps) //

// Метод -(id) copyWithZone: (NSZone *) zone; уже не нужно определять в секции @interface, однако его нужно определить в секции @implimentation.

Если ваш класс принимает несколько протоколов, то просто перчислите их в треугольных скобках через запятую.

@interface AddressBook: NSObject

Итак, мы подошли к концу нашего введения в Objective-C. Дальнейшее изучение Objective-C вы можете продолжить в следующих разделах нашего блога.