Hibernate use subclass of data class entity

I have an entity like this:

@NoArgsConstructor
@AllArgsConstructor
@Getter
@Entity
public class EBase {
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  @Column(name = "e_id", nullable = false)
  private Integer id;

  @Column(name = "name")
  protected String name;

  @Column(name = "letters")
  protected byte letters;
}

To modify data I use an other class:

@NoArgsConstructor
@AllArgsConstructor
public class E extends EBase {
  public void setName(String name) {
    super.name = name;
    super.letters = (byte) name.length();
  }
}

I know that can be solved very different and I would never store the length of a string like this. But its good to visualize my problem. I want to have an entity that has only Getters and Setters no "real" other methods.
Now lets create an entity:

public class Main {
  public static void main(String[] args) {
    final E e = new E();
    e.setName("Test");
    Database.getSession().save(e);
  }
}

My question is: Is this possible?

I tried a factory class like

@RequiredArgsConstructor
@Getter
class EFactory {
  private final EBase e;
  public void setName(String name) {
    e.setName(name);
    e.setLetters((byte) name.length());  // setters in EBase implemented
  }

  public EBase get() {
    return e;
  }
  
}

with:

public class Main {
  public static void main(String[] args) {
    EBase e = new EBase();
    e = new EFactory(e).setName("Test").get();
    Database.getSession().save(e);
  }
}

but this is not very fancy. Is the solution mentioned above possible even if E is not an entity?

The builder pattern is used to create immutable objects. For instance:

public class EBase {
    private final Integer id;
    private final String name;
    private final byte letters;

    private EBase(Builder builder) {
        this.id = builder.id;
        this.name = builder.name;
        this.letters = builder.letters;
    }

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public byte getLetters() {
        return letters;
    }

    protected static class Builder {
        private Integer id;
        private String name;
        private byte letters;

        public Builder setId(Integer id) {
            this.id = id;
            return this;
        }

        public Builder setName(String name) {
            this.name = name;
            return this;
        }

        public Builder setLetters(byte letters) {
            this.letters = letters;
            return this;
        }

        public EBase build() {
            return new EBase(this);
        }
    }
}

Now, if you're using hibernate, you want to store objects in an SQL database, and, if you can store objects without ever modifying them, most of the time, you will want to have the ability to modify them.

Of course you could move all your setters to another class, like this:

public class EBase {
    private Integer id;
    private String name;
    private byte letters;

    public interface Updater {
        public Updater setId(Integer id);
        public Updater setName(String name);
        public Updater setLetters(byte letters);
    }

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public byte getLetters() {
        return letters;
    }

    public Updater getUpdater() {
        return new Updater() {
            @Override
            public Updater setId(Integer newId) {
                id = newId;
                return this;
            }

            @Override
            public Updater setName(String newName) {
                name = newName;
                return this;
            }

            @Override
            public Updater setLetters(byte newLetters) {
                letters = newLetters;
                return this;
            }
        };
    }
}

But I don't see why you would need inheritance.

That said, I would recommand you to use neither of those patterns, and just declare getters and setters in the same class.