We Keep Coding

Why use exdend and implement at same time [duplicate]

The full context being:
public class RClass<T extends Comparable<T>>
Would I be right in saying that the statement in the title means that the arguments plugged into the method must either be an object of a class which implements Comparable OR one of its derived classes?
Thanks.

This means that the type parameter must support comparison with other instances of its own type, via the Comparable interface.
An example of such a class is provided in the Oracle tutorial Object Ordering. Note the similar pattern to T extends Comparable<T> in the excerpt below:
public class Name implements Comparable<Name> {
...
public int compareTo(Name n) { ... }
}

Java- The meaning of <T extends Comparable<T>>?
a) Comparable <T>
is a generic interface (remember it's an "interface" i.e not a "class")
b) extends means inheritance from a class or an interface.
From above-said point#a, it is an interface..(Remember it is an inheritance from an "interface" i.e not from a "class")
c)From above-said both points #a & #b,
here "one interface" extends "another interface".
There should be an interface defined for this class..
just an example here is
interface MinMax<T extends Comparable<T>> {
T min();
T max();
}
d) now your class i.e public class RClass {} SHOULD
1# EITHER "implement" this "generic interface" Comparable<T> ..!!!
ex: public class RClass<T> implements Comparable<T>
2# OR create an interface and extend to this "generic interface" Comparable<T>
ex:
interface MinMax<T extends Comparable<T>> {
T min();
T max();
}
class RClass<T extends Comparable<T>> implements MinMax<T> {
.....
.....
}
Here,
Pay special attention to the way that the type parameter T is declared by RClass and
then passed to MinMax. Because MinMax requires a type that implements Comparable,
the implementing class (RClass in this case) must specify the same bound. Furthermore,
once this bound has been established, there is no need to specify it again in the implements clause.

Somewhere in that class, the programmer needs to write something like
if(t.compareTo(othert) < 0) {
...
}
For that to work, the type T must have a compareTo-method which compares it to another object of type T. Extending Comparable guarantees the existence of such a method, among other things.

It means that you can only create an instance of RClass with a type which quite literally extends Comparable<T>. Thus,
RClass<Integer> a;
is acceptable, since Integer extends Comparable<Integer>, while
RClass<Object> b;
is not, since Object is not a class which extends comparable at all.

Yes, and bear in mind that objects of classes derived from Comparable ARE Comparable objects. Inheritance is a is-a relationship.

Simply put, the generic type T must be comparable in order to compareTo. otherwise you cannot do T.compareTo.
In Item 28 Effective java, it suggests: "always use Comparable<? super T> in preference to Comparable<T>. <T extends Comparable<? super T>>"

==>guhanvj, <T extends Comparable<T>> means that <T> is having upper bound of Comparable<T> objects. So <T> can have types of Byte, Character, Double, Float, Long, Short, String, and Integer classes which all implements Comparable<T> interface for natural ordering.

Java generics - what is the difference?

Consider that I have following interface:
public interface MyInterface<T extends Number>
In another class I want to declare a method like this:
public <T extends MyInterface<?>> void abc(T a);
Is this a correct way? Or maybe should I write:
public <T extends MyInterface<T>> void abc(T a);
What is the difference between these two declarations?

Some interfaces are intended to take the implementing class as the generic type.
For instance, the Comparable interface is usually implemented as:
class MyClass implements Comparable<MyClass>
because then the method
int compareTo(T o);
declared in Comparable can be used to compare an instance of MyClass to another instance of the same class.
Other interfaces have a generic parameter of a different type. For instance, List<T>, where T indicates the type of object contained within the list.
If you declare a method with:
public <T extends MyInterface<T>> void abc(T a);
then you're saying that the class T implements the interface MyInterface in the way that classes implement the Comparable interface - with themselves as the generic type. That might or might not be appropriate depending on what MyInterface actually is.
If you declare a method with:
public <T extends MyInterface<?>> void abc(T a):
then you not placing any constraint on the generic type in T's implementation of MyInterface.
The other option is
public void abc(MyInterface<?> a);
which is the simplest way to write a method that will accept any implementation of MyInterface.

How can I limit a generic data structure to allow only elements of a specific interface?

Say I want to create a generic class for storing objects, but it shall only store objects that implement a specific interface.
The interface goes something like this:
interface GenericSortedList<E> extends Iterable {
void add(E e);
E get(String key);
}
Instances of GenericSortedList shall only be allowed to contain objects that implement the interface Comparable. How'd I do this?

You can introduce an upper bound on your type parameter E.
interface GenericSortedList<E extends Comparable<E>> extends Iterable<E>
Also make sure you pass E as the type parameter to Iterable, or else it will extend the raw form of the Iterable interface.
To make it more flexible, you can put a wildcard and a lower bound on the E inside Comparable.
interface GenericSortedList<E extends Comparable<? super E>> extends Iterable<E>
This way, a superclass
class Foo implements Comparable<Foo>
and its subclass
class Bar extends Foo
can fit E's restrictions.

Basically:
interface GenericSortedList<E extends Comparable> extends Iterable {
void add(E e);
E get(String key);
}

Java generics extends syntax

Can someone please explain me this class definition statement
public class BinarTree<Type extends Comparable<Type>> {...
I completely understand the purpose of it but not the syntax. According to me it should be just
public class BinarTree<Type extends Comparable> {...
What's the meaning of
<Type extends Comparable<Type>> ?
^^^^

Comparable is a generic interface. The reason behind that is to avoid casting to a specific type in the Comparable#compareTo(...) method.
So if a Type extends Comparable<Type> this would mean that the Type will derive a method with signature
public int compareTo(Type t1)
instead of
public int compareTo(Object o1)

The interface Comparable is itself a template.
So what you have there is a template with a parameter that must extend a template.
And specifically it must extend a template that received the extending class as a parameter.
Comparable is a template for interfaces that implement an order relationship and implement the method int compareTo(TYPE o).
So it's normal to define a class:
class FooBar implements Comparable<FooBar> {...
A binary tree wouldn't work for a class that was declared:
class FooBar implements Comparable<Snafu> {...
That's because you would be able to compare FooBars to Snafus but not each other.

In
public class BinarTree<Type extends Comparable>{...
Type can be any Comparable, also Comparable<Integer> or Comparable<OtherType>. If this is what you want, it is fine. Most times, I think you know what you want to compare exactly, so specialize the Comparable to Comparable<Type>

Wildcards as method attributes in java

Is it possible to use wildcards as an attribute itself and not as a type parameter?
public void doSomething(<? extends Context> myObject){
}
I want to make sure that my object extends Context and also implements a certain interface.
Using wildcards as a return type is valid but using it as an attribute seems to not work
public <? extends MyClass> validMethod(){
}

Yes it's possible, you have to define it before the return type.
public <T extends MyClass> void myMethod(T param);

You don't explicitly state (for your case) which is the interface and which is the class, but if you wanted to have a generic type bound to both extending a class and an interface, this would be the general form for it.
public <T extends Number & Comparable<T>> T findNumber(List<T> elements) { }
Number is an abstract class; Comparable is an interface. I believe what you have to specify them in this order - concrete before interface.