objective c的iphone开发中的“代表”是什么?[复制品]

看到这个 discussion

委托允许一个对象在事件发生时向另一个对象发送消息。例如,如果您使用 NSURLConnection class . nsurlconnection有三个常见的委托:

 - (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error
 - (void)connectionDidFinishLoading:(NSURLConnection *)connection
 - (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response

当nsurlconnection遇到故障、成功完成或从网站接收到响应时,将分别调用这些委托中的一个或多个。

委托是指向对象的指针,对象具有委托持有者知道如何调用的一组方法。换句话说,是 启用特定回调的机制 从后来创建的对象。

一 很好的例子是 UIAlertView . 你创造了一个 uiAlctVIEW 对象向用户显示一个短消息框,可能为用户提供两个按钮(如“确定”和“取消”)的选择。这个 uiAlctVIEW 需要一种方法来回拨您,但它没有要回拨哪个对象和要调用哪个方法的信息。

为了解决这个问题,你可以 self 指针指向 uiAlctVIEW 作为委托对象,作为交换,您同意(通过声明 UIAlertViewDelegate 在对象的头文件中)实现 uiAlctVIEW 可以打电话,例如 alertView:clickedButtonAtIndex: .

退房 this post 对于 快速介绍委托设计模式和其他回调技术 .

参考文献:

• UIAlertView class reference
• UIAlertViewDelegate class reference
• Apple's guide to Delegates and Data sources

委托是一种设计模式;没有特殊的语法或语言支持。

委托只是一个对象,当某些事情发生时,另一个对象向其发送消息,以便委托可以处理原始对象未设计用于的特定于应用程序的详细信息。这是一种不用子类化就可以定制行为的方法。

我认为维基百科的这篇文章描述得最好: http://en.wikipedia.org/wiki/Delegation_pattern

它“只是”一个设计模式的实现,在objective-c中非常常见

我试着用简单的程序来阐述它

两个班

学生H

#import <Foundation/Foundation.h>

@interface Student : NSObject
@property (weak) id  delegate;
- (void) studentInfo;
@end

学生。

#import "Student.h"
@implementation Student
- (void) studentInfo
{
    NSString *teacherName;
    if ([self.delegate respondsToSelector:@selector(teacherName)]) {
        teacherName = [self.delegate performSelector:@selector(teacherName)];
    }
    NSLog(@"\n Student name is XYZ\n Teacher name is %@",teacherName);
}
@end

老师,H

#import <Foundation/Foundation.h>
#import "Student.h>

@interface Teacher: NSObject
@property (strong,nonatomic) Student *student;
- (NSString *) teacherName;
- (id) initWithStudent:(Student *)student;
@end

老师。

#import "Teacher.h"

@implementation Teacher

- (NSString *) teacherName
{
    return @"ABC";
}
- (id) initWithStudent:(Student *)student
{
    self = [ super init];
    if (self) {
        self.student = student;
        self.student.delegate = self;
    }
    return self;
}
@end

主m

#import <Foundation/Foundation.h>
#import "Teacher.h"
int main ( int argc, const char* argv[])
{
    @autoreleasepool {

        Student *student = [[Student alloc] init];
        Teacher *teacher = [[Teacher alloc] initWithStudent:student];

        [student studentInfo];

    }
    return 0;
}

解释 ::

1. 从主方法开始 initWithStudent:student 将执行

   1.1教师物品的性质 学生 '将分配给Student对象。

   一点二 self.student.delegate = self

       means student object's delegate will points to teacher object
   

2. 从主方法开始 [student studentInfo] 将被调用

   二点一 [self.delegate respondToSelector:@selector(teacherName)] 这里委托已经指向teacher对象以便它可以调用 “TeacherName”实例方法。

   2.2这样 [self.delegate performSelector:@selector(teacherName)] 很容易执行。

看起来教师对象将委托分配给学生对象来调用它自己的方法。

这是一个相对的概念,在这里我们看到学生对象 教师姓名 “方法,但它基本上是由教师对象本身完成的。

拜托!请查看下面的简单逐步教程,了解代理在iOS中的工作方式。

Delegate in iOS

我已经创建了两个viewcontroller(用于将数据从一个发送到另一个)

1. firstviewcontroller实现委托(它提供数据)。
2. secondviewcontroller声明委托(它将接收数据)。

下面的示例代码可能对您有所帮助。

应用委托.h

#import <UIKit/UIKit.h>

@class FirstViewController;

@interface AppDelegate : UIResponder <UIApplicationDelegate>

@property (strong, nonatomic) UIWindow *window;
@property (strong, nonatomic) FirstViewController *firstViewController;

@end

应用委托.m

#import "AppDelegate.h"
#import "FirstViewController.h"

@implementation AppDelegate

@synthesize firstViewController;

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
    // Override point for customization after application launch.

    //create instance of FirstViewController
    firstViewController = [[FirstViewController alloc] init];

    //create UINavigationController instance using firstViewController
    UINavigationController *firstView = [[UINavigationController alloc] initWithRootViewController:firstViewController];

    //added navigation controller to window as a rootViewController
    self.window.rootViewController = firstView;

    [self.window makeKeyAndVisible];
    return YES;
}

- (void)applicationWillResignActive:(UIApplication *)application
{
    // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
    // Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.
}

- (void)applicationDidEnterBackground:(UIApplication *)application
{
    // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later. 
    // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
}

- (void)applicationWillEnterForeground:(UIApplication *)application
{
    // Called as part of the transition from the background to the active state; here you can undo many of the changes made on entering the background.
}

- (void)applicationDidBecomeActive:(UIApplication *)application
{
    // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
}

- (void)applicationWillTerminate:(UIApplication *)application
{
    // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
}

@end

firstviewcontroller.h

#import <UIKit/UIKit.h>
#import "SecondViewController.h"

@interface FirstViewController : UIViewController<MyDelegate>

@property (nonatomic, retain) NSString *mesasgeData;

@property (weak, nonatomic) IBOutlet UITextField *textField;
@property (weak, nonatomic) IBOutlet UIButton *nextButton;

- (IBAction)buttonPressed:(id)sender;

@property (nonatomic, strong) SecondViewController *secondViewController;

@end

FirstViewController.m

#import "FirstViewController.h"

@interface FirstViewController ()
@end

@implementation FirstViewController

@synthesize mesasgeData;
@synthesize textField;
@synthesize secondViewController;

#pragma mark - View Controller's Life Cycle methods

- (void)viewDidLoad
{
    [super viewDidLoad];

}

- (void)didReceiveMemoryWarning
{
    [super didReceiveMemoryWarning];

}

#pragma mark - Button Click event handling method

- (IBAction)buttonPressed:(id)sender {

    //get the input data from text feild and store into string
    mesasgeData = textField.text;

    //go keypad back when button clicked from textfield
    [textField resignFirstResponder];

    //crating instance of second view controller
    secondViewController = [[SecondViewController alloc]init];

    //it says SecondViewController is implementing MyDelegate
    secondViewController.myDelegate = self;

    //loading new view via navigation controller
    [self.navigationController pushViewController:secondViewController animated:YES];    
}

#pragma mark - MyDelegate's method implementation

-(NSString *) getMessageString{
    return mesasgeData;
}

@end

第二视图控制器.h

//declare our own delegate
@protocol MyDelegate <NSObject>

-(NSString *) getMessageString;

@end

#import <UIKit/UIKit.h>

@interface SecondViewController : UIViewController

@property (weak, nonatomic) IBOutlet UILabel *messageLabel;

@property (nonatomic, retain) id <MyDelegate> myDelegate;

@end

第二视图控制器.m

#import "SecondViewController.h"

@interface SecondViewController ()
@end

@implementation SecondViewController

@synthesize messageLabel;
@synthesize myDelegate;

- (void)viewDidLoad
{
    [super viewDidLoad];    
    messageLabel.text = [myDelegate getMessageString];    
}

- (void)didReceiveMemoryWarning
{
    [super didReceiveMemoryWarning];
}

@end

我认为,一旦你了解了代表们,所有这些答案都很有意义。就我个人而言,我来自C/C++的领域,之前的程序语言如Fortran等,所以这是我在C++范例中找到类似的类比的2分钟。

如果我要解释一个C++程序员的委托,我会说

什么是代表?这些是指向另一个类中的类的静态指针。分配指针后,可以调用该类中的函数/方法。因此,您的类的一些函数是“委托”(在C++世界中由类对象指针指向)到另一个类。

什么是协议?从概念上讲,它的作用与作为委托类分配的类的头文件类似。协议是一种明确的方式,用于定义需要在类中实现哪些方法,而类的指针在类中设置为委托。

如何在C++中做类似的事情?如果您试图在C++中实现这一点,您将通过定义类定义中的类(对象)指针,然后将它们连接到其他类,这些类将作为委托给基类提供附加功能。但是这种连接需要在代码中维护,并且将是笨拙和容易出错的。目标C只是假设程序员不擅长维护这个抽取,并提供编译器限制来强制执行干净的实现。

委托触发对象C中的自动事件。如果将委托设置为对象,则它通过委托方法将消息发送到另一个对象。

这是一种不需要子类化就可以修改类行为的方法。

具有委托方法的每个对象。当特定对象参与用户交互和程序流周期时,这些委托方法会激发。

简单地说:委托是一种允许对象相互交互而不在它们之间创建强相互依赖关系的方式。

委托捕获用户的录制操作,并根据用户录制操作执行特定操作。

委托只是对象的实例,我们可以代表该对象调用方法。也有助于在该对象的rumtime中创建方法。