method call within a parenthesis

This might be a basic question but I can't find a explanation of it. In the following example,

restResponse = Optional.ofNullable((K) (((RestConnector) restConnector).connect(healthCheckVO.getRestConnectorRequest())));

I know that two parenthesis: ((RestConnector) restConnector) are needed to cast variable restConnector to type RestConnector before calling its connect() method. but why the result of the call needs to be wrapped in another parenthesis?

(   ((RestConnector) restConnector).connect(healthCheckVO.getRestConnectorRequest())   )

while this particular brackets are not required, it is quite common to use them:

here is quick example, which works as expected - other variable is casted to another class:

Class temp = (Class)other;

now, lets imagine we need to cast object and call method, this does not compile, because casting is applied to result of MethodOfClass, not to variable other

Something temp = (Class)other.MethodOfClass();

this is why you have to use:

Something temp = ((Class)other).MethodOfClass();

now, you want to cast result of the method:

Something temp = (Something)((Class)other).MethodOfClass();

and it works, until again you need to call method on result, so it is much easier to wrap everything in brackets from the very beginning, so you can later add method call

but, all these brackets actually create mess, so as part of good will - just refactor it to:

var request = healthCheckVO.getRestConnectorRequest();
var connector = (RestConnector)restConnector;
var response = connector.connect(request);
restResponse = Optional.ofNullable((K)response);

or something along this idea - less mental load per line of code