what's the difference between a method referenced by an asterisk and method that isn't in Golang?

Let’s suppose I have a struct, and this struct has 2 methods. one is written with an asterisk and the other one isn’t.
Here is the code to understand the example.

type object struct{
    name string
    age int
}

func (obj *object) methodOne{
    // do something
} 
func (obj object) methodTwo{
    // do something
}

I know about pointers, but still didn’t understand the concept in this example.

>Solution :

As docs says:

func (s *MyStruct) pointerMethod() { } // method on pointer
func (s MyStruct)  valueMethod()   { } // method on value

For programmers unaccustomed to pointers, the distinction between
these two examples can be confusing, but the situation is actually
very simple. When defining a method on a type, the receiver (s in the
above examples) behaves exactly as if it were an argument to the
method. Whether to define the receiver as a value or as a pointer is
the same question, then, as whether a function argument should be a
value or a pointer. There are several considerations.

First, and most important, does the method need to modify the
receiver? If it does, the receiver must be a pointer. (Slices and maps
act as references, so their story is a little more subtle, but for
instance to change the length of a slice in a method the receiver must
still be a pointer.) In the examples above, if pointerMethod modifies
the fields of s, the caller will see those changes, but valueMethod is
called with a copy of the caller’s argument (that’s the definition of
passing a value), so changes it makes will be invisible to the caller.

Second is the consideration of efficiency. If the receiver is large, a
big struct for instance, it will be much cheaper to use a pointer
receiver.

Next is consistency. If some of the methods of the type must have
pointer receivers, the rest should too, so the method set is
consistent regardless of how the type is used. See the section on
method sets for details.

For types such as basic types, slices, and small structs, a value
receiver is very cheap so unless the semantics of the method requires
a pointer, a value receiver is efficient and clear.