问几个Object转换到String的问题

Question

class MyList {
public static void main(String[] args) {
Object[] o = new Object[]{1, 2, 3};
String[] s = (String[])o;
System.out.print(s);
}
}这段代码可以通过编译，但是会抛出ClassCastException，这里把Object转化到String哪里不对了？String不是Object的子类吗？class MyList {
public static void main(String[] args) {
Object o = new Object(1);
String s = (String)o;
System.out.print(s);
}
}这样写编译器就直接报错了，为什么刚才没报错，这里报了？import java.util.*;class MyList {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<String>();
list.add("one ");
list.add("two ");
list.add("three ");
String[] sa = new String[3];
sa = (String[]) list.toArray();
for (String s : sa)
System.out.print(s);
}
}其实我想问的是这段代码，问题应该和第一个问题一样。

Answer 1

奇闻~ String是Object的子类，就一定可以把Object转为String？第二段报编译错误是因为你给Object的构造方法传入了一个参数。

Answer 2

sa = (String[]) list.toArray(new String()[0]);

Answer 3

恩，但是我想知道为什么这么写不对?
String[] sa = new String[3];
sa = (String[]) list.toArray();
Object为什么不能转成String?

Answer 4

Object  toString()方法 直接转换 
当然如果是自定义的类型，需要复写该方法

Answer 5

  本题的关键是对对象的理解：这样写是行的： 
        Object[] o = new String[]{"1", "2", "3"};   // Object o = new String[]{"1", "2", "3"};也行
        String[] s = (String[])o;
        System.out.print(s[0]);
  为什么是，这不是将Object对象转成String对象。而是其实际对象是Object对象转成String[]数组对象。理解了这一点
 那么本题的下一 sa = (String[]) list.toArray();因为toArray()返回的是一组对象数组。因为内部定义是Object[]
数组。你就是将Object[] 转成String[]这样是不行的。请区分数组对象。与数组对象中无素的对象

Answer 6

先是第一个问题，没错，String是Object的子类，只能保证String可以向上转型为Object正确，而由String s = (String)o;这是将Object向下转型为String了，这就错了，动物不一定都是老虎，就是这个道理
第二个问题，Object的构造函数不含参数的，你可以参考一下：http://blog.163.com/itworker@126/blog/static/1339832200871042632484/，至于你说的第一个为什么正确，其实第一个你的构造方法本身就有问题，你需要在看一下数组的初始化，还有在第一段程序中，你的System.out.print(s);你也不对的，若想输出，你需要重新定义 toString函数
最后第三个问题，还是关于类型转换的，两个不同的类不要随便就强制转换，虽然他们都是继承自Object类，同上

Answer 7

class Test {
public static void main(String[] args) {
Object[] o = new Object[] { "1 ", "2 ", "3 " };
String[] s = (String[]) o;
System.out.print(s[0]);
}
}
这么写为什么也不对呢？

Answer 8

但是我原来是就是String[]数组，只是转成Object数组在转回来，为什么不行？

Answer 9

class Test {
public static void main(String[] args) {
Object[] o = new String[] { "1", "2", "3" };
String[] s = (String[]) o;
System.out.print(s[0]);
}
}
这么写，运行是没错的。class Test {
public static void main(String[] args) {
Object[] o = new Object[] { "1", "2", "3" };
String[] s = (String[]) o;
System.out.print(s[0]);
}
}这么写，可以编译，运行时有Exceptionclass Test {
public static void main(String[] args) {
Object o = "a";
String s = (String)o;
System.out.print(s);
}
}这么写又能正确输出了！请高手分析分析

Answer 10

最后一段 是JVM自动将"a"转成String对象了，所以跟上面的一样 可以

Answer 11

class Test {
    public static void main(String[] args) {
        Object[] o = new String[] { "1", "2", "3" };
        String[] s = (String[]) o;
        System.out.print(s[0]);
    }
}在创建对象时，就指明了是String型，即使你把“String[] s = (String[]) o;"省略，输出System.out.print(o[0]);也是正确的
class Test {
    public static void main(String[] args) {
        Object[] o = new Object[] { "1", "2", "3" };
        String[] s = (String[]) o;
        System.out.print(s[0]);
    }
}你转换的类型为String[]——String数组，有这种类型的对象么？String数组只是存放String对象
class Test {
    public static void main(String[] args) {
        Object o = "a";
        String s = (String)o;
        System.out.print(s);
    }
}Object o = "a";等效与Object o = new String("a");，把String s = (String)o;省略直接输出System.out.print(o);也是正确的，和第一个例子同样概念

Answer 12

上面这个代码我说得不对class Test {
    public static void main(String[] args) {
        Object[] o = new Object[] { "1", "2", "3" };
        String[] s = (String[]) o;
        System.out.print(s[0]);
    }
}

Answer 13

报错：Object cannot be cast to String，不能从Object转换为String/Integer...

Answer 14

String[] s = (String[])o;
把Object窄化为某个具体类是在运行时才进行的，所以编译器无法报错，因为编译器不知道你会给o什么值，可能是阿猫阿狗也可能是String，所以只能由JVM运行时报ClassCastException

Answer 15

Java中允许向上和向下转型，但是这个转型是否成功是根据Java虚拟机中这个对象的类型来实现的。Java虚拟机中保存了每个对象的类型。而数组也是一个对象。数组的类型是[Ljava.lang.Object。把[Ljava.lang.Object转换成[Ljava.lang.String是显然不可能的事情，因为在这个是一个向下转型，而虚拟机只保存了这是一个Object的数组，不能保证数组中的元素是String的，所以这个转型不能成功。数组里面的元素只是元素的引用，不是存储的具体元素，所以数组中元素的类型还是保存在Java虚拟机中的。

Answer 16

class MyList {
    public static void main(String[] args) {
        Object[] o = new Object[]{1, 2, 3};
        String[] s = (String[])o;
        System.out.print(s);
    }
}强制转换中如果确认Object是个String那样才可以转换，比如web开发中
String a = (String)request.getAttribute("a");request.getAttribute()得到的是Object型的~但是的确是String~~但是Object[] o = new Object[]{1, 2, 3};中Object[]还可以是Integer[]

Answer 17

Object[] o = new Object[] { "1", "2", "3" }; 这里你其实还是创建了一个Object[]，并没有创建String[]，虽然你数组里面存储的都是String，但这并没有把你的Object[]从本质上变成一个String[]，所以这时试图将Object[]转成String[]是失败的，因为你并没有创建String[]，换句话说，内存中其实不存在一个String[]。
而Object[] o = new String[] { "1", "2", "3" }; 这里你是实际创建了一个String[]，然后向上转型为Object[]，内存中确实是一个String[]，所以当你再次向下转型为String[]时可以成功转换。
楼主其实是混淆了“数组的向上转型”和“数组元素的向上转型”两个概念。上面的第一种情况中，只存在数组元素的向上转型，不存在数组的向上转型，所以也就没有相应的向下转型。
如果还不能理解的话，可以把数组想象为贴有标签的抽屉。一个抽屉上贴着“书籍”的标签，虽然你往里边放的都是小说书，但你并没有把抽屉上的标签相应地变成“小说书”，所以它本质上还是“放书籍的抽屉”，没有变成“放小说书的抽屉”，当然就不能当作“放小说书的抽屉”来用；而如果一个抽屉上贴着“小说书”的标签，那么它可以被当作一个“放书籍的抽屉”，但本质上它是一个“放小说书的抽屉”，既可以当作“放书籍的抽屉”来用，也可以当作“放小说书的抽屉”来用。