问一个关于继承和泛型的问题

Question

看代码吧class SuperClass
{
    public boolean copy(SuperClass dst, SuperClass src){return true;}
}
class A extends SuperClass
{
    String s;
    public boolean copy(A dst, A src)
    {
         dst.s = src.s;
         return true;
    }
    public A(){s="";}
}
class C<T extends SuperClass>
{
    public void test()
    {
        T a = new T();
        T b = new T();
        a.copy(a, b);
    }
    public C(){}
}
class Test
{
    C<A> ca = new C<A>();
    ca.test(); 
}我想要实现的效果是执行test函数时可以根据ca的类型自动执行该类型的copy函数，我知道现在这样的代码是不对的，哪位高人能指点下应该怎么改能实现我要的效果呢。

Answer 1

上面笔误啦，是根据<T>的类型，呵呵

Answer 2

 T a = new T();
        T b = new T();没有T这个类，你怎么用T来new实例呢？？？

Answer 3

public void test(T a, T b)
    {
        a.copy(a, b);
    }

Answer 4

package com.johnston;public class Test { public static void main(String[] args) {
// TODO Auto-generated method stub
C<A> ca = new C<A>();
    ca.test(); 
}}
class SuperClass
{
    public boolean copy(SuperClass dst, SuperClass src){return true;}
}
class A extends SuperClass
{
    String s;
    public boolean copy(A dst, A src)
    {
         dst.s = src.s;
         return true;
    }
    public A(String name){s=name;}
}
class C<T extends SuperClass>
{

    public void test()
    {
        A a = new A("a");
        A b = new A("b");
       
        a.copy(a, b);
        System.out.println("a:" + a.s + "\nb:" + b.s);
    }
    public C(){}
}运行结果：
a:b
b:b你写得代码不太规范，没有把相关的意思表达出来，
你再想想

Answer 5

看不大明白
用  obj instanceof Class ? 

Answer 6

谢谢johnston提醒，前面急匆匆写的，确实很多错误，现在改一下        public class Test { 
    public static void main(String[] args) { 
    // TODO Auto-generated method stub 
        C <A> ca = new C <A>(); 
        ca.test();
    }  } 
class SuperClass 
{ 
    public boolean copy(SuperClass dst, SuperClass src){System.out.println("i'm from superclass");return true;} 
} 
class A extends SuperClass 
{ 
    String s; 
    public boolean copy(A dst, A src) 
    { 
        dst.s = src.s;
                System.out.println("i'm from A")
        return true; 
    }
    public A(String name){s=name;} 
} 
class C <T extends SuperClass> 
{      public void test() 
    { 
        T a = (T)(new A("a"));//这里用强制转换是因为知道T和A是同一种类型，因为我的程序里new A("a")原本是一个和T有关的函数，返回类型是T
        T b = (T)(new A("b"));
        a.copy(a, b);  
    } 
    public C(){} 
} 我知道这段代码问题在哪里，因为a的类型限制了只能访问到基类的copy函数，我只是想用它来说明我想要实现的效果，就是基类中有一个函数的参数类型为该基类本身，然后继承类中也有同名的该函数，参数类型为继承类本身，有什么办法能实现类似多态的效果，用基类的引用指向某一个对象，根据对象的类型自动调用该名字的函数呢（因为参数类型不同所以和一般的多态不一样）。当然你可能会建议我在继承类中的函数也使用基类类型，但这是不行的，因为继承类中的函数我还想访问继承类自己的方法和成员，所以，有谁有好办法呢

Answer 7

我根据你的问题重写了一下,
你看看对你有没有帮助,代码如下:/**
 * 关于继续与泛型的简单应用
 * 实现的效果是执行test函数时可以根据JavaGeneric<SubClass>的SubClass类型自动执行该类型的copy函数
 * 泛型的主要作用就是为了更加安全,不需要进行相关的强制类型转换
 * 因为强制类型转换有时会使程序发生转换错误
 */
package com.johnston;/**
 * 泛型测试类
 * @author johnston
 * 
 * @version 2009-05-31
 */
public class JavaGenericTest<T extends SuperClass> { public static void main(String[] args) {
SubClass sc1 = new SubClass("a");   //子类对象sc1 
SubClass sc2 = new SubClass("b");     //子类对象sc2
JavaGeneric<SubClass> jgsub = new JavaGeneric<SubClass>(new SubClass("a")); //泛型对象jgsub
jgsub.test(sc1, sc2);

SuperClass superc1 = new SuperClass("super1");
SuperClass superc2 = new SuperClass("super2");
JavaGeneric<SuperClass> jgsuper = new JavaGeneric<SuperClass>(new SuperClass("a")); //泛型对象jgsuper
jgsuper.test(superc1, superc2);
}
}/**
 * 父类
 * @author johnston
 *
 */
class SuperClass {
String s;
//与子类操作区别开,父类操作不进行copy操作,执行清空操作
    public boolean copy(SuperClass dst, SuperClass src) {
     System.out.println("父类操作(清空操作):");
     dst.s = "";
     src.s = "";
     return true;
    } public SuperClass(String s) {
super();
this.s = s;
}
    
}
/**
 * 子类,要重写父类的方法,重写时所有参数都应该相同,否则就不是重写
 * @author johnston
 *
 */
class SubClass extends SuperClass {
String s;
@Override
public boolean copy(SuperClass dst, SuperClass src) {
System.out.println("子类操作(复制操作):");
dst.s = src.s;
return true;
}

public SubClass(String s) {
super(s);
this.s = s;
}

}
/**
 * 泛型类
 * @author johnston
 *
 * @param <T> 对应子类的类型
 */
class JavaGeneric<T extends SuperClass> {
private T t;
public JavaGeneric(T t) {
super();
this.t = t;
}
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
public void test(T sc1, T sc2) {
this.t.copy(sc1, sc2);
System.out.println("sc1:" + sc1.s + "\nsc2:" + sc2.s);
}
}

Answer 8

上面程序运行结果如下：
子类操作(复制操作):
sc1:b
sc2:b
父类操作(清空操作):
sc1:
sc2:

Answer 9

看看<<Head First Java>>里的泛型就明白了

Answer 10

先谢谢楼上几位的帮助。
不过我觉得我的问题还是没解决，我详细描述下我遇到的问题吧。
我现在在做一个jdo的数据库的程序，会出现很多实体类，他们各自有各自的成员和方法，我想做的就是赋予每个类一个copy方法，该方法能把该类中所有的成员都进行一次拷贝，这就决定了每个类的copy的参数类型肯定是不同的（基类没办法包含所有继承类的成员），但我又想以一种统一的方式（类似多态）去调用该copy函数，用泛型只是我觉得可能可以实现的一种途径而已，只要能达到目的并不一定局限于用泛型的方法。

Answer 11

我自己解决了，还是用泛型的方法，贴一下吧，或许有人需要。public class Test { 
        public static void main(String[] args) { 
        // TODO Auto-generated method stub 
            C <SubClass> ca = new C <SubClass>(); 
            ca.test();
        }     } 
    class SuperClass<T> 
    { 
        public boolean copy(T dst, T src){System.out.println("i'm from superclass");return true;} 
    } 
    class SubClass extends SuperClass<SubClass> 
    { 
        String s; 
        public boolean copy(SubClass dst, SubClass src) 
        { 
            dst.s = src.s;
            System.out.println("i'm from SubClass");
            return true; 
        }
        public SubClass(String name){s=name;} 
    } 
    class C <T extends SuperClass<T>>    {         public void test() 
        { 
            T a = (T)(new SubClass("a"));//这里用强制转换是因为知道T和SubClass是同一种类型，因为我的程序里new SubClass("a")原本是一个和T有关的函数，返回类型是T
            T b = (T)(new SubClass("b"));
            a.copy(a, b);        } 
        public C(){}
    }