Choose random card from a deck
You did many things right. Great! =)

Readability and complexity reduction

Your 

private String rank;


is nice and readable, but what is a rnk in 

public Card(String rnk, String sut)


?

I would not suggest to compromise on the readability of publicly visible variable names. (And I would neither suggest doing so on any other variable of any access level.)

If there's no good alternative name for parameter names, use this to differentiate the readable (and equal) variable and parameter names:

public Card(String rank, String suit) {
    this.rank = rank;
    this.suit = suit;
}


A common alternative solution is to add an underscore character to the variable name like so:

private String _rank;
private String _suit;  


Speaking of those two variables, it might make sense to make them final. After all, the suit of a card should never be changed. This reduces complexity, because you can only ever set the value once.

Top-Down design (refactoring)


  a randomly selected card from a deck of 52 cards.


You are not doing that at all. You pick some random rank and some other random suit and construct a card from that. The concept of a "deck" doesn't exist at all in your code. You merely have it implicitely defined just by how your random number generation works.

From top-down design code, I'd expect to see some object representing the deck of cards and some mechanism to get a random card from it. E.g.

Deck cardDeck = new Deck();
Card randomCard = cardDeck.getRandomCard();


Documentation

The public documentation of the constructor parameters

* @param rnk The rank of the card
* @param sut The suit of the card


is not adding any new information, while the hidden comments of the variables do:

/* The card rank : Ace,2,3,4,5,6,7,8,9,10,Jack,Queen,King */
/* The card suit : Clubs, Diamonds, Hearts, Spades */


I wish I could see those when being clueless about how to invoke the constructor.

My personal opinion is that comments like 

/* Instance variables */


and

/* Constructor */


do not add any value. If you want them or if you are forced to add them, you should be consistent though and also add

/* Public methods*/


to your classes.

Object oriented

rank and suit should be Enum Types. One part of object oriented philosophy is to create types in a way that they are helpful. A string is a string, but a Suit is not a Rank. Among many others, this has the benefit of preventing mistakes like the following from even compiling:

private Card selectCardFromDeckRandomly() {
    String rank = selectRandomCardSuit();
    String suit = selectRanomCardRank();
    return (new Card(rank, suit));  
}



  Note: still not in a position to use arrays.


You actually are in exactly that position.
In you case, limiting your code to not use arrays is what reduces your ability to improve it the most.

The use of enums leads to the use of their values() method (which returns an array), which allows you to get rid of the switches, resulting in more generic code.

Oh, and btw. isn't String [] args an array?