Interfaces, factories and Generics

Question

I'm used to a declaration/implementation programming style
where the declaration suggests a default implementation,
a so called object factory.
Unfortunatelly I do not know how to extend this style to Generics.
Please look at the example below.
The declaration and the implementation are fine to -Xlint:unchecked.
But: regardless how I use it, it will not compile without warnings.
Any idea how to change the code in order to keep the style?
Example:
the declaration:
================
package de.toolsprofi.example.factory;
public interface Thing<T> {
public T get(); public void set( T t );
public class Factory {
public static Thing newInstance() {
return new de.toolsprofi.example.factory.impl.Thing();}}}
the implementation:
===================
package de.toolsprofi.example.factory.impl;
public class Thing<T> implements de.toolsprofi.example.factory.Thing<T> {
public Thing() {this.t=null;}
private T t;
public T get() {return t;} public void set( T t ) { this.t = t; }}
the usage:
==========
package de.toolsprofi.example.factory.use;
import de.toolsprofi.example.factory.Thing;
public class Use {
public void use1() {
Thing<String> thing = Thing.Factory.newInstance();
thing.set( "bar" );}
public void use2() {
Thing thing = Thing.Factory.newInstance();
((Thing<String>)thing).set( "foo" );}
public void use3() {
Thing<String> thing = (Thing<String>)(Thing.Factory.newInstance());
thing.set( "bar" );}}

Answer 1

Thank you, Yay. I havn't thought about using abstract classes. So I'm not sure if I understand your suggestion right. I will experiment with that incitation. Jet it seems to me that I just have to drop the static in the declaration and change the rule for factory usage in order to gain a default implemention:
//===declaration package
package declare;
public interface Thing<T> {
    public T get(); public void set( T t );
    public class Factory<T> {
        public Thing<T> newInstance() {
            return new de.toolsprofi.example.factory.impl.Thing<T>();
//===default implementation package
package declare.impl;
public class Thing<T> implements declare.Thing<T> {
    public Thing() {this.t=null;}
    private T t;
    public T get() {return t;} public void set( T t ) { this.t = t; }
//=== some usage package
package use;
import declare.Thing;
public class Use {
    public void use() {
        Thing<String> thing = new Thing.Factory<String>().newInstance();
        thing.set( "hi" );
}