An OOP Text implementation (not nullable & always "trimmed")

gistfile1.txt

@Test
@DisplayName("Any nullable text should always produce an empty value")
void testTextDefaultValue() {
    assertEquals("", new Text(null).toString());
}

Text.java

import java.util.Objects;

public class Text implements CharSequence {

    protected final CharSequence origin;

    public Text(final String origin) {
        this.origin = origin == null ? "" : origin.trim();
    }

    public Text(final Object origin) {
        this.origin = origin == null ? "" : origin.toString().trim();
    }

    public Text(final CharSequence origin) {
        this.origin = origin instanceof String str ? str.trim() : "";
    }

    public boolean isBlank() {
        return this.origin instanceof String str && str.isBlank();
    }

    @Override
    public String toString() {
        return this.origin.toString();
    }

    @Override
    public int length() {
        return this.origin.length();
    }

    @Override
    public char charAt(final int index) {
        if (index < 0 || index >= length()) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return this.origin.charAt(index);
    }

    @Override
    public CharSequence subSequence(final int start, final int end) {
        final int length = length();
        if (start < 0 || start > end || end > length) {
            throw new StringIndexOutOfBoundsException(
                "begin " + start + ", end " + end + ", length " + length);
        }
        return this.origin.subSequence(start, end);
    }

    @Override
    public boolean equals(final Object o) {
        if (this == o) return true;
        if (!(o instanceof Text)) return false;
        return Objects.equals(this.origin, ((Text) o).origin);
    }

    @Override
    public int hashCode() {
        return Objects.hash(this.origin);
    }
}