Question

I am trying to teach myself objective-c, but coming from a Python/Java background, it is proving very difficult. I tried to post a bunch of points I am confused on, but it was marked as too vague, so I’ll break it into sections.

First, every example of a delegate and outlet I’ve found uses cocoa view code to get the idea across. Unfortunately, I don’t yet understand enough of the code to grasp the example’s point. So, can anyone provide a more basic example of a delegate? My understanding is that it is a way of subclassing; how is this better than traditional subclassing? Why does every cocoa project automatically include appDelegate.m? Can delegates be used for other purposes, not just GUI stuff?

Okay, I think I see. So a delegate is a class that conforms to the protocol of some other class. A protocol is simply a list of methods and variables that have to (or can, if set to optional) be implemented in the delegate class. To make a delegate, you have to use the @interface keyword, then the name of your delegate, then (in < > signs) the protocol name? So if class c1 wants to set itself up as a delegate of class c, class c must first specify a protocol, right? You would then be able to implement everything in c’s protocol in c1:
@interface c1;
I feel like I’m missing some bits there, but hopefully I have the concepts right. 🙂 This also explains the mysterious less- and greater-than signs; they declare what interface the delegate implements.

Outlets are similarly always tied to view code. They seem to be some kind of inter-object messaging system. Is that right? Again, an example of a basic outlet that is not mixed in with complex GUI statements would be great.
So outlets are never needed? I know that IBOutlet and IBAction are not needed except for use with Interface Builder, but I thought outlets were more general than that? The docs seemed to indicate that they are not even specifically for interfaces, but could be used for anything.

Thanks in advance for any help.

Answer 1

Update: Delegates don’t have to conform to protocols. Protocols just make it easier to require some classes to have methods. It allows you to know for certain an object one has set as a delegate implements a certain method so you can call it safely, and allows the compiler to verify that method is indeed implemented (if you declare a delegate instance variable as id<SomeProtocol> delegate, the compiler will give a warning or error if you try to set delegate to an object of a class that doesn’t conform to SomeProtocol.

Protocols help ensure safety, but they’re not strictly necessary. A class can have a delegate (or multiple!), and they don’t have to conform to any protocols at all.

As for outlets, no, they’re specifically and only used with Interface Builder. The IBOutlet and IBAction keywords have no effect on code (they’re even stripped out before compile time) – they’re only markers for Interface Builder to look for so it knows which properties and methods should be accessible within the interface. The term ‘outlet’ is a direct reference to something marked as an IBOutlet, and is really not used in any other context that I can tell.

Again, it’s okay if you don’t understand this right away. Think it over a bit, and at some point, it’ll just ‘click’. I was caught up on delegates for a long time, just like this, before one day, I realized that delegates really aren’t any special. They’re regular objects referenced by other objects – it’s just that this design pattern has a special name (delegation), and these objects are only called delegates. They could just as easily be called gyros or falafels, and the net effect would be the same. 😛
You don’t need to name an object delegate for it to be a delegate; it’s just a convention.

---

About delegates: the first thing to understand, and this got me for a while until I had the proper “Aha!” moment, is that there is nothing special about a “delegate”. The word “delegate” is just a title for a type of object that another class depends on, very often for content or decision-making. A developer will use a delegate when they don’t want to (or can’t) tie one of their classes to another class by name – it’s an Object-Oriented way of decoupling and making classes more generic.

Now, very often, classes will require delegates to have specific methods they rely on, and one way to ensure that is with a protocol (more commonly known as an interface in Java). Protocols define a list of methods; classes “conform” to a protocol if they declare they do in their interface (e.g. @interface IFObject : NSObject <SomeProtocol> { ... }) and if they implement all the methods they’re required to. Protocols can have optional methods as well.

This model is used often with view controllers, views, and the GUI in general because many AppKit and UIKit classes are written to be as generic as possible. NSTableView, for instance, implements the most basic behavior it can possibly implement without requiring any implementation-specific information; for the rest, it relies on other objects, ones that conform to the NSTableViewDelegate and NSTableViewDataSource protocols. Any object can conform to the protocols, as long as they implement the right methods (and in this case, a controller class will usually implement methods from both protocols, but it doesn’t have to be so). In fact, one easy way to understand this topic better is to take a look at NSTableView – it’s got a delegate property and a dataSource property, but in effect, they’re no different. delegate could be called monkeyButt, and the concept would still work. The key is to not treat delegates as a black box – there’s nothing special about them.

Delegates can be also used for non-GUI purposes; one concrete example, as you mention, is the app delegate. NSApplication sends a delegate notifications to let it know when the application has been launched (among other things), so it can set up shop. Again, any object can be a delegate to any other object, for any purpose. It’s simply a convention.

---

Briefly about outlets: as others have mentioned, outlets are simply connections between an interface defined in an XIB and your code. They’re a way of letting Xcode link up the interface to the appropriate elements so that when your application loads the interface file, it can load up the right pieces of code or execute them.

They’re generally an easier way of setting up an interface – they’re not strictly necessary (you can create an interface programmatically, without using an XIB file), but if you do decide to go the XIB route, they’re how you relate your interface to your code.