static insights?

[Jon Camilleri]

I am afraid that my function for counting cards named getWinner(), is not actually reading the Card objects that are passed to it, since I am counting the ordinal() values of static values, which will have a value in any case, whether or not they are contained in the ArrayList<Card> passed to the method getWinner()

Will you confirm my stupidity, and, suggest alternatives?

package poker;

import java.awt.Image;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;
import javax.imageio.ImageIO;

import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Logger;

import poker.Card.Rank;
public class Poker {

	public static final short MAX_CARDS_IN_DECK = 52;
	public static final short MAX_SUITS_IN_DECK = 4;
	public static final short MAX_RANK_IN_DECK = 13;
	public static final short MAX_PLAYERS_PER_TABLE = 5;
	public static final short MAX_GAMES = 1;
	//TODO: 
	//1. implement concurrent games and UI at a later stage.
	//2. implement Joker, which can act as a wild card (Card.java and Poker.java) FIX.
	
	public static double amountOnTable;
	public static final String CURRENCY_SYMBOL = "€";
	
	public static void main(String[] args) {

	BasicConfigurator.configure();
	
	readIcons();
	
	boolean shuffled = true;
	getCards(shuffled);
	
	Player playerOne = new Player("Player One", 10000.00);
	playerOne.getCardFromDealer(getTopCard());
	playerOne.getCardFromDealer(getTopCard());
	if (playerOne.betAmount(100.00) == false) {
                  System.out.println("WARNING: Player tried to bet " + CURRENCY_SYMBOL +
                  "100.00, whilst the balance available is " + CURRENCY_SYMBOL + playerOne.getBalance());}


	Player playerTwo = new Player("Player Two", 10000.0);
	playerTwo.getCardFromDealer(getTopCard());
	playerTwo.getCardFromDealer(getTopCard());
	Double _amountforPlayerTwo = 10000.0;
	if (playerTwo.betAmount(_amountforPlayerTwo) == false) {
                        System.out.println("WARNING: Player tried to bet " + CURRENCY_SYMBOL + 
                        _amountforPlayerTwo + ", whilst the balance available is " + 
                       CURRENCY_SYMBOL + playerTwo.getBalance());}

	Player playerThree = new Player("Player Three", 10000.0);
	playerThree.getCardFromDealer(getTopCard());
	playerThree.getCardFromDealer(getTopCard());
	if (playerThree.betAmount(100.00) == false) {System.out.println(
                       "WARNING: Player tried to bet " + CURRENCY_SYMBOL +
                       "100.00, whilst the balance available is " + CURRENCY_SYMBOL +
                       playerThree.getBalance());}

	Player playerFour = new Player("Player Four", 10000.0);
	playerFour.getCardFromDealer(getTopCard());
	playerFour.getCardFromDealer(getTopCard());
	if (playerFour.betAmount(100.00) == false) {System.out.println(
                       "WARNING: Player tried to bet " + CURRENCY_SYMBOL +
                       "100.00, whilst the balance available is " + CURRENCY_SYMBOL +
                       playerFour.getBalance());}

	Player playerFive = new Player("Player Five", 10000.0);
	playerFive.getCardFromDealer(getTopCard());
	playerFive.getCardFromDealer(getTopCard());
	if (playerFive.betAmount(100.00) == false) {System.out.println(
                      "WARNING: Player tried to bet " + CURRENCY_SYMBOL + 
                      "100.00, whilst the balance available is " + CURRENCY_SYMBOL +
                      playerFive.getBalance());}

	for (int iBettingRounds = 0; iBettingRounds < 3; iBettingRounds++) {
		playerOne.getCardFromDealer(getTopCard());
		playerOne.betAmount(100.00);

		playerTwo.getCardFromDealer(getTopCard());
		playerTwo.betAmount(100.00);

		playerThree.getCardFromDealer(getTopCard());
		playerThree.betAmount(100.00);

		playerFour.getCardFromDealer(getTopCard());
		playerFour.betAmount(100.00);

		playerFive.getCardFromDealer(getTopCard());
		playerFive.betAmount(100.00);
	}

	System.out.println(playerOne);
	System.out.println(playerTwo);
	System.out.println(playerThree);
	System.out.println(playerFour);
	System.out.println(playerFive);

	System.out.println("Cards held by dealer:");
	for (int i = 0; i < deckOfCards.size(); i++) { System.out.println((i + 1) +"." + deckOfCards.get(i));}

	deckOfCards.trimToSize();

	ArrayList<Player> _players = new ArrayList<Player>();
	_players.add(playerOne);
	_players.add(playerTwo);
	_players.add(playerThree);
	_players.add(playerFour);
	_players.add(playerFive);
	System.out.println("And the winners are...");
	for (Player _p: getWinner(_players)) {
		System.out.println (_p + "Score: " + _p.getCurrentGameScore() +
                 " High Score: " + _p.getHighScore());
	}
	
	}
	private static void getCards (boolean _shuffled) {
		short iCount = 0;
		for (short suit = 1; suit <= MAX_SUITS_IN_DECK; suit++){
			for (short rank = 1; rank <= MAX_RANK_IN_DECK; rank++) {
				deckOfCards.add(iCount, new Card(suit, rank));
				iCount++;
			}}

		if (_shuffled == true){Collections.shuffle(deckOfCards, new Random());}

	}

	private static Card getTopCard() {
		Card _cardRemoved = deckOfCards.get(1);
		deckOfCards.remove(1);
		return _cardRemoved;
	}

	private static void readIcons(){

    	String _filename;

    	//read icons
    	Image _image = null;
    	File _file = null;
    	InputStream _is = null;
    	for (int i = 1; i < MAX_CARDS_IN_DECK + 1; i++) {
    	try {

    		/* Security information: filenames should not be altered manually by an Administrator, and,
    		 should be available within the same directory where the source code runs. */

    			if (i < 10) {_filename = "0" + Integer.toString(i);}
    			else {_filename = Integer.toString(i);}

    			String _temp = _filename;
    			_filename = _temp + ".GIF";

    			//TODO: Relative path might change when implementing?
    			_filename = System.getProperty("user.dir") + "\\img\\" + _filename;

    		_file = new File(_filename);

    		//read from an input stream
    		_is = new BufferedInputStream (new FileInputStream(_filename));

    		_image = ImageIO.read(_is);
    		if (_file.exists()) {
    		CardIcons.add(_image);
    		//_log.debug(_filename + " loaded.");
    		}
    	}
    	catch (IOException e) { _log.debug(e.getMessage()); }
    	}
    }

	//TODO: write ranking rules
	private static ArrayList<Player> getWinner(ArrayList<Player> _players) {

		ArrayList<Player> _winners = new ArrayList<Player>();

		/*TODO:	1. Player.setRanking(_ranking) for each of the players:
		Ranking 
		for hand # - highest ranking wins

		_highCardPoints = High-card ranking scores																Score
		Card.Rank.Suit.ACE																						+14
		Card.Rank.Suit.KING																						+13
		Card.Rank.Suit.QUEEN																					+12
		Card.Rank.Suit.JACK																						+11
		Card.Rank.Suit.TEN																						+10
		Card.Rank.Suit.NINE																						+9
		Card.Rank.Suit.EIGHT																					+8
		Card.Rank.Suit.SEVEN																					+7
		Card.Rank.Suit.SIX																						+6
		Card.Rank.Suit.FIVE																						+5
		Card.Rank.Suit.FOUR																						+4
		Card.Rank.Suit.THREE																					+3
		Card.Rank.Suit.TWO																						+2

		_handRanking = Scores by hand ranking	
		----------------------
		1. 		Straight flush.  Five cards in sequence all of the same suit.									*1000000000
		2. 		Four of a kind.  Four cards of the same rank i.e. two pairs.									*100000000
		3.		Full house.		 Three cards of the same rank, and, a pair of cards with the same rank.			*10000000
		4.		Flush.			 Five cards of the same suit.													*1000000
		5.		Straight.		 Five cards in sequence, not necessarily of the same suit.						*100000
		6. 		Three of a kind. Three cards of the same rank.													*10000
		7.		Two pair.		Two pairs of cards, each having the same rank.  Higher ranks win.				*1000
		8.		One pair.		One pair of cards with the same rank.											*100
		9.      High card.		Cards in order of their rank. 													*10


		Higher cards get higher points.
		Further information at http://en.wikipedia.org/wiki/Poker_hands.
		*/

		/*TODO: If two or more players have equal high ranking, then players get to split the pot, hence, add both players to the winning
				ArrayList and return the ArrayList.
		*/

		int _suitCount = 0;
		int _rankCount = 0;
		ArrayList<Card> _cardsAtHand = new ArrayList<Card>();

		//scores will be in the same order as _players TODO: set to equal the size of _players
		long _handRanking[] = new long[_players.size()];
		int _highCardPoints[] = new int[_players.size()];
		long _totalScore[] = new long[_players.size()];

		for (Player _p : _players) {
			boolean _rankingFound = false;

			for (int iPlayer = 0; iPlayer < _players.size(); iPlayer++) {
			_cardsAtHand = _players.get(iPlayer).getCardsHeld();

			/* Straight flush */
			for (Card _card: _cardsAtHand) {

				switch (_card.getSuit()) {
						case CLUBS	:		_suitCount += Card.Suit.CLUBS.ordinal(); 		break;
						case DIAMONDS : 	_suitCount += Card.Suit.DIAMONDS.ordinal(); 	break;
						case HEARTS : 		_suitCount += Card.Suit.HEARTS.ordinal(); 		break;
						case SPADES :   	_suitCount += Card.Suit.SPADES.ordinal();		break;
						default :			break;
				}

				switch (_card.getRank()) {
					case ACE 	:	{_rankCount += Card.Rank.ACE.ordinal();
									 _highCardPoints[iPlayer] += 14;
									 break; }
					case KING 	:	{_rankCount += Card.Rank.KING.ordinal(); 
									_highCardPoints[iPlayer] += 13;
									break;}
					case QUEEN	:	{_rankCount += Card.Rank.QUEEN.ordinal(); 
									_highCardPoints[iPlayer] +=12;
									break;}
					case JACK	:	{_rankCount += Card.Rank.JACK.ordinal(); 
									_highCardPoints[iPlayer] += 11;
									break;}
					case TEN    :	{_rankCount += Card.Rank.TEN.ordinal(); 
									_highCardPoints[iPlayer] += 10;
									break;}
					case NINE	:	{_rankCount += Card.Rank.NINE.ordinal(); 
									_highCardPoints[iPlayer] += 9;
									break;}
					case EIGHT	:	{_rankCount += Card.Rank.EIGHT.ordinal(); 
									_highCardPoints[iPlayer] += 8;
									break;}
					case SEVEN  : 	{_rankCount += Card.Rank.SEVEN.ordinal(); 
									_highCardPoints[iPlayer] += 7;
									break;}
					case SIX 	:	{_rankCount += Card.Rank.SIX.ordinal(); 
									_highCardPoints[iPlayer] += 6;
									break;}
					case FIVE	:	{_rankCount += Card.Rank.FIVE.ordinal(); 
									_highCardPoints[iPlayer] += 5;
									break;}
					case FOUR	:	{_rankCount += Card.Rank.FOUR.ordinal(); 
									_highCardPoints[iPlayer] += 4;
									break;}
					case THREE	:	{_rankCount += Card.Rank.THREE.ordinal(); 
									_highCardPoints[iPlayer] += 3;
									break;}
					case TWO	:	{_rankCount += Card.Rank.TWO.ordinal(); 
									_highCardPoints[iPlayer] += 2;
									break;}
					default		:	break;
				}
			}
			/* all hands must be from the same suit, hence, the total points must be the squares of the Card.Suit.<RANK>.ordinal() values */
			if (!(_suitCount == 0 || _suitCount == 5 || _suitCount == 10 || _suitCount == 15)) {
				_handRanking[iPlayer] = 0;
				_highCardPoints [iPlayer]= 0; }
			else if ( (_rankCount >= 10) && (_rankCount <=50) && ((_rankCount % 5) == 0) )	{
					_rankingFound = true;
					_handRanking[iPlayer] = 1000000000;
					_winners.add(_p);
					
					if (_highCardPoints[iPlayer] == 60)  _log.debug("Royal flush" + _p);
					else _log.debug("Straight flush " + _p);}
			
			if (!_rankingFound) {
				/* 2. Four of a kind*/

				for (Card _card : _cardsAtHand) {
					switch (_card.getRank()) {
					case ACE:	_rankCount += Card.Rank.ACE.ordinal(); break;
					case KING: 	_rankCount += Card.Rank.KING.ordinal(); break;
					case QUEEN:	_rankCount += Card.Rank.QUEEN.ordinal(); break;
					case JACK: _rankCount += Card.Rank.JACK.ordinal();break;
					case TEN: _rankCount += Card.Rank.TEN.ordinal();break;
					case NINE: _rankCount += Card.Rank.NINE.ordinal();break;
					case EIGHT: _rankCount += Card.Rank.EIGHT.ordinal();break;
					case SEVEN: _rankCount += Card.Rank.SEVEN.ordinal();break;
					case SIX: _rankCount += Card.Rank.SIX.ordinal();break;
					case FIVE: _rankCount += Card.Rank.FIVE.ordinal();break;
					case FOUR: _rankCount += Card.Rank.FOUR.ordinal();break;
					case THREE: _rankCount += Card.Rank.THREE.ordinal();break;
					case TWO: _rankCount += Card.Rank.TWO.ordinal();break;
					default: break;
					}
				}
				if ((_rankCount > 0) && (_rankCount < 48) && (_rankCount % 4 == 0))  {
					_rankingFound = true;
					_handRanking[iPlayer] = 100000000;
				}
				}

			if (!_rankingFound) {
				/* 3. Full house */
				int _rankCountForFullHouse[] = new int[Card.RANKING_CARDS_PER_SUIT]];
				for (Card _card : _cardsAtHand) {
					switch (_card.getRank()) {
					case ACE:	_rankCountForFullHouse[Card.Rank.ACE.ordinal()] += Card.Rank.ACE.ordinal(); break;
					case KING: 	_rankCountForFullHouse[Card.Rank.KING.ordinal()] += Card.Rank.KING.ordinal(); break;
					case QUEEN:	_rankCountForFullHouse[Card.Rank.QUEEN.ordinal()] += Card.Rank.QUEEN.ordinal(); break;
					case JACK: _rankCountForFullHouse[Card.Rank.JACK.ordinal()] += Card.Rank.JACK.ordinal();break;
					case TEN: _rankCount += Card.Rank.TEN.ordinal();break;
					case NINE: _rankCount += Card.Rank.NINE.ordinal();break;
					case EIGHT: _rankCount += Card.Rank.EIGHT.ordinal();break;
					case SEVEN: _rankCount += Card.Rank.SEVEN.ordinal();break;
					case SIX: _rankCount += Card.Rank.SIX.ordinal();break;
					case FIVE: _rankCount += Card.Rank.FIVE.ordinal();break;
					case FOUR: _rankCount += Card.Rank.FOUR.ordinal();break;
					case THREE: _rankCount += Card.Rank.THREE.ordinal();break;
					case TWO: _rankCount += Card.Rank.TWO.ordinal();break;
					default: break;
					}
			}

			if (!_rankingFound) {
				/* 4. Flush */
			}
			
			if (!_rankingFound) {
				/* 5. Straight */
			}

			if (!_rankingFound) {
				/* 6. Three of a kind */
			}

			if (!_rankingFound) {
				/* 7. Two pair */
			}

			if (!_rankingFound) {
				/* 8. One pair */
			}

			if (!_rankingFound) {
				/* 9. High cards */
			}
		_totalScore[iPlayer] = _highCardPoints[iPlayer] * _handRanking[iPlayer];
		_p.setCurrentGameScore(_totalScore[iPlayer]);
		}}

		//..and the winners are...
		short _iPlayer = 0;
		long _highScore = 0;

		//read highest scores
		for (Player _p: _players) {
			if (_highScore < _p.getCurrentGameScore()) {_highScore = _totalScore[_iPlayer];}
			_iPlayer++;
		}

		//set winner(s)...
		_iPlayer = 0;
		for (Player _p: _players ) { 
			if (_p.getCurrentGameScore() == _highScore) {_winners.add(_p);}
			_iPlayer++;
		}
			_winners.trimToSize();
			return _winners;
		}

	private static ArrayList<Image> CardIcons = new ArrayList<Image>();
	private static ArrayList<Card> deckOfCards = new ArrayList<Card>();
	private static final Logger _log = Logger.getLogger(Poker.class);


	/* References
	 * ----------
	 * Texas Hold'em rules are used throughout the game.
	 * Information about poker at http://en.wikipedia.org/wiki/Poker.
	 * List of poker hands at http://en.wikipedia.org/wiki/Poker_hands.
	 * Rules for Texas Hold'Em at http://en.wikipedia.org/wiki/Texas_hold_'em.  This will be implemented at a later stage.
	 * Steve Badger, How to Play Poker at http://www.playwinningpoker.com/articles/how-to-play-poker.
	 * Graphics to be implemented at a later stage.
	 */
}

package poker;
import java.util.*;
import org.apache.log4j.BasicConfigurator;
public class Player {

public Player (String _name, Double _balance) {
	this.name = _name;
	this.balance = _balance;
}

public ArrayList<Card> getCardsHeld() {return CardsHeld;}
public void getCardFromDealer (Card _card) {CardsHeld.add(_card);}

public boolean equals (Object other) {
	if ((other == null) || (!(other instanceof Player))) return false;

	if (this == other) return true;

	if (getClass() != other.getClass()) return false;

	@SuppressWarnings("unused")
	Player _player = (Player) other;
	return  this.hashCode() == other.hashCode();	
}

public String toString() {

	String _cardsHeld = ""; 
	for (int i = 0; i < CardsHeld.size(); i++) 		{_cardsHeld += CardsHeld.get(i).toString() + "; ";}

	return (name + " holds the following cards: " + _cardsHeld) ;
}

public int hashCode() {
	int _hash = 7;
	int _cpCount = this.name.codePointCount(0, this.name.length());
	int _codePointV = 0;

	for (_cpCount = 0; _cpCount < this.name.codePointCount(0, this.name.length()); _cpCount++) {
		_codePointV += this.name.codePointAt(_cpCount);
	}
	_hash = _hash * 31 + _codePointV;  
	return _hash; 
}
private ArrayList<Card> CardsHeld = new ArrayList<Card>();

public String getName () {return name; }
public Double getBalance () {return balance;}
public boolean betAmount(Double _amountToBet) {
	if (_amountToBet <= balance) {
		balance -= _amountToBet;
		return true;}

	else return false;
}
public void addWinnings (Double _amountWon){
		balance += _amountWon;
}
public void setRanking (short _winningRank){
	this.winningRank = _winningRank;
}
public short getRanking () {return this.winningRank;}

public long getCurrentGameScore() {return this.scoreOfCurrentGame;}
public void setCurrentGameScore(long _currentScore) {
	this.scoreOfCurrentGame = _currentScore;
	if (_currentScore > this.highScore) this.highScore = _currentScore;}

public long getHighScore() {return this.highScore;}

private String name;
private Double balance;
private short winningRank;
private long scoreOfCurrentGame;
private long highScore;
//TODO: persist stats on text file
}

package poker;
import java.util.*;
import org.apache.log4j.BasicConfigurator;
public class Player {

public Player (String _name, Double _balance) {
	this.name = _name;
	this.balance = _balance;
}

public ArrayList<Card> getCardsHeld() {return CardsHeld;}
public void getCardFromDealer (Card _card) {CardsHeld.add(_card);}

public boolean equals (Object other) {
	if ((other == null) || (!(other instanceof Player))) return false;
	if (this == other) return true;

	if (getClass() != other.getClass()) return false;

	@SuppressWarnings("unused")
	Player _player = (Player) other;
	return  this.hashCode() == other.hashCode();
}

public String toString() {

	String _cardsHeld = "";
	for (int i = 0; i < CardsHeld.size(); i++) 		{_cardsHeld += CardsHeld.get(i).toString() + "; ";}

	return (name + " holds the following cards: " + _cardsHeld) ;
}

public int hashCode() {
	int _hash = 7;
	int _cpCount = this.name.codePointCount(0, this.name.length());
	int _codePointV = 0;

	for (_cpCount = 0; _cpCount < this.name.codePointCount(0, this.name.length()); _cpCount++) {
		_codePointV += this.name.codePointAt(_cpCount);
	}
	_hash = _hash * 31 + _codePointV; 
	return _hash;
}
private ArrayList<Card> CardsHeld = new ArrayList<Card>();

public String getName () {return name; }
public Double getBalance () {return balance;}
public boolean betAmount(Double _amountToBet) {
	if (_amountToBet <= balance) {
		balance -= _amountToBet;
		return true;}

	else return false;
}
public void addWinnings (Double _amountWon){
		balance += _amountWon;
}
public void setRanking (short _winningRank){
	this.winningRank = _winningRank;
}
public short getRanking () {return this.winningRank;}

public long getCurrentGameScore() {return this.scoreOfCurrentGame;}
public void setCurrentGameScore(long _currentScore) {
	this.scoreOfCurrentGame = _currentScore;
	if (_currentScore > this.highScore) this.highScore = _currentScore;}

public long getHighScore() {return this.highScore;}

private String name;
private Double balance;
private short winningRank;
private long scoreOfCurrentGame;
private long highScore;
//TODO: persist stats on text file
}

I think I have already resolved this , but have had doubts , basically because I am selectively switching between the cards in my suit.

for (Card _card: _cardsAtHand) {

				switch (_card.getSuit()) {
						case CLUBS	:		_suitCount += Card.Suit.CLUBS.ordinal(); 		break;
						case DIAMONDS : 	_suitCount += Card.Suit.DIAMONDS.ordinal(); 	break;
						case HEARTS : 		_suitCount += Card.Suit.HEARTS.ordinal(); 		break;
						case SPADES :   	_suitCount += Card.Suit.SPADES.ordinal();		break;
						default :			break;
				}

[Wouter Oet]

That is a whole lot of code. I don't think anybody is going to read that. Making a small selection of it will increase the number of people reading it. Anyway I did a quick scan and found that your code contain a lot of duplicate code, long methods, weird constructs (such as if(... == false)), wrong variable names (variable names shouldn't begin with an underscore) and a lot of magic numbers. I would focus of fixing that because it is more error prone, harder to comprehend and hard to read.

[Ernest Friedman-Hill]

Totally agree with Wouter. Note that the less code you write, the fewer bugs you'll have. Excessive wordiness just provides places for bugs to hide. As an example, that last block of code you've highlighted could equivalently be written:

for (Card _card: _cardsAtHand) {
    _suitCount += _card.getSuit().ordinal(); 				
}				

and you could do the same with several of the the big switches on Rank as well.

[Jon Camilleri]

Wouter Oet wrote:That is a whole lot of code. I don't think anybody is going to read that. Making a small selection of it will increase the number of people reading it. Anyway I did a quick scan and found that your code contain a lot of duplicate code, long methods, weird constructs (such as if(... == false)), wrong variable names (variable names shouldn't begin with an underscore) and a lot of magic numbers. I would focus of fixing that because it is more error prone, harder to comprehend and hard to read.

Well, you can have a look at line 163 (getWinners()..) onwards that's the gory logic bit (which I'm working on in work breaks

I was thinking of reading the "magic numbers" from a text file, however, on second thoughts it would be a pointless operation because I would store them within variables that my tiny program processes in any case.

[Campbell Ritchie]

Jon Camilleri wrote: . . . line 163 (getWinners()..) onwards that's the gory logic bit (which I'm working on in work breaks . . .

Not any more. Another dreadful feature of you code is the long lines, which make it too hard to read. So I have added new lines, and removed lots of unnecessary whitespace. It goes to show you that there are god reasons for this style suggestion, and this one, too.

[Jon Camilleri]

Campbell Ritchie wrote:

Jon Camilleri wrote: . . . line 163 (getWinners()..) onwards that's the gory logic bit (which I'm working on in work breaks . . .

Not any more. Another dreadful feature of you code is the long lines, which make it too hard to read. So I have added new lines, and removed lots of unnecessary whitespace. It goes to show you that there are god reasons for this style suggestion, and this one, too.

Well thanks for that, I would like to note that Gary, suggests that class should be coded as follows:

class ClassName 
{
constructor(s)

method(s)

field(s)
}

This is slightly different from the recommended layout (see 1.3)

What I was worried about was whether is was more readable to include getter and setter methods that simply read from and to fields grouped with the field(s) for easier readability or with fields. What do you think?

This would be the suggested layout for classes:

 public Foo
{
 private FieldType _name
 public getName() { return this._name;} //option A
 public static float PI = 3.14159265f;   

 Foo ()

 public getName() {return this._name;} //option B
}

[Campbell Ritchie]

Style is that identifiers never begin with underscores, except for package names under certain special circumstances. Always begin identifiers with a letter; $ should be reserved for a class name generated by the compiler.

Who is Gary?

No, don't intersperse getters and setters amongst the field names.

If you are given a style guide, stick to it. It is a useful discipline learning to program according to a particular style.

[Jon Camilleri]

Campbell Ritchie wrote:Style is that identifiers never begin with underscores, except for package names under certain special circumstances. Always begin identifiers with a letter; $ should be reserved for a class name generated by the compiler.

Who is Gary?
Gary Cornell and Cay S. Horstmann are the authors of [url= "http://java.sun.com/developer/Books/javaprogramming/corejavavolumeone"]Core Java Volume I and II[/url].

No, don't intersperse getters and setters amongst the field names.

If you are given a style guide, stick to it. It is a useful discipline learning to program according to a particular style.

I agree, I'm "by the book" professionally, but stick to fancy jargon when troubleshooting, and, building toy (training) programs.