Are command patterns efficient enough, and what's the concrete benefit of it?

Question

So today I am learning and implementing Command Patterns for handling input and movement for objects.

So my question is:

1. Am I getting the implementation of Command Patterns right or do I need to modify it? If so, can somebody give me a little example on to improve it.
2. I know that it improves code reusability. But what difference does it make when I just use a simple MovementScript.cs to my game object component? Wouldn't it just be the same and take less time to write rather than making a whole Command Pattern?

The one I attached to the gameobject is only the InputHandler. Here's my code which involves moving an object:

This is my Input Handler or as far as I know as The Client

public class InputHandler : MonoBehaviour
{
GameObject theObject;
public Command buttonA, buttonD;
public float acceleration, maxSpeed;

Movement moves;

void Awake()
{
    theObject = gameObject;
    moves = new Movement(theObject, acceleration, maxSpeed);
}

void Start()
{
    buttonA = new MoveLeft(moves);
    buttonD = new MoveRight(moves);
}

void Update()
{
    HandleInput();
}

public void HandleInput()
{
    if (Input.GetKey(KeyCode.A))
    {
        buttonA.Execute();
    }
    else if (Input.GetKey(KeyCode.D))
    {
        buttonD.Execute();
    }
}
}

The Command abstract class

public abstract class Command
{

//The Receiver of the command..
protected IReceiver receiver = null;

public Command(IReceiver receiver)
{
    this.receiver = receiver;
}

public abstract void Execute();
}

The Receiver class (where I implemented the logic, which is the movement)

public class Movement : IReceiver
{
public ACTION_LIST currentMoves;
private GameObject theObject;
private float acceleration;
private float maxspeed;

public Movement(GameObject theObject, float acceleration, float maxspeed)
{
    this.theObject = theObject;
    this.acceleration = acceleration;
    this.maxspeed = maxspeed;
}

public void Action(ACTION_LIST moves)
{
    if (moves == ACTION_LIST.MOVERIGHT)
        MoveRight(theObject);
    else if (moves == ACTION_LIST.MOVELEFT)
        MoveLeft(theObject);
}

public void MoveRight(GameObject obj)
{
    obj.GetComponent<Rigidbody2D>().AddForce(new Vector2(acceleration, obj.GetComponent<Rigidbody2D>().velocity.y));
}

public void MoveLeft(GameObject obj)
{
    obj.GetComponent<Rigidbody2D>().AddForce(new Vector2(-acceleration, obj.GetComponent<Rigidbody2D>().velocity.y));
}

}

Interface of receiver, to make things easier..

public enum ACTION_LIST
{
    MOVERIGHT,
    MOVELEFT
}

public interface IReceiver
{
    void Action(ACTION_LIST moves);
}

The concrete command. I only posted 1 of the movements..

public class MoveRight : Command
{
public MoveRight(IReceiver receiver):base(receiver)
{

}

public override void Execute()
{
    receiver.Action(ACTION_LIST.MOVERIGHT);
}
}

Answer 1

I disagree with Joe Blow and others saying that Unity is a bunch of scripts and not OOP. I use main script with single entry point and create all objects and components dynamically. I even use interfaces, mock and unit tests.

So, using Command pattern is ok. But I don't see a reason to use it in your case. Command pattern could be very handy in case when you need a stack of commands to be able Do() and Undo() your commands (Editor, Strategy game). Please read more here: http://gameprogrammingpatterns.com/command.html