Co and contravariance

[Pho Tek]

Is co- and contravariance a concept related to inheritance or can it apply to normal method parameters ?

e.g.

class Food{}
class Grass extends Food {}
class Antelope extends Food {}
 
public class Main2 
{
    public static void main(String[] args) {
        Main2.eat( new Food() );
        Main2.eat( new Grass() );
        Main2.swallow( new Food() ); // compile-time error
        Main2.swallow( new Grass() );
    }
    public static void eat( Food f ) {}
    public static void swallow( Grass f ) {}
}

So I get a compile-time error because the method parameters to swallow is covariant i.e. it only accepts Grass and its subtypes.

Am I correct in my reasoning ? Thanks

[Sunny Jain]

although legally it should accept Grass and its subtype..!!
but consider the following case:

Food f_ = new Grass();

here actual object is of type Grass..
so in this case:
Main.swallow(f_) should work..but compiler give you complaint..!!

but this is correct..in order to avoid such condition..Java has a concept called upcasting

so compiler will allow following to work:

Main2.swallow((Grass)f_);

now it works finally..but delima is..
if Food f_ = new Food();

Then also it will work fine..!! at this time it will give you run time exception..!! ClassCastException..!!

[Pho Tek]

Well let's supposed that casting of any sort is disallowed.
Then the parameter is covariant.

However if the parameter type is a generic type & the method is a generic method; then it is contravariant.
I'm thinking out loud here - and would appreciate some feedback/correction.
e.g.

public class ContravariantParams
{
    public static <T> void boo( T t, Collection<T> c )
    {
        c.add( t );
    }
 
    public static void main(String[] args)
    {
        List<Number> nums = new ArrayList<Number>();
        ContravariantParams.boo( Integer.valueOf(1), nums );
 
        List<Integer> ints = new ArrayList<Integer>();
        ContravariantParams.boo( Integer.valueOf(1), ints );
    }
}