前言：

按照时间顺序，事件的生命周期是这样的：

　　事件的产生和传递（事件如何从父控件传递到子控件并寻找到最合适的view、寻找最合适的view的底层实现、拦截事件的处理）->找到最合适的view后事件的处理（touches方法的重写，也就是事件的响应）

章节顺序正好和事件的时间顺序相反：

　　事件处理->事件的产生和传递

其中重点和难点是：

　　1.如何寻找最合适的view

　　2.寻找最合适的view的底层实现（hitTest:withEvent:底层实现）

（一）iOS中的事件

iOS中的事件可以分为3大类型：
- 触摸事件
- 加速计事件
- 远程控制事件
这里我们只讨论iOS中的触摸事件。

1.1.响应者对象(UIResponder)

学习触摸事件首先要了解一个比较重要的概念-响应者对象（UIResponder）。

在iOS中不是任何对象都能处理事件，只有继承了UIResponder的对象才能接受并处理事件，我们称之为“响应者对象”。以下都是继承自UIResponder的，所以都能接收并处理事件。
- UIApplication
- UIViewController
- UIView

那么为什么继承自UIResponder的类就能够接收并处理事件呢？

　　因为UIResponder中提供了以下4个对象方法来处理触摸事件。

UIResponder内部提供了以下方法来处理事件

触摸事件

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event;

- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event;

- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event;

- (void)touchesCancelled:(NSSet *)touches withEvent:(UIEvent *)event;

加速计事件

- (void)motionBegan:(UIEventSubtype)motion withEvent:(UIEvent *)event;

- (void)motionEnded:(UIEventSubtype)motion withEvent:(UIEvent *)event;

- (void)motionCancelled:(UIEventSubtype)motion withEvent:(UIEvent *)event;

远程控制事件

- (void)remoteControlReceivedWithEvent:(UIEvent *)event;

-----------------------------------------------------------

（二）事件的处理

下面以UIView为例来说明触摸事件的处理。

// UIView是UIResponder的子类，可以覆盖下列4个方法处理不同的触摸事件

// 一根或者多根手指开始触摸view，系统会自动调用view的下面方法

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event

// 一根或者多根手指在view上移动，系统会自动调用view的下面方法（随着手指的移动，会持续调用该方法）

- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event

// 一根或者多根手指离开view，系统会自动调用view的下面方法

- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event

// 触摸结束前，某个系统事件(例如电话呼入)会打断触摸过程，系统会自动调用view的下面方法

- (void)touchesCancelled:(NSSet *)touches withEvent:(UIEvent *)event

// 提示：touches中存放的都是UITouch对象

需要注意的是：以上四个方法是由系统自动调用的，所以可以通过重写该方法来处理一些事件。

如果两根手指同时触摸一个view，那么view只会调用一次touchesBegan:withEvent:方法，touches参数中装着2个UITouch对象
如果这两根手指一前一后分开触摸同一个view，那么view会分别调用2次touchesBegan:withEvent:方法，并且每次调用时的touches参数中只包含一个UITouch对象
重写以上四个方法，如果是处理UIView的触摸事件。必须要自定义UIView子类继承自UIView。因为苹果不开源，没有把UIView的.m文件提供给我们。我们只能通过子类继承父类，重写子类方法的方式处理UIView的触摸事件（注意：我说的是UIView触摸事件而不是说的 UIViewController的触摸事件）。如果是处理UIViewController的触摸事件，那么在控制器的.m文件中直接重写那四个方法即可！

/************************自定义UIView的.h文件************************/

#import <UIKit/UIKit.h>

@interface WSView : UIView

@end

/************************自定义UIView的.m文件***********************/

#import "WSView.h"

@implementation WSView

// 开始触摸时就会调用一次这个方法

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event

{

    NSLog(@"摸我干啥！");

}

// 手指移动就会调用这个方法

// 这个方法调用非常频繁

- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event

{

    NSLog(@"哎呀，不要拽人家！");

}

// 手指离开屏幕时就会调用一次这个方法

- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event

{

    NSLog(@"手放开还能继续玩耍！");

}

@end

/**************************k控制器的.m文件*************************/

#import "ViewController.h"

#import "WSView.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {

    [super viewDidLoad];

    // 创建自定义view

    WSView *touchView = [[WSView alloc] initWithFrame:CGRectMake(100, 100, 100, 100)];

    // 背景颜色

    touchView.backgroundColor = [UIColor redColor];

    // 添加到父控件

    [self.view addSubview:touchView];

}

@end

注意：有人认为，我要是处理控制器的自带的view的事件就不需要自定义UIView子类继承于UIView，因为可以在viewController.m 文件中重写touchBegan:withEvent:方法，但是，我们此处讨论的是处理UIView的触摸事件，而不是处理 UIViewController的触摸事件。你是在viewController.m文件中重写touchBegan:withEvent:方法，相当于处理的是viewController的触摸事件，因为viewController也是继承自UIResponder，所以会给人一种错觉。

所以，还是那句话，想处理UIView的触摸事件，必须自定义UIView子类继承自UIView。

2.1.UIView的拖拽

那么，如何实现UIView的拖拽呢?也就是让UIView随着手指的移动而移动。

　　重写touchsMoved:withEvent:方法

此时需要用到参数touches，下面是UITouch的属性和方法：

NS_CLASS_AVAILABLE_IOS(2_0) @interface UITouch : NSObject

@property(nonatomic,readonly) NSTimeInterval      timestamp;

@property(nonatomic,readonly) UITouchPhase        phase;

@property(nonatomic,readonly) NSUInteger          tapCount;   // touch down within a certain point within a certain amount of time

// majorRadius and majorRadiusTolerance are in points

// The majorRadius will be accurate +/- the majorRadiusTolerance

@property(nonatomic,readonly) CGFloat majorRadius NS_AVAILABLE_IOS(8_0);

@property(nonatomic,readonly) CGFloat majorRadiusTolerance NS_AVAILABLE_IOS(8_0);

@property(nonatomic,readonly,retain) UIWindow    *window;

@property(nonatomic,readonly,retain) UIView      *view;

@property(nonatomic,readonly,copy)   NSArray     *gestureRecognizers NS_AVAILABLE_IOS(3_2);

- (CGPoint)locationInView:(UIView *)view;

- (CGPoint)previousLocationInView:(UIView *)view;

@end

2.1.1.UITouch对象

当用户用一根手指触摸屏幕时，会创建一个与手指相关的UITouch对象
一根手指对应一个UITouch对象

如果两根手指同时触摸一个view，那么view只会调用一次touchesBegan:withEvent:方法，touches参数中装着2个UITouch对象
如果这两根手指一前一后分开触摸同一个view，那么view会分别调用2次touchesBegan:withEvent:方法，并且每次调用时的touches参数中只包含一个UITouch对象

2.1.1.1.UITouch的作用

保存着跟手指相关的信息，比如触摸的位置、时间、阶段
当手指移动时，系统会更新同一个UITouch对象，使之能够一直保存该手指在的触摸位置
当手指离开屏幕时，系统会销毁相应的UITouch对象
提示：iPhone开发中，要避免使用双击事件！

2.1.1.2.UITouch的属性

触摸产生时所处的窗口
- @property(nonatomic,readonly,retain) UIWindow *window;
触摸产生时所处的视图
- @property(nonatomic,readonly,retain) UIView *view;
短时间内点按屏幕的次数，可以根据tapCount判断单击、双击或更多的点击
- @property(nonatomic,readonly) NSUInteger tapCount;
记录了触摸事件产生或变化时的时间，单位是秒
- @property(nonatomic,readonly) NSTimeInterval timestamp;
当前触摸事件所处的状态
- @property(nonatomic,readonly) UITouchPhase phase;

2.1.1.3.UITouch的方法

(CGPoint)locationInView:(UIView *)view;
- 返回值表示触摸在view上的位置
- 这里返回的位置是针对view的坐标系的（以view的左上角为原点(0, 0)）
- 调用时传入的view参数为nil的话，返回的是触摸点在UIWindow的位置
(CGPoint)previousLocationInView:(UIView *)view;
- 该方法记录了前一个触摸点的位置

代码实现：

- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event

{

    // 想让控件随着手指移动而移动,监听手指移动

    // 获取UITouch对象

    UITouch *touch = [touches anyObject];

    // 获取当前点的位置

    CGPoint curP = [touch locationInView:self];

    // 获取上一个点的位置

    CGPoint preP = [touch previousLocationInView:self];

    // 获取它们x轴的偏移量,每次都是相对上一次

    CGFloat offsetX = curP.x - preP.x;

    // 获取y轴的偏移量

    CGFloat offsetY = curP.y - preP.y;

    // 修改控件的形变或者frame,center,就可以控制控件的位置

    // 形变也是相对上一次形变(平移)

    // CGAffineTransformMakeTranslation:会把之前形变给清空,重新开始设置形变参数

    // make:相对于最原始的位置形变

    // CGAffineTransform t:相对这个t的形变的基础上再去形变

    // 如果相对哪个形变再次形变,就传入它的形变

    self.transform = CGAffineTransformTranslate(self.transform, offsetX, offsetY);

}

-----------------------------------------------------------

（三）iOS中的事件的产生和传递

3.1.事件的产生：

发生触摸事件后，系统会将该事件加入到一个由UIApplication管理的事件队列中
为什么是队列而不是栈？因为队列的特定是先进先出，先产生的事件先处理才符合常理，所以把事件添加到队列。
UIApplication会从事件队列中取出最前面的事件，并将事件分发下去以便处理，通常，先发送事件给应用程序的主窗口（keyWindow）。

主窗口会在视图层次结构中找到一个最合适的视图来处理触摸事件，这也是整个事件处理过程的第一步。

找到合适的视图控件后，就会调用视图控件的touches方法来作具体的事件处理。

3.2.事件的传递：

触摸事件的传递是从父控件传递到子控件

掌握：如果父控件不能接受触摸事件，那么子控件就不可能接收到触摸事件

应用如何找到最合适的控件来处理事件？
- 1.首先判断主窗口（keyWindow）自己是否能接受触摸事件
- 2.触摸点是否在自己身上
- 3.从后往前遍历子控件，重复前面的两个步骤（首先查找数组中最后一个元素）
- 4.如果没有符合条件的子控件，那么就认为自己最合适处理

UIView不能接收触摸事件的三种情况：

不允许交互：userInteractionEnabled = NO
隐藏：如果把父控件隐藏，那么子控件也会隐藏，隐藏的控件不能接受事件
透明度：如果设置一个控件的透明度<0.01，会直接影响子控件的透明度。alpha：0.0~0.01为透明。

注意：默认UIImageView不能接受触摸事件，因为不允许交互，即userInteractionEnabled = NO，所以如果希望UIImageView可以交互，需要userInteractionEnabled = YES。

总结一下：1.点击一个UIView或产生一个触摸事件A，这个触摸事件A会被添加到由UIApplication管理的事件队列中（即，首先接收到事件的是UIApplication）。

　　　　　2.UIApplication会从事件对列中取出最前面的事件（此处假设为触摸事件A），把事件A传递给应用程序的主窗口（keyWindow）。

　　　　　3。窗口会在视图层次结构中找到一个最合适的视图来处理触摸事件。（至此，第一步已完成）

iOS事件传递->处理->响应

如果想让某个view不能接收事件（或者说，事件传递到某个view那里就断了），那么可以通过刚才提到的三种方式。比如，设置其userInteractionEnabled = NO;那么传递下来的事件就会由该view的父控件处理。

例如，不想让蓝色的view接收事件，那么可以设置蓝色的view的userInteractionEnabled = NO;那么点击黄色的view或者蓝色的view所产生的事件，橙色的view就会成为最合适的view。事件都会由橙色的veiw处理。

所以，不管视图能不能处理事件，只要点击了视图就都会产生事件，关键看该事件是由谁来处理！也就是说，如果视图不能处理事件，点击视图，还是会产生一个触摸事件，只是该事件不会由被点击的视图处理而已！

注意：如果设置父控件的透明度或者hidden，会直接影响到子控件的透明度和hidden。如果父控件的透明度为0或者hidden = YES，那么子控件也是不可见的！

3.3.（重难点）如何寻找最合适的view

应用如何找到最合适的控件来处理事件？

1.首先判断主窗口（keyWindow）自己是否能接受触摸事件
2.触摸点是否在自己身上
3.从后往前遍历子控件，重复前面的两个步骤（首先查找数组中最后一个元素）
4.如果没有符合条件的子控件，那么就认为自己最合适处理

详述：1.主窗口接收到应用程序传递过来的事件后，首先判断自己能否接手触摸事件。如果能，那么在判断触摸点在不在窗口自己身上

　　　2.如果触摸点也在窗口身上，那么窗口会从后往前遍历自己的子控件（遍历自己的子控件只是为了寻找出来最合适的view）

　　　3.遍历到每一个子控件后，又会重复上面的两个步骤（传递事件给子控件，1.判断子控件能否接受事件，2.点在不在子控件上）

　　　4.如此循环遍历子控件，直到找到最合适的view，如果没有更合适的子控件，那么自己就成为最合适的view。

找到最合适的view后，就会调用该view的touches方法处理具体的事件。所以，只有找到最合适的view，把事件传递给最合适的view后，才会调用touches方法进行接下来的事件处理。找不到最合适的view，就不会调用touches方法进行事件处理。

注意：之所以会采取从后往前遍历子控件的方式寻找最合适的view只是为了做一些循环优化。因为相比较之下，后添加的view在上面，降低循环次数。

3.3.1.寻找最合适的view底层剖析

两个重要的方法：

hitTest:withEvent:方法
pointInside方法

3.3.1.1.hitTest：withEvent：方法

什么时候调用：
- 只要事件一传递给一个控件你这个控件就会调用他自己的hitTest：withEvent：方法
作用：
- 寻找并返回最合适的view(能够响应事件的那个最合适的view)

拦截事件的处理：

正因为hitTest：withEvent：方法可以返回最合适的view，所以可以通过重写hitTest：withEvent：方法，返回指定的view作为最合适的view。
不管点击哪里，最合适的view都是hitTest：withEvent：方法中返回的那个view。
拦截事件的传递过程，想让谁处理事件谁就处理事件。

事件传递给谁，就会调用谁的hitTest:withEvent:方法。

注意：如果hitTest:withEvent:方法中返回nil，那么调用该方法的控件本身和其子控件都不是最合适的view，也就是在自己身上没有找到更合适的view。那么最合适的view就是该控件的父控件。

所以事件的传递顺序是这样的：

　　产生触摸事件->UIApplication事件队列->[UIWindow hitTest:withEvent:]->返回合适的view->[子控件 hitTest:withEvent:]->返回合适的view

　　事件传递给窗口或控件的后，就调用hitTest:withEvent:方法寻找更合适的view。所以是，先传递事件，再根据事件在自己身上找更合适的view。

　　不管子控件是不是最合适的view，都要先把事件传递给子控件，经过子控件调用自己的hitTest:withEvent:方法验证后才知道有没有更合适的view。即便父控件是最合适的view了，子控件的hitTest:withEvent:方法还是会调用，不然怎么知道有没有更合适的！即，如果确定最终父控件是最合适的view，那么该父控件的子控件的hitTest:withEvent:方法也是会被调用的。

　　注意：想让谁成为最合适的view就重写谁自己的父控件的hitTest:withEvent:方法返回指定的子控件，或者重写自己的hitTest:withEvent:方法 return self。

但是在自己的hitTest:withEvent:方法中返回自己有时候会出现问题，因为会存在这么一种情况，如果点不在自己身上，还要要求返回自己作为最合适的view，采用返回自己的方法可能会导致还没有来得及遍历自己，就有可能已经遍历了点真正所在的view，返回的不是自己而是点真正所在的view。所以还是建议在父控件的hitTest:withEvent:中返回子控件作为最合适的view！

例如：whiteView有redView和greenView两个子控件。redView先添加，greenView后添加。如果要求无论点击那里都要让redView作为最合适的view（把事件交给redView来处理）那么只能在whiteView的hitTest:withEvent:方法中return self.subViews[0];这种情况下在redView的hitTest:withEvent:方法中return self;是不好使的！

// 这里redView是whiteView的第0个子控件

#import "redView.h"

@implementation redView

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event

{

    return self;

}

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event

{

    NSLog(@"red-touch");

}

@end

// 或者

#import "whiteView.h"

@implementation whiteView

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event

{

    return self.subviews[0];

}

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event

{

    NSLog(@"white-touch");

}

@end

特殊情况：

谁都不能处理事件，窗口也不能处理
- 窗口的hitTest：withEvent：方法return nil
只能有窗口处理事件
- 控制器的view的hitTest：withEvent：方法return nil
hitTest：withEvent：中return nil的意思是调用当前hitTest：withEvent：方法的view不是合适的view，子控件也不是合适的view。如果同级的兄弟控件也没有合适的view，那么最合适的view就是父控件。

寻找最合适的view底层剖析之hitTest：withEvent：方法底层做法

/************************************************ hitTest:withEvent:方法底层实现************************************************/

#import "WSWindow.h"

@implementation WSWindow

// 什么时候调用:只要事件一传递给一个控件，那么这个控件就会调用自己的这个方法

// 作用:寻找并返回最合适的view

// UIApplication -> [UIWindow hitTest:withEvent:]寻找最合适的view告诉系统

// point:当前手指触摸的点

// point:是方法调用者坐标系上的点

- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event

{// 1.判断下窗口能否接收事件

    if (self.userInteractionEnabled == NO || self.hidden == YES || self.alpha <= 0.01) return nil;

    // 2.判断下点在不在窗口上

    // 不在窗口上

    if ([self pointInside:point withEvent:event] == NO) return nil;

    // 3.从后往前遍历子控件数组

    int count = (int)self.subviews.count;

    // 0 1

    for (int i = count - ; i >= ; i--) {

        // 获取子控件

        UIView *childView = self.subviews[i];

        // 坐标系的转换,把窗口上的点转换为子控件上的点

        // 把自己控件上的点转换成哪个控件上点

        CGPoint childP = [self convertPoint:point toView:childView];

         UIView *fitView = [childView hitTest:childP withEvent:event];

        if (fitView) {// 如果能找到最合适的view

            return fitView;

        }

    }

    // 4.没有比自己更合适的view

    return self;

}

// 作用:判断下传入过来的点在不在方法调用者的坐标系上

// point:是方法调用者坐标系上的点

//- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event

//{

//    return NO;

//}

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event

{

    NSLog(@"%s",__func__);

}

@end

hit:withEvent:方法底层会调用pointInside:withEvent:方法判断点在不在方法调用者的坐标系上。

3.3.1.2.pointInside:withEvent:方法

pointInside:withEvent:方法判断点在不在当前view上（方法调用者的坐标系上）如果返回YES，代表点在方法调用者的坐标系上;返回NO代表点不在方法调用者的坐标系上，那么方法调用者也就不能处理事件。

-----------------------------------------------------------

（四）事件的响应

4.1.触摸事件处理的整体过程

1>用户点击屏幕后产生的一个触摸事件，经过一系列的传递过程后，会找到最合适的视图控件来处理这个事件

2>找到最合适的视图控件后，就会调用控件的touches方法来作具体的事件处理
touchesBegan…
touchesMoved…
touchedEnded…

3>这些touches方法的默认做法是将事件顺着响应者链条向上传递，将事件交给上一个响应者进行处理

4.2.响应者链条示意图

响应者链条：是由多个响应者对象连接起来的链条
作用：能很清楚的看见每个响应者之间的联系，并且可以让一个事件多个对象处理。
响应者对象：能处理事件的对象

如何判断上一个响应者
1> 如果当前这个view是控制器的view,那么控制器就是上一个响应者
2> 如果当前这个view不是控制器的view,那么父控件就是上一个响应者

响应者链条：
在iOS程序中无论是最后面的UIWindow还是最前面的某个按钮，它们的摆放是有前后关系的，一个控件可以放到另一个控件上面或
下面，那么用户点击某个控件时是触发上面的控件还是下面的控件呢，这种先后关系构成一个链条就叫“响应者链”。在iOS中响应者链的关系可以用下图表示：

aaarticlea/png;base64,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" alt="" />

响应者链的事件传递过程:

1>如果当前view是控制器的view，那么控制器就是上一个响应者，事件就传递给控制器；如果当前view不是控制器的view，那么父视图就是当前view的上一个响应者，事件就传递给它的父视图
2>在视图层次结构的最*视图，如果也不能处理收到的事件或消息，则其将事件或消息传递给window对象进行处理
3>如果window对象也不处理，则其将事件或消息传递给UIApplication对象
4>如果UIApplication也不能处理该事件或消息，则将其丢弃

事件处理的整个流程总结：

　　1.触摸屏幕产生触摸事件后，触摸事件会被添加到由UIApplication管理的事件队列中（即，首先接收到事件的是UIApplication）。

　　2.UIApplication会从事件队列中取出最前面的事件，把事件传递给应用程序的主窗口（keyWindow）。

　　3.主窗口会在视图层次结构中找到一个最合适的视图来处理触摸事件。（至此，第一步已完成)

　　4.最合适的view会调用自己的touches方法处理事件

　　5.touches默认做法是把事件顺着响应者链条向上抛。

touches的默认做法：

#import "WSView.h"

@implementation WSView

 //只要点击控件,就会调用touchBegin,如果没有重写这个方法,自己处理不了触摸事件

// 上一个响应者可能是父控件

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event

{

    NSLog(@"%s",__func__);

    // super:父类 superview:才是父控件

    // 调用系统默认的做法 UIView

    // super ->UIView

    [super touchesBegan:touches withEvent:event];

    // 默认会把事件传递给上一个响应者,上一个响应者是父控件,交给父控件处理

}

@end

事件的传递与响应：
- 1、当一个事件发生后，事件会从父控件传给子控件，也就是说由UIApplication -> UIWindow -> UIView -> initial view,以上就是事件的传递。
- 2、接下来是事件的响应。首先看initial view能否处理这个事件，如果不能则会将事件传递给其上级视图（inital view的superView）；如果上级视图仍然无法处理则会继续往上传递；一直传递到视图控制器view controller，首先判断视图控制器的根视图view是否能处理此事件；如果不能则接着判断该视图控制器能否处理此事件，如果还是不能则继续向上传递；（对于第二个图视图控制器本身还在另一个视图控制器中，则继续交给父视图控制器的根视图，如果根视图不能处理则交给父视图控制器处理）；一直到 window，如果window还是不能处理此事件则继续交给application处理，如果最后application还是不能处理此事件则将其丢弃
- 3、在事件的响应中，如果某个控件实现了touches...方法，则这个事件将由该控件来接受，如果调用了[supertouches….];就会将事件顺着响应者链条往上传递，传递给上一个响应者；接着就会调用上一个响应者的touches….方法

如何做到一个事件多个对象处理：

因为系统默认做法是把事件上抛给父控件，所以可以通过重写自己的touches方法和父控件的touches方法来达到一个事件多个对象处理的目的。

事件的传递和响应的区别：

事件的传递是从上到下（父控件到子控件），事件的响应是从下到上（顺着响应者链条向上传递：子控件到父控件）。

秒客网

iOS事件传递->处理->响应

前言：

（一）iOS中的事件

1.1.响应者对象(UIResponder)

-----------------------------------------------------------

（二）事件的处理

2.1.UIView的拖拽

2.1.1.UITouch对象

2.1.1.1.UITouch的作用

2.1.1.2.UITouch的属性

2.1.1.3.UITouch的方法

-----------------------------------------------------------

（三）iOS中的事件的产生和传递

3.1.事件的产生：

3.2.事件的传递：

3.3.（重难点）如何寻找最合适的view

3.3.1.寻找最合适的view底层剖析

特殊情况：

寻找最合适的view底层剖析之hitTest：withEvent：方法底层做法

-----------------------------------------------------------

（四）事件的响应

4.1.触摸事件处理的整体过程

4.2.响应者链条示意图

相关文章