问一个基础问题,怎么在参数中传递类类型

Question

类结构是这样
基类为WINDOW
继承类为SUBWINDOW1与继承类为SUBWINDOW2
问题：
我想做一个通用的函数，来实现给dotest一个参数，例如该参数是SUBWINDOW1，该函数内就创建SUBWINDOW1的一个实例。SUBWINDOW2类似。请问怎么写
protected void doTest(WINDOW){
    SUBWINDOW1 sb=new SUBWINDOW1()}
dotest(SUBWINDOW1)

Answer 1

protected void doTest(SUBWINDOW1 w1){
    SUBWINDOW1 sb=new SUBWINDOW1()
}protected void doTest(SUBWINDOW2 w2){
    SUBWINDOW2 sb=new SUBWINDOW2()
}方法重构
不要定义
protected void doTest(WINDOW){
}
这个方法

Answer 2

public class Window {
public void dotest(Window w) {
if(w instanceof SubWindow1) {
SubWindow1 s1 = new SubWindow1();
} else if(w instanceof SubWindow2) {
SubWindow2 s2 = new SubWindow2();
}
}
}

Answer 3

或者用 instanceof 关键字protected void doTest(WINDOW win){
if (win instanceof SUBWINDOW1) {
SUBWINDOW1 sb=new SUBWINDOW1();
} else if (win instanceof SUBWINDOW2) {
SUBWINDOW2 sb=new SUBWINDOW2();
}
}

Answer 4

条件
基类为WINDOW
继承类为SUBWINDOW1与继承类为SUBWINDOW2

Answer 5

用这些RTTI的东西，逐一对比，类一多写N个if 

Answer 6

用泛型+Class对象可以package csdn;class Window {    public void printType() {
        System.out.println("It's Window");
    }}class SubWindow1 extends Window {    public void printType() {
        System.out.println("It's SubWindow1");
    }}class SubWindow2 extends Window {    public void printType() {
        System.out.println("It's SubWindow2");
    }}public class WindowTest {    /**
     * 你要的doTest函数
     * 
     * @param <T>
     * @param clazz
     */
    public static <T extends Window> void doTest(Class<T> clazz) {
        try {
            Window win = clazz.newInstance();
            win.printType();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }    public static void main(String[] args) {
        doTest(Window.class);
        doTest(SubWindow1.class);
        doTest(SubWindow2.class);
    }
}

Answer 7

这个涉及到了设计模式一些理念，可以参考多个设计模式的思想
可以使用Composite模式，或者Decorator模式的设计方式
当然也可以自己使用反射方式来判断参数的具体类型

Answer 8

如果参数是对象用getClass取到Class对象先：
    /**
     * 你要的doTest函数
     * 
     * @param <T>
     * @param clazz
     */
    public static <T extends Window> void doTest(T win) {
        try {
            Window newWin = win.getClass().newInstance();
            newWin.printType();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }    public static void main(String[] args) {
        doTest(new Window());
        doTest(new SubWindow1());
        doTest(new SubWindow2());
    }

Answer 9

嗯，blazingfire老大比较符合我的要求，thx

Answer 10

嗯，参数应该是class of object类型，即类类型，谢谢了

Answer 11

有个问题需要继续问一下package csdn;class Window {
 
}class SubWindow1 extends Window {
public  static void printType() {
System.out.println("It's SubWindow1");
}
}class SubWindow2 extends Window {
public  static void printType() {
System.out.println("It's SubWindow2");
}
}public class WindowTest {
/**
 * * 你要的doTest函数 * *
 * 
 * @param <T> *
 * @param clazz
 */
public static <T extends Window> void doTest(Class<T> clazz) {
try {
//是静态函数如何调用？

} catch (Exception e) {
e.printStackTrace();
}
} public static void main(String[] args) {
doTest(SubWindow1.class);
}
}

Answer 12

静态函数调用？类名.方法名以前写过一个通用DAO类，也用到过这种传递类类型的参数。

Answer 13

给你个提示//===================================Window==================================
package com.csdn;import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;public abstract class Window {

static Window doTest(String className) throws ClassNotFoundException,
SecurityException, NoSuchMethodException, IllegalArgumentException,
InstantiationException, IllegalAccessException,
InvocationTargetException {
Class<?> obj = Class.forName(className);
Class<?>[] parameterType = null;
Constructor co = obj.getConstructor(parameterType);
Object[] initArgs = null;
Window d = (Window) co.newInstance(initArgs);
return d;
} abstract void testPrint();
}//===========================================
package com.csdn;public class SubWindow extends Window { void testPrint(){
System.out.println("aaa");
}
}//===========================================
package com.csdn;public class SubWindow2 extends Window {
@Override
void testPrint() {
// TODO Auto-generated method stub
System.out.println("bbb");
}
}//========================test===================
package com.csdn;public class Test {

/**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
Window.doTest("com.csdn.SubWindow").testPrint();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

Answer 14

这又是何必呢，都new出来了，直接用呗

Answer 15

收到你的消息了。如果static 方法在window基类，那就用你new出的对象直接调用呀（就是有一个warnings）。如果要调用之类的static方法可能就要反射了,因为静态方法不能覆盖。package csdn;class Window {    public void printType() {
        System.out.println("It's Window");
    }    public static void printType2() {
        System.out.println("static printType2 It's Window");
    }}class SubWindow1 extends Window {    public void printType() {
        System.out.println("It's SubWindow1");
    }    public static void printType2() {
        System.out.println("static printType2 It's SubWindow1");
    }}class SubWindow2 extends Window {    public void printType() {
        System.out.println("It's SubWindow2");
    }    public static void printType2() {
        System.out.println("static printType2 It's SubWindow2");
    }
}public class WindowTest {    /**
     * 你要的doTest函数
     * 
     * @param <T>
     * @param clazz
     */
    public static <T extends Window> void doTest(Class<T> clazz) {
        try {
            Window win = clazz.newInstance();
            clazz.getMethod("printType2").invoke(null);
            win.printType();
            System.out.println();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }    public static void main(String[] args) {
        doTest(Window.class);
        doTest(SubWindow1.class);
        doTest(SubWindow2.class);
    }
}