blocks|key|462842|text|对象实例的运行时类型与静态推断的类型不同。编译器将尝试估计程序中每个变量的类型，以便及早捕获某些类型的错误。在这种情况下，a[0]将始终是一个数组，但是编译器不知道这一点。由于是从对象数组中获取对象，因此编译器只知道a[0]是一个对象。因此，它会引发错误。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|462843|如果你知道某些东西总是某种类型，但是编译器不能识别它，你可以通过插入一个显式类型转换来解决这个问题。|462844|System.out.println(((Object[])a[0])[0]);|code-block|syntax|javascript|462845|entityMap^0|1P|4|30|4|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

The runtime type of an object instance differs from the statically inferred type. The compiler will try to estimate what type each variable could be in the program, in order to catch certain types of errors early. In this case, <code>a[0]</code> will always be an array, but the compiler doesn't know this. Since you are getting an object out of an object array, all the compiler knows is that <code>a[0]</code> is an object. Therefore it raises an error.

In cases where you know something will always be a certain type but the compiler can't figure it out, you can get around this by inserting an explicit cast.

<pre><code>System.out.println(((Object[])a[0])[0]);
</code></pre>

blocks|key|246294|text|因为在Java中数组是一个对象，所以第一次和第二次赋值会将数组存储为对象数组的第一个元素。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|246295|Object[]+a+=+{null,+"foo"};
Object[]+b+=+{"bar",+b};|code-block|syntax|javascript|246296|现在，您已经将a对象数组的第一个元素更改为包含值b而不是数组。但因为它是一个对象数组。从它出来的一切都将是对象..|offset|length|style|CODE|246297|因为a是一个对象..所以，你显然不能访问这样的东西：-|246298|System.out.println(a[0][0]);|246299|您可以尝试将对象a类型转换为对象数组..：-|246300|System.out.println(((Object[])a[0])[0]);|246301|entityMap^0|0|0|7|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Since array in Java is an object, so the 1st and 2nd assignment, will store your array as the 1st element of your Object array..

<pre><code>Object[] a = {null, "foo"};
Object[] b = {"bar", b};
</code></pre>

Now, you have changed your 1st element of <code>a</code> object array to contain value b instead of array.. But since it is an array of object. Everything coming out of it will be object..

Since a[0] is an object..
So, you clearly can't access something like this: - 

<pre><code>System.out.println(a[0][0]);
</code></pre>

You can try to typecast your object a[0] to object array..: -

<pre><code>System.out.println(((Object[])a[0])[0]);
</code></pre>

blocks|key|462898|text|执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|462899|System.out.println(((Object[])a[0])[0]);|code-block|syntax|javascript|462900|这将在运行时将对象“强制转换”为对象数组。|462901|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Do:

<pre><code>System.out.println(((Object[])a[0])[0]);
</code></pre>

This will "cast" the object to an object array at runtime.

blocks|key|246322|text|你所做的一切都等同于这个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|246323|Object+a+=+{"bar",+"foo"};
System.out.println(a[0]);|code-block|syntax|javascript|246324|它也不能编译。|246325|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Everything that you are doing is equivalent to this

<pre><code>Object a = {"bar", "foo"};
System.out.println(a[0]);
</code></pre>

which doesn't compile either.

blocks|key|462978|text|由于我最近做了很多C%2B%2B编码，我发现Java语言在类型检查方面比C%2B%2B严格得多。Java将除了原始类型之外的所有内容都看作对象，但是Java在区分Array和non-Array类型方面更进了一步。在像"a+=+b;“这样的赋值过程中，Java首先检查它是否是Array类型，然后再执行常规的多态类型检查过程。如果你想让你的代码工作，你应该这样做...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|462979|Object[][]+a+=+{{null},+{"foo"}};
Object[]+b+=+{"bar",+new+java.util.Date()};
a[0]+=+b;|code-block|syntax|javascript|462980|通过查看作为参数传递给Class.forName()的java+Class签名，您可以看到Java是如何特别注意数组类型的。例如，数据类型..|462981|com.foo.Bar[][]+barsIn2D;|462982|可以用下面的签名加载...|462983|//+[+=>+Array
//+[[+=>+Array+of+Array+type
//+L<object>;+=>+Object,+not+Array
Class.forName("[[Lcom/foo/Bar;");|462984|如您所见，签名以'[‘或'L’开头。这告诉我们它是否是一个数组，是否优先于"Lcom/foo/Bar;“。|462985|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

As I do a lot of C++ coding lately, I find that Java is a lot more strict in type checking then C++ is. Java sees everything but primitive types as Object but Java goes one step further in distinguishing Array and non-Array types. During assignment like "a[0] = b;" , Java first check to see if it is an Array type or not, after that it goes through regular polymorphic type checking procedure. If you wish to make your code work, you should do...

<pre><code>Object[][] a = {{null}, {"foo"}};
Object[] b = {"bar", new java.util.Date()};
a[0] = b;
</code></pre>

You can see how java take special care on array types by looking into Java Class signature that is passed to Class.forName() as parameter. For example, data type ..

<pre><code>com.foo.Bar[][] barsIn2D;
</code></pre>

can be loaded with signature below...

<pre><code>// [ =&gt; Array
// [[ =&gt; Array of Array type
// L&lt;object&gt;; =&gt; Object, not Array
Class.forName("[[Lcom/foo/Bar;");
</code></pre>

As you see, signature starts with either '[' or 'L'. 
This tells us whether its an array or not takes precedence over "Lcom/foo/Bar;".

<pre><code>public class RefMix {
 public static void main(String[] args) {
 Object[] a = {null, "foo"};
 Object[] b = {"bar", b};
 a[0] = b;

 System.out.println(a[0][0]);
 }
}
</code></pre>

My understanding is that arrays are objects in Java, and therefore a subclass of the Object type. My further understanding is that a 2-dim array is implemented as an array of references to arrays. Therefore I don't understand why my a[0][0] does not produce <code>bar</code> in the code above. Instead it doesn't compile:

<pre><code>RefMix.java:7: array required, but java.lang.Object found
</code></pre>

Object type in Java and referencing arrays

编译器

Java

public class RefMix {  public static void main(String[] args) {    Object[] a = {null, "foo"};    Object[] b = {"bar", b};    a[0] = b;    System.out.println(a[...

问Java中的对象类型和引用数组
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的对象类型和引用数组EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的对象类型和引用数组
EN