CODEWITHSUNDEEP
iosswiftuiview
Noodles
Noodles

Reputation: 25

Wrapping my mind around Objects in iOS

I'm having trouble understanding the idea of objects. From what I've read, they're instances of a class. When learning swift, they're quite easy to understand. Simply create a class and create an instance of it, and from there, you can modify it's properties and call its methods:

class ExampleClass {
    let ExampleProperty = "rabbit"
}

let exampleInstance = ExampleClass()

But I don't see how that translates when using iOS, since I haven't seen any objects being created explicitly yet:

var example = Wss()

So my questions are:

  1. Are things like buttons, labels, and sliders objects?

-If so, where's the "code" behind them? Why do buttons, labels, etc. display even before they're connected through outlets and actions to the View Controller? Is there a hidden "var thisButton = ThisViewController()" embedded into each of those sliders and buttons?

  1. If my assumptions are wrong, can someone explain to me how objects work?

Upvotes: 2

Views: 125

Answers (4)

Caleb
Caleb

Reputation: 125007

But I don't see how that translates when using iOS, since I haven't seen any objects being created explicitly yet

There's no difference between the objects in iOS and what you understand objects to be. Objects are instances of a class. What you need to understand is that your own code is not the only place where objects can be created, and your own code will often interact with objects created outside your code. Here's a simple example:

let defaults = NSUserDefaults.standardUserDefaults()

Here defaults gets a reference to a user defaults object that the system provides. You never need to instantiate NSUserDefaults yourself.

Are things like buttons, labels, and sliders objects?

Yes, those are instances of UIButton, UILabel, and UISlider, respectively.

If so, where's the "code" behind them?

It's in the UIKit framework. You don't get to see the source code for those classes, but you can still use them by linking the framework into your app.

Why do buttons, labels, etc. display even before they're connected through outlets and actions to the View Controller?

You're talking about storyboards here. When you set up a view in Xcode's storyboard editor, the data that's stored in the storyboard file is essentially an archive containing serialized objects. When a view controller is instantiated from a storyboard, the objects in the storyboard are recreated from that data and then connected to the view controller's outlets. You can start this process yourself by instantiating a new view controller like this:

let storyboard = UIStoryboard(name: "MyStoryboard", bundle: nil)
let controller = storyboard.instantiateViewController(withIdentifier: "MyViewController")

You don't usually need to do that, though, because the segues in your storyboard provide for transitioning between scenes, including creating the view controller that's the destination of a given segue.

Upvotes: 0

Duncan C
Duncan C

Reputation: 131426

Building on Alexander's answer:

UIView objects have a method init(frame:) that lets you create a new UIView object with a specified frame.

Other UIView subclasses might have init methods that take additional parameters.

UIView objects also support an init method init(coder:) that knows how to create an object from a stream of stored data. This is known as "deserializing" the object, or converting it from a byte-stream back into a running object.

When you build an object in a Storyboard or XIB file in Interface Builder, the system serializes the object into a byte stream and saves it into your Storyboard/XIB.

Then when you invoke the storyboard scene/XIB, the system reads the data stream and uses it to recreate (deserialize) the objects that are described in the storyboard/XIB.

The effect is essentially the same as if you wrote a bunch of code that created and configured all your views, but instead of writing all that code you are able to build your interface in Interface Builder, which is faster and easier to create, and MUCH faster and easier to update and maintain than a bunch of custom code.

Upvotes: 0

Alexander
Alexander

Reputation: 63271

"Is there a hidden "var thisButton = ThisViewController()" embedded into each of those sliders and buttons?"

No, and this is exactly where interface builder excels. Much of Xcode's modern Interface Builder comes from NeXTSTEP. When you drag out a new UI component like NSButton and place it on your story board, Xcode is instantiating a new object of the NSButton class for you. When you save your file, Xcode serializes all the objects of your story board into a .nib file. At the time when this was invented, it was quite revolutionary, all made possible because of the dynamism of Objective C. It made GUI programming much simpler and dynamic. Every object in your story board is aware of its class. For example, when you instantiate a new NSButton, you can open the inspector and see for yourself that its class is NSButton. When you add custom views to your application, they keep track of their class in the same way. Whenever a nib file is loaded, these views are instantiated from their classes. You might have noticed that you never override the initializer of your views. Instead, you override methods like awakeFromNib. This is because there's a lot of behind the scenes work being done for you, from the time the object is first instantiated, to the time. During this time IBOutlets and IBActions are bound for you.

Competitors tried to make similar interface building applications, but they ultimately resorted to doing code generation behind the scenes. In these systems, when you saved your interface file, the program would generate a source file that contains code that instructs how to instantiate these objects anew whenever the interface is loaded. However, it proved significantly more complex a task then just serializing the objects, so these systems were error prone, and significantly harder to debug (because you'd be trying to debug machine generated source files).

Upvotes: 1

Rui Peres
Rui Peres

Reputation: 25917

Answering your questions:

  1. Yes. Your objects are just being created from a NIB, or Storyboard. So the NIB, or Storyboard, will create those visual (UI) elements for you, which you can then be accessed via the IBOutlets
  2. Your assumptions, are not completely wrong as in, there is in fact something allocating those objects for you. The NIB, or Storyboard, just describe a way for those objects to be created. Also some other customisations, like frames, colors, etc.

More about how this ties up can be found here.

Upvotes: 0

Related Questions