Advanced PHP Introduction to Object-Oriented Programming

Hello again, and welcome back to Educator.com's Advanced PHP with MySQL course.0000

Today's lesson is a very exciting lesson, because we are going to be providing an introduction to object-oriented programming.0005

Specifically, we are going to talk a little bit about, just in general, what object-oriented programming is.0012

We are going to talk about how, in a way, we have been doing somewhat of a means of object-oriented programming through the use of associative arrays.0018

We are going to talk about what classes are and how to define them.0026

And then, we are going to talk about what objects are and the difference between classes and objects,0031

which is a common difficulty to understand for first-time students to object-oriented programming.0036

We are going to talk about what is known as instantiating classes, or creating objects.0043

And then, we are going to talk about how to get and set properties of an object we create.0048

Object-oriented programming is a paradigm of programming that allows you to work with objects in your code.0057

You take real-world objects, such as a person, and you model that in your code with user-defined data types.0068

And your programs work by manipulating and performing different functions on these different objects.0077

It is kind of an abstract concept, so it is maybe best explained by example.0085

As mentioned, for example, in the real world, there are people; and you have a person who has a first name and a last name.0090

Now, what we can do is take this real-world object, this person object, and model that in our code in a code object.0108

What we would do is create a user-defined data type that encapsulates information about that real-world object person.0117

So, we might create a class in our code that allows us to create what are known as person objects.0125

And a person object will have different attributes to it: you might have, for example, a first name attribute and a last name attribute.0135

What we do for object-oriented programming is take these real-world objects and model them in our code as a user-defined data type.0150

So, this person object is actually a user-defined data type that we are going to create, and that is known as creating a class.0158

Now, there are a number of benefits for using object-oriented programming,0167

one of which is that it makes your code a little bit easier to understand and talk about.0171

It is more intuitive to humans to talk about dealing with different objects (for example, a person object),0174

and saying, "I want to perform this operation on a person," as opposed to talking about integers and arrays.0181

Additionally, it is a way to pass around a related amount of data in one particular variable.0188

For example, one of the things we are going to be creating in our web application is a cart object that is going to represent a shopping cart in our store.0195

So, what we can do is: maybe we will have a method that will say, "Calculate total."0209

And we can pass it a (this isn't the proper syntax, but) cart object.0221

What that is going to allow us to do is: within that cart object, it is going to contain all of the information0229

about all of the items in the cart, what quantities they are, and so forth.0233

Now, this is as opposed to maybe (instead) having a calcTotal method where we have to provide0237

the item ID of each particular item, and the price of each particular item, and so forth.0246

And now, we can pass all that information in a cart.0255

Another way would be if we had an example that wanted to print out the name of a person.0258

We could just pass it a person object, and it could use that to extract the first name and last name of the person,0261

as opposed to having to pass two separate parameters, first name and last name.0269

One other thing to note, also: an important feature of objects is that not only can they contain data, but they also can have methods on them.0274

So, we could have this cart object that contains information about all of the items in our cart,0286

and in this cart object, we can do something called create methods, where the cart object will have a method called calcTotal.0291

What it is: we get a cart object in our code; we define it; we populate it with items;0304

and then, what we do is run this method on the cart object by itself, and it will calculate the total for us.0310

So, that is another benefit of using objects: they contain data, and then they also have methods and functions that they can operate on themselves with.0317

In a way, we have kind of been using object-oriented programming a little bit through the use of associative arrays.0328

As mentioned, one of the benefits of using objects is that you can encapsulate a number of different pieces of data--0336

for example, about a person--in one variable; you can create a person data type,0341

and then create a variable that is of that person data type.0347

And you just pass around that one variable, and you can access all of the information0350

(as we are going to see), such as the first name and the last name.0354

We have kind of been doing that with...for example, we have been using an array in our web application a lot called items.0357

And items has contained a number of keys (for example, itemID).0365

When we have a function that needs to operate on an item, we are just passing it this variable items.0371

So, in a way, we have already been doing that data encapsulation.0377

Now, what object-oriented programming does is gives us a formal way to declare what properties are part of an item.0380

For example, in our store items, we have a couple of different properties that we are using.0388

We have an item ID, a name, a price, a description, and an image file extension.0393

And the way we having been doing that is modeling that as an associative array, with a key for each of these0400

different properties of an item, and then setting a value to it.0405

But an associative array is just a general array that anybody can use.0409

You could add other key values to it; for example, you could just call something and assign a random key to it.0416

But what we are going to do is create a user-defined data type for an item.0425

We are going to create an item class, and that is going to allow us to create item objects.0429

And we will explain the difference between classes and objects in a little bit.0433

And what that is going to allow us to do is restrict what properties and what values a particular item object can have.0437

As mentioned, a class is a formal description of a particular real-world object that you are going to model in code.0449

It is essentially a template for a user-defined data type.0457

So, for a person, for example, we talked about the person object.0460

The person class would be a user-defined data type (it is something we can define in our code)0464

that says a person is an object that maybe contains two properties: it contains a first name and a last name.0470

And as mentioned, a class definition...when you create a user-defined data type, you can create properties in that class, such as first name and last name.0477

And then, as mentioned, you can also create methods, which we are not going to get into in today's lesson.0487

We are going to get into it in a future lesson.0492

That allows you to define methods that work on that particular object.0494

For example, for a cart object, you could say "calculate the total."0499

In PHP, the way you define a user-defined data type, which is called a class (and classes are used to create objects):0506

you use the class keyword; and class names in PHP follow the same rules as variable names, minus the dollar sign.0514

And by convention, they always have their first letter capitalized.0522

Additionally, the convention is: every time you define a new user-defined data type, you define it in its own file.0526

So, it follows a one-class-per-file convention.0533

And the PHP file that the class is defined in typically has the same name as the name of the class.0537

For example, if we are defining a Person class, we define it in its own file, and we are going to show what that looks like in a second.0546

And we are going to define it in a file called Person.php.0554

Typically, you also store your classes in, for example, a 'classes' subdirectory of your web application,0557

so that they all are located in one spot.0563

And then, what you can do is: when you define a class, you can define different properties.0566

For example, a person might have two different properties: it might have a first name and a last name.0570

Well, what you can do in a class is define properties using the syntax here of the public (which is a keyword),0575

followed by the variable name of the property you want to assign.0582

So, for any random object, we might have a property called property1.0585

We don't need to worry so much about the public keyword right now; we are going to talk a little bit more about that in future lessons.0591

But for now, we can just say that that is what we are going to be using to define our classes.0597

And when you define a property of a class, you can also provide it a default value.0601

For example, we could provide it a constant value, like the string literal value 1.0606

Let's take a look at a class we have created that is going to model an item in our store.0612

Here, we have a file called Item.php, because it is defining a class called Item.0617

We can see the class keyword here; we can see the name of the class immediately following the class keyword.0621

In this case, it's Item, and the first letter is capitalized.0627

And then, we can see that the class definition is located within a pair of curly braces.0630

What we have done here is defined a number of properties, which are also sometimes called attributes, or members, of a particular class.0636

We are saying that the Item class has five different properties.0644

One of them is going to be called itemID; and here is a comment for a programmer that is going to say that is going to represent the ID of the item.0648

It is going to have a property called name, a property called price, a property called description, and a property called imageFileExt.0656

These, again, over here, are just comments that describe to the programmer what these different properties are going to represent.0665

Here, what we have done is created our own user-defined data type.0672

We are saying, "We are creating a data type that is going to be called an Item, just as you would have an int or a float or a bool."0679

"Now, we have a new data type called item, and it is going to contain a number of different properties,"0687

"just as an array is a composite data type that can contain a number of different values in it."0693

And as we saw, we have been using associative arrays to hold a number of different data values for a particular item,0697

Now, we are saying we have this item data type, and it is going to contain a number of different pieces of data--0704

In this case, five particular pieces of data.0709

Now, this is valid PHP code; and you actually could go and load it in your browser.0712

If I go and load Item.php, it is not going to do anything, but it is PHP code, and it is what is called a class definition file.0716

And it tells PHP, when you create an instance of an Item class, what it is going to look like.0726

Objects refer to a particular instance of a class or a user-defined data type.0740

What an object is: it takes that class template (maybe that class template for Item you have created), and it fills in those values.0748

When you create an object, it is known as instantiating, or creating an instance of a class.0756

Let's take a look at a diagram that explains this a little bit better, that talks about classes versus objects.0769

Here we have a class; and this would be defined in our file, like in a class definition file, with the class keyword.0776

For example, let's say we define a class that is going to represent a person.0782

We are going to say that the person is going to have two properties, a first name and a last name.0788

Well, that Person class just defines what that data type will look like.0792

It is going to say that it is a data type that has two values: a first name and a last name.0796

Well, in our code, when we want to create a Person (it is called instantiating an object,0801

when we want to use a Person object), we have to create an instance of it.0810

And then, what it does is: we are assigning that data type to a variable and assigning values to it.0814

For example, when we create an instance of a class, we create what is known as an object.0823

And now, an object is going to be a PHP variable (here, for example, we are going to call it person1).0829

And an object is going to have the values of the class it is representing populated.0835

So, maybe we are going to create a Person object called person1 with the first name Joe and the last name Smith.0841

And maybe we will create another instance in our code of a Person object.0848

It is called person2, and we are going to assign the name Jane Jones to that object.0854

In a way, it is very similar to in PHP, where there is the int (or integer) data type that defines what an integer is.0859

PHP knows what it is, and so that is sort of like the class for an integer.0868

But any time you want to use an integer in your code, you create a variable, and you assign it a value.0872

In an analogous way, what this statement here is doing is: this is creating an object called int1 that is of the Integer class.0882

So, it is kind of something similar to what we have been doing, except we are using our own user-defined data types.0891

In PHP, the way that you instantiate a new class, or you create an object of a particular class, is using the new keyword.0900

And it has this form here.0907

So, what we do is: we declare a variable, and using an assignment operator, we have the new keyword,0909

followed by the name of the class we want to create an instance of, followed by opening and closing parentheses.0916

So, this line right here says, "Create the variable person1, and then set it to be an object of the Person class."0922

So, "Have it be of the data type that is represented by the Person class."0931

Now, one thing to note is that, if you were to run this within your script, PHP has to know what a Person class is.0938

It is not something that is defined in PHP.0948

For example, in our last example, we defined our Item object in a file called Item.php.0952

So, Person is going to be defined (by convention) in a file called Person.php, and it is going to provide that class definition for what a Person is.0957

Well, PHP needs to know about that in order for this statement to make sense.0967

Any time you use a particular class in a file, you need to either include this Person.php file,0970

or you can include the class definition with the script itself, which is not a recommended practice.0977

So, what we are always going to do is create our classes in separate files, and then include those within whatever scripts need them.0983

If we go and look at a script we call createItemObject.php, what this is going to do is instantiate (or create an instance of) our Item class.0992

Now, we defined our Item class as being a user-defined data type that has these five different properties to it.1002

Well, in createItemObject, the first thing we have done is: we have an include statement that says we are going to include this Item.php class definition file.1008

And here, we have sorted it in a subdirectory called classes, which is a common convention.1019

So now, our PHP has included Item.php, and it has that class definition for Item; it knows what Item is, so it can create an Item object.1024

Down here, what we do is create an instance of that class; we create an actual Item object.1034

We take the class, and we turn it into an object.1039

We are creating a variable called item1, and we are saying, "We are going to create this variable item1,1043

and it is going to be of the class type Item; so it is going to have the user-defined data type known as item."1048

Now, this right here doesn't do too much; but we are going to talk about properties in a second (which is going to show a little more).1055

This is code that just runs; it is not going to output anything.1061

But what it goes and does is loads that Item.php file, and then item1 is now an instance of that Item class.1065

We went and (it is not going to do anything, but) loaded it in our browser; we can see that it outputs this HTML header that we had in the file.1075

But it doesn't really do anything; but it shows that the code was appropriately run.1085

Now, as mentioned, you have to have the class definition file included within a script, where you are creating an instance of that class.1090

For example, here we are creating an instance of the class Item; we had to include the class definition file for item.php.1101

If not, PHP doesn't know how to declare it.1107

Let's say we misspell this, and we include a file called item3.php.1109

Well, now when PHP gets down here and tries to create an Item class, it is not going to know what it is,1114

because it hasn't included the appropriate file, Item.php.1120

For example, now, if we save this, and we go and run the script again, we can see a couple of things.1125

One is that we get a warning that says item3.php could not be found.1132

But the one we are more interested in for this particular lesson is: it says, "Class Item is not found."1137

It is saying, on line 20 (if we look back at our code), "You tried to create an instance of the Item class, but we don't know what the Item class is."1142

And so, that is where this error message comes in here: "Class Item not found."1156

One of the things that objects have, that we mentioned that classes have, is: they define properties that a particular object of that class can have.1163

For example, a Person object, or a Person class, might have two properties: a first name and a last name.1171

Well, in PHP, there is a special syntax that is used: it is a dash followed by a greater than sign1180

that allows you to set, and then also get, the values of a particular object's properties.1186

So, after you have already created an object--after you have done something like item1=new,1192

which is the keyword used to create a new instance of an item object,1202

if we wanted to set a particular property of this item, we use this notation here.1208

So, what we do is: we have the name of the object variable that we created using the new method.1217

We have this dash followed by a greater than sign, and then the property that we want to set followed by the value.1225

For example, we know, in our Item class, we have a name property.1232

So, if we wanted to set the name of our Item object that we created, we say item1 (which is the variable1236

that refers to the new item object that we have created--so it's an actual object);1244

we use this operator--the dash followed by the greater than sign, followed by the name of the property we want to set.1248

If we look back at our Item.php, it has a property called name.1257

And then, we are going to set it equal to maybe the string Basketball.1267

So now, what we have done is set the name property that is associated with this item1 object.1273

Now, one thing to note is that a class defines the data type of a user-defined data type; it defines what values it can have.1284

However, when we create a new object, it creates a whole new instance of that class.1294

For example, if we went down here, and we defined a new Item called item2, and we set it equal to an Item object,1301

this item2 has its own copy of the name property, so we can go down here and set the name of the item2 Item to Other--to something else.1317

Now, we have two objects that are of the Item class type (the Item data type).1336

And each one of those objects has their own copy of the properties defined.1344

This is how we represent different items in our code.1350

This is going to be item #1, that has the name Basketball; this is going to be item #2 that has the name Other.1352

And then, what we can do is (let me erase some of this here): we can also use that same - sign,1360

followed by the greater than sign, to access a particular object's property.1367

For example, we might want to echo this name property.1373

And the way you would do that would be: you get the object name, item1; then you have this dash sign,1377

followed by the greater than sign, and then the name of the property you want to get the value of.1386

In this example here, this is saying, "For the item1 object, go and retrieve the value associated with the name property for that item."1395

Now, in our other example that I just erased...1406

In this case, what it is going to do is echo 'Basketball.'1410

Now, if we had run this same code on that Item we had just created (let's assume it was still here, up in this section);1414

if we had done, instead, item2, dash, greater than, name, what would be output would be 'Other.'1420

And that is because each Item object that we create has its own set of all of those properties defined in the Item class.1431

So, every time that we instantiate class Item using the new keyword, we create a variable, and we assign it this Item class type,1439

it gets its own version of all of these different properties.1448

Each one has its own itemID, its own name, its own price.1453

And the way you access and set those is using the dash, followed by the greater than sign.1456

Let's take a look at accessing and setting properties in action.1464

We have a script called itemObjectProperties.php that has the same beginning as our last script.1469

We include the Item class definition; we instantiate--we create a new Item object, and we set it equal to this variable item1.1476

And then, now we are going to go through and set all of the different properties of this Item, using this dash, greater than operator.1488

We are going to say, for item1 (which is this new Item object we have created), we are going to set its itemID to 1001.1494

We are going to set its name equal to Baseball, its price to $4.99, its description to this, and its extension equal to that.1501

And then, what we are going to do is access these different properties.1508

Now that we have set them, we can extract the values from that particular Item object.1512

So, on that Item object, we are going to extract all of the values into separate variables.1517

We are going to say, "Set a variable called itemID equal to the item ID that the Item object associated with the variable item1 has."1523

The key thing here is that it's the itemID associated with the item1 instance of an object.1535

In our last example, if this had been item2, the item ID could be the same, but typically it would be something different.1540

The key here is that, when you are accessing a property of a particular object,1548

you are accessing the properties of a particular instance of that object.1553

In this case, we are accessing the item1 instance of the object.1557

We go ahead and extract all of the different properties, using this dash, greater than sign.1561

And then, we just go ahead and output that.1569

If we go ahead and look at this code in our browser, itemObjectProperties.php,1572

we can see that what it has done is gone and, after having set all those properties, output all of the different values that we had set.1577

Now, one thing to notice is that...let's say we tried this code before we set any of the properties--1586

before we performed this set operation up here; well, our Item class, when it is initially created, doesn't have any values for these.1594

So, when this is run, when you try to access itemID, it is not going to return anything, because no value for that exists.1603

It, in fact, is null; so if we go ahead and save that script and reload it,1611

we can see that, the first time we try to access the information associated with the item1 object1616

(which is an object of the Item class), no values are set.1622

Now, as mentioned in our class definition, we can include default values.1627

So, let's say, for example, that we set a default value for the name property of an Item class.1631

And we will just call it default; so any time we create a new object that is of the class Item, it is going to have five different properties.1643

And the property name is going to have the value set to default.1654

And then, any other properties--you have to have manually set them, in order to have them set a value.1660

Now, you can overwrite this default property, which is what you would do, using that dash, greater than operator.1664

But at least, when this object starts, it has a default property.1672

So now, we go back and look at our code here.1674

After we have created this new Item object, and we try to retrieve all of its different properties,1678

this one for name is going to return that name 'default,' because it is already set when you create this Item class.1686

Before you set any properties to it, it already has a default value provided.1697

So, when we output this information before we have set all of the other values, it is going to output that name.1700

If we go and look at our code now, we can see that up here, it output the name 'default.'1706

And that is because we had provided a default value for it.1711

And so, you can see, also, that we were able (down here) to rename the object item1 to Baseball,1717

so that when we output the information for this object a second time, we can see that default has been changed to Baseball.1725

One of the key things to note is the difference between classes and objects;1737

and that is a very complex concept when you are first starting to work with object-oriented programming.1741

Just to reiterate, a class is the template for a user-defined data type that you are creating.1749

You are saying, "I am creating an item class, and it is going to have 5 different properties," for example.1756

Now, any time you want to create a variable that is of that class, you instantiate it using the new keyword.1762

You are creating a new variable that contains all 5 of those properties--for example, for the Item object.1769

And every time you call this new Item object, it creates a whole new copy of all of those properties.1779

So, when we call item2--if we set this to item2=new Item(), item2, again, is going to have its own copy of all of those different properties.1787

So, the class just describes the structure of what an Item object looks like.1798

When you create an instance of the class using the new keyword, it creates spots in memory for all the different properties of that.1804

And you can set them; and each object you create has its own copy of those,1813

and you can set and change them as you need, during the course of your script.1817

For the homework challenge for today, I just want you to create a class called Address that represents a street address.1824

It should have four properties: street, city, state, and zipcode (which represent the different parts of this real-world object).1830

For example, you could have an abstract model of an address, and you could say,1841

"We are going to model this address in our code as something that has these four parts to it."1845

Then, you do that in its own class definition file, and then, in a separate script, create an instance of the Address class using the new keyword.1850

And then, set values for all four of the properties of that object, using the dash, greater than syntax.1861

Then, like we did in the example, use the same dash, greater than syntax1873

to access the values that you have set for those particular properties and output them.1878

So, you can see that you were able to define the class appropriately,1884

that you were able to know how to set the properties of the class,1890

and also that you were able to access those properties of the class.1893

Be sure, when you do this, that you follow the one-class-per-file convention,1896

which means that you are going to define Address in its own file, called Address.php.1901

And remember that, in your script, when you create an instance of the Address object,1905

that you include that class definition file within your script.1913

That way, PHP knows what an Address class data type is.1917

And then also, just make sure (and we will get to this in future lessons) that when you define your properties1924

in your class definition file, you precede them with the public keyword.1930

And again, if we look at our Item.php, within the curly braces of this class's definition,1935

you have the public keyword, followed by a variable name1943

for a particular property you want that object to have, followed by a semicolon.1948

So, here we have five different statements that declare properties for that particular class.1952

That ends today's lesson; thank you for watching Educator.com--I look forward to seeing you next time.1959