一些笔试面试时遇到的以及自己准备的题目

问：谈谈你对网站安全的建议 
1.后台管理程序不要放在公网上，若要放在公网上，必须设定复杂的用户名和密码。这主要是因为后台管理程序可以上载文件，而上载了木马之后对计算机有较大的危害，另外，上载文家的程序必须要指定安全的类型，如不允许jsp、exe等带有破坏性的文件上传。 
2.除开WEB服务的端口，包括http和https，不要开放其它的端口。如telnet、FTP等端口，让黑客不能靠近服务器。 

3.远程管理的机器也必须设

问：上面的程序中哪个语句是错误的

 Stuct Foo{
      Foo(){}
      Foo(int){}
      void fun(){}
 };
int main (){
     Fooa(10); (1)
     a.fun(); (2)
     Foo b(); (3)
     b.fun(); (4)
}

答:（4）出错。（3）不是创建对象，而是一个函数的申明，（3）可以编译通过，而当（4）时就不行了。
 
问：struct 和 class 的区别
1.      最本质的区别：默认的继承访问权限。struct是public的，class是private的。struct作为数据结构的实现体，它的默认数据访问控制是public的，而class作为对象的实现体，他默认的城院变量访问控制是private的。
2.      struct在定义的时候可以用{}赋初值，而class不行。因为class有构造函数。受到访问控制的约束。
 
问：C++中不能被重载的运算符
重载操作符的限制：
8.1 并不是所有的操作符都能被重载。除了.  .*  ::  ? :  sizeof typeid这几个运算符不能被重载，其他运算符都能被重载
8.2 重载不能改变该运算符用于内置类型时的函义，程序员不能改变运算符+用于两个int型时的含义。
8.3 运算符函数的参数至少有一个必须是类的对象或者类的对象的引用。这种规定可以防止程序员运用运算符改变内置类型的函义。
8.4 重载不能改变运算符的优先级。
8.5 重载不能改变运算符的结合律。
8.6 重载不能改变运算符操作数的个数。比如+需要两个操作数，则重载的+也必须要有两个操作数
 
 
问：排序方法中元素比较次数与初始化排序无关的是哪种排序方法
选择排序。

每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。可以看到，每次都是遍历一遍剩下要排序的部分，找出其最大值或最小值。

问：二分查找的理论

二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

问：采取 FIFO 页面淘汰算法,如何计算缺页
什么是缺页中断：  缺页中断就是要访问的页不在主存，需要操作系统将其调入主存后再进行访问。
缺页率:在进行内存访问时，若所访问的页已在主存，则称此次访问成功；若所访问的页不在主存，则称此次访问失败，并产生缺页中断。若程序P在运行过程中访问页面的总次数为S,其中产生缺页中断的访问次数为F,则其缺页率为：F/S
FIFO：根据页面进入内存时间的长短作为置换标准。总是淘汰在内存中停留时间最长的页面，即最先进入内存的页面。这个算法的实现很简单：把一个进程所有在内存中的页按照进入内存的时间顺序组成队列，选择淘汰页面时，总是选择队首的页面，新的页面进入内存，将其放置在对尾。
LRU：当需要置换一个页面时，选择在最近一段时间最久没有使用过的页面予以淘汰。
OPT：根据今后使用页面的时间作为置换标准。

Clock:利用Clock算法时，只需为每页设置一个引用位，再将内存中所有页面都通过链接指针链接成一个环形队列，由一个指针指向最老的页面

问：页式存储系统，如何计算分块的大小
某页式存储管理中，地址寄存器长度为24位，其中页号占14位，则主存分块大小为多少字节？怎么计算？

地址寄存器24位，页号14位，那么页面大小就用10位来描述（24-14）。2的14次冥就是16K，即主存可划分为16K个页。2的10次冥就是1K，即每个页面大小为1K。

问：判断单向链表是否存在环的最佳方案是什么？

答：用两个指针，pSlow，pFast，就是一个慢一个快 慢的一次跳一步， 快的一次跳两步， 什么时候快的追上慢的了（就是pSlow == pFast || pSlow->next == pFast），就表示有环

问：Servet生命周期
Servlet生命周期分为三个阶段：
　　1，初始化阶段 调用init()方法
　　2，响应客户请求阶段　　调用service()方法
　　3，终止阶段　　调用destroy()方法
Servlet初始化阶段：
　　在下列时刻Servlet容器装载Servlet：
　　　　1，Servlet容器启动时自动装载某些Servlet，实现它只需要在web.XML文件中的<Servlet></Servlet>之间添加如下代码：
                              <loadon-startup>1</loadon-startup>
　　　　2，在Servlet容器启动后，客户首次向Servlet发送请求
　　　　3，Servlet类文件被更新后，重新装载Servlet
　　Servlet被装载后，Servlet容器创建一个Servlet实例并且调用Servlet的init()方法进行初始化。在Servlet的整个生命周期内，init()方法只被调用一次。
Servlet工作原理：
　　首先简单解释一下Servlet接收和响应客户请求的过程，首先客户发送一个请求，Servlet是调用service()方法对请求进行响应的，通过源代码可见，service()方法中对请求的方式进行了匹配，选择调用doGet,doPost等这些方法，然后再进入对应的方法中调用逻辑层的方法，实现对客户的响应。在Servlet接口和GenericServlet中是没有doGet,doPost等等这些方法的，HttpServlet中定义了这些方法，但是都是返回error信息，所以，我们每次定义一个Servlet的时候，都必须实现doGet或doPost等这些方法。
　　每一个自定义的Servlet都必须实现Servlet的接口，Servlet接口中定义了五个方法，其中比较重要的三个方法涉及到Servlet的生命周期，分别是上文提到的init(),service(),destroy()方法。GenericServlet是一个通用的，不特定于任何协议的Servlet,它实现了Servlet接口。而HttpServlet继承于GenericServlet，因此HttpServlet也实现了Servlet接口。所以我们定义Servlet的时候只需要继承HttpServlet即可。
　　Servlet接口和GenericServlet是不特定于任何协议的，而HttpServlet是特定于HTTP协议的类，所以HttpServlet中实现了service()方法，并将请求ServletRequest,ServletResponse强转为HttpRequest和HttpResponse。

public void service(ServletRequest req,ServletResponse res) 
  throws ServletException,IOException
{
      HttpRequest request;
      HttpResponse response;
  
     try
     {
         req = (HttpRequest)request;
         res = (HttpResponse)response;
      }catch(ClassCastException e)
      {
         throw new ServletException("non-HTTP request response"); 
      }
      service(request,response);
}

   代码的最后调用了HTTPServlet自己的service(request,response)方法，然后根据请求去调用对应的doXXX方法，因为HttpServlet中的doXXX方法都是返回错误信息，

protected void doGet(HttpServletRequest res,HttpServletResponse resp)
  throws ServletException,IOException
{
   String protocol = req.getProtocol();
   String msg = IStrings.getString("http.method_get_not_supported");
   if(protocol.equals("1.1"))
   {
      resp.sendError(HttpServletResponse.SC.METHOD.NOT.ALLOWED,msg);
    }
   esle
    {
      resp.sendError(HttpServletResponse.SC_BAD_REQUEST,msg);
    }
}

所以需要我们在自定义的Servlet中override这些方法！
源码面前，了无秘密！
---------------------------------------------------------------------------------------------------------------------------------
Servlet响应请求阶段：
　　对于用户到达Servlet的请求，Servlet容器会创建特定于这个请求的ServletRequest对象和ServletResponse对象，然后调用Servlet的service方法。service方法从ServletRequest对象获得客户请求信息，处理该请求，并通过ServletResponse对象向客户返回响应信息。
　　对于Tomcat来说，它会将传递过来的参数放在一个Hashtable中，该Hashtable的定义是：
private Hashtable<String String[]> paramHashStringArray = newHashtable<String String[]>();
　　这是一个String-->String[]的键值映射。
　　HashMap线程不安全的，Hashtable线程安全。
-----------------------------------------------------------------------------------------------------------------------------------
Servlet终止阶段：
　　当WEB应用被终止，或Servlet容器终止运行，或Servlet容器重新装载Servlet新实例时，Servlet容器会先调用Servlet的destroy()方法，在destroy()方法中可以释放掉Servlet所占用的资源。
-----------------------------------------------------------------------------------------------------------------------------------
Servlet何时被创建：
　　1，默认情况下，当WEB客户第一次请求访问某个Servlet的时候，WEB容器将创建这个Servlet的实例。
　　2，当web.xml文件中如果<servlet>元素中指定了<load-on-startup>子元素时，Servlet容器在启动web服务器时，将按照顺序创建并初始化Servlet对象。
　　注意：在web.xml文件中，某些Servlet只有<serlvet>元素，没有<servlet-mapping>元素，这样我们无法通过url的方式访问这些Servlet，这种Servlet通常会在<servlet>元素中配置一个<load-on-startup>子元素，让容器在启动的时候自动加载这些Servlet并调用init()方法，完成一些全局性的初始化工作。
 
Web应用何时被启动：
　　1，当Servlet容器启动的时候，所有的Web应用都会被启动
　　2，控制器启动web应用
-----------------------------------------------------------------------------------------------------------------------------------------------
Servlet与JSP的比较：
　　有许多相似之处，都可以生成动态网页。
　　JSP的优点是擅长于网页制作，生成动态页面比较直观，缺点是不容易跟踪与排错。

　　Servlet是纯Java语言，擅长于处理流程和业务逻辑，缺点是生成动态网页不直观。

问：在try的括号里面有return一个值，那是否还执行finally里的代码。是在return前执行还是return后执行

在return之后，函数返回之前

问：final,finally,finalize的区别
final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。
finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入finally 块（如果有的话）。

finalize—方法名。Java 技术允许使用finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

问：接口和抽象类有什么区别？你选择使用接口和抽象类的依据是什么？
接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。
抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。
人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.
所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。
第一点． 接口是抽象类的变体，接口中所有的方法都是抽象的。而抽象类是声明方法的存在而不去实现它的类。
第二点． 接口可以继承，抽象类不行
第三点． 接口定义方法，不能实现，而抽象类可以实现部分方法。
第四点． 接口中基本数据类型为static 而抽类象不是的。
当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。
 
接口可以实现也可以继承，抽象类不行
抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的
所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度的。
 
问：下列哪一个关键码序列不符合堆的定义？( C )
A. a、c、d、g、h、m、p、q、r、x B. a、c、m、d、h、p、x、g、o、r
C. a、d、p、r、c、q、x、m、h、g D. a、d、c、m、p、g、h、x、r、q
 
从答案看，都是小根堆关键码序列，根据小根堆的定义，
K[i]<= K[2i]
K[i]<= K[2i+1]
用完全二叉树表示很直观，也就是要能组成这样一个完全二叉树：
所有的父结点的值都应该小于左右子孩子结点的值。
 
答案c中关键码序列用完全二叉树表示后很容易看出，在d结点值d大于了左子结点值c，这不符合小根堆定义,同样在r结点值r大于了左子结点值m和右子结点值n。
 
而其他答案都符合小根堆定义。
 
因为关键码序列是符合小根堆定义的一个序列，他是完全二叉树中关键字从根开始从上到下，从左到右的这样一个顺序，也即符合完全二叉树中子树结点是父结点k[2i]和k[2i+1]的。比如答案a组成的完全二叉树如下：
----------------a----------------
-----------c---------d
--------g-----h-----m--p

------q--r---x

问：在 SOCKET 通信过程中,下列哪些函数是客户端需要调用,但是服务端不需要调用的函数?

1. socket() 2. bind() 3. connect()4. send()

socket(),
创建一个用来通信的socket，函数创建成功返回成功的socket值，失败返回-1.

该函数服务端和客户端都需要调用。

bind(),
将一个socket与一个计算机IP/端口绑定。绑定后，该端口可以监听到这个socket的信息。
函数调用成功返回0，失败返回-1.

该函数服务端需要调用

listen(),
监听一个socket端口，看是否有客户端连接的请求，
函数成功返回0，失败返回-1

该函数服务端需要调用

connect(),
客户端连接函数，连接成功服务端后，才可以与服务端通信。
函数成功返回0，失败返回-1.

该函数客户端需要调用。

accept()
接受到客户端的请求，返回一个新的socket，返回新的socket用来发送和接受数据，而原来的socket可以继续监听连接请求。
函数调用成功返回一个新的socket值，失败返回-1.

该函数服务端需要调用

所以：
服务端调用API的顺序是：
socket（）A创建一个socketA
bind () A将socketA与server的IP，端口绑定
listen() A，监听socketA上是否有客户端连接的请求
accept（A）返回socket B，如果A上接受到一个客户端的请求，会得到一个用来与这个客户端接受发送数据的socketB
客户端调用API的顺序是：
socket A,建立一个通信用的socketA
connect A，用A连接一个服务端

如果客户端与服务端连接成功，双方可以用recv（）来接受数据，用sendto()发送数据。

问：将网络地址映射为链路层相应地址的协议是（ C ）

A.DNS   B.TCP  C.ARP   D.RARP

问：交换机不具有下面哪项功能？【 C 】

 A、转发过滤     B、回路避免      C、路由转发      D、地址学习

问：求运行结果（）

public class Test { 
   public static final String MESSAGE="taobao"; 
   public static void main(String[] args) { 
      String a = "tao"+"bao"; 
      String b = "tao"; 
      String c = "bao"; 
      System.out.println(a==MESSAGE);     
      System.out.println( (b+c)==MESSAGE);   
   } 
} 

对于这道题，考察的是对String类型的认识以及编译器优化。Java中String不是基本类型，但是有些时候和基本类型差不多，如String b = "tao"; 可以对变量直接赋值，而不用 new 一个对象（当然也可以用 new）。所以String这个类型值得好好研究下。
Java中的变量和基本类型的值存放于栈内存，而new出来的对象本身存放于堆内存，指向对象的引用还是存放在栈内存。例如如下的代码：
int i=1; 
String s = new String("HelloWorld");  
变量i和s以及1存放在栈内存，而s指向的对象”Hello World”存放于堆内存。
栈内存的一个特点是数据共享，这样设计是为了减小内存消耗，前面定义了i=1，i和1都在栈内存内，如果再定义一个j=1，此时将j放入栈内存，然后查找栈内存中是否有1，如果有则j指向1。如果再给j赋值2，则在栈内存中查找是否有2，如果没有就在栈内存中放一个2，然后j指向2。也就是如果常量在栈内存中，就将变量指向该常量，如果没有就在该栈内存增加一个该常量，并将变量指向该常量。
如果j++，这时指向的变量并不会改变，而是在栈内寻找新的常量（比原来的常量大1），如果栈内存有则指向它，如果没有就在栈内存中加入此常量并将j指向它。这种基本类型之间比较大小和我们逻辑上判断大小是一致的。如定义i和j是都赋值1，则i==j结果为true。==用于判断两个变量指向的地址是否一样。i==j就是判断i指向的1和j指向的1是同一个吗？当然是了。对于直接赋值的字符串常量（如String s=“Hello World”；中的Hello World）也是存放在栈内存中，而new出来的字符串对象（即String对象）是存放在堆内存中。如果定义String s=“Hello World”和String w=“Hello World”，s==w吗？肯定是true，因为他们指向的是同一个Hello World。
堆内存没有数据共享的特点，前面定义的String s = new String("Hello World");后，变量s在栈内存内，Hello World 这个String对象在堆内存内。如果定义Stringw =new String("Hello World");，则会在堆内存创建一个新的String对象，变量w存放在栈内存，w指向这个新的String对象。堆内存中不同对象（指同一类型的不同对象）的比较如果用==则结果肯定都是false，比如s==w？当然不等，s和w指向堆内存中不同的String对象。如果判断两个String对象相等呢？用equals方法。
说了这么多只是说了这道题的铺垫知识，还没进入主题，下面分析这道题。MESSAGE成员变量及其指向的字符串常量肯定都是在栈内存里的，变量a运算完也是指向一个字符串“taobao”啊？是不是同一个呢？这涉及到编译器优化问题。对于字符串常量的相加，在编译时直接将字符串合并，而不是等到运行时再合并。也就是说String a = "tao"+"bao";和String a = "taobao";编译出的字节码是一样的。所以等到运行时，根据上面说的栈内存是数据共享原则，a和MESSAGE指向的是同一个字符串。而对于后面的(b+c)又是什么情况呢？b+c只能等到运行时才能判定是什么字符串，编译器不会优化，想想这也是有道理的，编译器怕你对b的值改变，所以编译器不会优化。运行时b+c计算出来的"taobao"和栈内存里已经有的"taobao"是一个吗？不是。b+c计算出来的"taobao"应该是放在堆内存中的String对象。这可以通过System.out.println((b+c)==MESSAGE);的结果为false来证明这一点。如果计算出来的b+c也是在栈内存，那结果应该是true。Java对String的相加是通过StringBuffer实现的，先构造一个StringBuffer里面存放”tao”,然后调用append()方法追加”bao”，然后将值为”taobao”的StringBuffer转化成String对象。StringBuffer对象在堆内存中，那转换成的String对象理所应当的也是在堆内存中。下面改造一下这个语句System.out.println( (b+c).intern()==MESSAGE);结果是true，intern()方法会先检查String池(或者说成栈内存)中是否存在相同的字符串常量，如果有就返回。所以intern()返回的就是MESSAGE指向的"taobao"。再把变量b和c的定义改一下

final String b = "tao"; 
final String c = "bao"; 
System.out.println( (b+c)==MESSAGE); 

现在b和c不可能再次赋值了，所以编译器将b+c编译成了”taobao”。因此，这时的结果是true。
在字符串相加中，只要有一个是非final类型的变量，编译器就不会优化，因为这样的变量可能发生改变，所以编译器不可能将这样的变量替换成常量。例如将变量b的final去掉，结果又变成了false。这也就意味着会用到StringBuffer对象，计算的结果在堆内存中。
    如果对指向堆内存中的对象的String变量调用intern()会怎么样呢？实际上这个问题已经说过了，(b+c).intern()，b+c的结果就是在堆内存中。对于指向栈内存中字符串常量的变量调用intern()返回的还是它自己，没有多大意义。它会根据堆内存中对象的值，去查找String池中是否有相同的字符串，如果有就将变量指向这个string池中的变量。

String a ="tao"+"bao"; 
String b = newString("taobao"); 
System.out.println(a==MESSAGE); //true  
System.out.println(b==MESSAGE);  //false 
b = b.intern(); 
System.out.println(b==MESSAGE); //true 
System.out.println(a==a.intern());//true  

问:堆和栈的区别？
管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。
申请大小：
栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。
碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出
分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。

分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的。

问：定义属性时，什么情况使用copy、assign、retain？
assign用于简单数据类型，如NSInteger,double,bool,
retain和copy用于对象，
copy用于当a指向一个对象，b也想指向同样的对象的时候，如果用assign，a如果释放，再调用b会crash,如果用copy 的方式，a和b各自有自己的内存，就可以解决这个问题。
retain 会使计数器加一，也可以解决assign的问题。
另外：atomic和nonatomic用来决定编译器生成的getter和setter是否为原子操作。在多线程环境下，原子操作是必要的，否则有可能引起错误的结果。
加了atomic，setter函数会变成下面这样：
if (property != newValue) {
[property release];
property = [newValue retain];

}

iOS有没有垃圾回收？
Objective-C 2.0也是有垃圾回收机制的，但是只能在Mac OS X Leopard 10.5 以上的版本使用。

tableView的重用机制？
　查看UITableView头文件，会找到NSMutableArray*  visiableCells，和NSMutableDictnery* reusableTableCells两个结构。visiableCells内保存当前显示的cells，reusableTableCells保存可重用的cells。
　　TableView显示之初，reusableTableCells为空，那么tableView dequeueReusableCellWithIdentifier:CellIdentifier返回nil。开始的cell都是通过[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier]来创建，而且cellForRowAtIndexPath只是调用最大显示cell数的次数。
　　比如：有100条数据，iPhone一屏最多显示10个cell。程序最开始显示TableView的情况是：
　　1. 用[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier]创建10次cell，并给cell指定同样的重用标识(当然，可以为不同显示类型的cell指定不同的标识)。并且10个cell全部都加入到visiableCells数组，reusableTableCells为空。
　　2. 向下拖动tableView，当cell1完全移出屏幕，并且cell11(它也是alloc出来的，原因同上)完全显示出来的时候。cell11加入到visiableCells，cell1移出visiableCells，cell1加入到reusableTableCells。
3. 接着向下拖动tableView，因为reusableTableCells中已经有值，所以，当需要显示新的cell，cellForRowAtIndexPath再次被调用的时候，tableView dequeueReusableCellWithIdentifier:CellIdentifier，返回cell1。cell1加入到visiableCells，cell1移出reusableTableCells；cell2移出visiableCells，cell2加入到reusableTableCells。之后再需要显示的Cell就可以正常重用了。

问：ViewController 的loadView、viewDidLoad、viewDidUnload分别是什么时候调用的，在自定义ViewCointroller时在这几个函数中应该做什么工作？
由init、loadView、viewDidLoad、viewDidUnload、dealloc的关系说起

init方法
在init方法中实例化必要的对象（遵从LazyLoad思想）
init方法中初始化ViewController本身

loadView方法
当view需要被展示而它却是nil时，viewController会调用该方法。不要直接调用该方法。
如果手工维护views，必须重载重写该方法
如果使用IB维护views，必须不能重载重写该方法
loadView和IB构建view
你在控制器中实现了loadView方法，那么你可能会在应用运行的某个时候被内存管理控制调用。 如果设备内存不足的时候， view 控制器会收到didReceiveMemoryWarning的消息。 默认的实现是检查当前控制器的view是否在使用。 如果它的view不在当前正在使用的view hierarchy里面，且你的控制器实现了loadView方法，那么这个view将被release, loadView方法将被再次调用来创建一个新的view。

viewDidLoad方法
viewDidLoad 此方法只有当view从nib文件初始化的时候才被调用。
重载重写该方法以进一步定制view
在iPhone OS 3.0及之后的版本中，还应该重载重写viewDidUnload来释放对view的任何索引
viewDidLoad后调用数据Model

viewDidUnload方法
当系统内存吃紧的时候会调用该方法（注：viewController没有被dealloc）
内存吃紧时，在iPhone OS 3.0之前didReceiveMemoryWarning是释放无用内存的唯一方式，但是OS 3.0及以后viewDidUnload方法是更好的方式
在该方法中将所有IBOutlet（无论是property还是实例变量）置为nil（系统release view时已经将其release掉了）
在该方法中释放其他与view有关的对象、其他在运行时创建（但非系统必须）的对象、在viewDidLoad中被创建的对象、缓存数据等 release对象后，将对象置为nil（IBOutlet只需要将其置为nil，系统release view时已经将其release掉了）
一般认为viewDidUnload是viewDidLoad的镜像，因为当view被重新请求时，viewDidLoad还会重新被执行
viewDidUnload中被release的对象必须是很容易被重新创建的对象（比如在viewDidLoad或其他方法中创建的对象），不要release用户数据或其他很难被重新创建的对象

dealloc方法
viewDidUnload和dealloc方法没有关联，dealloc还是继续做它该做的事情

问：ViewController的didReceiveMemoryWarning是在什么时候调用的？默认的操作是什么？

当程序接到内存警告时View Controller将会收到这个消息：didReceiveMemoryWarning

从iOS3.0开始，不需要重载这个函数，把释放内存的代码放到viewDidUnload中去。

这个函数的默认实现是:检查controller是否可以安全地释放它的view(这里加粗的view指的是controller的view属性)，比如view本身没有superview并且可以被很容易地重建（从nib或者loadView函数）。

如果view可以被释放，那么这个函数释放view并调用viewDidUnload。

你可以重载这个函数来释放controller中使用的其他内存。但要记得调用这个函数的super实现来允许父类（一般是UIVIewController）释放view。

如果你的ViewController保存着view的子view的引用，那么，在早期的iOS版本中，你应该在这个函数中来释放这些引用。而在iOS3.0或更高版本中，你应该在viewDidUnload中释放这些引用。

问：delegate和notification区别，分别在什么情况下使用？
KVC(Key-Value-Coding)
KVO（Key-Value-Observing）
理解KVC与KVO（键-值-编码与键-值-监看）
当通过KVC调用对象时，比如：[self valueForKey:@”someKey”]时，程序会自动试图通过几种不同的方式解析这个调用。首先查找对象是否带有 someKey 这个方法，如果没找到，会继续查找对象是否带有someKey这个实例变量（iVar），如果还没有找到，程序会继续试图调用 -(id) valueForUndefinedKey:这个方法。如果这个方法还是没有被实现的话，程序会抛出一个NSUndefinedKeyException异常错误。
(Key-Value Coding查找方法的时候，不仅仅会查找someKey这个方法，还会查找getsomeKey这个方法，前面加一个get，或者_someKey以及_getsomeKey这几种形式。同时，查找实例变量的时候也会不仅仅查找someKey这个变量，也会查找_someKey这个变量是否存在。)
设计valueForUndefinedKey:方法的主要目的是当你使用-(id)valueForKey方法从对象中请求值时，对象能够在错误发生前，有最后的机会响应这个请求。

问：id、nil代表什么？
id
id和void *并非完全一样。在上面的代码中，id是指向struct objc_object的一个指针，这个意思基本上是说，id是一个指向任何一个继承了Object（或者NSObject）类的对象。需要注意的是id是一个指针，所以你在使用id的时候不需要加星号。比如id foo=nil定义了一个nil指针，这个指针指向NSObject的一个任意子类。而id *foo=nil则定义了一个指针，这个指针指向另一个指针，被指向的这个指针指向NSObject的一个子类。
 
nil
nil和C语言的NULL相同，在objc/objc.h中定义。nil表示一个Objctive-C对象，这个对象的指针指向空（没有东西就是空）。