OOP practice "empty" object

Question

Is it a good or bad practice, to use empty instance?

There is "product" class, initiated with id:

class product
{
    __construct($id = 0)
    {
        // populate class, there is no product with id = 0
    }

    function new($name, $data)
            ...
}


$product = new Product(123); // normal using

But I also need to create new product, so there is no initial object, and I create empty one:

$product = new Product();
$product->new($name, $data);

Is it good or bad?
May be I should create usual function new_product(), outside product class, because it does not use it's instance, just creates empty.
What is the best practice for this problem?

Wait, so, you're using an instance to create an instance, what? — BoltClock, Feb 04 '11 at 08:05
how can I get `new()` without creating instance? Using static function? Is it how it should be? — Qiao, Feb 04 '11 at 08:07

score 4 · Answer 1 · answered Feb 04 '11 at 08:21

If I understand you correctly and I've followed your methodology correctly, you most likely want something like this. This way you wouldn't need to create an instance of the Product class to create a new product.

class Product {
    public function __construct($id = 0) {
        // Load the data for existing product with Id > 0
    }

    public static function create($name, $data) {
        // Create a new product from scratch
        $obj = new self();
        $obj->Name = $name;
        // Do something with data
        return $obj;
    }
}

// Load a product
$product = new Product(123);

// Creating a product
$product = Product::Create('My new product', /* Data? Possible an array */);

score 3 · Accepted Answer · edited Feb 04 '11 at 08:56

Both could be good practices. Maybe your implementation of the second is not that good.

In fact, the second one is a simple implementation of factory pattern. Check this link, and you'll understand better:

http://en.wikipedia.org/wiki/Factory_method_pattern

Maybe the thing is the factory method should be in some class like ProductFactory so, ProductFactory->new(...) would be the best way to have your great factory!

score 2 · Answer 3 · edited May 23 '17 at 12:04

Ideally, an object's state should always be valid. This is usually more a matter of internal state rather than externally visible state, but you could apply the concept here. If having an empty name or data, or an ID of 0 isn't valid (if an ID of 0 is a marker for "doesn't exist in persistant storage", then it's valid), then it's not best practice. The reason for insisting the code keep the object valid and not the programmer is that doing otherwise relies on the programmer reading the class's documentation. When someone using your class in their e-commerce site e-mails you a complaint that the orders they receive have blank items, you'll see the wisdom of this approach.

To implement the best-practice of always keeping valid state in PHP, you can use the factory pattern, as Matías mentions, or simply have static methods on product to create products (which is a little simpler than the factory pattern; these methods are technically just constructors). Alternatively, you can use func_get_args to manually implement constructor overloading (examine the arguments and take different actions depending on what they are). This will catch invocation errors at run-time rather than compile-time, and is in this way inferior to the other approaches.

Of course, it could be perfectly valid for products to be missing some properties during script execution, but invalid for the properties to be missing for stored objects. If this is the case, the code that stores/retrieves products would enforce non-empty properties.

b7kich · Answer 4 · 2011-02-04T23:26:30.203

0

Bad form. Essentially you have given a setter method with a confusing name.

Also you're mixing constructor initialization with setter initialization. Choose one or the other, but not both.

edited Feb 04 '11 at 23:26

answered Feb 04 '11 at 08:08

b7kich

4,253
3
28
29

OOP practice "empty" object

4 Answers4