I’m John C Bland II

Husband, Father, Tech Author, Deacon.
Founder ofย Katapult Media, and full-stack polyglot developer.
Political Free Agents Podcast Host.

I create. I launch.

YouTube Channel

I post regular fun on YouTube like me playing the bass and anything else I find fun.ย 

Get Something Built

All project work goes through Katapult Media. Business is open. Let’s chat.

Learning Objective-C for me is about learning how to read the code in comparison to other languages I know. Here is what I know so far about classes.

I may say this in all of my posts but this is just weird to me. I won’t get long winded here but I do want to post a few examples. Keep in mind I’m posting these as I learn so there is a lot of knowledge to be had. With that said, you might see me do a part 2 of this post clarifying something I may have posted here.

I believe there is another way but for now I’m going to state how it is, at this point, in the book I’m reading.

@interface Name: ParentClass
type variable
type variable
type variable
(scope) (return type) methodName;
(scope) (return type) methodName;
@implementation ClassName
(scope) (return type) methodName
//do something
//return variable;
(scope) (return type) methodName: (var type) varName
//do something
//return variable

This is the core structure but what I expect is to not have to define an interface in the class file. This way we can create interfaces separate and implement in multiple classes. I assume you can but I haven’t gotten that far in the book. (update: found a link here that interfaces as separate files, as expected)

@interface – References the interface section
@implementation – References the interfaces implementation (the class itself)

I’m praying there is some form of public, private, protected, etc but so far there are two scopes: – and +. HUH? I know…let me explain. ๐Ÿ˜‰ (update: found a link here that shows the scopes I “prayed” for above)

– denotes instance level methods/variables (in ECMA, someClassInstance.methodName)
+ denotes class level methods/variables (in ECMA, SomeClass.methodName)
Instantiating and Using

//allocates memory for a MyClass instance and returns a new instance of MyClass
myClassInstance = [MyClass alloc]; //alloc is a class level method; called on the class only
//initializes the class; assuming this is a constructor of sorts
myClassInstance = [myClassInstance init]; //init is an instance method; called on instances only

Note: Extending NSObject gives you the core logic for allocating memory so you don’t have to define it or the init.

That isn’t bad at all. I can read it and understand. What gets me is when you start compounding method calls. The above can also be written like this:

myClassInstance = [[MyClass alloc] init];

The order is [inner] to [[..] outer] so allocate first then call init. In ECMA terms:

myClassInstance = new MyClass();

๐Ÿ™‚ I started to write .init() on the end but .init() is the same as the constructor, from what I see. ๐Ÿ™‚
The next thing is to call an instance method from a class.

//get instance of class
myClassInstance = [[MyClass alloc] init];
//call method on class; void return type
[myClassInstance doSomething];
//call method on class; returns int
(int) myResult = [myClassInstance getMyInt];


int myResult = myClassInstance.getMyInt();//java/c#
var myResult:int = myClassInstance.getMyInt();//as3

I’m going to stop here for classes. There is a lot more to go over but this helped me understand some of the code I see here/there and I wanted to blog it so I had a running log of my learning points. More to come.


I tweaked the post to use the language syntax highlighter. It makes it easier to read the code.