:'( Not again... We'll miss you DJ...
I understand how you feel... Things have been stressed lately, and Souvik pushed things over the edge for you. I'm sorry about all this.
We understand and won't stop you from leaving, but you're always welcome back if you change your mind.
Others will write more heartfelt things, trust me.

My meaningless comment came from a misunderstanding about how it worked (I never used it )
You may now ignore it.
Darl, so it sounds like it works. Ikemike, could you elaborate?

Probably the difficulty part. Signing shouldn't be a problem AFAICT.

An example generic class, with two methods, display() and setThing(T):
class GenericClass<T> { //T stands for a certain class. Could be anything.
    public T thing;
    public void display() {
        System.out.println(thing.toString());
    }
    public void setThing(T thing) {
        this.thing = thing; //this.thing refers to the thing in this object, not the argument thing
}
public class Main {
    public static void main(String[] args) {
        GenericClass<String> test = new GenericClass<String>();
        test.setThing("Hello World!");
        test.display();
        GenericClass<Object> test2 = new GenericClass<Object>();
        test.setThing(new Object());
        test.display();
    }
}So we use GenericClass in two ways: one where T is String, the other where T is Object. When you do that, you can pretty much pretend that all the T's in the class definition were replace with either String or Object. setThing(T) works as either setThing(String) or setThing(Object) depending on whether the object is a GenericClass<String> or GenericClass<Object>.
Generics are extremely powerful, and C#, C++, Java, and possibly others have them.
Edit: Is it really called the diamond operator? Also, aren't generics like templates?

EDIT: I've noticed you've been posting a lot, momrocker. Why don't you create an account and join us?

We don't have guest posting. momrocker was here but was permbanned for trolling

Encapsulation and polymorphism (along with inheritance) are probably the key features of OOP. They make your code modular, flexible, extensible, and many other things.
Encapsulation (namely private variables) allows you to ignore the inner workings of another class/object and use the methods it provides. It frees you from having to deal with all the underlying things directly (like the networking and display examples) and allows delegation of tasks.
Polymorphism and inheritance also allow a common interface to classes. Example (Java):
abstract class IntegerOperation {
    public abstract int selfOperation();
    public abstract int binaryOperation(int otherArgument); //"abstract" just means that I'm not defining these methods
}
//IntegerOperation is a class that names two methods, selfOperation() and binaryOperation(int), that both return an int
//It is extended twice here:
class IncrementAdd extends IntegerOperation {
    public int number;
    public int selfOperation() {
        return number+1;
    }
    public int binaryOperation(int otherArgument) {
        return number+otherArgument;
    }
}
//Also here:
class DecrementSubtract extends IntegerOperation {
    public int number;
    public int selfOperation() {
        return number-1;
    }
    public int binaryOperation(int otherArgument) {
        return number-otherArgument;
    }
}
//And the main code here:
public class Main {
    public static void main(String[] args) {
        IntegerOperation intOp = new IncrementAdd();
        intOp.number = 5;
        System.out.println(intOp.selfOperation()); //Prints 6
        intOp = new DecrementSubtract();
        intOp.number = 20;
        System.out.println(intOp.binaryOp(13)); //Prints 7
    }
}So, despite the two methods having different definitions in the two classes, we can use each as an IntegerOperation and invoke its methods. Yay polymorphism!
Note: And yeah, we're trying to sell you OOP
Edit: And this was written before Ashbad's post. It demonstrates inheritance and polymorphism.

A 2.75hr drive from here... Too far, sorry

Haha, nice find