objective c пример кода
Objective-C
Для обозначения объектов используется специальный тип id. Переменная типа id фактически является указателем на произвольный объект. Для обозначения нулевого указателя на объект используется константа nil.
Вместо id можно использовать и более привычное обозначение с явным указанием класса. В частности последнее позволяет компилятору осуществлять некоторую проверку поддержки сообщения объектами — если компилятор из типа переменной не может сделать вывод о поддержке объектом данного сообщения, то он выдаст предупреждение. Тем самым язык поддерживает проверку типов, но в нестрогой форме (то есть найденные несоответствия возвращаются как предупреждения, а не ошибки).
Для посылки сообщений используется следующий синтаксис:
(Немного похоже на С++ конструкцию указатель->метод).
Все директивы, используемые Objective-C начинаются с символа @
Классы
Для объявления класса создается в заголовочном файле с расширением .h и использует синтаксис:
Реализация класса создается в файле с расшерением .m и использует синтаксис:
Пример:
Файл first.h
Здесь мы видим объявление класса с именем first порожденный от класса NSObject (В Apple runtime библиотеке все классы являются наследниками класса NSObject, если мы будем писать программы с использованием Cocoa, то будет хорошей практикой наследовать свои классы также от NSObject, предоставляющего множество полезных возможностей).
Директива #import подключает к нашему объявлению заголовок Cocoa.h, содержащий объявления всех классов и протоколов пространства Cocoa.framework.
Файл first.m
Начало файла реализации класса стандартно: с директивы #import «first.h», загружающей объявление класса.
Директива @implementation first говорит компилятору, что далее следует реализация класса first
Инициализатор можно и не перегружать, просто опустив его объявление и реализацию. Также класс может содержать несколько инициализаторов, также содержащих и аргументы.
Далее следует реализация методов, практически ничем не отличающаяся от обычного C
В вышеуказанном примере переменные a и b имеют зону видимости только внутри своего класса. Мы написали метод setA:(int) andB:(int) для установки их значений. Если же нам необходимо прочитать значение a или b, то необходимо написать методы возвращающие их.
Например: Выглядит весьма запарно.
Свойства
Сопутствующая директиве @property, директива говорящая компилятору, что необходимо создать методы для доступа к переменной носит наименование @synthesize и объявляется в файле реализации класса.
Синтаксис объявления свойства:>
Пример:
Файл myclass.h
Как видим здесь объявляется класс myclass с двумя переменными a и b, доступными извне с помощью объявления свойств.
Файл myclass.m
Вот так все стало проще. Теперь мы имеем для переменных методы, позволяющие считывать и записывать их значения.
Не надо забывать, что определение свойств сокращает лишь исходный код в редакторе, а компилятор создает методы, которые предоставляют механизм доступа к переменным класса, тем самым как раз увеличивая размер конечного приложения. Поэтому, если нет необходимости видимости переменной, то не стоит к ней объявлять и свойство.
Атрибуты свойств
Бывает не всегда нужно предоставлять полный доступ к переменной класса, в этом случае нужно ограничить его в объявлении @property:
Свойство только для чтения будет выглядеть так: @property (readonly) int a;
Семантика сеттеров свойств
Atomic
Как писать на Objective-C в 2018 году. Часть 1
Большинство iOS-проектов частично или полностью переходят на Swift. Swift — замечательный язык, и за ним будущее разработки под iOS. Но язык нераздельно связан с инструментарием, а в инструментарии Swift есть недостатки.
В компиляторе Swift по-прежнему находятся баги, которые приводят к его падению или генерации неправильного кода. У Swift нет стабильного ABI. И, что очень важно, проекты на Swift собираются слишком долго.
В связи с этим существующим проектам может быть выгоднее продолжать разработку на Objective-C. А Objective-C уже не тот, что был раньше!
В этом цикле статей мы покажем полезные возможности и улучшения Objective-C, с которыми писать код становится намного приятнее. Каждый, кто пишет на Objective-C, найдет для себя что-нибудь интересное.
let и var
Для начала добавим макросы let и var :
Если раньше писать const после указателя на Objective-C класс было непозволительной роскошью, то теперь неявное указание const (через let ) стало само собой разумеющимся. Особенно заметна разница при сохранении блока в переменную.
Для себя мы выработали правило использовать let и var для объявления всех переменных. Даже когда переменная инициализируется значением nil :
Единственное исключение — когда надо гарантировать, что переменной присваивается значение в каждой ветке кода:
Только таким образом мы получим предупреждение компилятора, если забудем присвоить значение в какой-то из веток.
Автовывод типа возвращаемого значения блока
Немногие знают, что компилятор умеет выводить тип возвращаемого значения блока:
Это очень удобно. Особенно если вы пишете «реактивный» код с использованием ReactiveObjC. Но есть ряд ограничений, при которых нужно явно указывать тип возвращаемого значения.
Generics и for. in
В Xcode 7 в Objective-C появились generics (точнее, lightweight generics). Надеемся, что вы их уже используете. Но если нет, то можно посмотреть сессию WWDC или прочитать здесь или здесь.
Мы для себя выработали правило всегда указывать generic-параметры, даже если это id ( NSArray * ). Таким образом можно легко отличить legacy-код, в котором generic-параметры еще не указаны.
Нам понадобится объявить новое свойство, которое будет использоваться только для получения типа в выражении typeof :
Теперь наш код выглядит намного лучше:
Generics и copy / mutableCopy
Чтобы избежать необходимости явного приведения типов, можно переобъявить методы с указанием возвращаемого типа. Например, для NSArray объявления будут такими:
warn_unused_result
Для следующего кода компилятор сгенерирует предупреждение:
overloadable
Немногие знают, что Clang позволяет переопределять функции в языке C (а следовательно, и в Objective-C). C помощью атрибута overloadable можно создавать функции с одинаковым названием, но с разными типами аргументов или с их разным количеством.
Переопределяемые функции не могут отличаться только лишь типом возвращаемого значения.
Boxed expressions
С помощью литералов и boxed expressions можно легко получить объект, представляющий число или булево значение. Но чтобы получить объект, оборачивающий структуру, нужно написать немного кода:
Для некоторых классов определены вспомогательные методы и свойства (наподобие метода +[NSValue valueWithCGPoint:] и свойства CGPointValue ), но это все равно не так удобно, как boxed expression!
Чтобы наша структура поддерживала boxed expressions, нужно просто добавить атрибут objc_boxable для структуры.
И мы можем использовать синтаксис @(. ) для нашей структуры:
Для остальных часто используемых структур мы можем добавить поддержку boxed expressions самостоятельно:
Compound literals
Еще одна полезная конструкция языка — compound literal. Compound literals появились еще в GCC в виде расширения языка, а позже были добавлены в стандарт C11.
Еще удобнее использовать такую конструкцию, когда часть полей равны нулю:
Конечно, в compound literals можно использовать не только константы, но и любые выражения:
Nullability
В Xcode 6.3.2 в Objective-C появились nullability-аннотации. Разработчики Apple добавили их для импортирования Objective-C API в Swift. Но если что-то добавлено в язык, то надо постараться поставить это себе на службу. И мы расскажем, как используем nullability в Objective-C проекте и какие есть ограничения.
Чтобы освежить знания, можно посмотреть сессию WWDC.
Мы стали также правильно расставлять nullability для всех приватных свойств и методов.
Пример использования макроса JMNonnull :
Полезные ссылки
→ Код для статьи выложен в gist.
Заключение
В первой части статьи мы постарались рассказать об основных возможностях и простых улучшениях языка, которые существенно облегчают написание и поддержку Objective-C кода. В следующей части мы покажем, как можно еще увеличить свою продуктивность с помощью enum’ов как в Swift (они же Case-классы; они же Алгебраические типы данных, ADT) и возможности реализации методов на уровне протокола.
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 «metric.h»
#import
Если заключить имя импортируемого файла в кавычки, то компилятор будет искать файл в локальных папках.
Если заключить имя импортируемого файла в треугольные скобки, то компилятор будет искать файл в только в специальной системной папке header-файлов, но в текущей папке поиск выполняться не будет.
*/
// Описание классов для создания объектов.
/*
В общем виде секция @interface имеет следующий формат записи:
@interface Имя-Нового-Класса-Объектов: Имя-Родительского-Класса-Объектов-от-которого-будут-унаследованы-все-имеющиеся-у-него-свойства-характеристики-и-методы
<
внутри данных фигурных скобок происходит объявление атрибутов-характеристик;
>
под скобками идет объявление методов;
Обычно принято начинать названия классов с заглавной буквы для того, чтобы программистам было легче отличать названия классов от других типов переменных, хотя это не обязательно.
*/
/*
@interface внутри фигурных скобок указывает какие типы данных содержатся в классе Fraction и имена этих типов данных. Каждый вновь созданный объект получит свои личные экземпляры этих данных.
*/
@interface Fraction: NSObject
<
int numerator;
int denominator;
>
/*
Для изменения данных в переменных, описанных внутри фигурных скобок, задается набор методов.
Знак минус (-) указывает компилятору Objective-C, что данный метод является методом, который будет использоваться непосредственно только объектами-экземплярами данного класса. Метод объекта-экземпляра класса выполняет определенную операцию только для своего определенного объекта-экземпляра класса. Метод объекта-экземпляра не может вызываться без предварительного создания самого объекта.
Знак плюс (+) указывает на метод класса, который выполняет определенную операцию над самим классом, например, создает новый экземпляр данного класса, как метод new. Метод класса может вызываться в любой момент без предварительного создания объекта.
Метод объекта-экземпляря (-) всегда может выполнять непосредственный доступ к переменным своего экземпляра. Однако, это не может делать метод класса (+), поскольку он применяется только к самому классу, а не к экземплярам этого класса.
Все переменные экземпляров класса скрыты от доступа извне и вне методов данного конкретного объекта недоступны.
Указывать тип возвращаемого значения для методов не обязательно, но для удобства понимания программистом программы рекомендуется это делать.
Если тип возвращаемого значения не будет указан, то по умолчанию будет возвращаться значение с типом (id)
Синтаксис объявления метода.
— (void) setNumerator : (int) n;
тип возвращаемый имя метода передается тип имя
метода тип аргумент аргумента аргумента
/*
Метод без двоеточия указывает на то, что этому методу не передаются никакие аргументы.
*/
/*
Примеры методов в Objective-C.
*/
— (void) print;
— (void) setNumerator: (int) n;
— (void) setDenominator: (int) d;
— (int) numerator;
— (int) denominator;
/*
В общем виде секция @implimentation имеет следующий формат:
@implimentation Имя-Нового-Класса
определение методов;
@end;
— (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 содержит код, в которой будут непосредственно создаваться и работать экземпляры объектов, созданные на основе классов, описанных в секциях @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 (@»Данное сообщение используется для отладки программы. Оно будет выведено в консоль отладчика.»);
/*
Особое сочетание \n используется как символ новой строки. Этот символ в программе указывает системе, что после него надо перейти на новую строку. Все символы, которые выводятся после символа \n, появятся на следующей строке ввода.
*/
NSLog (@»Это сообщение расположится на первой сткроке.\nЭто сообщение окажется на второй строке.\nА это на третьей.»);
/*
С помощью NSLog можно выводить на экран не только простые фразы, но и значения переменных или результаты вычисления.
*/
/*
Результат от сложения двух чисел сохраняется в переменной sum.
*/
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 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;
>
Файл тела программы 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) //
Если ваш класс принимает несколько протоколов, то просто перчислите их в треугольных скобках через запятую.
@interface AddressBook: NSObject
Итак, мы подошли к концу нашего введения в Objective-C. Дальнейшее изучение Objective-C вы можете продолжить в следующих разделах нашего блога.