提升Objective-C 2.0编程技巧：深入解析与实战指南

需积分: 33 15 浏览量更新于2024-07-23 收藏 3.4MB PDF 举报

"Effective Objective-C"是一本深入讲解Objective-C 2.0编程语言的专业书籍，旨在帮助读者掌握这个编程技术的关键细节和底层实现原理，从而提升在iOS和macOS开发中的技能。Objective-C作为Apple平台的主要编程语言，其设计哲学与C语言紧密融合，支持面向对象编程特性，如消息传递、动态类型系统和类别（Categories）等。本书不仅教授语法和核心概念，还涵盖了Objective-C 2.0的新特性，如Block和Grand Central Dispatch（GCD），这些特性对于现代iOS应用性能优化至关重要。作者可能还会讨论内存管理、KVC/KVO（Key-Value Coding/Observing）、以及Objective-C运行时机制，如Category在类扩展中的应用。值得注意的是，书中所包含的编程代码示例和配置教程是用ePub格式编写的，这是一种开放的标准电子书格式，但设备和应用程序对其支持程度各异。为了获得最佳阅读体验，用户应根据自己的阅读设备或应用程序的设置进行个性化调整，如字体大小、单列或多列布局、横竖屏模式等。部分代码展示可能会采用可点击放大图的形式，如果文本格式下代码呈现不够清晰，读者可以通过链接查看与打印版一致的图片。在阅读编程代码章节时，建议读者切换到单列模式和横屏显示，并将字体大小调至最小，以充分利用屏幕空间。同时，遇到需要查看完整代码列表的区域，可以直接点击链接跳转到专门的图片展示，返回前一页则可通过设备或应用的后退按钮操作。 "Effective Objective-C"是一本实用且详尽的指南，适合于Objective-C开发者深入学习和提升编程技巧，同时也对那些希望在现代苹果生态系统中建立高效应用的开发者具有很高的参考价值。通过理解和实践书中的内容，读者将能更好地利用Objective-C的强大功能，优化软件设计并编写出高质量的代码。

1. Accustoming Yourself to Objective-C

Objective-C brings object-oriented features to C through an entirely new syntax.

Often described as verbose, Objective-C syntax makes use of a lot of square brackets

and isn’t shy about using extremely long method names. The resulting source code is

very readable but is often difficult for C++ or Java developers to master.

Writing Objective-C can be learned quickly but has many intricacies to be aware of

and features that are often overlooked. Similarly, some features are abused or not fully

understood, yielding code that is difficult to maintain or to debug. This chapter covers

fundamental topics; subsequent chapters cover specific areas of the language and

associated frameworks.

Item 1: Familiarize Yourself with Objective-C’s Roots

Objective-C is similar to other object-oriented languages, such as C++ and Java, but

also differs in many ways. If you have experience in another object-oriented language,

you’ll understand many of the paradigms and patterns used. However, the syntax may

appear alien because it uses a messaging structure rather than function calling.

Objective-C evolved from Smalltalk, the origin of messaging. The difference between

messaging and function calling looks like this:

// Messaging (Objective-C)

Object *obj = [Object new];

[obj performWith:parameter1 and:parameter2];

// Function calling (C++)

Object *obj = new Object;

obj->perform(parameter1, parameter2);

The key difference is that in the messaging structure, the runtime decides which

code gets executed. With function calling, the compiler decides which code will be

executed. When polymorphism is introduced to the function-calling example, a form of

runtime lookup is involved through what is known as a virtual table. But with messaging,

the lookup is always at runtime. In fact, the compiler doesn’t even care about the type of

the object being messaged. That is looked up at runtime as well, through a process

known as dynamic binding, covered in more detail in Item 11.

The Objective-C runtime component, rather than the compiler, does most of the

heavy lifting. The runtime contains all the data structures and functions that are

required for the object-oriented features of Objective-C to work. For example, the

runtime includes all the memory-management methods. Essentially, the runtime is the

set of code that glues together all your code and comes in the form of a dynamic library

to which your code is linked. Thus, whenever the runtime is updated, your application

benefits from the performance improvements. A language that does more work at

compile time needs to be recompiled to benefit from such performance improvements.

Objective-C is a superset of C, so all the features in the C language are available

when writing Objective-C. Therefore, to write effective Objective-C, you need to

understand the core concepts of both C and Objective-C. In particular, understanding

the memory model of C will help you to understand the memory model of Objective-C

and why reference counting works the way it does. This involves understanding that a

pointer is used to denote an object in Objective-C. When you declare a variable that is

to hold a reference to an object, the syntax looks like this:

NSString *someString = @"The string";

This syntax, mostly lifted straight from C, declares a variable called someString whose

type is NSString*. This means that it is a pointer to an NSString. All Objective-C objects

must be declared in this way because the memory for objects is always allocated in

heap space and never on the stack. It is illegal to declare a stack-allocated Objective-C

object:

NSString stackString;

// error: interface type cannot be statically allocated

The someString variable points to some memory, allocated in the heap, containing an

NSString object. This means that creating another variable pointing to the same location

does not create a copy but rather yields two variables pointing to the same object:

NSString *someString = @"The string";

NSString *anotherString = someString;

There is only one NSString instance here, but two variables are pointing to the same

instance. These two variables are of type NSString*, meaning that the current stack

frame has allocated 2 bits of memory the size of a pointer (4 bytes for a 32-bit

architecture, 8 bytes for a 64-bit architecture). These bits of memory will contain the

same value: the memory address of the NSString instance.

Figure 1.1 illustrates this layout. The data stored for the NSString instance includes

the bytes needed to represent the actual string.

heap memory. When nonobject types (int, float, double, char, etc.) are the only data to

be held, a structure, such as CGRect, is usually used.

Before embarking on writing anything in Objective-C, I encourage you to read texts

about the C language and become familiar with the syntax. If you dive straight into

Objective-C, you may find certain parts of the syntax confusing.

Things to Remember

Objective-C is a superset of C, adding object-oriented features. Objective-C uses a

messaging structure with dynamic binding, meaning that the type of an object is

discovered at runtime. The runtime, rather than the compiler, works out what code to

run for a given message.

Understanding the core concepts of C will help you write effective Objective-C. In

particular, you need to understand the memory model and pointers.

Item 2: Minimize Importing Headers in Headers

Objective-C, just like C and C++, makes use of header files and implementation files.

When a class is written in Objective-C, the standard approach is to create one of each

of these files named after the class, suffixed with .h for the header file and .m for the

implementation file. When you create a class, it might end up looking like this:

// EOCPerson.h

#import <Foundation/Foundation.h>

@interface EOCPerson : NSObject

@property (nonatomic, copy) NSString *firstName;

@property (nonatomic, copy) NSString *lastName;

@end

// EOCPerson.m

#import "EOCPerson.h"

@implementation EOCPerson

// Implementation of methods

@end

The importing of Foundation.h is required pretty much for all classes you will ever

make in Objective-C. Either that, or you will import the base header file for the

framework in which the class’s superclass lives. For example, if you were creating an

iOS application, you would subclass UIViewController often. These classes’ header

files will import UIKit.h.

As it stands, this class is fine. It imports the entirety of Foundation, but that doesn’t

matter. Given that this class inherits from a class that’s part of Foundation, it’s likely that

a large proportion of it will be used by consumers of EOCPerson. The same goes for a

剩余310页未读，继续阅读

光影的追随者

粉丝: 2
资源: 11

提升Objective-C 2.0编程技巧：深入解析与实战指南

Effective Objective-C 2.0 中文版.zip

Effective Objective-C 2.0

Effective Objective-C(原版)

Effective Objective-C 2.0.pdf

Effective Objective-C 2.0 epub版

高清彩版 Effective Objective-C 2.0

Effective-Objective-C-2.0-Source-Code:Effective-Objective-C-2.0随书

Effective Objective-C 2.0&Obj;-C高级编程

Effective Objective-C 2.0 学习笔记目录

Effective Objective-C 2.0: 英文电子书指南

最新资源