significance of private with final modifier method

[Pradeep Kumar]

Hi ranchers,

A private method in a class is only visible inside the declaration class and cannot be overridden in the subclass.

Then what is the significance of having a private method with a final modifier? As far as I know there is no significance. If there is any specific significance kindly let me know.

[Jesper de Jong]

There is no special significance, and indeed, because methods that are private are only visible to the class itself and are not inherited by subclasses, it doesn't make much sense to make private methods final.

Note that for instance variables it's different, because the meaning of the word "final" is different: it means the value can't be changed once it's initialized (it doesn't have anything to do with inheritance).

[Ernest Friedman-Hill]

Note that inner classes can see eachother's privates, and those of the containing class. Therefore you could cook up a scenario where an inner class (which was also a subclass of another inner class) was blocked from overriding a final private method. That's awfully far-fetched, though, and I think "there's no purpose for it" is a fine answer in general.

[Hunter McMillen]

I just finished a project that has your exact example Ernest, except with an attribute and a class
The outer class is called SymbolTable and the inner nested class is called TableEntry, and the symbol table is made up of entries. SymbolTable only has one attribute which is a private final HashMap. And the only way I wanted the HashMap to be modified was from the SymbolTable class

Shortened Code Below:

    
/**
 * Tint
 * SymbolTable.java implements the guts of the sets and states symbol tables, which is then used by 
 * the singleton classes SetSymboLTable and StateSymbolTable.
 *
 * @author Hunter McMillen
 * @version2  April 3, 2010
 */
package SymbolTable;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public abstract class SymbolTable {
	
	/**
	 * TableEntry is a struct storing symbol information for the hashtable. It is private because its attributes
	 * are not, allowing easy access while hiding the SymbolTable implementation from clients.
	 */
	
	private final class TableEntry {	// record holding data in the hashtable
		public final String identifier;	// the symbol described
		public SymbolStatus status;		// whether this symbol is undefined, defined, or redefined
		public int line;				// where this symbol is defined, or if undefined ...
		public int column;				// ... where it first appears
		public int redefinitionLine;	// where this symbol is redefined
		public int redefinitionColumn;	// where this symbol is redefined
		public Object value; //value of the set or state objects
		
		public TableEntry( String identifier, int line, int column, SymbolStatus status, Object value ) {
			this.identifier = identifier;
			this.status = status;
			this.line = line;
			this.column = column;
			this.redefinitionLine = 0;
			this.redefinitionColumn = 0;
			this.value = value;
			}
		
	} // end class TableEntry
	
	private final HashMap<String,TableEntry> table;		// where the symbols are actually stored
	
	public SymbolTable() 
	{
		table = new HashMap<String,TableEntry>();
	}

Hope this helps,
Hunter

[Jesper de Jong]

Hunter, your example has a private final inner class TableEntry and a private final instance variable table but there is no private final method, which was what the original question was about.