class Instrument {
  abstract function jouerUnTruc();
}
class Percussion extends Instrument {
  function jouerUnTruc() {
    faireTocToc();
  }
}
class Cuivre extends Instrument {
  function jouerUnTruc() {
    fairePouetPouet();
  }
}

1. if ($typeobj=='percussion') then
2.     $obj = new Percussion()
3.   else ...

1. $obj = new $typeobj();

foreach (InstrumentClass myClass in InheritedClassesFromInstrument)
{
    if (myClass.IsFamilyOf(MonInstrument))
       return (Instrument)new MyClass(MonInstrument);
}
throw new Exception("Instrument non pris en charge !" );

try
{
  Instrument maFlute = Instrument.CreateInstrument("flûte" );
  maFlute.JouerNote(Intrument.Notes.Fa);
}
catch
{
  Console.WriteLine("Proutch" );
}

1. public class ImageReaderFactory
2. {
3.     public static ImageReader getImageReader( InputStream is )
4.     {
5.         int imageType = figureOutImageType( is );
7.         switch( imageType )
8.         {
9.             case ImageReaderFactory.GIF:
10.                 return new GifReader( is );
11.             case ImageReaderFactory.JPEG:
12.                 return new JpegReader( is );
13.             // etc.
14.         }
15.     }
16. }

<?php
    
function getObjXmlFournisseur($path) {
    if (!($docXML = new SimpleXMLElement($path, 0, true)))
        return false;
    $res = preg_match('#^(.*)/sites/delivery/(alexlee|finetunes)(.*)$#', $path, $tab);
    if (!$res)
        return false;
    
    $fourn = $tab[2];
    
    if ($fourn=='alexlee')
        $obj = new clXmlAlexlee($path, $docXML);
    elseif ($fourn=='finetunes')
        $obj = new clXmlFinetunes($path, $docXML);
    else
        return false;
        
    return $obj;
}
 
abstract class clXmlFournisseurMother {
        var $pathXML;
        var $docXML;
        var $fourn;
        var $rootPath;
        
        abstract protected function _getPathInDel($pathDeQuoi, $id);
        
        function getPathInDel($pathDeQuoi, $id) {
            if (is_file($path = $this->_getPathInDel($pathDeQuoi, $id))
                    and ($res = preg_match('#^(.*)/sites/delivery/(.*)$#', $path, $tab))) 
            {
                return $tab[2];
            }
            return false;
        }
}
 
class clXmlAlexlee extends clXmlFournisseurMother {
        function clXmlAlexlee($path, $docXML) {
            $res = preg_match('#^(.*/sites/delivery/alexlee)/(.*)$#', $path, $tab);
            $this->rootPath = $tab[1];
            $this->docXML = $docXML;
            $this->delPath = realpath(dirname($path).'/../..');
        }
        
        protected function _getPathInDel($pathDeQuoi, $id) {
            if (in_array($pathDeQuoi, array('mp3', 'wav', 'ext')) 
                    and ($tab = $this->docXML->xpath("//track[isrc='".$id."']/track_key" ))) 
            {
                if ($pathDeQuoi=='mp3' and $dirAudio = $this->getDir('audio'))
                    return $dirAudio.'/'.$tab[0].'.mp3';
                elseif ($pathDeQuoi=='wav' and $dirAudio = $this->getDir('audio'))
                    return $dirAudio.'/'.$tab[0].'.wav';
                elseif ($pathDeQuoi=='ext'  and $dirClips = $this->getDir('clips'))
                    return $dirClips.'/'.makeClipFileName($tab[0]);
            }
            return false;
        }
 
        function getDir($type) {
            $dir = ''; 
            switch ($type) {
                case 'deliv' : $dir = $this->delPath; break;
                case 'pochettes' : $dir = $this->delPath.'/graphics'; break;
                case 'audio' : $dir = $this->delPath.'/audio'; break;
                case 'clips' : 
                        $dir = $this->delPath.'/audio/clips';
                        if (!is_dir($dir)) 
                            $dir = $this->delPath.'/clips';
                        break;
            }
            return ($dir and is_dir($dir)) ? $dir : false;
        }
        
        function makeClipFileName($trackKey) {
            preg_match_all("|^([^_]*)_([^_]*)_(.*)$|", $trackKey, $out, PREG_SET_ORDER);
            if (!$out) {
                return false;
            }
            return $out[0][1].'_'.$out[0][2].'_clip_'.$out[0][3].'.mp3';
        }
}
 
class clXmlFinetunes extends clXmlFournisseurMother {
        function clXmlFinetunes($path, $docXML) {
            $res = preg_match('#^(.*/sites/delivery/finetunes/finetunes)/(.*)$#', $path, $tab);
            $this->rootPath = $tab[1];
            $this->docXML = $docXML;
            $this->delPath = realpath(dirname($path).'/..');
        }
 
        protected function _getPathInDel($pathDeQuoi, $id) {
            if (in_array($pathDeQuoi, array('mp3', 'wav', 'ext'))) {
                if ($pathDeQuoi=='wav' or $pathDeQuoi=='mp3')
                    $xpath = "//track[id[@type='isrc']='$id']/resource[@type='audiofile' and datatype='audio/$pathDeQuoi']/uri";
                elseif ($pathDeQuoi=='ext')
                    $xpath = "//track[id[@type='isrc']='$id']/resource[@type='prelistening' and quality[@type='bitrate']='64']/uri";
                        
                $tab = $this->docXML->xpath($xpath);
                return $this->rootPath.'/'.$tab[0];
                
                if (!$tab[0])
                    return false;
            }
        }
}

public abstract class GenericTextConverter
{
    public static ITextConverter GetTextConverter(string TextToConvert)
    {
        // Appelle le "CanConvert" de chaque classe héritée
        // Et retourne une instance de la première qui répond true
        // Le but de la manoeuvre, c'est que cette méthode n'aie pas besoin de 
        return (ITextConverter)new <LaClasseQuiVaBien>();
    }
}
 
public interface ITextConverter
{
    static bool CanConvert(string OriginalText);
 
    string Convert(string OriginalText);
    string Revert(string ConvertedText);
}
 
public class Converter1 : GenericTextConverter, ITextConverter
{
    static bool CanConvert(string OriginalText)
    {
        return (OriginalText.IndexOf('-') == 0)
    }
 
 
    string Convert(string OriginalText)
    {
        return "Convert1 : " + OriginalText.Replace(' ', '-');
    }
 
    string Revert(string ConvertedText)
    {
        return "Revert1 : " + ConvertedText.Replace('-', ' ');
    }
}
 
public class Converter2 : GenericTextConverter, ITextConverter
{
    static bool CanConvert(string OriginalText)
    {
        return (OriginalText.IndexOf('#') == 0)
    }
 
 
    string Convert(string OriginalText)
    {
        return return "Convert2 : " + OriginalText.Replace('t', '#');
    }
 
    string Revert(string ConvertedText)
    {
        return return "Convert2 : " + ConvertedText.Replace('#', 't');
    }
}

using System;
 
namespace HeritageExtensible
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] MesString = new string[]{"toto va à la plage", "pique-nique", "toto pique-nique à la plage"};
 
            foreach (string MaString in MesString)
            {
                ITextConverter MonConverter = GenericTextConverter.GetTextConverter(MaString);
                if (MonConverter != null)
                {
                    Console.WriteLine(MonConverter.Convert(MaString));
                }
                else
                {
                    Console.WriteLine("Impossible de convertir " + MaString);
                }
            }
 
            Console.ReadKey(true);
        }
    }
}

using System;
 
namespace HeritageExtensible
{
    public interface ITextConverter
    {
        bool CanConvert(string OriginalText);
 
        string Convert(string OriginalText);
    }
}

using System;
using System.Reflection;

namespace HeritageExtensible
{
    public abstract class GenericTextConverter
    {
        public static ITextConverter GetTextConverter(string TextToConvert)
        {
            Assembly MonAssembly = Assembly.GetExecutingAssembly();
            Type[] MesTypes = MonAssembly.GetTypes();

            foreach (Type MonType in MesTypes)
            {
                if (MonType.IsSubclassOf(Type.GetType("HeritageExtensible.GenericTextConverter" )))
                {
                    ITextConverter MonInstance = (ITextConverter)Activator.CreateInstance(MonType);
                    if (MonInstance.CanConvert(TextToConvert))
                    {
                        return MonInstance;
                    }
                }
            }
            return null;
        }
    }
}

using System;
 
namespace HeritageExtensible
{
    public class Converter1 : GenericTextConverter, ITextConverter
    {
        public bool CanConvert(string OriginalText)
        {
            return (OriginalText.IndexOf('-') == -1);
        }
 
        public string Convert(string OriginalText)
        {
            return "Convert1 : " + OriginalText.Replace(' ', '-');
        }
    }
 
    public class Converter2 : GenericTextConverter, ITextConverter
    {
        public bool CanConvert(string OriginalText)
        {
            return (OriginalText.IndexOf(' ') == -1);
        }
 
        public string Convert(string OriginalText)
        {
            return "Convert2 : " + OriginalText.Replace('-', ' ');
        }
    }
}

public static ITextConverter GetTextConverter(string TextToConvert)
        {
            foreach (string Converter in Directory.GetFiles("./converters", "*.dll" ))
            {
                FileInfo MonFichier = new FileInfo(Converter);
                Assembly MonAssembly = Assembly.LoadFile(MonFichier.FullName);
                Type[] MesTypes = MonAssembly.GetTypes();
 
                foreach (Type MonType in MesTypes)
                {
                    if (MonType.IsSubclassOf(Type.GetType("HeritageExtensible.GenericTextConverter" )))
                    {
                        ITextConverter MonInstance = (ITextConverter)Activator.CreateInstance(MonType);
                        if (MonInstance.CanConvert(TextToConvert))
                        {
                            return MonInstance;
                        }
                    }
                }
            }
            return null;
        }