大多数的答案是：“这与objc的存取方法有关”

怎么样才能有关呢？接下来通过几个小例子来看一下。

首先我们创建一个学生类：Student类

这个学生类里有学生的id和学生的姓名name

1. #import
4. @interface
5. Student : NSObject{
7. //idname
9. NSString *id;
11. NSString *name;
12. }
14. @property
15. (nonatomic,strong) NSString *id;
16. @property
17. (nonatomic,strong) NSString *name;
19. @end
21. 学生类的实现文件
23. #import
24. "Student.h"
26. @implementation
27. Student
29. @synthesize
30. id,name;
32. @end

如果使用上面的方法来定义学生类的属性的get、set方法的时候，那么其他类访问的时候就是：

获取student的名字通过student.name来获取,给名字赋值则使用[student

setName:@“eve”]; 其中student是Student类的对象，如果在Student类内部访问其成员属性使用[self
setName:@”evo”], 访问使用self.name;

上面的方法只是一种，但是很难解释self该不该使用。请看下面：

我们改写Student类

1. #import
4. @interface
5. Student : NSObject{
7. //idname
9. NSString *_id;
11. NSString *_name;
12. }
14. @property
15. (nonatomic,strong) NSString *id;
16. @property
17. (nonatomic,strong) NSString *name;
19. @end
21. .m文件
23. #import
24. "Student.h"
26. @implementation
27. Student
29. @synthesize
30. id = _id;
31. @synthesize
32. name = _name;
34. @end

可见这样的写法我们增加了_id和_name，其中@synthesize也有一定的变化。

如何这个时候使用self.name编译器就会报错，这样就说明了我们通常使用self.name实际使用的是student类name的get方法，同理name的set方法亦是如此。

另外网络上也有人从内存管理方面来说明的，我将其剪切出来以供学习：

ViewController.h文件，使用Student类，代码如下：

1. #import
2. @
3. class Student;
5. @
6. interface ViewController : UIViewController{
8. Student *_student;
9. }
11. @property
12. (nonatomic, retain) Student *student;
14. @end
16. ViewController.m文件，代码：
18. #import
19. "ViewController.h"
20. #import
21. "Student.h"
23. @implementation
24. ViewController
25. @synthesize
26. student = _student;
28. -
29. (void)didReceiveMemoryWarning
30. {
32. [super didReceiveMemoryWarning];
33. }
35. #pragma
36. mark - View lifecycle
38. -
39. (void)viewDidLoad
40. {
42. [super viewDidLoad];
43. }
45. -
46. (void) dealloc
47. {
49. [_student release];
51. _student = nil;
53. [super dealloc];
54. }
55. 其它的方法没有使用到，所以这里就不在显示了。
57. 在ViewController.m的viewDidLoad方法中创建一个Student类的对象
59. Student
60. *mystudent = [[Student alloc] init];
61. self.student
62. = mystudent;
63. [mystudent
64. release];

接下来就需要从内存角度来分析它们之间的区别了：

1、加self的方式：

1. Student
2. *mystudent = [[Student alloc] init];  //mystudent 对象
3. retainCount = 1;
4. self.student
5. = mystudent; //student 对象 retainCount = 2;
6. [mystudent
7. release];//student 对象 retainCount = 1;
8. retainCount指对象引用计数，student的property
9. 是retain 默认使用self.student引用计数+1。

2、不加self的方式

1. Student
2. *mystudent = [[Student alloc] init];  //mystudent 对象
3. retainCount = 1;
4. student
5. = mystudent; //student 对象 retainCount = 1;
6. [mystudent
7. release]; //student 对象内存已释放，如果调用，会有异常

3、加self直接赋值方式

self.student = [[Student alloc] init];//student 对象 retainCount =

2;容易造成内存泄露

由于objective-c内存管理是根据引用计数处理的，当一个对象的引用计数为零时，gcc才会释放该内存

个人总结：只需要在属性初始化的时候使用self.属性，其他时候直接使用属性名就行；使用self.是 使retaincount+1,为了确保当前类对此属性具有拥有权

个人使用习惯：

1. @interface CustomClass : UIViewController
2. {
3.     NSString *str
4. }
5. @property (retain, nonatomic) NSString *str; @implementation CustomClass @synthesize str; -（void）viewDidLoad
6. { //方法一  用alloc必须手动释放一次 self.str  =  [[NSString alloc]initWithString:@"my str"];
7.      [str release]; //方法二 用类方法不用 self.str =     [NSString stringWithString:@"my str"];
9.     以后调用时直接使用str，不必使用self.str
10.    [str appendString:@"\n"];
11. } //在dealloc中必须释放 - (void)dealloc
12. { //方法一  [str release];
13.     str = nil; //方法二 self.str = nil;
15.     [super dealloc];
16. }