Generics Entity and EntityDTO similar methods

Is there any way to unite getEntityId and getEntityDTOId?

public class Entity {
	
	private Integer id;

	public Integer getId() {return id;}

}

public class EntityDTO {
	
	private Integer id;

	public Integer getId() {return id;}

}

public class EntityProcessing {
	

	public Integer getEntityId(Entity entity) {

		return entity.getId();

	}

	public Integer getEntityDTOId(EntityDTO entityDTO) {

		return entityDTO.getId();

	}

}

I've read about Generics, but can't understand how to implement them in such a case.

You can for example create some interface:

public interface WithId {
    Integer getId();
}

and implement it (you need to implement this interface in all the classes you want to use in the EntityProcessing.getId method):

public class Entity implements WithId { // add implements ...
    
    private Integer id;

    @Override // add to mark that it's method from the interface
    public Integer getId() {return id;}

}

And now you can create one method to get id from all the classes implementing WithId interface:

public Integer getId(WithId withId) {
    return withId.getId();
}

The other option is to use abstract class containing the id field. But it's against Liskov Substitution Principle (L from SOLID object oriented programming principles).

And there is a limitation, that you can extend only one class in java, but you can implement multiple interfaces. So in my opinion better use interface like above, but for completeness I added this solution as well.

public abstract class WithId {
    private Integer id;

    public Integer getId() {
        return id;
    }
}

and extend the abstract class:

public class Entity extend WithId { // in this case add extend ...

    // you don't need to add anything here,
    // because field and the method are already present in the base class
}

And usage is the same as in the first solution above.

This solution at the first glance seems to be better because you can write the method only once in the abstract class, but you have to remember the limitations (you can extend only one class in java), because if you want in the future add another common field like e.g. createdDate - you can implement second interface e.g. WithCreatedDate, but you cannot extend second class

The example you provided, doesn't actually need to use generics, but it looks like you're learning about generics：

public class Test {
public static void main(String[] args) {
Entity entity = new Entity();
EntityDTO entityDTO = new EntityDTO();
EntityProcessing<Base> a = new EntityProcessing<>();
System.out.println(a.getEntityId(entity));
System.out.println(a.getEntityId(entityDTO));
System.out.println(EntityProcessing.getId(entity));
System.out.println(EntityProcessing.getId(entityDTO));
}
}
interface Base {
public Integer getId();
}
class Entity implements Base {
private Integer id = 1;
public Integer getId() {return id;}
}
class EntityDTO implements Base {
private Integer id = 2;
public Integer getId() {return id;}
}
// T must be a subtype of Base, otherwise, after generic erasure, the T type does not have a getId method
class EntityProcessing<T extends Base> {
public Integer getEntityId(T entity) {
return entity.getId();
}
// Generics Method
// T must be a subtype of Base, otherwise, after generic erasure, the T type does not have a getId method
// Note that there is no relationship between the <T> in the generic method and the <T> in the life of the generic class.You can completely replace the T here with an R, or any other char
// public static <F extends Base> Integer getId(F entity)
// public static <ABC extends Base> Integer getId(ABC entity)
// .....
public static <T extends Base> Integer getId(T entity) {
return entity.getId();
}
}