Why using getComponent to call objects in Unity? - unity3d

Question

I am new in unity, I'm just wondering why we call the player object like this :
private void OnTriggerEnter(Collider other)
{
// if the player hit the enemy then destroy the ememy
if (other.tag == "PLAYER" ) {
// like this
other.transform.GetComponent<Player>().damage();
}
while we can make the damege method static and call it like this :
private void OnTriggerEnter(Collider other)
{
// if the player hit the enemy then destroy the ememy
if (other.tag == "PLAYER" ) {
//other.transform.GetComponent<Player>().damage();
Player.damage();
}
why we call the object like this what the point
other.transform.GetComponent<Player>().damage();
does it effect performance ? or is it just another available way to call objects

Answer 1

I will try to explain this the best I can. This explanation isn't perfect, but I worded it so it makes the most sense.
A class is a file that contains code. There are two "types" of classes, static and non-static. Static classes can be accessed anywhere, but there is only ever 1 copy. For example, use UnityEngine.Mathf. That is a static class, so you can just do Mathf.(whatever).
The non-static class can have multiple copies. Non-static classes can have static methods and fields, which can be accessed like you would a static class. For most basic applications, these classes just use normal methods. These methods are instance-dependent.
For example, take a non-static Player class.
public class Player : MonoBehaviour {
//This is accessed using Player.instance
public static Player instance;
//This function only runs on the script you place on a GameObject
public void Start(){
//Sets the static instance to this instance
instance = this;
}
}
You can then access the active player instance with any other script (as long as the instance variable was set before)
public Player GetPlayer() {
//As you can see, you don't need a reference to a Player; you can just use the static instance.
Player instance = Player.instance;
return instance;
}
In conclusion, using Player.Whatever references the static version. Using playerInstance.Whatever references a runtime instance. If you will only have one runtime instance of a class, you can use the example above to allow other classes to access the instance.