Ready to get started coding object-oriented PHP? Me too, so let's get this show on the road.
 

A couple of months ago, I promised that we would start a series of TechTips for PHP designed to get you into writing modular, OO PHP. Or at least that's what I think I promised; it was a couple of months ago, and a lot has happened.

Then PHP 7 came along, and I ended up doing a couple of TechTips revolving around what that entailed. But now I'm ready to pick up where I left off, even though I hadn't really begun anything yet. Story of my life.

I have to be honest here. I don't really have a plan. As Indiana Jones said, 'I'm making it up as I go," and I just hope that by the end of the year I have given you a practical starting point for doing OO PHP.

Why OO?

Good question. PHP can be written procedurally just like RPG. So why bother with OO?

Simple. If you're going to get involved with PHP and do anything meaningful, you're going to be looking at code written by other people. And today, all the cool kids are using OO PHP, not procedural.

But why not start with procedural and go to OO later?

For the same reason you don't need to learn to drive a car before you take flight lessons. There's not a lot of carryover. Doing procedural first just gives you a lot of techniques that are not directly transferrable to OO, so why bother?

Come on now, quit stalling.

Classes

The starting point for any OO language is always to learn about classes. As you might expect, a class is a category or collection of things. The things are called objects, and they're members of a class.

Objects are pretty easy to understand. They're something real, something tangible.

A class, on the other hand, is not real. It's a blueprint for what that something looks like. It contains all of the information required to describe that object and is used every time we want to create a new occurrence of that class (that is, an object).

The process of creating an object from a class is called "instantiation." Yes, I agree, not the choice I would have made. I would have called it "creation" or "making an object" or something. But they call it instantiation, and there's nothing we can do but go along.

Typically, the verbiage used is "instantiate a new object"—that is, create a new object from the blueprint contained in the class definition.

OK, so a class is a blueprint, an object is a specific instance or member of that class, and the process of creating an object from a class is instantiation. The question now is, what code do we use to do this?  

Defining a Class

The first thing you have to do is define the class, the blueprint that you're going to use to create your objects.

class NAME   {

      'some data definitions'

     'some function definitions}

The above code is a generic example of defining a class. The word "class" is a keyword that tells the system that you're defining a class. NAME is the actual name I have given to the class—that is, this class will carry data and functions related to your name (or someone's name).

When I say "carry data and functions," that's exactly what I mean because, while in the procedural word there's a divide between data and functions (data is in F- or D-specs and functions are the C-specs), in the OO world they're combined and carried in the same envelope: the class.

As you can see, I haven't really identified the data or functions, and in a real class definition we would do that. We will add some of those details in just a minute…or next month; I haven't decided yet (making this up as I go, remember).

The final part of the class definition is the two braces: { and }. Braces are very important in PHP. They are not ornamental (as the parentheses sometimes are in RPG) but are required and critical parts of the syntax. For the class definition, you can see that they surround the data and function definitions.

There are two things that I want to be sure to mention at this point.

First, if you have any familiarity with PHP, then you know that, like /Free RPG, PHP uses the semicolon (;) as a delimiter at the end of code lines. In /Free, however, they're used at the end of every line including ELSE and other such things. PHP is a little more fluid. Semicolons are only used at the end of an "executable" line; they do not appear after anything enclosed in braces. Hence, there is no semicolon at the end of the CLASS definition; the keyword "class" and the braces take care of delimiting things. What we'll see in a bit is that we'll put semicolons after the lines defining the data and the functions—that is, within the braces.

Second, there's no set rule where the braces go. For instance, in the example above, the first brace goes a few spaces after the name of the class and the second brace goes at the start of the first or second line after the last executable statement in the definition. This is the format that most PHP users use.

I don't care for it that much myself. I like braces that go together to be in line, like this.

class NAME  

{

      'some data definitions'

     'some function definitions'

}

One of the things that's confusing about PHP is that sometimes you get a lot of brace pairs and it can get really confusing making sure they're all paired up properly. Putting them like I have them makes it easier. But I don't want to encourage you to do it this way because this isn't the way most of the other kids do it and I don't want to start no trouble. Although you do see it sometimes, so maybe the tide is turning.

Defining Data and Functions

Of course, the most important parts of a class definition are the data and functions that the class contains and… What? My time is up? Seriously, dude? Oh, OK.

Well, we'll pick this up next month when we'll finish seeing how to define a class and then how to instantiate an instance of an object in that class. Stay tuned.