PHP: Database Connection Class Constructor Method

First of all: this is pointless.

You are creating an object wrapper for the 10+ year old mysql_* function. This php extension is no longer maintained and the process of deprecation has already begun. You should not use this API for any new projects in 2012.

Instead you should learn how to use PDO or MySQLi and work with prepared statements.

That said .. lets take a look at your code:

• Constructor should receive all the parameters required for creating new instance, parameters should not be hard-coded in the class definition. What if you need to work with two databases at the same time ?
• When connection is created, it should be stored in object's scope variable. Something along the lines of $this->connection = mysql_conn.... Instead you store it in local variable, which you "loose" right after constructor is done.
• You should not use private variables for everything. They are not visible to classes which would extend your original class. Unless it is intentional, you should choose protected for this.
• The or die('..') bit most go. Do not stop the whole application if connection fails. Instead you should throw an exception, which then can be handled outside of the constructor.

Since your are only using them into the __construct method, you don't need them as class attributes. Only the $connection has to be kept for later use imho.

It might be much much better to not give any default values to those arguments but let them being set from the outside.

$db = new DatabaseConnection("localhost", "user", "password", "db");

They are plenty of PHP tools for that already, find them, read them and learn from that. First of all, use PDO and what is true in Java isn't always true in PHP.

The latter is probably better, but with an adjustment: pass some arguments to the constructor, namely the connection info.

Your first example is only useful if you've got one database connection and only if you're happy hard-coding the connection values (you shouldn't be). The second example, if you add say, a $name parameter as an argument, could be used to connect to multiple databases:

I'm new to OOP. Originally I was defining variables and assigning values to them within the class and outside of the constructor, but after an OOP lesson in Java today, I was told this is bad style and should be avoided.

class DatabaseConnection {
    private $dbHost;
    private $dbUser;
    private $dbPass;
    private $dbName;

    function __construct($config) {
        // Process the config file and dump the variables into $config
        $this->dbHost = $config['host'];
        $this->dbName = $config['name'];
        $this->dbUser = $config['user'];
        $this->dbPass = $config['pass'];

        $connection = mysql_connect($this->dbHost, $this->dbUser, $this->dbPass)
            or die("Could not connect to the database:<br />" . mysql_error());
        mysql_select_db($this->dbName, $connection) 
            or die("Database error:<br />" . mysql_error());
    }
}

So using this style, you now have a more useful class.

Here is mine and it works rather well:

class Database
{
   private static $_dbUser = 'user';
   private static $_dbPass = 'pwd';
   private static $_dbDB = 'dbname';
   private static $_dbHost = 'localhost';
   private static $_connection = NULL;

   /**
    * Constructor
    * prevents new Object creation
    */

   private function __construct(){
   }

   /**
    * Get Database connection
    * 
    * @return Mysqli
    */

   public static function getConnection() {
      if (!self::$_connection) {
     self::$_connection = @new mysqli(self::$_dbHost, self::$_dbUser, self::$_dbPass, self::$_dbDB);

         if (self::$_connection -> connect_error) {
            die('Connect Error: ' . self::$_connection->connect_error);
         }
      }
      return self::$_connection;
   }
}

By making the __construct empty, it prevents a new class being instantiated from anywhere. Then, make the function static so now all I need to do to get my connection is Database::getConnection() And this is all in an include file, in a password protected folder on the server and just included with each class file. This will also check to see if a connection is already open before attempting another one. If one is already established, it passes the open connection to the method.