How to use events in Unity to force one script to call the method of another script?

I read information and documentation about action, c# event and UnityEvent, as i understand you better not use UnityEvent because they are slower than c# event and action, but to use event or action you need to use public static to make one script subscribe to an event which is in another script, what is not safely.

So the question is how to use action or event without static right?

Edit: how i made action

Player script
public class Player : MonoBehaviour
{
    public event Action OnHitAction;

    public void TakeDamage(int damage)
    {
        OnHitAction?.Invoke();
    }
}

Animator script
public class PlayerAnimator : MonoBehaviour
{
    private Animator _animator;
    private Player _player;

    private void Awake()
    {
        _player = GetComponent<Player>();
        _player.OnHitAction += Hit;
        _animator = GetComponent<Animator>();
    }

    private void Hit()
    {
        _animator.SetTrigger("Hit");
    }
}

Every time someone says "use X because Y is slower", ask yourself some questions:

1. How much slower?
2. What is the absolute numbers?
3. And how frequently your use case appears?

So yes, maybe UnityEvents are slower than pure c# events, but that doesn't mean that you should skip them entirely. UnityEvents is a great way to communicate between scripts, especially between domains of your game, i.e. "Join game" Button and NetworkManager behaviour - both of them shouldn't know each other, but should be able to communicate, that is easily achieved by assigning NetworkManager as a target of Buttin's onClick UnityEvent.

Pure events are also used to build application control flow, especially together with interfaces, when objects that are not derived from UnityEngine.Object can subscribe to events of each other by obtainig them through DI. You need to make sure that object B that depends on object A is able to get A's instance directly, or some third object C (mediator) is able to subscribe B's handlers (methods or delegates) to the events of A.
Example of dependency inversion with events:

delegate Vector2InputHandler(Vector2);
interface IInputHandler 
{
    event Vector2InputHandler OnMoveInputChanged {get;}
    event Vector2InputHandler OnLookInputChanged {get;}
}
...
// class Player
void Start()
{
    IInputHandler inputHandler = GetComponent<IInputHandler>(); 
    inputHandler.OnMoveInputChanged  += HandleMoveInput;
    inputHandler.OnLookInputChanged += HandleLookInput;
}
void HandleMoveInput(Vector2 input) => ...
void HandleLookInput(Vector2 input) => ...

where the IInputHandler hides the implementation that could be in other assembly than the script that uses it, but we really doesn't need to know much about it here.

Anyway, I recommend you to stick with UnityEvents since they are OK performance-wise (until you start firing really a lot) and offers rich functionality in Editor.

Static events do have sense though when you handling such global things as application startup, scene loading, multiplayer session start etc., anything that happens not frequently and could potentially be used in a lot of places.