#ios develop note

  So Pretty My Life.

  发现自己放松了几天后，学习效率严重下降，而且拖延症又复发了~

  不过还好，慢慢调整吧，又制定了一周的学习计划，全是基础，但也有简单App的制作。

  今天看了教程的一部分，发现自己其实学到的不多，所以明天有些内容学会略读，学会抓住内容的痛点，继而提高效率。明天基本上一个小App就完工了(不能再拖了~.~),小成就会增加自信从而保持愉悦的心情，学习也会有很多乐趣。

  以后十二点以后尽量不写代码了，转而去思考(学习中思考是蛮重要了，学而不思则忘嘛~忘了就等于没学嘛~)

  虽然现在的学习也有些不太明确，但也渐渐明晰，知识体系慢慢在搭建，计划中二十号以后就开始专注于具体项目的分析中了，任务还蛮艰巨的，但没有挑战的人生怎能对得起自己吃的颗颗稻谷呢？！

  今天把iBook Author简单地了解下，计划中可以写两本书，一本是自己的日记，就是现在写的东西，配上优美励志的图片，是一本青春的学习历程记录。另一本是叫The iOS development，我对iOS开发中遇到知识的一个整体总结。现在突然又萌发了第三本，叫iOS程序员面试葵花宝典，专门收集面试题，祝我春节后找到工作吧~~阿门~

   我又开始闭关修炼了~

今天算是不错的开始吧，读完了薄薄的《The iOS Apprentice Getting Started》

虽然薄，但基础知识还是蛮多的，也使我理解了许多以前看视频中没有的细节介绍，感觉看文档比看视频学的知识要仔细，而且效果好。

下面摘录了一些这本书的要点：

1.局部变量和实例变量

local variables, as they only come into existence when some method action is performed and cease to exist when the action is done.

instance variable (or ivar for short), because its scope is the same as the scope of the object instance it belongs to. In other words, you use instance variables if you want to keep a certain value around, from one event to the next.

To make a distinction between the two types of variables, so that it’s always clear at a glance how long they will live, the names of instance variables are often prefixed with an underscore. That’s why you wrote _currentValue instead of just currentValue. This is not a requirement, but it is customary among Objective-C programmers.

I would like to point out one more time the difference between local variables and instance variables (or “ivars”). As you should know by now, a local variable only exists for the duration of the method that it is defined in, while an instance variable exists as long as the view controller (the object that owns it) exists.

Local variables are easy to recognize, because the first time they are used inside a method their name is preceded with a datatype, in this case int, NSString and UIAlertView.This syntax creates a new variable. Because the variable is created inside the method, it is restricted to that method only and does not exist outside of it. As soon as the method is done, the local variables cease to exist. The next time that method is invoked, these local variables are created anew.

 The instance variables,you can use them from any method, without the need to declare them again.

 To make the distinction between instance variables and local variables extra clear, it is a convention among Objective-C programmers to begin the names of instance variables with an underscore. That’s why you keep track of the total score in a variable named _score, so that it does not get confused for a local variable.

 Tip: Xcode will give a warning when you attempt to use the name of an instance variable for a local variable. It will say something to the effect of, “Local declaration of '_score' hides instance variable”. It’s not recommended to have a local variable that is named the same as an instance variable, because the local one takes precedence over the instance variable and effectively “hides” it. If you’re unaware of this overlap, you could be sneaking bugs into your app that will be very hard to find. It is always a good idea to pay attention to the warnings of Xcode. They may save you from doing things you did not really intend to. Small mistakes are easy to make!

  2.新版Xcode无需加’synthesize’

If you’ve played with Objective-C before, you may have heard that you need to “synthesize” your properties before you can use them. That used to be true but with the latest versions of Xcode, adding the @synthesize directive for your properties is no longer necessary. Simply add the @property line, connect the outlet in the storyboard, and you’re all set.

3.Properties VS. instance variables 属性和实例变量

Properties and instance variables have a lot in common. In fact, when you create a property, it is “backed” by an instance variable. That means your slider property stores its value in an instance variable named _slider (note the leading underscore). This instance variable was automatically added to the view controller by the Objective-C compiler.

Why? Well, a property needs to store its value somewhere and an instance variable is a good place for that. You can tell the difference between the two because properties are always accessed using self.

This uses the property:

self.slider.value = 50;

This uses the backing instance variable directly:

_slider.value = 50;

So what is the added benefit of using a property over an instance variable? There are several reasons but mainly instance variables are supposed to be used only by the insides of an object. Other objects aren’t intended to see them or use them.

Properties, however, can be accessed by other objects that are outside of your view controller.

4.Action method VS. normal methods

So what is the difference between an action method and a regular method? Nothing. An action method is really just the same as any other method. The only special thing is the (IBAction) specifier. This allows Interface Builder to see the method so you can hook it up to your buttons, sliders, and so on.

Other methods, such as viewDidLoad, do not have the IBAction specifier. This is a good thing because all kinds of mayhem would occur if you hooked them up to your buttons.

This is the simple form of an action method:

- (IBAction)doSomething;

You can also ask for a reference to the object that triggered this action:

- (IBAction)buttonTapped:(UIButton *)button;

  5.Delegates in three steps

 Delegates are used everywhere in the iOS SDK, so it’s good to remember that it always takes three steps to become someone’s delegate.

1) You declare yourself capable of being a delegate. Here, you did that by including <UIAlertViewDelegate> in your @interface line. This tells the

compiler that the view controller can actually handle the notification messages that are sent to it.

2) You let the object in question, in this case the UIAlertView, know that you wish to become its delegate. If you forget to tell the alert view that it has a delegate, then it will never send you any notifications.

3) Implement the delegate methods. It makes no point to become a delegate if you’re not responding to the messages you’re being sent! Often, delegate methods are optional, so you don’t need to implement all of them. For example, UIAlertViewDelegate actually declares seven different methods but for this app you only care about alertView:didDismissWithButtonIndex:.

  6.Note that instance variables have a default value of 0

7. Function VS. Method

8. listener pattern  VS. observer pattern

9.Storyboards have a neat trick for this: segues (pronounced “seg-way” like the silly scooters). A segue is a transition from one screen to another and they are really easy to add.

10.Hide Status Bar

Go to the Project Settings screen and under Deployment Info, Status Bar Style, check the option Hide during application launch.

 - (BOOL)prefersStatusBarHidden {

      return YES; 

       }

11.It’s only a small detail but the difference between a mediocre app and a great app is that great apps do all the small details right.

  12.Images should be in PNG format

    开始学习已经整整一周了，小结一下。

    第一天看了一天的苹果官方文档，我感觉效率极差，而且容易使人睡觉，看完后其实也没记住多少（怪自己没总结？）。

    第二天，听了建议，开始看完整的项目代码，可是当我看了代码后，感觉无从下手，就如同界面的设计，以前我只学过storeboard，没有接触过xib文件的界面设计，网上查了资料，还是不太懂。

    第三天学了Category，内存管理，ARC，第三方类库，以及调试中出现的几个问题的解答。

    第四天和第五天，因为一个涉及本地虚拟主机的小例子耽误了好多时间，不过涉及的还蛮多的比如Apache和PHP，MySQL的搭建，应用和服务器的通信等等。

    昨天和今天，小堕落了下，只完成了一个很简单的例子，看了几部电影。。。。

    前一周，算是有些收获吧，但感觉我还可以做得更好的。

    想了想，在下一个学习阶段应作出如下调整：

    1.学习周期调整为三天（7天实在是太长了，很容易堕落）

    2.每天需要简单地总结（我一直以为，即使没有收获，一天的总结也会让人有所收获，并能反省自己）

    3.三天一篇技术总结（知识有时候需要写出来才能记得牢，而且会有成就感，使自己进步）

    4.暂且以这个网站http://www.raywenderlich.com/tutorials 的内容为学习路线

    5.总结争取在12点之前完成

    6.每天应该列出要完成的目标

    7.培养好的作息和饮食习惯（健康的身体很重要！)

  今天开始分析具体的应用实例了，利用的是OSChina的客户端，发现要学习的东西蛮多的。

  首先是第三方类库的使用，大概了解了下流程，但还不太熟悉，明天要总结一下。

  基础部分，把类别(Category)学了下，写了个字符串翻转的小例子 

    看了下应用中UI是用xib写的，我没接触过，我只用过storyboard来写UI控件，得查查资料学习一下。

    今天还把Objective-C的内存管理学了学，有些还不太懂，等差不多理解了，然后总结下。文档中是这样介绍的：

Objective-C provides two methods of application memory management.

1.In the method described in this guide, referred to as “manual retain-release” or MRR, you explicitly manage memory by keeping track of objects you own. This is implemented using a model, known as reference counting, that the Foundation class NSObject provides in conjunction with the runtime environment.

  2.In Automatic Reference Counting, or ARC, the system uses the same reference counting system as MRR, but it inserts the appropriate memory management method calls for you at compile-time. You are strongly encouraged to use ARC for new projects. If you use ARC, there is typically no need to understand the underlying implementation described in this document, although it may in some situations be helpful. For more about ARC, see Transitioning to ARC Release Notes . 

   查了下，ARC现在都广泛使用了，而且不用再考虑retain,assign,dealloc这些关键字了。关于ARC看了几篇博客文章，总结得非常好：

http://www.raywenderlich.com/zh-hans/20855/ios-5-arc-入门-13

http://onevcat.com/2012/06/arc-hand-by-hand/

    期待某一天，我也能写出这样的文章。

    今天第一次用StackOverFlow解决具体的问题，感觉不错。

   今天是60天学习计划的第一天。     想想学习ios一个多月以来，除了把CS103p 2012-2013 Winter的课程看完，课堂程序敲了一些以外，也没啥收获的地方，并且最后几节的课程都是走马观花地看一看，也没有理解。还有通过准备找实习工作的一段时间使我对自己有了重新认识，我是一个动手能力很差、学的东西都很浅的一个人。     但这些也使我对iOS开发的学习有了一个比较明晰的道路，所以我打算重新开始学习iOS.     漫无目的地学习是很低效的，所以一定要有明确的目标。我觉得昨天那幅学习路线图就是很好的指引。我以前看过一本Objective—C的书籍，感觉看完后收获不大，而且看书会很消耗时间，不适合我这样的人。今天看了一些苹果官方的文档，感觉还不错，理解起来不是很吃力，而且篇幅不算很长。所以今后的学习方向为：制定大致的学习计划——>明确一天的学习任务——>官方文档+Google+视频+项目训练+微博(拓展视野)+总结——>提高学习方法和技术等级。     一定的代码量是保证实践水平提升的重要方法，所以每天都应该编码，理解其中重要的知识点，而且要做书面的总结。     有一些网站是自己每天必去的地方：     iOS Developer Library:  https://developer.apple.com/library/ios/navigation/  权威机构的文档，必看     Stackoverflow:  http://stackoverflow.com   虽然现在上面很多问题都不会，但每个tag下的介绍和链接还是蛮好的，争取早日自己的reputation有所突破。     Github: https://github.com  以后自己做的项目要放在上面     CS 193p iPhone Application Development :  http://www.stanford.edu/class/cs193p/cgi-bin/drupal/  算是世界上最好的iOS入门学习视频吧，要慢慢理解其中每一节的内容     其他的内容我觉得Google可以解决.     今天看了一个苹果的关于Objective—C的文档：Programming With Objective-C 128页的内容，看了64页，今天的效率着实不高，明天要提高，文档在这：https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html     下面是一些摘抄的主要内容：

Objective-C

The class interface  specifies exactly how a given type of object is intended to be used by other objects.In other words,it defines the public interface between instances of the class and the outside world.

The minus sign (-) at the front of the method name indicates that it is an instance method, which can be called on any instance of the class.

Historical Note: If you’re wondering why so many of the classes you encounter have an NS prefix, it’s because of the past history of Cocoa and Cocoa Touch. Cocoa began life as the collected frameworks used to build apps for the NeXTStep operating system. When Apple purchased NeXT back in 1996, much of NeXTStep was incorporated into OS X, including the existing class names. Cocoa Touch was introduced as the iOS equivalent of Cocoa; some classes are available in both Cocoa and Cocoa Touch, though there are also a large number of classes unique to each platform.

Two-letter prefixes like NS and UI (for User Interface elements on iOS) are reserved for use by Apple.

In general, method names should begin with a lowercase letter. If a method name involves multiple words, use camel case (capitalizing the first letter of each new word) to make them easy to read.

Note: If you’re used to using terms like the stack and the heap,a local variable is allocated on the stack, while objects are allocated on the heap.

Some objects need to be initialized with required values. An NSNumber object, for example, must be created with the numeric value it needs to represent.

Class Factory Methods Are an Alternative to Allocation and Initialization As mentioned in the previous chapter, a class can also define factory methods. Factory methods offer an alternative to the traditional [[alloc] init] process, without the need to nest two methods. A factory method is used like this: NSNumber *magicNumber = [NSNumber numberWithInt:42];

Objective-C Is a Dynamic Language As mentioned earlier, you need to use a pointer to keep track of an object in memory. Because of Objective-C’s dynamic nature, it doesn’t matter what specific class type you use for that pointer—the correct method will always be called on the relevant object when you send it a message.

Determining Equality of Objects if ([firstPerson isEqual:secondPerson]) 

Working with nil A nil value is the safest way to initialize an object pointer if you don’t have another value to use, because it’s perfectly acceptable in Objective-C to send a message to nil. If you do send a message to nil, obviously nothing happens. If you need to check to make sure an object is not nil (that a variable points to an object in memory), you can either use the standard C inequality operator: if (somePerson != nil) {     // somePerson points to an object } or simply supply the variable: if (somePerson) {     // somePerson points to an object } If the somePerson variable is nil, its logical value is 0 (false). If it has an address, it’s not zero, so evaluates as true. Use Accessor Methods to Get or Set Property Values By default, these accessor methods are synthesized automatically for you by the compiler, so you don’t need to do anything other than declare the property using @property in the class interface The synthesized methods follow specific naming conventions: The method used to access the value (the getter method) has the same name as the property. The getter method for a property called firstName will also be called firstName. The method used to set the value (the setter method) starts with the word “set” and then uses the capitalized property name. The setter method for a property called firstName will be called setFirstName:. Dot Syntax Is a Concise Alternative to Accessor Method Calls Getting a value using somePerson.firstName is the same as using [somePerson firstName] Setting a value using somePerson.firstName = @"Johnny" is the same as using [somePerson setFirstName:@"Johnny”] Most Properties Are Backed by Instance Variables Unless you specify otherwise, the synthesized instance variable has the same name as the property, but with an underscore prefix. For a property called firstName, for example, the synthesized instance variable will be called _firstName. - (void)someMethod {     NSString *myString = @"An interesting string";     _someString = myString; } In this example, it’s clear that myString is a local variable and _someString is an instance variable. - (void)someMethod {     NSString *myString = @"An interesting string”;     self.someString = myString;   // or     [self setSomeString:myString]; }

Note: The compiler will automatically synthesize an instance variable in all situations where it’s also synthesizing at least one accessor method. If you implement both a getter and a setter for a readwrite property, or a getter for a readonly property, the compiler will assume that you are taking control over the property implementation and won’t synthesize an instance variable automatically.

Properties Are Atomic by Default You can use the nonatomic property attribute to specify that synthesized accessors simply set or return a value directly, with no guarantees about what happens if that same value is accessed simultaneously from different threads. Property atomicity is not synonymous with an object’s thread safety Consider an XYZPerson object in which both a person’s first and last names are changed using  atomic accessors from one thread. If another thread accesses both names at the same time, the atomic getter methods will return complete strings (without crashing), but there’s no guarantee that those values will be the right names relative to each other. If the first name is accessed before the change, but the last name is accessed after the change, you’ll end up with an inconsistent, mismatched pair of names. This example is quite simple, but the problem of thread safety becomes much more complex when considered across a network of related objects.

When one object relies on other objects in this way, effectively taking ownership of those other objects, the first object is said to have strong references to the other objects. In Objective-C, an object is kept alive as long as it has at least one strong reference to it from another object. Because a weak reference doesn’t keep an object alive, it’s possible for the referenced object to be deallocated while the reference is still in use. To avoid a dangerous dangling pointer to the memory originally occupied by the now deallocated object, a weak reference is automatically set to nil when its object is deallocated.