class generics

[jacob deiter]

public class Box<T> {}

as per generic ,the above is use to pass parameter to the class Box ,then what is the use of constructor. which one is better?

[Campbell Ritchie]

Don't really understand your question.
The <T> means that you will have to specify a class which you are using. It means whatever you pass to the constructor will be a particular type, not specified at the moment.

[jacob deiter]

http://java.sun.com/docs/books/tutorial/java/generics/bounded.html

public class Box<T> {
 
    private T t;          
 
    public void add(T t) {
        this.t = t;
    }
 
    public T get() {
        return t;
    }
 
    public <U extends Number> void inspect(U u){
        System.out.println("T: " + t.getClass().getName());
        System.out.println("U: " + u.getClass().getName());
    }
 
    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<Integer>();
        integerBox.add(new Integer(10));
        integerBox.inspect("some text"); // error: this is still String! 
    }
}

At the line , �Box<Integer> integerBox = new Box<Integer>();�

It create class and passing �Interger� into it.

My question is if a class is defined as follow

Class A{
 
A(Interger k) {}
 
}

Please ignore rest part of the program

A b=new A(nw interger(10);

Then in conductor also I can pass a value to class

What is the difference between passing through �constructor� and �Formal type parameter�

[Chandra Bhatt]

Hi jacob,

When you write Box<Integer> a = new Box<Integer>();
you call it " A Box object parameterized with Integer is created"
But you have not initialized by passing value to its constructor as:

Box<Integer> box = new Box<Integer>(10);
Now you have initialized the Box objects member variable with value 10,
passed as constructor parameter.

[Campbell Ritchie]

The formal type parameter tells the compiler what sort of data this class will contain.
The constructor parameter receives the actual value.
The fact that the word "parameter" is used in different places to mean different things can be confusing.

Is that any use?

[Chandra Bhatt]

    
 
class Box<T> {
 
void method1(T t){
}
 
void method2(T t1, T t2) {
}
 

public static void main(String... args) {
    Box<Integer> box = new Box<Integer>();
    box.method1(new Integer(10));// correct
    box.method1(10.4f); // compiler error, because u have promised that your
    //box object is parameterized with Integer class only
 
    Box<Float> box2 = new Box<Float>();
    box2.method1(10.2f); //correct now, because this time its parameterized     //with Float
 
}
}