That is not a rephrase but a completely different and incorrect statement.
getLogger() is a static method of the Logger class. What it returns is an
instance, but the method doesn't belong to that instance.
You do not need to use getName() - log4j was actually designed to use the
class itself as the argument to the factory method, which confers certain
advantages to tuning log capabilities at runtime.
Logger logger = Logger.getLogger( getClass() ); // instance version
I prefer the Logger class to Category. What Apache says about Category:
This class has been deprecated and replaced by the Logger subclass. It will be kept around to preserve backward compatibility until mid 2003.
(The first sentence, "... deprecated ...", is in bold face and red in the
Javadoc.)
Let's see, what month is it now?
Internally, whenever log4j is asked to produce a Category object, it will instead produce a Logger object. Log4j 1.2 will never produce Category objects but only Logger instances.
Seriously, what made you decide to go with Category?
Some say any use of non-constant static variables is suspect at least, and
likely wrong. I personally prefer to use an instance variable, but you must
use a static logger in static methods.
Yes, but don't worry. log4j built thread-handling into their methods. In
fact, you can control how the output looks to show which thread is logging.
Okay, I've learned a little bit more. I ran the following test program
and realized that you can create the logger either way, with slightly
different semantics, depending.
The creation of the logger has identical semantics either way, regardless.
The question remains: if statically declared, does the logger do its own
sequencing, or is the user headed for trouble in a threaded environment?
Do you mean if your logger variable is static, could you be heading for
trouble? Not AFAIK from log4j. They build Logger to handle multi-threaded
logging. In fact, you usually emit a thread identifier in your logging output
to help disentangle what you're reading therein.
import org.apache.log4j.Category;
class log4j {
This is an inadvisable name for the class since it is the same as the name of
an external package, one even used by the class. This makes the code harder
to grok. It also doesn't follow Sun's recommendation to name classes with an
initial upper-case letter.
static Category log = Category.getInstance(log4j.class.getName());
This is where it is strange to see what looks like a package name as a
function argument.
// Category log = Category.getInstance(log4j.class.getName());
// Note that 'int count' can't be referenced from (static) main()
// but 'static int count' *can* be referenced from (non-static) sub()
Sure, because the instance has access to the class but not vice versa.
Nothing earth-shattering there.
// int count = 0;
static int count = 0;
public static void main (String[] args)
{
log4j logger = new log4j ();
This is even more confusing. Typically "logger" would be used as an instance
of the Logger class from the log4j package.
// note that you can call log.debug only when it's declared to be static
You cannot call instance methods or refer to instance variables from static
methods by the definition of static.
log.debug("main: entered");
System.out.println ("hello world");
logger.sub();
// you can call logger.log.debug whether it's static or not
logger.log.debug ("main: " + count);
Right, because you call your example instance 'logger' and your logger 'log'.
Your observations are correct and the example shows them well. They pertain
to static versus instance ownership, not so much to the log4j library as such;
the illustrated principles are fundamental to Java programming.
Sun recommends that class names begin with upper-case letters, non-constant
variables (seems redundant, that phrase) and methods should start with
lower-case letters. Both should start each "internal word" (compound word
part) with its own initial capital letter. Compile-time constants should be
named with all upper-case letters, and separate compound word parts with
underscores, according to Sun's guidelines.
public class InitialUpperCaseLetter
{
private static final String CONSTANT_ALL_UPPERCASE = "";
int variableInitialLowerCase;
public void methodInitialLowerCase()
{
}
}
The use of mixed upper- and lower-case letters, sometimes called "camel case",
or more fetchingly, "camelCase", aids readability.
