public void Attack()
{
    _animator.SetTrigger("Attack");
    Collider2D[] hitEnemies = Physics2D.OverlapCircleAll(_attackPoint.position, _attackRange, _enemyLayer);
    foreach (Collider2D enemy in hitEnemies)
    {
        enemy.GetComponent<PlayerAnimator>().TakeDamage(_attackDamage);// 在第二个脚本中使用<EnemyAnimator>
    }
}

That's OOP basics - In such a case you have mainly two options:
You should have 
- an interface if it is only about having the same method signatures but completely different behavior
   public interface IDamageable
   {
       void TakeDamage(float damage);
   }
   And then
   public class PlayerAnimator : MonoBehaviour, IDamageable
   {
       public void TakeDamage(float damage)
       {
           Debug.Log("I'm a player and do a certain thing when I take {damage} amount of damage");
       }
   }
   public class EnemyAnimator : MonoBehaviour, IDamageable
   {
       public void TakeDamage(float damage)
       {
           Debug.Log("I'm an enmy and do something completely different when I take {damage} amount of damage");
       }
   }
- go through inheritance and have a common parent class which already implements common behavior and can then be extended - if needed at all
   // Careful with this naming in that case!
   public class Damageable : MonoBehaviour
   {
       virtual void TakeDamage(float damage)
       {
           Debug.Log("This is the common default behavior for my inheritors - except they overwrite or extend it");
       }
   }
   and
   public class PlayerAnimator : Damageable 
   {
       public override void TakeDamage(float damage)
       {
           // First call the default implementation
           base.TakeDamage(damage);
           Debug.Log("I'm a player and do some additional stuff");
       }
   }
   public class EnemyAnimator : Damageable 
   {
       public override void TakeDamage(float damage)
       {
           Debug.Log("I'm an enmy and decided to not do the default thing but something completely different");
       }
   }
Here if you don't need any different behavior between `EnemyAnimator` and `PlayerAnimator` the answer would be easy: Just stick to a single class then!
And then I would go
public void Attack()
{
    _animator.SetTrigger("Attack");
    var hitEnemies = Physics2D.OverlapCircleAll(_attackPoint.position, _attackRange, _enemyLayer);
    foreach (Collider2D enemy in hitEnemies)
    {
        // OPTION A
        if(enemy.TryGetComponent<IDamageable>(out var damageable))
        // or OPTION B
        // if(enemy.TryGetComponent<Damageable>(out var damageable))
        {
            damageable.TakeDamage(_attackDamage)
        }
    }
}

public static class AttackManager
{
    public static void Attack<T>(Animator attackerAnimator, Transform attacker, float attackRange, float damage, int targetLayer) where T : AnimatorBase
    {
        attackerAnimator.SetTrigger("Attack");
        Collider2D[] hitTargets = Physics2D.OverlapCircleAll(attacker.position, attackRange, targetLayer);
        foreach (Collider2D target in hitTargets)
        {
            target.GetComponent<T>().TakeDamage(damage);
        }
    }
}

//我将其设为抽象类，您可以以其他方式做，如@derHugo的回答中所述
public abstract class AnimatorBase : MonoBehaviour
{
    public abstract void TakeDamage(float damage);
}

public class PlayerAnimator : AnimatorBase
{
    public override void TakeDamage(float damage)
    {
        Debug.Log("玩家受到伤害");
    }
}

public class EnemyAnimator : AnimatorBase
{
    public override void TakeDamage(float damage)
    {
        Debug.Log("敌人受到伤害");
    }
}

AttackManager.Attack<PlayerAnimator>(attackerAnimator: animator,
                                 attacker: enemy,
                                 attackRange: range,
                                 damage: _attackDamage,
                                 targetLayer: LayerMask.GetMask("player"));

AttackManager.Attack<EnemyAnimator>(attackerAnimator: animator,
                                 attacker: player,
                                 attackRange: range,
                                 damage: _attackDamage,
                                 targetLayer: LayerMask.GetMask("enemy"));

public void Attack(EnemyAnimator enemyAnimator)
{
    _animator.SetTrigger("Attack");
    Collider2D[] hitEnemies = 
    Physics2D.OverlapCircleAll(_attackPoint.position, _attackRange, 
    _enemyLayer);
    foreach (Collider2D enemy in hitEnemies)
    {
        enemy.GetComponent<PlayerAnimator>().TakeDamage(_attackDamage);
    }
}