Prenons l'exemple d'un Chien :

<?php
class Chien
{
protected $name;

public function __construct($name)
{
$this->name = $name;
}

public function __destruct()
{
}
}
?>

• public (comportement par défaut) : Accessible depuis la classe elle-même, depuis une classe dérivée et depuis l'extérieur de la classe ;
• protected : Accessible depuis la classe elle-même et depuis une classe dérivée ;
• private : Accessible seulement depuis la classe elle-même.

Le constucteur et le destructeur ci-dessus sont facultatifs. Vous n'êtes pas dans l'obligation de les déclarer (surcharger), PHP en définit un lui-même si vous ne le faites pas. En ce cas, ils auront un comportement par défaut.

La coutume est de surcharger au moins le constructeur. Le destructeur est moins souvent utile, mais par exemple dans le cas d'un gestionnaire de flux (fichier, URI, etc.), il est très pratique d'y placer l'appel à la fonction de fermeture de flux.

L'héritage est un moyen de réutiliser le code. On définit une hiérarchie de classes, et les classes enfant héritent de ses propriétés et méthodes.

L'héritage se fait au moyen du mot clef extends. En PHP, il n'est pas possible de faire de l'héritage multiple comme d'autres langages le permettent.

class Mammifère
{
protected $age;
protected $nom;

public function __construct($nom, $age)
{
$this->age = $age;
$this->nom = $nom;
}

public function afficherAge()
{
echo $this->age.' ans<br />';
}

public function afficherNom()
{
echo $this->nom.'<br />';
}
}

class Chien extends Mammifère
{
public function aboyer()
{
echo 'Ouah !';
}
}

class Humain extends Mammifère
{
public function saluer()
{
echo 'Bonjour !';
}
}

$monChien = new Chien('Medor', 10);
$monChien->afficherNom();
$monChien->afficherAge();
$monChien->aboyer();

$moi = new Humain('Guillaume', 25);
$moi->afficherNom();
$moi->afficherAge();
$moi->saluer();

Ici, nous voyons que les classes Chien et Humain héritent des méthodes afficherNom() et afficherAge(), ainsi que des propriétés $nom et $age. De plus, nous n'avons pas besoin de définir le constructeur de ces deux classes puisqu'il est déjà présent dans leur parent Mammifère et puisqu'il ne change pas.

Non, mais il est possible d'utiliser des Interfaces.

Les Interfaces sont des patrons de classes. Par exemple, j'ai un ensemble de classes et je veux être certain qu'elles partagent certains traits caractéristiques.

Je pourrais le faire avec de l'héritage mais, dans certaines situations, ce n'est pas adapté. Admettons que j'aie deux classes "Chien" et "Voiture". Il me sera difficile de trouver comment les faire hériter de la même superclasse, pourtant on peut leur trouver des points communs : "se déplacer" est un exemple parmi d'autres.

interface Déplaçable
{
// Déclaration de la méthode et de ses paramètres (pas de corps)
public function déplacerVers($destination);
}

class Chien implements Déplaçable
{
public function déplacerVers($destination)
{
// Corps de la méthode
}
}

class Voiture implements Déplaçable
{
public function déplacerVers($destination)
{
// Corps de la méthode
}
}

À l'inverse de l'héritage (une classe ne peut hériter que d'un seul parent en PHP 5), une classe peut implémenter autant d'interfaces qu'elle le veut.

Lorsqu'une classe implémente une interface, elle doit en déclarer toutes les méthodes : si elle ne le fait pas, PHP affiche une erreur à l'exécution du script.

L'héritage doit être utilisé lorsqu'une classe est un sous ensemble d'une autre classe. Par exemple : un Mammifère est un Animal, un Humain et un Chien sont des Mammifères. Nous avons donc des classes Chien et Humain qui héritent de Mammifère, et Mammifère qui hérite d'Animal.

Les interfaces doivent être utilisées lorsque des classes partagent des comportement identiques, en-dehors de toute généalogie. Cela peut avoir lieu aussi bien à un niveau fonctionnel que purement de programmation. Par exemple, les classes Animal et Véhicule ne partagent rien qui leur permettent d'hériter de la même superclasse mais l'on peut considérer qu'elles partagent la capacité de déplacement, ce qui se traduit donc par l'implémentation d'une interface commune.

La réponse est oui. Il faut tout de même savoir que les déclarations des différentes classes doivent être faites avant l'appel à session_start lorsque l'objet fait partie de la session courante (comprenez qu'il a été enregistré). Les déclarations des classes peuvent être chargées manuellement (fonctions require ou include) ou automatiquement (fonction magique __autoload). En voici un exemple pour illustrer :

class Utilisateur
{
    protected $identifiant;
    protected $login;

    public function __construct($id, $login)
    {
        $this->identifiant = $id;
        $this->login = $login;
    }
    
    public function getLogin()
    {
        return $this->login;
    }
    
    public function getIdentifiant()
    {
        return $this->identifiant;
    }
}

Enregistrement dans la session :

session_start();
require_once('utilisateur.class.php'); // Peut être effectué avant comme après session_start()
 
$_SESSION['util'] = new Utilisateur(1, 'toto');

Et enfin, utilisation des données de la session :

require_once('utilisateur.class.php'); // Déclaration impérativement avant session_start()
session_start();

if (isset($_SESSION['util']))
{
    echo 'Bonjour ' . $_SESSION['util']->getLogin();
}

• Les attributs de type ressource ne sont pas sérialisables (une connexion à une base de données par exemple) ;
• Si la session est démarrée automatiquement (directive session.auto_start positionnée à 1), vous n'arriverez pas à utiliser directement des objets puisque les classes ne pourront être connues.