My First Class - Any Good?

CMellor · 07-13-2008, 08:25 PM

Hey,

I've never coded using PHP 5's OOP, and while I was planning a new project, I knew I was going to be using it, as well as using the MySQLi function. I've read loads of stuff now on OOP and I think I've got the hang of it, sorta, but at a newbie stage... ya know? lol

I whipped up this code, I just want you to tell me what I did right and wrong and how it can be improved:

PHP Code:


			
<?php
class math {

    const host = 'localhost';
    const user = 'root';
    const pass = 'blergh';
    const db = 'project';
    
    public function __construct() {
        // Start MySQLi connection
        $mysqli = new mysqli(self::host, self::user, self::pass, self::db);
        // Check if connect
        if(mysqli_connect_errno()) {
            throw new exception('MySQLi did not connect');
        }
    }
        
    public function plus($x, $y) {
        $this->x = $x;
        $this->y = $y;
        
        return $this->x + $this->y;
    }

}

$class = new math;

try {
    echo $class->plus(22, 55);
}
catch(exception $e) {
    echo $e->getMessage();
}

?>

Cheers!

drewbee · 07-13-2008, 09:54 PM

It is a good start! A few things:

You dont have the class instance variables x and y defined.

Code:

$this->x = $x;
$this->y = $y;

Below your database constant variables, put this

PHP Code:


			
var $x;
var $y;

Now your assignments above can actually place these variables, and if you wanted to access what you recently put through the last function call:

PHP Code:


			
$class = new math;

try {
    echo $class->plus(22, 55);
    echo 'We added ' . $class->x . ' + ' . $class->y;
}
catch(exception $e) {
    echo $e->getMessage();
}

?>

MysqlI rules, doesn't it? :D

PHP Code:


			
$db = new mysqli('localhost', 'user', 'pass', 'database');
$query = $db->query("SELECT col1, col2, col3 FROM table WHERE foo = 'bar'");

if ($query->num_rows > 0)
{
    while ($row = $query->fetch_array())
    {
        echo $row['col1'] . ' ' . $row['col2'] . ' ' . $row['col3'];
     }
}
else
{
    echo 'no records found';
}

delayedinsanity · 07-13-2008, 10:13 PM

Quote:

Now your assignments above can actually place these variables, and if you wanted to access what you recently put through the last function call:

Actually, since PHP supports dynamic properties, once they are set, they are accessible either way. So you don't necessarily have to define every property you plan on using, it's just good practice. Take the following for example;

PHP Code:


			
class var_test
{

    public function set ($x, $y)
    {
        $this->x = $x;
        $this->y = $y;
    }

    public function show ()
    {
        echo 'X: <strong>',$this->x,'</strong><br />';
        echo 'Y: <strong>',$this->y,'</strong><br />';
    }

    public function add ()
    {
        echo $this->x,'+',$this->y,'=',$this->x+$this->y;
    }

};

$pTest = new var_test;
$pTest->show();
$pTest->set(10, 10);
$pTest->show();
$pTest->add();
echo '<br />',$pTest->x;

The first call to show() will return Notice: Undefined property: var_test::$x in...but the second time it works as the properties have been set, even though they were not laid out in the class.
-m

drewbee · 07-13-2008, 11:17 PM

Yeah :) I am more about pushing good standards before they start making poor programming standards.

I wish PHP was more strict in this area, heh.

delayedinsanity · 07-13-2008, 11:45 PM

I'm glad it's not. As I mentioned, and as you said, it is good practice to define properties that you are going to need, and in a lot of cases it's even better practice to make sure those properties are intialized to some degree in your construct or any method that needs them.

That being said, there are situations where using a dynamic property can be an asset. If you want, you can even use the built in magic functions so that any dynamic variables you plan on using will exist inside of a defined property, like so;

PHP Code:


			
class dynamic_properties
{
    private $dynamic = array();

    public function display_library ()
    {
        echo '<pre>';
        print_r($this->dynamic);
        echo '</pre>';
    }

    public function __set($szName, $szValue)
    {
        $this->dynamic[$szName] = $szValue;
    }

    public function __get($szName)
    {
        if (isset($this->dynamic[$szName]))
            return $this->dynamic[$szName];
    }
    
    public function __isset($szName)
    {
        return isset($this->dynamic[$szName]);
    }
    
    public function __unset($szName) 
    {
        unset($this->dynamic[$szName]);
    }

};

$pDynamic = new dynamic_properties;
$pDynamic->var1 = 'Hello, ';
$pDynamic->var2 = 'world!';

echo $pDynamic->var1,$pDynamic->var2,'<br />';

$pDynamic->display_library();

A zen buddhist once said, "There are as many ways to the one as there are people."
-m

CMellor · 07-14-2008, 01:15 AM

I thought we didn't use var anymore? I'm using PHP 5. Isn't it:

PHP Code:


			
public $x
public $y

???

delayedinsanity · 07-14-2008, 01:46 AM

Yeah, var is php4 OOP. With PHP5 you set visibility with the public, private and protected keywords.
-m

sketchMedia · 07-14-2008, 08:33 AM

yes using var is deprecated and removed completely in php6 i think.

Tanax · 07-14-2008, 12:11 PM

Why are you using self::$localhost and self:: all over the place?
If you're using PHP5, then you have use a static variable, and you aren't, so.. you need to use $this->localhost etc.

xenon · 07-14-2008, 12:41 PM

Because you can't access class constants and/or static properties using the $this keyword.

drewbee · 07-14-2008, 12:59 PM

Quote:

Originally Posted by sketchMedia

yes using var is deprecated and removed completely in php6 i think.

Man are you serious? Thats annoying. lol. Looks like its time for some code re-write.

CMellor · 07-14-2008, 03:26 PM

Quote:

Originally Posted by Tanax

Why are you using self::$localhost and self:: all over the place?
If you're using PHP5, then you have use a static variable, and you aren't, so.. you need to use $this->localhost etc.

Quote:

Originally Posted by xenon

Because you can't access class constants and/or static properties using the $this keyword.

Urm, yeah, what he said ^

I'd always used define and remembered once I saw a different way of doing that with OOP, ala const so seeing as I love being different, I did it that way :P

drewbee · 07-14-2008, 03:31 PM

Quote:

Originally Posted by CMellor

Urm, yeah, what he said ^

I'd always used define and remembered once I saw a different way of doing that with OOP, ala const so seeing as I love being different, I did it that way :P

Though what you do is correct. Constants are usually accessed through the self:: or ClassName:: while properties (public variables) are accessed through $this.

I've seen some really funky stuff going along with inheritance and constants though so I stayed away from them :D

CMellor · 07-14-2008, 03:32 PM

Sorry for the double post!

Is it good coding to put the MySQL connection inside the __construct function?

Also I tried doing:

PHP Code:


			
public function __destruct() {
    mysqli_close();
}

But I got errors :\

drewbee · 07-14-2008, 03:38 PM

Well, since this is a math class, I would actually have a seperate class for the database as well

PHP Code:


			
class Math
{
    public mysqli;
 
    public function __construct()
    {
          $this->mysqli = new mysql('local','user','pass','db');
    }
}
 
$math = new Math;
$math->mysqli->query("SELECT....");

sketchMedia · 07-14-2008, 04:27 PM

Static methods/variables and class constants are bound to the class therefore we must use self to reference the current class, $this however references the current object not class, remember there is a fundamental difference between the two; that is why you can't use $this to access methods/properties marked as static or class constants because they are bound to the class not the object.

Tanax · 07-14-2008, 04:35 PM

Hm, weird.. well if I were you I would use private $localhost instead of constants

drewbee · 07-14-2008, 05:00 PM

Quote:

Originally Posted by sketchMedia

Static methods/variables and class constants are bound to the class therefore we must use self to reference the current class, $this however references the current object not class, remember there is a fundamental difference between the two; that is why you can't use $this to access methods/properties marked as static or class constants because they are bound to the class not the object.

Thanks for that explanation. I havn't used method / variable scoping to much yet, and this makes sense.

I guess my real question is, what is the purpose to making a static method vs public? I understand private, protected, and public, but not static.

edit:
Declaring class members or methods as static makes them accessible without needing an instantiation of the class.

More on visibility:
The visibility of a property or method can be defined by prefixing the declaration with the keywords: public, protected or private. Public declared items can be accessed everywhere. Protected limits access to inherited and parent classes (and to the class that defines the item). Private limits visibility only to the class that defines the item.

Tanax · 07-15-2008, 08:14 AM

Static methods are awesome. But not really needed in this case drewbee

xenon · 07-15-2008, 06:35 PM

Quote:

Originally Posted by Tanax

Static methods are awesome. But not really needed in this case drewbee

That depends. If you only need only one connection to the database (you usually don't need more than one), then a singleton could be implemented:

PHP Code:


			
class XYZ
{
     protected static $instance = null;
     
     public static function getInstance()
     {
         if(self::$instance instanceof self === false) self::$instance = new self();

         return self::$instance;
     }

     private function __construct() { }

     private function __clone() { }
}

That way, you can't clone or create multiple instances of the same object. But again, that depends, there are cases when you need a clone of the db object (e.g.: nested fetching), and in that case it's better if you leave out the implementation of the magic clone method.