Objective-C学习笔记

@interface section describes the class, its data components, and its methods, whereas the @implementation section contains the actual code that implements these methods.

@interface 声明类的定义，成员跟方法

@implementation 是具体的实现

@interface section
@implementation section
program section

命名规则与c一样，字母及下划线开头，区分大小写字母
定义类名用大写字母，定义method,variables,objects通常是小写字母
AddressBook     This could be a class name.
currentEntry     This could be an object.
current_entry     Underscores are also used by some programmers as word parators.
addNewEntry     This could be a method name.
 
//------- @interface section -------

@interface Fraction: Object    //声明继续类
{
  int  numerator;        //成员变量
  int  denominator;
}
-(void) print;                //实例方法 instance  method
-(void) setNumerator: (int) n;
-(void) setDenominator: (int) d;   
+(void) makeNumber;            //类方法 class method
@end

objc中有了类内部方法的概念，class method 只能供类内部调用，不能对外，类似于c++中的public 和private的概念。
-    (void)    setNumerator:    (int)    n；
method type,return type,method name,method takes argument,argument type,argument name

//------- @implementation section -------
@implementation Fraction;
-(void) print
{
  printf (" %i/%i ", numerator, denominator);
}
-(void) setNumerator: (int) n
{
  numerator = n;
}
-(void) setDenominator: (int) d
{
  denominator = d;
  }
@end

//------- program section -------
int main (int argc, char *argv[])
{
  Fraction  *myFraction;//声明一个指针
  // Create an instance of a Fraction
  myFraction = [Fraction alloc];//分配一个Fraction
  myFraction = [myFraction init];//初始化
    // Fraction *myFraction = [[Fraction alloc] init];

  // Set fraction to 1/3
  [myFraction setNumerator: 1];//函数调用，类似于c++中myFraction.setNumerator(1);
  [myFraction setDenominator: 3];//c++中myFraction.setDenominator(3);
  // Display the fraction using the print method
  printf ("The value of myFraction is:");
  [myFraction print];//c++中myFraction.print();
  printf ("/n");
  [myFraction free];//释放分配的内存
  return 0;
}
类型id可以是任意类型的对象

#import "Fraction.h" //可以使用include的方式，但是没有防止重复引用的功能
多参数以colon分隔 
有2种的命名方式
参数带名称：-(void)    setTo: (int) n over: (int) d;
不带参数名称：-(int) set: (int) n: (int) d;
写参数的注释是为了更好的读代码
- (void) add: (Fraction *) f
传递指针的方式 [f denominator]调用 == C/C++ 中的f->denominator
局部变量、静态变量 与 C/C++中一样，只初始化一次
[self reduce]; //调用本身的对象 类似于C++ 中的this指针

[[aFraction add: bFraction] print];  a little roundabout 转弯抹角
//先返回一个指针，然后直接调用其函数 C++中没有这个语法概念

Extension Through Inheritance—Adding New Methods
Many times the idea of inheritance is used to extend a class. As an example, let's assume you've just been assigned the task of developing some classes to work with 2D graphical objects such as rectangles, circles, and triangles. For now, we'll just worry about rectangles. In fact, let's go back to exercise 9 from Chapter 4, "Data Types and Expressions," and start with the @interface section from that example:



@interface Rectangle: Object
{
    int  width;
    int  height;
}

-(void)  setWidth: (int) w;
-(void)  setHeight: (int) h;
-(int)  width;
-(int)  height;
-(int)  area;
-(int)  perimeter;
@end

You have methods to set the rectangle's width and height, return those values, and calculate its area and perimeter. Let's also add a method that will allow you to set both the width and the height of the rectangle with the same message call, which is as follows:



-(void) setWidth: (int) w and Height: (int) h;

Assume you typed this new class declaration into a file called Rectangle.h. Here's what the implementation file Rectangle.m might look like:



#import "Rectangle.h"

@implementation Rectangle;

-(void) setWidth: (int) w
{
     width = w;
}

-(void) setHeight: (int) h
{
     height = h;
}

-(void) setWidth: (int) w and Height: (int) h
{
    width = w;
    height = h;
}

-(int) width
{
    return width;
}

-(int) height
{
    return height;
}

-(int) area
{
    return width * height;
}

-(int) perimeter
{
    return (width + height) * 2;
}
@end

Each method definition is straightforward enough. Program 8.2 shows a main routine to test it.

Program 8.2
#import "Rectangle.h"
#import <stdio.h>

int main (int argc, char *argv[])
{
       Rectangle *myRect = [[Rectangle alloc] init];

       [myRect setWidth: 5 andHeight: 8];

       printf ("Rectangle: w = %i, h = %i/n",
              [myRect width], [myRect height]);
       printf ("Area = %i, Perimeter = %i/n",
              [myRect area], [myRect perimeter]);
       [myRect free];

       return 0;
}

Program 8.2 Output
Rectangle: w = 5, h = 8
Area = 40, Perimeter = 26

myRect is allocated and initialized; then its width is set to 5 and its height to 8. This is verified by the first printf call. Next, the area and the perimeter of the rectangle are calculated with the appropriate message calls, and the returned values are handed off to printf to be displayed.

After working with rectangles for a while, suppose you now need to work with squares. You could define a new class called Square and define similar methods in it as in your Rectangle class. Alternately, you could recognize the fact that a square is just a special case of a rectangle—one whose width and height just happen to be the same.

Thus, an easy way to handle this is to make a new class called Square and have it be a subclass of Rectangle. That way, you get to use all of Rectangle's methods and variables, in addition to defining your own. For now, the only methods you might want to add would be to set the side of the square to a particular value and retrieve that value. The interface and implementation files for your new Square class are shown in Programs 8.3 and 8.4.

Program 8.3 Square.h Interface File
#import "Rectangle.h"

@interface Square: Rectangle;

-(void) setSide: (int) s;
-(int) side;
@end

Program 8.4 Square.m Implementation File
#import "Square.h"

@implementation Square: Rectangle;

-(void) setSide: (int) s
{
  [self setWidth: s andHeight: s];
}

-(int) side
{
  return width;
}
@end

Notice what you did here. You defined your Square class to be a subclass of Rectangle, which is declared in the header file Rectangle.h. You didn't need to add any instance variables here, but you did add new methods called setSide: and side.

Even though a square has only one side, and you're internally representing it as two numbers, that's okay. All that is hidden from the user of the Square class. You could always redefine your Square class later if necessary; any users of the class wouldn't have to be concerned with the internal details because of the notion of data encapsulation discussed earlier.

The setSide: method takes advantage of the fact that you already have a method inherited from your Rectangle class to set the values of the width and height of a rectangle. So, setSide: calls the setWidth:andHeight: method from the Rectangle class passing the parameter s as the value for both the width and the height. There's really nothing else you have to do. Someone working with a Square object can now set the dimensions of the square by using setSide: and take advantage of the methods from the Rectangle class to calculate the square's area, perimeter, and so on. Program 8.5 shows the test program and output for your new Square class.

Program 8.5 Test Program test2.m
#import "Square.h"
#import <stdio.h>

int main (int argc, char *argv[])
{
  Square *mySquare = [[Square alloc] init];

  [mySquare setSide: 5];

  printf ("Square s = %i/n", [mySquare side]);
  printf ("Area = %i, Perimeter = %i/n",
      [mySquare area], [mySquare perimeter]);
  [mySquare free];

  return 0;
}

Program 8.5 Output
Square s = 5
Area = 25, Perimeter = 20

To compile your program, remember that you have to tell the compiler that your program consists of three files: Rectangle.m and Square.m, which define the class methods, and test2.m, which contains your test routine. (Remember, you don't specify the .h header files to the compiler because they're imported directly into the programs.) If you're building your program from the command lines, here's what your gcc command line might look like:



gcc Square.m Rectangle.m test2.m –o test2 –l objc

The way you defined the Square class is a fundamental technique of working with classes in Objective-C: taking what you or someone else has done before and extending it to suit your needs. In addition, a mechanism known as categories enables you to add new methods to an existing class definition in a modular fashion—that is, without having to constantly add new definitions to the same interface and implementation files. This is particularly handy when you want to do this to a class for which you don't have access to the source code. You'll learn about categories in Chapter 11, "Categories, Posing, and Protocols."

A Point Class and Memory Allocation
The Rectangle class stores only the rectangle's dimensions. In a real-world graphical application, you might need to keep track of all sorts of additional information, such as the rectangle's fill color, line color, location (origin) inside a window, and so on. You can easily extend your class to do this. For now, let's deal with the idea of the rectangle's origin. Assume that the "origin" means the location of the rectangle's lower-left corner within some Cartesian coordinate system (x, y). If you were writing a drawing application, this point might represent the location of the rectangle inside a window, as depicted in Figure 8.4.

Figure 8.4. A rectangle drawn in a window.


In Figure 8.4 the rectangle's origin is shown at (x1, y1).

You could extend your Rectangle class to store the x, y coordinate of the rectangle's origin as two separate values. Or you might realize that, in the development of your graphics application, you'll have to deal with a lot of coordinates and therefore decide to define a class called Point (you might recall this problem from exercise 7 in Chapter 3):



#import <objc/Object.h>

@interface Point: Object
{
  int  x;
  int  y;
}

-(void) setX: (int) xVal;
-(void) setY: (int) yVal;
-(void) setX: (int) xVal andY: (int) yVal;
-(int) x;
-(int) y;
@end

#import <objc/Object.h>

@class Point; //编译器只需要关心，Point 是一个类的定义
@interface Rectangle: Object
{
  int   width;   -----------》成员变量的定义
  int   height;
  Point *origin;
}

-(void)    setWidth: (int) w;   ------》声明方法
-(void)    setHeight: (int) h;
-(void)    setOrigin: (Point *) pt;
-(Point *) origin;
-(int)   width;
-(int)   height;
-(int)   area;
-(int)   perimeter;
@end