How to force type on return value in a generic class?

Let's say I have a generic class:

public final  class MyClass<T> {
    private List<T> list;

    public MyClass(){

    }
}

Two questions:

I want to force the user to create a generic return type as well, this is why I created a generic class but apparently he can do this:

MyClass item = new MyClass();

and also this:

MyClass item = new MyClass<Customer>();

I want to force the developer to define their return type with the same type they supplied so they would only be able to do:

MyClass<Customer> item= new MyClass<Customer>();

The purpose of this class is to get a type in the constructor, let's say class Customer, and create a generic list of that type but since the return object is passed between the application layer I want to force it to have a signature MyClass<Customer> so its easy to understand the type of list it contains.

As already mentioned in the comments, for backwards compatibility reasons generics are not forced.

If you ask the type class as constructor parameter your developers will have to think of a type:

private static class MyClass<T> {
    private List<T> list;

    public MyClass(Class<T> clazz){

    }
}

public static void main(String args[])
{
	MyClass myclass=new MyClass(Object.class);
}

But as you can see, they can always pass Object

> The purpose of this class is to get a type in the constructor, let's say class Customer, and create a generic list of that type...

No, you don't need this as the developer of MyClass. You can safely do something like this in your code (and it has nothing to do with whether the caller will use the raw MyClass type):

public final  class MyClass<T> {
    private List<T> list;

    public MyClass(){
    	this.list = new ArrayList<>();
    }
}

Beside the fact that Java allows this for good (and practical) reasons, your type parameter being unbounded simply suggests that you yourself don't care much either (Java uses Object by default when MyClass is used instead of MyClass<Something>).

If, however, what you're looking for is dynamic behavior based on the type, like instantiating elements dynamically, then the best is to take the class instance itself from your caller:

public final  class MyClass<T> {
	private Class<T> type;
    private List<T> list;

    public MyClass(Class<T> type){
    	this.type = type;
    	this.list = new ArrayList<>();
    }

    //then use type to perform your dynamic behavior on the element type
}

This will force your callers to send a type, therefore making it almost pointless for them to use the raw type. But you should have a reason to do this too.