Home > Articles > Security > Network Security

A Quick and Dirty Introduction to OOP with PHP

  • Print
  • + Share This
Most PHP programs are written in the traditional style of programming, but PHP also can accommodate object-oriented programming (OOP), which is preferable when creating large programs. Chris Cosentino shows you here how to use OOP with PHP.
From the author of

Most PHP programs are written in the traditional style (old school) of programming. You create functions to manipulate different pieces of data, and you call those functions during the "main" execution phase of your program.

PHP also offers object-oriented programming (OOP), which is now the preferred method of creating large programs. Java and C++ are object-oriented programming languages. OOP takes data and treats it like a "think."

Think of a car. A car is an object that has properties (color, make, model) and various states (parked, in reverse, going X miles an hour). Using OOP, you can manage your data more easily if your data mimics "objects."

Objects are created and managed through structures called classes. The data is manipulated within these classes with structures called methods. In reality, methods are nothing more than functions, yet they can work only within the confines of the class in which they are contained.

So, if we have a car object, we would need to manage it using a class. And we would need to manipulate the data for that object using methods (functions).

Using our car analogy, we could create a simple object that keeps track of a car's make. For example:

class CAR {
   var $manufacturer;

   function setMake($make) {
     $this->manufacturer=$make
   }
   
   function getMake() {
     return $this->manufacturer;
   }
}

This example is a simple class that contains one property called $make. The class also has two methods to manipulate that $make data. One function sets the $make, and the other function retrieves the make.

You'll notice that the functions (methods) use $this->manufacturer. That is referring to the classes' value for that variable. It's a miniglobal variable that is useable across all the functions in the class.

You would create this object in a PHP page like so:

$limo1 = new CAR;

This creates a new car object. The new keyword may be new to you—it's used only to create a new object. The $limo1 variable refers to a whole object. When you want to manipulate part of the object, you call a method:

$limo1->setMake("Caddy");

This sets the $make of $limo1 to Caddy (Cadillac). The -> operator is used to specify which method you are using within the object.

Once you have set the $make property of $limo1, you can retrieve it at any time using the getMake() method, like this:

$make = $limo1->getMake();

At this point, $make = Caddy.

Extending Classes

One of the other neat things about classes is that you can build upon classes. You can create a new class that is an extension of an existing class. The extension can use all of the methods of the class that it extends, plus any new classes that it adds for itself. You create an extension like this:

class STRETCH extends CAR {
   var $seats;
   
   function setSeatingLimit($limit) {
     $this->seats = $limit;
   }
}

So, in essence, the previous code is identical to this:

class STRETCH {
   var $make;
   var $seats;
   
   function setMake($make) {
     $this->make=$make
   }
   
   function getMake() {
     return $this->make;
   }
   function setSeatingLimit($limit) {
     $this->seats = $limit;
   }
}

You can build base classes and then reuse those base classes and modify them for many extended classes. You save time and coding effort through reuse.

So you have the ability to create a class and extend it. Let's build a small application to try out your new skills.

oop.php

The application in Listing 1 simply lets you add some properties to an object. It then returns the properties in a nicely formatted page.

Consult the upcoming section "How the Script Works" for details on each line on the script.

Listing 1: oop.php

1. <html>
2. <head>
3. <title>OOP CAR</title>
4. </head>
5. <body bgcolor="#FFFFFF" text="#000000">
6. <?
7. class CAR {
8. var $manufacturer;
9. var $color;
10. var $registration_number;
11. function setMake($make) {
12. $this->manufacturer=$make;
13. }
14. function getMake() {
15. return $this->manufacturer;
16. }
17. function setColor($color) {
18. $this->color=$color;
19. }
20. function getColor() {
21. return $this->color;
22. }
23. function setRegNum($reg_num) {
24. $this->registration_number=$reg_num;
25. }
26. function getRegNum() {
27. return $this->registration_number;
28. }
29. }
30. class STRETCH extends CAR {
31. var $seats;
32. function setSeatingLimit($limit) {
33. $this->seats = $limit;
34. }
35. function getSeatingLimit() {
36. return $this->seats;
37. }
38. } 
39. function print_form() {
40. ?>
41. <form action=oop.php method=post>
42. <p>Enter the properties of the Stretch Limo:
43. <br>Make: <input type="text" name="make">
44. <br>Color: <input type="text" name="color">
45. <br>License Plate Number: <input type="text" name="reg_num">
46. <br>Seating Limit: <input type="text" name="limit">
47. <br><input type="submit" name="submit" value="Submit">
48. </form>
49. <?
50. }
51. function set_properties($make, $color, $reg_num, $limit) {
52. global $limo;
53. $limo = new STRETCH;
54. $limo->setMake($make);
55. $limo->setColor($color);
56. $limo->setRegNum($reg_num);
57. $limo->setSeatingLimit($limit);
58. }
59. function display_car($limo) {
60. ?>
61. <h3>Here are the properties for the Limo:
62. <ul>
63. <li>Make: <? echo $limo->getMake(); ?>
64. <li>Color: <? echo $limo->getColor(); ?>
65. <li>Registration Number: <? echo $limo->getRegNum(); ?>
66. <li>Seating Limit: <? echo $limo->getSeatingLimit(); ?>
67. </ul>
68. <?
69. }
70. if(isset($submit)) {
71. set_properties($make, $color, $reg_num, $limit);
72. display_car($limo);
73. } else {
74. print_form();
75. }
76. ?>
77. </body>
78. </html>

How the Script Works

Take a look at what each line in Listing 1 does:

1–5

This is the normal HTML start of a page.

6

Here is the beginning of the PHP script.

7

This line begins the class declaration. The CAR class declaration goes through line 29.

8–10

These lines create variables for use within the class.

11–13

This is a method in the class. This function sets the manufacturer variable to the value of an external variable called $make.

14–16

Another method in the class, this one returns the manufacturer variable.

17–28

These are more methods, similar in design, but with different properties than the first two methods.

29

This line ends the CAR class declaration.

30

This line begins the class declaration. The STRETCH class declaration goes through line 38. Notice that the STRETCH class extends the CAR class so that it can use all of the methods within CAR, plus its own methods.

31

This line creates variables for use within the class.

32–37

Here are more methods, similar in design, but with different properties than the methods in the CAR class.

38

This line ends the STRETCH class definition

39–50

This is a short function that prints out a form to enter the Limo information.

51–58

This function creates an instance of the STRETCH class called $limo and sets its properties to those filled in on the form.

59–69

This function displays the properties in the $limo instance of the STRETCH class.

70

This line check to see if the Submit button (from the properties entry form) was pushed. If it was, then lines 71–72 are executed. If not, line 73 is executed.

71–72

The set_properties function (line 51) and the display_car function (line 59) are executed.

73–75

These lines are executed if the Submit button was not pushed. The print_form function is run (line 39).

76

This line ends the PHP portion of the script.

77–78

These lines close out the HTML in the script.


  • + Share This
  • 🔖 Save To Your Account