Question

I have noticed that there are two ways to cast objects (the difference is the placement of the outer parenthesis):

 1. SimpleType simpleType = ((SimpleType) (property.getType()));
 2. SimpleType simpleType = ((SimpleType) property).getType();

Are they doing the same thing ?

Answer 1

Are they doing the same thing ?

No they are not.

• The first one is casting your value returned from
  property.getType() to SimpleType. (Invocation is done before Casting)
• The second one is first casting your property to SimpleType and
  then invoking the getType() method on it. (Casting is done before Invocation).

---

You can also understand it from the precedence of parenthesis. Since it has the highest precedence, it will be evaluated first.

First Case: –

So, in ((SimpleType) (property.getType()));: –

(property.getType())

is evaluated first, then the casting is performed. In fact you don’t really need a parenthesis around that. (property binds tighter to the dot (.) operator than the cast operator). So, invocation will always be done before casting. Unless you force it to reverse as in the below case: –

Second Case : –

In ((SimpleType) property).getType(): –

((SimpleType) property)

is evaluated first, then the invocation is done. As, now you have enclosed property inside the brackets, due to which it binds tighter to the cast operator, due to higher precedence enforced by parenthesis.