• The .h file isn't needed, because in Java we don't separate the declaration of a function/method's prototype from its definition. They are the same. However, and this is important, the notion of a function's prototype is very much there, except that in Java it is referred to as the function's signature.
• All the function definitions need to be wrapped up in a public class definition. It might seem natural to name the class "card", but according to Java's naming conventions we really ought to call it "Card", because class names should begin with uppercase letters.
• The source code file is named Card.java because the file name must match the name of the public class inside.
• Each function definition must be prefaced with "public static".
• The function names "cardstring" and "mkdeck" need to be changed to "cardString" and "mkDeck" to match camel-case conventions.
• Array declaration

  string* F = new string[15]{ ...

  needs to be changed to

  String[] f = new string[]{ ...

  to match Java's array declaration rules and naming conventions. Needing to remove the "15" from the "[ ]" is interesting! It is a compile-time error to both give a size for the array and give an initializer list of values for the array. This makes some sense, since the array length can be inferred from the initializer list. We also make the analogous changes for the "S" array and the "D" array.
• Important! Creating the f and s arrays in cardString does not cause a memory leak in Java as it did in C++. This is because Java is "garbage collected", so the f and s arrays will be automatically reclaimed when the JVM recognizes they are no longer needed.
• The shuffle function/method changes the most. This is because there is no "global" function rand that we can call to generate a random number. Instead, we need a Random object that we use to call the nextInt method. (This will make more sense once we get a bit more into OOP.) So, the prototype (or "signature" in Java parlance) for the shuffle function has to change to add a new parameter Random rand> so we can make the call "rand.nextInt(52)".
• Last, but not least, each public class is allowed to have its own public static void main(String[] args) method. This is a huge benefit when we try "bottom-up" programming, because it makes it easy to add in testing code - in this case that means code that is there to test the function/methods we have put into class Card, but which is not part of the larger program we are ultimately creating. We've made use of exactly that feature here:

  $ java Card
  Testing Card ...
  Orig Deck: 2♣ 3♣ 4♣ 5♣ 6♣ 7♣ 8♣ 9♣ 10♣ J♣ K♣ Q♣ A♣ 2♦ 3♦ 4♦ 5♦ 6♦ 7♦ [...]
  Shuffled : 6♠ 5♦ 8♣ 10♦ J♠ 4♥ 2♣ 9♠ 2♠ K♦ A♠ Q♣ K♥ 6♦ 6♥ 7♠ 3♥ 2♦ 5♣ 9♦ [...]
  $ java Card
  Testing Card ...
  Orig Deck: 2♣ 3♣ 4♣ 5♣ 6♣ 7♣ 8♣ 9♣ 10♣ J♣ K♣ Q♣ A♣ 2♦ 3♦ 4♦ 5♦ 6♦ 7♦ [...]
  Shuffled : 10♠ 8♥ 5♣ 5♥ 5♦ 9♦ 9♣ Q♠ 6♦ 7♠ A♠ K♠ K♥ 7♦ A♥ J♥ 10♥ 2♠ 6♣ [...]
  	      

$ java Bar
d[12] = A♣

$ javac Player.java Rat.java
$ java Rat
Jose
$5.0
114 

• A key idea in this translation is that the array created by

  Player[] p = new Player[n];

  ... is an array of references. I.e. p[i] is not an actual "Player", it is a reference to a player object. Specifically, when you create an array of Objects (as opposed to bultins like int or char), you get an array of references that have all been initialized to null. Thus we have the line

  p[i] = new Player();

  inside the for loop. It creates the actual objects that the array elements refer to.
• Remember that all the functions/methods from Card have to be prefaced with "Card.", since we are outside of the class definition for Card.
• Note that we get rid of the "delete[]" statements. In Java memory is collected automatically when it is no longer used.

• $ javac Game.java 
  $ java Game 
  3 Frodo Gimli Merry
  Frodo $5.0 6♦
  Gimli $5.0 8♣
  Merry $5.0 9♦