Just look at the name and make the following guesses:
ContractModelis a DTO, responsible for transmitting data;ContractModel是一个DTO，负责传输数据；
ContractQueryModel是一个查询参数对象，负责接收从ControllerContractQueryModelis a query parameter object, responsible for receiving fromControllerQuery parameters passed from (or other places);
Since they are all querying Contract, the fields are basically the same, but for the convenience of future expansion, inheritance is used here to implement it.

But in actual applications, DTO and query parameters are generally not the same structure. DTO is as shown in the title of the question, and query parameters are generally the plural form of the DTO field, for example:

public class ContractQueryModel implements Serializable { private Set templateCategaries = Collections.emptySet(); private Set names = Collections.emptySet(); private Set codes = Collections.emptySet(); ... }

In addition, @BodhiXuguang mentioned theRichter replacement principle, you can take a look at this, it mentions possible problems with the design of the subject.

Not sure what your question is: "The meaning of inheritance"? Or "Why does ContractQueryModel only override thetoStringmethod"?

What if you don’t understand the “meaning of inheritance”? Then I think the most basic understanding is for reuse. You can read the documentation:

Document address: Inheritance

If your doubt is, why did you inherit it for a long time and only rewrite thetoStringmethod in the end?

I think the main reason is because the author wants to satisfy the opening and closing principle and wants a newtoString方法，又不想对原代码ContractModelmethod, but does not want to modify the original codeContractModel. In any case, you should discuss the details directly with the author, who may have deeper considerations. I can't tell much more from your code snippet.

Added:

I personally understand that this is not an "agency model" because it does not meet the basic characteristics of the "agency model". Regarding the agency model, see the following diagram:

From this we know that in proxy mode, the proxy class should implement the same interface as the proxy class. TheContractQueryModelhere does not have this feature.

Finally, I would like to talk about a superficial understanding of design patterns. The so-called design pattern is a best practice paradigm for solving specific problems. Some patterns have fixed characteristics and some do not. Therefore, based on just a few simple classes of the subject, it is difficult for me to judge which design pattern he is without the context (I mean those that do not have fixed characteristics).

If you only override a toString method and use inheritance, the design itself is problematic.
If your guess is correct, ContractModel is a model used in the persistence layer, and ContractQueryModel is a model used in the business layer. For convenience, a certain developer directly made the two into an inheritance relationship.
Personally, I am very disgusted with this model of separation of data and logic. I prefer the following method:

Contract contract = new Contract(); contract.setName(...) ... contract.save(); ... Contract other = Contract.find(...); ...

You guys are so funny, I don’t even know what I want to ask, but you still answer it, and this question has become the recommendation of the week, it’s weird