[farrell2k]

I'm interested in listing and explaining terminology and other things, in simple terms, that confuse new Java programmers. It would be great to get others involved as well. Please submit explanations of things that confused you.

CHECKED EXCEPTION - A checked exception is any exception that is checked by the Java compiler at compile time. Your programs will not compile until these exceptions are handled. e.g. having to surround FileWriter in a try/catch block.

FileWriter w = null;
		try {
			w = new FileWriter("file.txt");
		} catch (IOException e) {
			e.printStackTrace();
		}

UNCHECKED EXCEPTION - Basically, any exception that is not checked by the compiler. These exceptions are the ones that blow up in your face at run time. Hint: RuntimeException - NullPointedException, IndexOutOfBoundsException, etc.

TYPE ERASURE - Fancy name for a simple compiler trick. All it means is that when you write with generics in Java:

List<String> groceries = new ArrayList<String>();
groceries.add("milk");
String s = groceries.get(0);

The compiler turns it to this:

List groceries = new ArrayList();
groceries.add("milk");
String s = (String) groceries.get(0);

The bytecode for both examples are identical due to "type erasure". Nothing complicated.

[andrewsw]

It will be good to get in early that Java != Javascript

[blackcompe]

Term:

Reflection

Formal Definition:

In computer science, reflection is the ability of a computer program to examine (see type introspection) and modify the structure and behavior (specifically the values, meta-data, properties and functions) of an object at runtime. ~Wikipedia

Explain:

When I first began programming, I saw this term used continuously in development forums and tutorials, but despite attempts to demystify it, I could never fully understand it. I knew bits and pieces, but I couldn't use the term confidently.

Reflection can occur on different levels, but most commonly it's referred to mean programmatically examining (and possibly modifying) an object's definition at runtime. Determining an object's type, super type, interfaces, and methods, or adding a method to an object's prototype (in Javascript), are all examples of reflection.

Examples:

• The instanceof operator in Java. You can do a lot more with the reflection API. This is examining code at runtime.
  
• Self-modifying code in viruses. This is modifying existing code at runtime.
  
• The eval() function in Javascript. This is adding code at runtime.

Advantages:

Reflection is used in many frameworks and libraries to achieve things that would otherwise be impossible to do. Some examples are:

• Software Testing: Defining units tests and properties via annotations.
  
• IOC frameworks (Spring, EJB): Locating registered objects via annotations.

Disadvantages:

• Reflective operations are slower.
  
• It's hard to infer about the behavior of reflective code, which excludes it from compile-time checks.
  
• May allow access to private members, which can be a security issue.

Code Sample:

Spoiler

import java.lang.reflect.Method;


/**
 * A simple example that demonstrates the use of the reflection
 * API to execute all methods on an object that belong to a 
 * specified interface, if the object implements the interface.
 * 
 * Notice in main(), nothing is known about the type of the variable 
 * 'obj', yet we're still able examine its definition and achieve our
 * desired behavior.
 * 
 * @author Blackcompe
 */

interface Foo { void foo(); }
interface Bar { void bar(); }

class FooBar implements Foo, Bar
{
	public void foo() { System.out.println("foo"); }
	public void bar() { System.out.println("bar"); }
}

public class Main
{	
	public static void main(String[] args) throws Exception
	{
		String interfaceName = "Bar";
		Object obj = new FooBar();
		for(Class<?> cls: obj.getClass().getInterfaces())
			if(cls.getName().equals(interfaceName))
				for(Method mth: cls.getDeclaredMethods())
					mth.invoke(obj);
	}
}