Why does this show error when I write MyConsumer<String> implements Consumer<String>?

class MyConsumer<String> implements Consumer<String>{
    @Override
    public void accept(String s){
        System.out.println("hello".toUpperCase());
        System.out.println(s.toUpperCase());
    }
}

gives error:

ConsumerTest.java:22: error: cannot find symbol
System.out.println(s.toUpperCase());
^
symbol: method toUpperCase()
location: variable s of type String
where String is a type-variable:
String extends Object declared in class MyConsumer

this doesn't give error:

class MyConsumer implements Consumer<String>{
    @Override
    public void accept(String s){
        System.out.println("hello".toUpperCase());
        System.out.println(s.toUpperCase());
    }
}

Why can anyone explain?

You are implementing the Consumer interface shown below:

/**
 * Represents an operation that accepts a single input argument and returns no
 * result. Unlike most other functional interfaces, {@code Consumer} is expected
 * to operate via side-effects.
 *
 * <p>This is a <a href="package-summary.html">functional interface</a>
 * whose functional method is {@link #accept(Object)}.
 *
 * @param <T> the type of the input to the operation
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Consumer<T>

This interface has a type parameter called T. To implement this interface one has to specify what the type parameter stands for. For example you can specify that you want to implement it with a String type parameter:

class MyConsumer implements Consumer<String>

Here the <String> means the type parameter T of Consumer is assumed at compile time to be a String.

Hence the overidden accept method has a String parameter:

@Override
public void accept(String s){
    System.out.println("hello".toUpperCase());
    System.out.println(s.toUpperCase());
}

This is all fine but when you do this:

class MyConsumer<String> implements Consumer<String>

You are introducing a new type parameter for the MyConsumer class, confusingly called 'String'. Now Consumer<String> is no longer specifying the String class, but referring to the new type parameter. You get the same situation as this:

class MyConsumer<S> implements Consumer<S>{
    @Override
    public void accept(S s){
        System.out.println("hello".toUpperCase());
        System.out.println(s.toUpperCase()); // compilation error
    }
}

So this becomes a generic class, for which the type parameter still needs to be defined. Hence the compiler cannot match s.toUppercase().

You can prove this by fully qualifying the references to the String class:

public class MyConsumer<String> implements Consumer<java.lang.String> {
    @Override
    public void accept(java.lang.String s){
        System.out.println("hello".toUpperCase());
        System.out.println(s.toUpperCase());
    }
}

(this compiles)

Your class declares its own type <String>, which is why without it there is no error:

class MyConsumer implements Consumer<String> { ...

The first occurrence of String in this declaration...

class MyConsumer<String> implements Consumer<String>

...is just the name of a type parameter of MyConsumer. String in class MyConsumer<String> does not refer to java.lang.String. After all, this is syntactically the same as:

class MyConsumer<T> implements Consumer<String>

Then, in the accept method, you used String as the parameter type. This String also does not refer to java.lang.String. It instead refers to the type parameter named String you just declared. java.lang.String is said to be shadowed by the type parameter String.

> Some declarations may be shadowed in part of their scope by another declaration of the same name, in which case a simple name cannot be used to refer to the declared entity.
>
> A declaration d of a type named n shadows the declarations of any other types named n that are in scope at the point where d occurs throughout the scope of d.

Since you want a consumer that consumes a java.lang.String, your class doesn't need to be generic.

If you actually want your class to be generic, and want to use String as the type parameter name for some weird reason, you should use the fully qualified name, java.lang.String, when declaring the parameter of accept.

@Override
public void accept(java.lang.String s){
    ...
}

In the first example String is just a "type name", just like T, K, V or so. During the compilation it becomes Object which does not have method toUpperCase. You should read about type erasure. In the second example you are telling the compiler that the type should be a String, so no problems in here.