Factory Pattern Implementation in PHP
Coding Critique

public static function makeNumber( $type, $number ) {
    $numObject = null;
    $number = null;


Well, that almost certainly isn't right.  You take a parameter which you then ignore, overwriting it locally.  

public static function makeNumber( $type, $number = null ) {
    $numObject = null;


That seems like it might be more useful.  You accept a parameter if offered.  Otherwise, you give it a default value.  That may or may not be what you wanted to do.  

        case 'float':
            $numObject = new Float( $number );
            break;


You can make this simpler if you want:

        case 'float':
            return new Float( $number );


That way you can get rid of $numObject entirely.  

        default:
            $numObject = new Integer( $number );
            break;


You don't need a break; in the last clause.  You can just let it fall through after a default: clause.  

Factory Method

You have this tagged factory-method, but you aren't using a factory method.  The factory method is when you have a method that can return different results depending on the exact class of the object.  So you might have 

class CompositeNumberFactory {
    public static function makeNumber( $first, $second );
}

class FractionFactory extends CompositeNumberFactory {
    public static function makeNumber( $first, $second ) {
        return new Fraction($first, $second);
    }
}

class Fraction implements iNumber {
    private $numerator;
    private $denominator;

    function __construct($numerator, $denominator) {
        $this-&gt;numerator = $numerator;
        $this-&gt;denominator = $denominator;
    }


This gets more interesting if FractionFactory is called something else, e.g. RationalFactory.  Then the caller may not even know that they have a Fraction.  They just know that they have the normal iNumber methods.  

Factory Pattern

There is a variant of the factory pattern that does work something like you specify, but it would normally have different types.  E.g. 

        case 'decimal':
            return new Double( $number );
        case 'bit64':
            return Long( $number );
        case 'whole':
            return new Unsigned( $number );


This allows the user to not know what the various types are, just how the user would describe them.  Also, this allows the underlying implementation to change without impacting the user.  For example, if we moved from a 32-bit operating system to a 64-bit operating system, the second case might change from Long to Integer.