Last month, we started looking at OO coding in PHP as we try to do something that is both practical and modern. We will keep going in that direction until somebody tells me to knock it off. You've been warned.

Do you remember what we did last month? Yeah, it's a little vague for me too. But I think we defined how you set up a class. And it sort of looked like this:

class NAME  

{

      'some data definitions'

     'some method definitions'

}

But we never got into what the data and the functions looked like. So let's do that now. Why data and functions? Because unlike RPG and other procedural languages, OO languages do not keep data and functions separated. They are two sides of different coins, and both need to be included in a class definition.

Data Definitions

We call it data, but in the OO world it's called data. Oh, that's the same. Sorry. Generally, there are some differences in the names, and I got carried away.

We'll start with data. In OO PHP, data is not defined in a separate part of the script the way it is in RPG. Rather, it's defined in the class where it's used. And yes, for those of you who are thinking of RPG subprocedures, these data elements are local variables. Their scope of control is just within the class. Global data elements can be defined, but we're not going into that now.

The data definition consists of two pieces of information:

First, the security level of the data—that is, whether it's public, private, or protected. Public makes it available everywhere that the class is available. Private makes it available only in the class where it's defined. Protected is accessible only within a class, an object, or a child of the class that has extended it (that is, within the family to which this class belongs). We'll talk more about what that means when we talk about polymorphism, which will probably be in about a year.

Second, the name of the data element, which always begins with a dollar sign ($) but otherwise can be practically anything and any length. If you have multiple words, they can be separated by underscores (_), but the normal format is camel case notation: start with a lowercase letter, and then each new word in the variable name capitalizes the first letter (i.e., $firstName).

And that's it. Nothing about what type of data it is (string, floating point, object, etc.). Nothing about how big the data is (how many characters, how many decimals, etc.).

PHP is a loosely typed language, which means that the type of the variable is set when the value is assigned. And it also means that you can change that data type whenever you feel like it just by assigning a new and different value to the data.

I know. Scares me too. But they've been doing it for a long time, and it seems to be working OK. PHP isn't the only web language to handle data this way, but it does take some getting used to for anyone coming from an RPG-type background.

Function Method Definition

The other things defined in the class are the functions that are going to be used on the data we've just defined. But we don't call them functions. In OO, they're called "methods," so that's the term we'll use from here on out. What's confusing is that even though in OO they're called methods, the keyword that will be used to define these methods is "function." Truth be told, you will to a certain extent see the terms "function" and "method" used interchangeably.

The method can be anything you want. For example, if the inbound data is numeric, then the method could be to sum those fields and calculate the average. Or it could be to create a text string and display that on the screen. Or to access a database and read a record.

You can pass parms in to a method, and those will be listed in parentheses following the method name. Naturally, these variables will have to either be defined in the class definition (local variables) or be global variables that were defined previously in the script.

For the purposes of this lesson, we'll keep it really simple and just set a value and then display that on the screen.

What Does it Look Like?  

It looks like this:

Class name

{   public $firstName;

public $lastName;

      public function printName($firstName, $lastName)            

{   echo 'My name is' + ' ' + $firstName +

                     ' ' + $lastName;

      }

}

OK, so what do we have here? Some of this will be review from last month.

First, we have the Class keyword to indicate that we're defining a new class here.

Second, we have the class name, which happens to be "name."

Third, we have defined two data elements: $firstName and $lastName. We haven't assigned values to these two fields; that's something you'll do when you create an object for this class (that is, when you instantiate the object). If we did it in the class definition, then we'd be setting them up as constants because the same value would be assigned each time we instantiate.

Fourth, we come to the methods. In our case, we have only one, but if we had more, we would just list them under each other. The function has a structure much like the Class, so let's take a closer look at it.

      public function printName($firstName, $lastName)            

{   echo 'My name is' + ' ' + $firstName +

                     ' ' + $lastName;

      }

First there's the authority: public, private, or protected.

Then we have the keyword "function." Yes, I know I called this a "method," and that's what people refer to it as, but the keyword is function. Don't even start.

Next is the name of the function (or method), which in this case is printName. Note that, like class names and unlike variable names, the function name does not start with a $. Also, you might have noticed that most of the names that we have developed use the so-called camel syntax.

If there are parameters that the function uses, they're enclosed in parentheses, as the $firstName and $lastName are.

Then comes another set of braces that enclose whatever we want to have done by this function. In this case, it's to create a concatenated sentence using constants and the variables and have it displayed on the page by the echo command.

Finally, there are semicolons after both the data and the method definitions, plus braces surrounding them both.

And that's all there is to it.

Using the Class

OK, so we have now defined a class. The question is, how do we use this?

We use it to instantiate new objects. That is, we use the pattern contained in the class to create new members in that class.

$myName = testClass new ('Dave', 'Shirey');

It's that simple. All the code was in the class definition, and all we had to do to instantiate the object ($myName) was to issue this command and provide the input parms. What's interesting to notice is that we didn't really issue a command here—no CRTCLSOBJ like we might in CL. What we did was similar to a function call, where we set a variable, in this case $myName, equal to the function that we want to kick off.

And what would be the value in the variable $myName? Why "My name is Dave Shirey," of course. And with the echo, every time you instantiate this class, that message would appear on the web page.

So what next? Well, couple of things I want to point out, but time's up again. See you next month, when we kind of finish classes up and also work on actually doing this in Zend Studio or WAMP (haven't decided which yet).