Logan K. <lo*********@gmail.com> wrote:
What is a PHP class? I've seen a lot of talk about these and how they
can help you out, but I've never seen a very good explanation. I've
been working with PHP for just over 6 months and usually hard code
everything into my scripts. Recently I've begun putting frequently-used
things (like my MySQL connect function) in a seperate file and
including them. But I still haven't seen the use of classes or even
functions for that matter. And one more thing - how do you set up a
function to accept variables?
Could someone please help me out?!?!
Whew! Thats a lot to explain in 1 post! I'll give you a nickel tour, but
it's a lot to digest and you should really look into it.
Basically, it's like grouping functions and the data those functions operate
on together in a box.
Before you can know what a class is, you have to understand functions:
$variable = "Unset";
set_function($parameter){
global($variable);
$variable = $parameter;
}
get_function($parameter){
global($variable);
echo "I am some_function, I was handed: $parameter";
return($variable);
}
# Use some_function, giving it $parameter (a variable)
another_function("Set global variable");
get_function("Hello");
get_function("World");
Ok, here we've got a couple functions and a global variable that the two
functions work with. Great. Now imagine those two functions being applied
to different variables, lets say, $variable is someones phone number and you
want to work with different people, you're out of luck in that even.
OR imagine name problems (What if you wrote another function called
set_function(), how to keep which is which?)
Well, the different variables can be handled with array references and
parameters:
Person_construct($first,$last){
return(array(FIRST => $first, LAST => $last));
}
Person_set_last(&$stash,$value){ $stash[FIRST] = $value; }
Person_set_first(&$stash,$value){ $stash[LAST] = $value; }
Person_get_first(&$stash){ return($stash[FIRST]); }
Person_get_last(&$stash){ return($stash[LAST]); }
Here we have a very primitive object model, since the functions
can operate on different sets of data. You can do stuff like:
$customer = Person_construct("Bob","Jones");
Person_get_first($customer); //... etc..
But, you have to remember to pass $stash to each function, and it'd be a LOT
easier to just say get_first(); However, get_first() may already be used. You
can kind of see this design pattern in non-object oriented languages and code,
stuff like the mysql_xxx accepting a resource link, or file system functions
accepting a file handle. Our "$handle" in this case is called $stash. Object
oriented classes provide this handle automatically.
Also, You might have different types of Persons, such as Employees and
Customers, they all have first and last names, but a customer doesn't earn
a salary and an employee probably shouldn't be sent catalogs on christmas.
This is where classes come into the picture. You can do stuff like:
class Person {
public function __construct($first,$last){
$this->first = $first;
$this->last = $last;
}
public function getName() /....
/* ...more functions, but with classes, we call them "methods" */
}
class Employee extends Person {
public function getSalary() // Return employee salary.
}
An employee is ALSO a person, (a specific kind of person but still a person)
because it extends the Person class. So, it has a getName() method even
though none was written for it. code re-use, portions of code that
are designed to work with "Persons" can handle employees and customers
with the same ease.
The $this is like our $stash earlier, except with classes and objects,
one doesn't pass it along as the first parameter, one uses it to
call the method (invoke the function): $emplyee->getName()
There is something called a constructor and a 'new' operator, these things tell
PHP which class is associated to $employee, so it nows which bit of code
to run. Hence, no need for those long Employee_getName(&$stash) lines. (Well
that and lots of other advantages, like being able to change the class for
employee w/out breaking all your other code)
There are a LOT more things to look into, such as exceptions, interfaces,
abstraction and more.. but these are the very basics.
Jamie
--
http://www.geniegate.com Custom web programming
User Management Solutions Perl / PHP / Java / UNIX
