调用方面声明的方法(Calling methods declared in an aspect)

 在这一点上，我想到的是，带有@property的实例变量必须在类的init方法中没有自己的情况下使用，并在dealloc中释放它们 
 
 这与事实完全相反。 @property只是让变量在课堂外公开。 如果您有另一个类调用该对象，它将查找头文件（.h文件），如果它没有看到该名称的变量，它将在编译过程中发出警告，并在运行时发生错误。 当使用合成属性（顺便说一句，你的合成可以全部在一行上，但是并不重要，例如：@synthesize varA，varB，varC;），使用self会自动保留并保留一个保留计数。 
 
- (id) initClass:(NSString *)desc{ //Note the "-" instead of the "+" here, this is an instance method, not a class method
    self = [super init];

    if( self ){
        [self setVarA:[NSString stringWithString:desc]];
        [self setVarB:[OtherClass initClassWithAutorelease:@"a description"]];

        [varB aMethod:@"something"];
    }

    return self;
}
 
 在其他方法中，对所有情况使用自我都很方便。 
 
 非常不真实。 如果有的话，这会增加对调用堆栈的另一个调用，并使执行速度变慢（通过一次操作，但仍然比需要的多一次）。 考虑这个例子： 
 
[[self varA] doStuff:@"OMG"];
 
 与 
 
[varA doStuff:@"OMG"];
 
 第二个将只访问一个指针，第一个指针必须访问2个指针才能得到相同的结果。 
 
 首先，我想如果我在init方法中使用self.varA =，那么retain计数器会增加，所以我必须在dealloc方法中释放它，即使对象尚未使用alloc，copy或new创建。 
 
 不真实的。 该类处理第一个保留，因此，它也处理发布。 当你的课堂被释放时，它会将一个发布版本发布到它保留的所有东西上。 如果你在你的dealloc中发布一个版本，这实际上会将其保留计数减少到-1，并产生一个内存错误。 如果你使用self.varA = someObject设置属性，那么当你的类被处理时它会给它一个释放。 如果你做了self.varA = [someObject retain]，那么你将不得不在dealloc中发布一个版本。 
 
 或者我可以在init中只使用varA =，我不需要发布。 
 
 真的，你不需要做一个释放，因为你没有保留。 但是如果其他东西将这个对象的保留计数降低到0，那么在你的类中没有任何东西强制对象保持活动状态，并且它将被释放，并且如果引用它，内存错误。 
 
 对于其他类方法，最好使用setter / getter，这样我就可以使用self.varA =，... appendString：self.varA ...或... = self.varA没有问题。 这一切是正确的吗？ 
 
 不，看看上面的原因。 如果要更改对象的实例，只能使用[self setVarA：newValue]，合成将处理其余部分。 否则，只需使用[varAval]来获取您需要的数据。 
 
 第二个疑问是，在内存管理和简单性方面最好的方法是在init方法中为实例变量分配一个对象，使用或不使用autorelease？ 如果我给它分配一个没有autorelease的，我将不得不释放它，但如果我使用autorelease变量可以在我想要之前释放（如autoreleased self.varB = [OtherClass ...将在dealloc方法中使用，每当MyClass发布）。 
 
 如果你在init中创建一个新对象，autorelease它。 如果你只做一个常规的alloc初始化，你将不得不在你的dealloc中释放它。 变量在您想要之前不会被释放，因为您通过属性对其进行了保留。 EX 
 
-(id) init {
   self = [super init];

   if(self) {
       [self setVarA:[[[NSString alloc] init] autorelease]]; //Sets a new instance of NSString, autoreleased
   }

   return self;
}
 
 这是正确的，你不需要在你的dealloc中做任何事情。 您正在创建一个保留计数为2的对象（一个用于您在此处执行的分配，另一个用于合成设置类中的值时执行的保留）。 现在，如果它自动释放，它的留存率只会减少1，并且您的财产中仍然有留存，所以它不会在您的课程发布前发布 
 
-(id) init {
   self = [super init];

   if(self) {
       [self setVarA:[[NSString alloc] init]]; //Sets a new instance of NSString
   }

   return self;
}
 
 再次，您创建一个保留计数为2的对象。您需要在dealloc中执行一个[varA release]以将保留计数降低到足以让您的类在发布时释放。 
 
 第三，即使我不在init方法中使用它们，我是否必须释放所有实例变量，但是我可以在同一类的其他方法中使用它们（读/写）？ （就像方法1中的varC或未使用的varD一样）。 
 
 不，你不想发送释放到释放的对象。 在我看来，你真的不应该使用dealloc，但是如果你决定要确定，那么最糟糕的情况是检查对象是否为null，如果不是，则释放它 
 
if(varD != null)
   [[self varD] release];
 
 第四，如果我在initClass和dealloc方法中做得很好，我是否需要在方法1中分配新值之后照顾varA？ 换句话说，这会产生内存泄漏吗？ 
 
 NSString没有内存泄漏。 这个方法返回一个自动释放对象。 当您为[self varA]指定新值时，它将释放旧对象并保留新对象。 
 
 第五，如果我声明autorelease这个类像一个实例变量在ViewController（MyClass * c; ... c = [[[MyClass alloc] initClass：@“description”] autorelease];），我设置了@property，如果我用c = ...而不是self.c = ...来使用它，我必须做一个发布吗？ 据我所知，行为与我的例子相同，所以我应该在viewDidLoad或viewWillAppear中使用setter / get方法，并在dealloc中将其释放，而不会自行释放它。 
 
 两种情况下都不需要发布。 这个alloc增加了释放次数1，autorelease会将它减少到0.如果你做了self.c，那么它会将它增加到2，并且当你的班级减少到0（从autorelease减少一个，从属性减少一个）发行了。 你不需要在dealloc中做任何事情。 
 
 第六个也是最后一个，对于一个实例变量是varA与self-> varA相同。 
 
 是的，他们指向内存中的相同位置。 

At this point what I have in mind is that the instance variables with @property have to be use without self in the init method of the class and release them without self in the dealloc 
 
This is completely the opposite of what is true. @property just makes the variable public outside of the class. If you have another class call that object, it will look in the header file (.h file), if it doesn't see a variable by that name, it will throw a warning during compile, and an error during runtime. When using properties with synthesize (btw, your synthesize can be all on one line, doesn't really matter though, ex: @synthesize varA, varB, varC;), using self automatically retains and keeps a retain count.
 
- (id) initClass:(NSString *)desc{ //Note the "-" instead of the "+" here, this is an instance method, not a class method
    self = [super init];

    if( self ){
        [self setVarA:[NSString stringWithString:desc]];
        [self setVarB:[OtherClass initClassWithAutorelease:@"a description"]];

        [varB aMethod:@"something"];
    }

    return self;
}
 
in other methods it is convinient to use self for all cases. 
 
Very untrue as well. If anything, this adds another call to the call stack and makes the execution slower (by one operation, but still, one more than needed). Consider this example:
 
[[self varA] doStuff:@"OMG"];
 
versus
 
[varA doStuff:@"OMG"];
 
The 2nd one will only access one pointer, where as the first one will have to access 2 pointers to get to the same result.
 
First, I suppose that if I use self.varA= in the init method the retain counter increase so I have to release it in the dealloc method, even if the object has not been created with alloc, copy or new. 
 
Untrue. The class handles the first retain, and because of this, it handles a release as well. When your class is released, it sends a release to everything it has a retain on. If you do a release in your dealloc, this will actually decrease its retain count to -1 and create a memory error. If you set the property with self.varA = someObject, then it will give it a release when your class is dealloced. If you did self.varA = [someObject retain], then you would have to do a release in the dealloc.
 
Or I can use only varA= in the init and I will not need to do a release. 
 
Kinda true, you would not need to do a release because you did not do a retain. But if something else lowers the retain count to 0 on this object, there is nothing in your class that forces the object to stay alive, and it will be freed, and if you reference it, memory error.
 
For other class methods it's better to use the setter/getter so I can use self.varA=, ... appendString:self.varA ... or ...=self.varA without problem. Is all this correct?
 
No, see why above. Only use [self setVarA:newValue] if you are changing the instance of the object, the synthesize will handle the rest. Otherwise just use [varA value] to get what ever data you need.
 
Second doubt, what is best in terms of memory management and simplicity, to assign to an instance variable an object in the init method with or without autorelease? If I assign to it one without autorelease I will have to dealloc it but if I use autorelease the variable could be released before I want (like the autoreleased self.varB = [OtherClass... that will be used in the dealloc method whenever the MyClass is released).
 
If you are creating a new object in init, autorelease it. You will have to release it in your dealloc if you do just a regular alloc init. The variable will not be released before you want it because of the retain you do on it through the property. EX
 
-(id) init {
   self = [super init];

   if(self) {
       [self setVarA:[[[NSString alloc] init] autorelease]]; //Sets a new instance of NSString, autoreleased
   }

   return self;
}
 
This is correct, you do not need to do anything in your dealloc. You are creating an object with a retain count of 2 (one for the alloc you did here, and 1 for the retain you do when the synthesize sets the value in your class). Now, if it autoreleases, its retain will only go down by 1, and you will still have the retain from your property, so it will not release before your class releases
 
-(id) init {
   self = [super init];

   if(self) {
       [self setVarA:[[NSString alloc] init]]; //Sets a new instance of NSString
   }

   return self;
}
 
Again, you create an object with a retain count of 2. You will need to do a [varA release] in the dealloc to knock the retain count down enough for it to be released when your class is released.
 
Third, do I have to dealloc all my instance variables even if I don't use them in the init method but I could use them (read/write) in other methods of the same class? (Like varC in method1 or varD that is not used).
 
No, you do not want to send releases to freed objects. You really should never use a dealloc in my opinion, but if you decide you want to for sure, then the worst case is to check to see if the object is null, and if its not, then release it
 
if(varD != null)
   [[self varD] release];
 
Fourth, do I need to take care of varA after assigning the new value in method1 if I did it well in the initClass and dealloc methods? In other words, will this generate memory leaks?
 
No memory leaks from NSString. This method returns an autoreleased object. When you assign a new value to [self varA], it will release the old object, and retain the new object.
 
Fifth, if I declare with autorelease this class like an instance variable in a ViewController (MyClass *c; ... c = [[[MyClass alloc] initClass:@"description"] autorelease];) and I set the @property, do I have to do a release if I use it with c=... instead of self.c=...? As far as I know the behavior is the same than in my example so I should use the setter/get method in the viewDidLoad or viewWillAppear and released it in the dealloc without self..
 
You don't need a release in either scenario. The alloc increases the release count by 1, the autorelease will decrease it to 0. If you did self.c, that would increase it to 2, and decrease to 0 (one decrease from autorelease, and one from the property) when your class is released. You do not need to do ANYTHING in dealloc.
 
Sixth and last one, for a instance variable is varA the same that self->varA?
 
Yes, they point to the same location in memory.