It says T must be a type that implements both interfaceA and interfaceB interfaces.
Your second example says that T must be of any type that implements the Number interface only.
class A<T extends interfaceA & interfaceB> means
that T is bounded by two interfaces. Thus,any type argument passed to T must implement interfaceA and interfaceB.
Sample program for your understanding :-
interface X{
public void eat();
}
interface Y{
public void drink();
}
class XYZ implements X,Y{
@Override
public void eat(){
System.out.println("I am eating.");
}
@Override
public void drink(){
System.out.println("I am drinkin too!");
}
}
class A<T extends X & Y> {
public void display(){
XYZ x=new XYZ();
x.eat();
x.drink();
System.out.println("Type of XYZ is "+x.getClass().getName());
}
}
public class Sample1{
public static void main(String[] args) {
A<XYZ> a=new A<>();
a.display();
}
}
This means that type which argument passed to T must implement interfaces X and Y.
Like shown in the given code :-
A<XYZ> a=new A<>(); //here only XYZ(substituted in place of T) can be passed because it implements both interface X and interface Y
I hope this much helps you understand and point out the differences!!!
I would go with @shekhar suman's example, but i would change last class and main:
class A<T extends X & Y> {
public void display(T t){
t.eat();
t.drink();
System.out.println("Type of T is "+t.getClass().getName());
}
}
public static void main(String[] args) {
A<XYZ> a=new A<>();
a.display(new XYZ());
}
If there was no extends like this: Class A<T> Class A was a generic class, accepting any class T.
However in case of Class A<T extends InterfaceA & InterfaceB> T can be any class that implements both interfaceA and interfaceB.
In other words you want to make sure T is not any random class, and satisfies some conditions.
InterfaceAnotinterfaceA.