Looks like you mean the special case pattern (particular implementations are the Option or the Null Object pattern).

There are Java implementations of the Option type, named Optional, in Java 8 and in the Guava libraries.

In your case, you'll be using Optional<SomeObject> and having this implementation (I'm using the Guava implementation):

Optional<SomeObject> getSomeObject(List<SomeObject>, int x) {
    /* Search for object in list that has a properties
        with value x */
    if (found) {
        return Optional.of(objectFound);
    } else {
        return Optional.absent(); // or Optional.empty(); in Java 8
    }
    // if objectFound variable is null when not found, you can simply use
    // return Optional.fromNullable(objectFound);
    // or return Optional.ofNullable(objectFound); in Java 8
}

So the code is self-explainable about returning an optional object. You would then have:

void doSomething(Optional<SomeObject> o) {
    if (o.isPresent()) {
        SomeObject someObject = o.get();
        /* Do action 1 */
    } else {
        /* Do action 2 */
    }
    // or opt.map(/* action 1 */).orElse(/* action 2 */); in Java 8
}

So, draw doesn't actually return anything (useful), instead you're just printing the stars directly to the output stream.

Instead, what you should (probably be) doing, is building a String within the draw method which can be returned to the caller, for example...

public String draw() {
    StringJoiner outter = new StringJoiner("\n");
    for (int i = 1; i <= this.height; i++) {
        StringJoiner inner = new StringJoiner(" ");
        for (int j = 1; j <= this.width; j++) {
            inner.add("*");
        }
        outter.add(inner.toString());
    }
    return outter.toString();
}

Now, I'm using StringJoiner for simplicity (and because I'm lazy and it's just an amazing class), but you could equally get away with using StringBuilder, but you'd need to inject the additional properties yourself.

Then calling System.out.println(rectangle.toString()); would actually print the return result from the draw method

Runnable example...

import java.util.StringJoiner;

public class Test {

    public static void main(String[] args) {
        new Test();
    }

    public Test() {
        Rectangle rectangle = new Rectangle(5, 3);

        System.out.println(rectangle.toString());
    }

    public class Rectangle {

        int width;
        int height;

        public Rectangle(int width, int height) {
            this.width = width;
            this.height = height;
        }

    public String draw() {
        StringJoiner outter = new StringJoiner("\n");
        for (int i = 1; i <= this.height; i++) {
            StringJoiner inner = new StringJoiner(" ");
            for (int j = 1; j <= this.width; j++) {
                inner.add("*");
            }
            outter.add(inner.toString());
        }
        return outter.toString();
    }

        public String toString() {
            return draw();
        }
    }
}

In all the code I write, I avoid returning null from a function. I read that in Clean Code.

The problem with using null is that the person using the interface doesn't know if null is a possible outcome, and whether they have to check for it, because there's no not null reference type.

In F# you can return an option type, which can be some(Person) or none, so it's obvious to the caller that they have to check.

The analogous C# (anti-)pattern is the Try... method:

public bool TryFindPerson(int personId, out Person result);

Now I know people have said they hate the Try... pattern because having an output parameter breaks the ideas of a pure function, but it's really no different than:

class FindResult<T>
{
   public FindResult(bool found, T result)
   {
       this.Found = found;
       this.Result = result;
   }

   public bool Found { get; private set; }
   // Only valid if Found is true
   public T Result { get; private set;
}

public FindResult<Person> FindPerson(int personId);

...and to be honest you can assume that every .NET programmer knows about the Try... pattern because it's used internally by the .NET framework. That means they don't have to read the documentation to understand what it does, which is more important to me than sticking to some purist's view of functions (understanding that result is an out parameter, not a ref parameter).

So I'd go with TryFindPerson because you seem to indicate it's perfectly normal to be unable to find it.

If, on the other hand, there's no logical reason that the caller would ever provide a personId that didn't exist, I would probably do this:

public Person GetPerson(int personId);

...and then I'd throw an exception if it was invalid. The Get... prefix implies that the caller knows it should succeed.

Deciding whether or not null is a allowed as an object value is a decision that you must make consciously for your project.

You don't have to accept a language construct just because it exists; in fact, it is often better to enforce a strict rule against any nullvalues in the entire project. If you do this, you don't need checks; if a NullPointerException ever happens, that automatically means that there is a defect in your code, and it doesn't matter whether this is signalled by a NPE or by some other sanity check mechanism.

If you can't do this, for instance because you have to interoperate with other libraries that allow null, then you do have to check for it. Even then it makes sense to keep the areas of code where null is possible small if possible. The larger the project, the more sense it makes to define an entire "anti-corruption layer" with the only purpose of preserving stricter value guarantees than is possible elsewhere.

Change your return type to java.lang.Integer . This way you can safely return null