Java泛型求解

Question

本帖最后由 leisore 于 2010-11-24 17:50:21 编辑

Answer 1

/// 处理器接口
interface Process<IN, OUT> {
    OUT process(IN r);
}// 处理器工厂接口
interface IProcessFactory {
    Process<? extends Serializable, ? extends Serializable> getProcess();
}// 处理器工厂
class ProcessFactory implements IProcessFactory {
    ProcessFactoryProxy proxy = new ProcessFactoryProxy();    public Process<? extends Serializable, ? extends Serializable> getProcess() {
        return proxy.getProcess();
    }
}//处理器工厂代理
class ProcessFactoryProxy implements IProcessFactory {
    public Process<? extends Serializable, ? extends Serializable> getProcess() {
       // 问题：编译器error
        // Type mismatch: cannot convert from StringProcess to Process<? super Serializable,? super Serializable>
        return new StringProcess();
    }
}// 处理器一个实现类
class StringProcess<IN, OUT> implements Process<IN, OUT> {    public OUT process(IN r) {
        return null;
    }
}
不如改成这试试

Answer 2

/// 处理器接口
interface Process<IN, OUT> {
    OUT process(IN r);
} // 处理器工厂接口
interface IProcessFactory {
    Process<? super List, ? super List> getProcess();
} // 处理器工厂
class ProcessFactory implements IProcessFactory {
    ProcessFactoryProxy proxy = new ProcessFactoryProxy();     public Process<? super List, ? super List> getProcess() {
        return proxy.getProcess();
    }
} //处理器工厂代理
class ProcessFactoryProxy implements IProcessFactory {

    public Process<? super List, ? super List> getProcess() {
        // 问题：编译器error
        // Type mismatch: cannot convert from StringProcess to Process<? super Serializable,? super Serializable>
        return new StringProcess();
    }
} // 处理器一个实现类
class StringProcess implements Process<List, List> { public ArrayList process(List r) {
return null;
}
}
楼主你理解错了这两中是什么意思？
"? super T"和"? extends T",都是java泛型通配符,而用法又有区别,
还有super 和extends 不是java类关系中的超类和继承的意思,他是通配符的下限和上限限制.这样你就知道为什么，1楼的和我的就可以了。

Answer 3

/// 处理器接口
    interface Process<IN, OUT> {
        OUT process(IN r);
    }    // 处理器工厂接口
    interface IProcessFactory {
        Process<? super AbstractList, ? super AbstractList> getProcess();
    }    // 处理器工厂
    class ProcessFactory implements IProcessFactory {
        ProcessFactoryProxy proxy = new ProcessFactoryProxy();        public Process<? super AbstractList, ? super AbstractList> getProcess() {
            return proxy.getProcess();
        }
    }    //处理器工厂代理
    class ProcessFactoryProxy implements IProcessFactory {
        
        public Process<? super AbstractList, ? super AbstractList> getProcess() {
        // 问题：编译器error
            // Type mismatch: cannot convert from StringProcess to Process<? super Serializable,? super Serializable>
            return new StringProcess();
        }
    }    // 处理器一个实现类
    class StringProcess implements Process<AbstractList, AbstractList> {        public ArrayList process(AbstractList r) {
            return null;
        }
        //这个就不对了。
//        public List process(AbstractList r) {
//            return null;
//        }
    }
这个例子比较好说明这点上限

Answer 4

你那return的是StringProcess而函数所Process类型的

Answer 5

为什么IN不可以是ArrayList呢，而OUT可以是呢
即为什么不可以是这样：class StringProcess implements Process<List, List> {
public ArrayList process(ArrayList r) {
return null;
}
}继续请教

Answer 6

自己临时解决办法，使用？通配符，如下：public class MyTest {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
Process<String, String> process = (Process<String, String>)new ProcessFactory().getProcess();
System.out.println(process.process("123"));
}
}// 处理器接口
interface Process<IN, OUT> {
OUT process(IN r);
}// 处理器工厂接口
interface IProcessFactory {
Process<?, ?> getProcess();
}// 处理器工厂
class ProcessFactory implements IProcessFactory {
ProcessFactoryProxy proxy = new ProcessFactoryProxy(); @Override
public Process<?, ?> getProcess() {
return proxy.getProcess();
}
}// 处理器工厂代理
class ProcessFactoryProxy implements IProcessFactory {
@Override
public Process<?, ?> getProcess() {
return new StringProcess();
}
}// 处理器一个实现类
class StringProcess implements Process<String, String> { @Override
public String process(String r) {
return r;
}
}

Answer 7

? extends A 
上限：表示只能放入 A 或A的子类
? super A
下限：表示只能放入 Object 到 A 的类，不能是A的子类

Answer 8

说错了。。更正class A{}
class B extends A{}
class C extends B{}public class GenericTest {
public static void main(String[] args) { List<? extends A> list = new ArrayList<A>();//创建通过由于 子类不确定 添加其它任何类型都会错误 
list.add(null);//可以添加
list.add(new Object());//错误
list.add(new A());//错误
List<? super A> list2 = new ArrayList<A>();
list2.add(null);
list2.add(new Object());//错误
list2.add(new A());
list2.add(new B());
list2.add(new C());
}
}