== Needless to say, comparison is a comparison of memory addresses in any case.
equals comparison is a method call. The default implementation (Object class) uses ==:

public boolean equals(Object obj) {
    return (this == obj);
}

First code:
What is compared is the String object, and the String class overrides the equals() method and what is compared is the string content, so s1 equals s2 is output.

You have no problem understanding this!

Second code:
What is compared is the test object. The test class does not override the equals() method, so the memory address is compared by default, thus outputting obj1 not equals obj2.

I think we should put aside the code implementation first and look directly at the meaning of the equals method - to compare whether the object is the same.
So the question is, how can objects be considered the same? This is decided by the author of the class to which the object belongs, and only he can decide how instances of the class he creates should compare identically.

I don’t know who the author of String is, but do you agree with his equals implementation? When comparing strings, you should compare whether the character sequences are the same.

As for test, its author is you, and you did not define how to compare the test object, but you called equals to compare it. What will be the result at this time? It can only be the equals result of the parent class of the test class. The default parent class is the Object class. @ch_gilbert has already explained~

equals depends on the specific implementation

public class A{ 
    private String color;
    private int weight;
     public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public boolean equals(Object obj){
            if (obj == null)
                return false;
          if (this == obj)
                return true;
            if (getClass() != obj.getClass())
                return false;
            A other = (A) obj;
            if (color == null) {
                if (other.color != null)
                    return false;
            } else if (!color.equals(other.color))
                return false;
            if (weight != other.weight)
                return false;
            return true;
    }

}

What you said is really complicated. After reading it, I should have a correct understanding
I'll post the source code of the Stirng.equals method, it's obvious.

 public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = count;
        if (n == anotherString.count) {
        char v1[] = value;
        char v2[] = anotherString.value;
        int i = offset;
        int j = anotherString.offset;
        while (n-- != 0) {
            if (v1[i++] != v2[j++])
            return false;
        }
        return true;
        }
    }
    return false;
    }

==. equals To put it bluntly, isn’t it just a method? The exact result depends on how it is achieved, so why bother worrying about it?
Suppose equals is written like this

How about, == is different, it only returns true if it is "111111".

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            if (anotherString.equals("111111")) {
                return true;
            }
        }
        return false;
    }

Do you understand that? equalsThis thing is just a method! Because there is it in Object, other Classs inherit it, so it looks special.