Implementing different user types through classes and interfaces in Java

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.

UserType interface could define all your methods

Member could implement all methods but with the non-behaviour

Moderator could inherit from member and override the methods it requires behaviour for

Admin could inherit from Moderator and override the additional methods it requires behaviour for

That would be simpler I think, but less clever