Using a larger prime as a multiplier when overriding hashCode()

I have been reading about hashcode functions for the past couple of hours and have accumulated a couple of questions regarding use of prime numbers as multipliers in custom hashcode implementations. I would be grateful if I could get some insight regarding following questions:

• In a comment to @mattb's answer here, @hstoerr advocates for use of larger primes (such as 524287) instead of the common prime 31. My question is, given the following implementation of a hashcode functions for a pair or elements:

  @Override
  public int hashCode() {
      final int prime = 31;
      int hash1 = (pg1 == null) ? 0 : pg1.hashCode();
      int hash2 = (pg2 == null) ? 0 : pg2.hashCode();
      return prime * (hash1 ^ hash2);
  }
  

doesn't this lead to an overflow on the returned int if prime is a large number?

• Assuming that the overflow is not a problem (JVM doing an automatic cast) is it better to do a bitshift instead of a cast?

• I imagine the performance of the hashcode function vary significantly based on the complexity of the hashcode. Does the size of the prime multiplier not effect the performance?

• Is it better/smarter/faster to use multiple primes in a custom hashcode function instead of a single multiplier? If not, is there some other advantage? See the example below from @jinguy's answer to a relevant question:

  public int hashCode() {
      return a * 13 + b.hashCode() * 23 + (c? 31: 7);
  }
  

where a is an int, b is a String and c is boolean.

• How about something like long lhash = prime * (hash1 ^ hash2); then using (int)((lhash >> 32) ^ lhash)? That's something I saw on anot