Question

Problem
I’m fairly new to design patterns, and have been studying the book, Head First Design Patterns. I need to implement a system with 3 kinds of users: Member, Moderator, Admin. A Moderator can perform everything that a Member can, plus added stuff, an Admin can perform everything that a Moderator can, plus added stuff. I have made a basic sketch of how this can be implemented with interfaces and classes; being inexperienced, I need advice from the SO community about this design – whether it’s too bloated or silly, or if it needs corrections. So please bear with me.

Possible solution
Here are the interfaces:

public interface AdminBehavior
{
    public addUser();
    public deleteUser();
}

public interface ModeratorBehavior
{
    public blockUser();
    public deletePost();
}

Behavior classes:

public class AdminBehaviors implements AdminBehavior
{
    public addUser()        {
        ...
    }
    public deleteUser()     {
        ...
    }
}

public class NoAdminBehaviors implements AdminBehavior
{
    public addUser()        {
        ...//cannot do
    }
    public deleteUser()     {
        ...//cannot do
    }
}

+ Same as above done for Moderators...classes ModeratorBehaviors and NoModeratorBehaviors

The actual User classes:

public class Member
{
    protected ModeratorBehavior moderatorBehavior;
    protected AdminBehavior adminBehavior;

    public Member()     {
        moderatorBehavior = new NoModeratorBehavior();
        adminBehavior = new NoAdminBehavior();
    }

    public login()      {
        ...
    }
    public logout()     {
        ...
    }
    public post()       {
        ...
    }
    public comment()        {
        ...
    }

    //Moderator priv'ed actions
    public blockUser()      {
        moderatorBehavior.blockUser();
    }
    public deletePost()     {
        moderatorBehavior.deletePost();
    }

    //Admin priv'ed actions
    public addUser()        {
        adminBehavior.addUser();
    }
    public deleteUser()     {
        adminBehavior.deleteUser();
    }
}

public class Moderator extends Member
{
    public Moderator()  {
        moderatorBehavior = new ModeratorBehavior();
        adminBehavior = new NoAdminBehavior();
    }
}

public class Admin extends Moderator ((or Member?))
{
    public Admin()  {
        moderatorBehavior = new ModeratorBehavior();
        adminBehavior = new AdminBehavior();
    }
}

Personally, I feel that this seems a bit over-done or confusing…better ways to do it?

Answer 1

I quite like it… does seem bloated though.

I’d probably just use inheritance. Admin extends Moderator extends Member implements UserType.