已知一类名存在一String中，现有一Object 对象，如何把这Object对象强制转换为String中的类类型？
(Class.forName(typeString))(theObject)试过了，不行


注意： 各位马友，不要误解题目 ！ ！细看...........
[ 本帖最后由 sps457 于 2011-07-21  14:52 编辑 ]

Object 默认的toString 方法返回的是对象的地址，重写类的toString ()方法，然后调用就是了。
例子
package com.heima.forumAns;

public class XXXObject {
        /****************成员变量和访问器***********************/
        private String name;
        private int age;
        private String address;
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
        public int getAge() {
                return age;
        }
        public void setAge(int age) {
                this.age = age;
        }
        public String getAddress() {
                return address;
        }
        public void setAddress(String address) {
                this.address = address;
        }
        /***************构造方法**************/
        public XXXObject(String name, int age, String address) {
                super();
                this.name = name;
                this.age = age;
                this.address = address;
        }
        /**************重写toString()方法*************************/
        @Override
        public String toString() {
                return "XXXObject [name=" + name + ", age=" + age + ", address="
                                + address + "]";
        }
        public static void main(String[] args) {
                XXXObject xxxObject = new XXXObject("zhangsan",15,"beijing");
                System.out.println(xxxObject.toString());
        }
}
打印结果：XXXObject [name=zhangsan, age=15, address=beijing]
[ 本帖最后由 杨志罡 于 2011-07-21  04:02 编辑 ]

嗯嗯  学习了 谢谢

沙发童鞋，估计是误解题目了。
   题目并没有说让你按某种形式输出类，即重写toString方法。而是说已知一个字符串是一个类的类名，暂时将此类记作类A。如何才能将另外一个类（B）强制类型转化为此类（A）。
如果是平时我们会这样写：（A）new B（）；但是关键是，这里的A是一字符串，并不是类A。

向下转型，是有前提的。
前提：Object obj = new Person();
之后才可以执行：Person p = (Person )obj;
若obj本质上不是Person类型的，执行强制类型转换的时候，会抛ClassCastException异常。

对象类型转换时，“必须先存在向上转型，才可以进行向下转型”。

楼主说，楼主列出来的那种转换的方法不行，那么您可以把您的代码，完整的贴出来吗？
[ 本帖最后由 cxy_zy 于 2011-07-21  12:58 编辑 ]

基础测试类，只是提供数据测试用。[code]package com.test;

public class DemoTest {
        private String name = "zxx";
       
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }

}[/code]下面为核心代码类。[code]package com.test;
/**
*
* 类说明：在仅知道一个类的名字的基础上，获得该类，并调用该类的方法.
* 作者：test
* 版本：v1.0
* 修改历史：
*/
public class Demo {

        /**
         * @param args
         * @throws ClassNotFoundException
         * @throws IllegalAccessException
         * @throws InstantiationException
         */
        public static void main(String[] args) throws Exception {
                // TODO Auto-generated method stub
               
                /**下面首先通过反射获得类**/
                String className="com.test.DemoTest";
                Object obj= Class.forName(className).newInstance();
               
                /***下面编译错误 ！！！ 不能将Object转化为DemoTest**/
                System.out.println((Class.forName(className))obj.getName());
        }

}[/code]不知各位马友，谁有解决方案 ？

调试，你可以设置断点，然后监视你那个Object返回的类型，但是你可以在监视中看到它所返回的准确类型，然后再转换成你想要的类型。 也可以使用Convert.ToString(Object obj)方法，这个方法不会抛出任何异常，不过好像效率不是很高。通常都可以得到你想要的值。obj.ToString、(string)obj、obj as string。这个几个也可以。不过用强制转换(string)obj要求obj的运行时类型必须是string。如果不是，就会抛出异常。用as方法则会相对平稳，当obj的运行时类型不是string时会返回null而不抛出异常。

用时：2小时。
问题状况评价：基本解决（个人意见）。[code=java]package test;


public class Demo {

      
        public static void main(String[] args) throws Exception {
                // TODO Auto-generated method stub
               
                /**下面首先通过反射获得类**/
                String className="test.DemoTest";
                Object obj= Class.forName(className).newInstance();
               
               
               // obj.getName();
                System.out.println(obj instanceof DemoTest);
               
                        
                                               
                //System.out.println((Class.forName(className))obj.getName());
               
               
               
                Class clazz = Class.forName(className);// clazz 只是一个DemoTest类的一个字节码对象的引用，它可以生成DemoTest类的对象，但无法产生 class DemoTest（对象是由类产生的）。
                System.out.println(clazz.getName().length());
               String leiming = clazz.getName().substring(clazz.getName().lastIndexOf('.')+1,clazz.getName().length());
               
                //System.out.println((leiming)obj); //拿到了类名也没有用，因为它只是一个字符串
               System.out.println((DemoTest)obj);//此时在obj后面加"."但点不出getName()方法。
               System.out.println(((DemoTest)obj).getName()); //这时可以，(DemoTest)obj)，把他们包括起来，是告诉编译器，先把obj转换成DemoTest，再让obj参与下一步的操作
               System.out.println((Class.forName(className))==Object.class); //false
               System.out.println((Class.forName(className))==obj.getClass());//true ,说明obj的Class是有加载DemoTest时产生的
               
               
               /*
                * Object obj= Class.forName(className).newInstance();
                * 等式左边的含义：声明一个Object 的对象变量obj
                * 等式右边的含义：生成一个DemoTest对象
                * "="赋值号 的意义：把右边的Demot对象的内存地址赋值给左边的Object对象引用obj ，obj装的是子类的内存地址        -------（Object类是一切类的超类）
                * (DemoTest)obj---------> 这是一种强制转换表达式，是父类Object的引用obj向下转换为子类DemoTest的引用，这相当于对编译器说了一句话，哥们，这东西本属于我的，我现在要拿回来。
对象类型的转换，括号里面的必须是一个类，即class。基本数据类型的转换有点不一样，但思想基本是同的。
                *
                * 经过上面一步后，obj就可以调出getName()方法了。
                *
                * (clazz)obj  ---->这为什么转不了呢，因为clazz只是一个引用，一个内存地址值。如果Class类能产出class DemoTest，那么就有可能装换成功。
                *
                * 其实，new对象的时候，返回给我们的只是该对象的内存地址，我们无法直接操作该对象，因为该对象存在与计算机内存中的某个地方，你看不见它，也莫不着它，你想操作它，只能根据它返回的那个引用。
                *
                *
                *
                */
                //下面是基本数据类型的自然转换（低精度向高精度）与强制类型转换（高向低---如：高赋值给低）
                int i = 5;
                double j = i;
               
                double k = 10 ;               
               // i =  k; //报错：高精度的数据想赋值给低精度时，需要把它强制性的行低精度转换。
                //这好比高高在上的父类要向下面的子类转换时，你必须指明子类的具体的类型，否则父类那么多的子类，父类的引用不知道转换成哪个子类。
                i = (int)k;//这样才正确。
               
               
               
               
               
        }

}[/code]以下为参考资料：父类与子类，数据类型转换[code=java]Java 语言的多态性机制导致了引用变量的声明类型和其实际引用对象的类型可能不一致，在结合虚方法调用规则可以得出下述结论：声明为同种类型的两个引用变量调用同一个方法时，也可能会有不同的行为。为更准确的鉴别一个对象的真正类型，java语言引入了instanceof操作符，其使用格式为：<引用类型变量>instanceof<引用类型>
这是boolean类型的表达式，当instanceof左侧的引用类型所引用的对象的实际类型是其右侧给出的类型或其子类类型时，整个表达式的结果为true，反之为false。
案例名称：instanceof关键字的使用
程序名称：InstanceOfTest.java
class Person2 extends Object{}
class Student2  extends Person2{}
class Worker extends Person2{}
public class InstanceOfTest {
        public void method(Person2 e){
                if(e instanceof Person2){
                        System.out.println("this is Students");
                }
                else if(e instanceof Worker){
                        System.out.println("this is Worker");
                }
                else{
                        System.out.println("this is a Person");
                }
        }
        public static void main(String[] args) {
                InstanceOfTest t=new InstanceOfTest();
                Worker w=new Worker();
                t.method(w);
        }
}
程序解释：InstanceOfTest类的method1方法，根据传入的不同对象确定调用不同的语句，java基本类型的相互转换，包括自动类型转换和强制类型转换机制，java引用类型数据也存在类似的机制。
○1默认类型转换：子类类型的数据可以直接赋值给父类类型的引用变量。
○2强制类型转换：也称为对象造型，父类类型的数据可以被强制转换为其子类的类型。造型的语法格式为：（子类类型）父类类型数据，使用方法如程序CastingTest.java所示。
案例名称：强制类型转换
程序名称：CastingTest.java
class Person3{
        String name;
}
class Student3 extends Person3{
        String school="pku";
        public String getSchool(){
                return school;
        }
}
public class CastingTest {
        public void method(Person3 e){
                //System.out.println(e.getSchool());//非法
                if(e instanceof Student3){
                        Student3 me=(Student3)e;
                        System.out.println(me.getSchool());
                }
        }
        public static void main(String[] args) {
                CastingTest t=new CastingTest();
                Student3 m=new Student3();
                t.method(m);
        }
}
程序解释:语句t.method(m)中的m是Student3的实例，method方法的参数“method（Person3e）”因此吗赋值给了Person3声明的变量。因此方法getSchool（）没有在父类Person3中定义，因此不能直接调用，使用前需要竞夺强制转换。
强制转换是还需要注意一次额问题：
        无继承关系的引用类型间的转换是非法的，编译时会出错;
        并不是任意的父类类型数据都可以被造型为子类类型，在造型前可以使用instanceof操作符测试一个对象的类型，以避免运行是出错。[/code]