blocks|key|107109|text|值1适合于一个字节；1%2B1也是如此；当变量是constant+folding时，编译器可以执行最终操作。(换句话说:编译器在执行%2B操作时不使用foo；而是使用"raw“1值)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|107110|但是，当变量不是最终变量时，所有关于转换和提升的有趣规则都会生效(请参阅here；您想要阅读5.12节关于扩大原语转换的内容)。|107111|对于第二部分:使一个数组为，仍然允许您更改它的任何字段；所以，再一次；不可能进行常量折叠；因此，“加宽”操作再次开始。|BOLD|107112|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Constant_folding|1|https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html^0|1Z|3|M|G|0|0|10|4|1|0|D|1A|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@$9|11|A|12|1|13]]|E|$]]|$1|H|3|I|5|6|7|14|8|@$9|15|A|16|B|J]]|D|@]|E|$]]|$1|K|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]]]

The value 1 fits nicely into a byte; so does 1+1; and when the variable is final, the compiler can do <a href="https://en.wikipedia.org/wiki/Constant_folding" rel="noreferrer">constant folding</a>. (in other words: the compiler doesn't use <code>foo</code> when doing that + operation; but the "raw" 1 values)

But when the variable is not final, then all the interesting rules about conversions and promotions kick in (see <a href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html" rel="noreferrer">here</a>; you want to read section 5.12 about widening primitive conversions).

For the second part: making an array final still allows you to change any of its fields; so again; no constant folding possible; so that "widening" operation is kicking in again.

blocks|key|104921|text|JLS+(§5.2)具有使用常量表达式进行赋值转换的特殊规则|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|104922|104923|此外，如果表达式是类型为byte、short、char或int的常量表达式(§15.28)：|blockquote|style|CODE|104924|104925|104926|104927|如果变量的类型是byte、short或char，并且常量表达式的值可以在变量的类型中表示，则可以使用缩小基元转换。|unordered-list-item|104928|104929|如果我们沿着上面的链接，我们可以在常量表达式的定义中看到这些|104930|104931|104932|104933|原语类型的|104934|文本和引用常量变量(§4.12.4).|104935|的String|104936|The类型的加性运算符%2B和名称名称(§6.5.6.1)的文本|104937|104938|如果我们遵循上面的第二个链接，我们可以看到|104939|104940|原语类型或类型为String的变量称为常量变量，即final，并使用编译时常量表达式(§15.28)进行初始化。|104941|104942|104943|由此可以得出，只有当foo是常量变量时，才能将foo+%2B+foo赋值给fooFoo。要将其应用到您的案例中：|104944|因为常量变量不是final.，所以|104945|byte+foo+=+1;+不定义常量变量|BOLD|104946|104947|104948|final+byte+foo+=+1;+确实定义了一个常量变量，因为它是final的，并且是用常量表达式(原始文字)初始化的。|104949|104950|104951|final+byte+foo+=+fooArray[0];+不定义常量变量，因为它不是用常量表达式初始化的。|104952|104953|请注意，fooFoo本身是否为final并不重要。|104954|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.2|1|https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.28|2|https://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.12.4|3|https://docs.oracle.com/javase/specs/jls/se7/html/jls-6.html#jls-6.5.6.1|4^0|5|4|0|0|0|C|4|H|5|N|4|S|3|12|6|1|0|0|0|0|8|4|D|5|J|4|0|0|0|0|0|0|0|A|7|2|0|1|6|0|B|1|I|8|3|0|0|0|0|8|6|P|5|17|6|4|0|0|0|A|3|N|9|Z|6|0|8|5|0|0|D|E|1|0|0|0|0|J|10|5|K|17|0|0|0|0|T|U|O|0|T|0|0|0|P|4|6|F|5|0^^$0|@$1|2|3|4|5|6|7|28|8|@]|9|@$A|29|B|2A|1|2B]]|C|$]]|$1|D|3|-4|5|6|7|2C|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|2D|8|@$A|2E|B|2F|H|I]|$A|2G|B|2H|H|I]|$A|2I|B|2J|H|I]|$A|2K|B|2L|H|I]]|9|@$A|2M|B|2N|1|2O]]|C|$]]|$1|J|3|-4|5|6|7|2P|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|2Q|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|2R|8|@]|9|@]|C|$]]|$1|M|3|N|5|O|7|2S|8|@$A|2T|B|2U|H|I]|$A|2V|B|2W|H|I]|$A|2X|B|2Y|H|I]]|9|@]|C|$]]|$1|P|3|-4|5|6|7|2Z|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|30|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|31|8|@]|9|@]|C|$]]|$1|T|3|-4|5|G|7|32|8|@]|9|@]|C|$]]|$1|U|3|-4|5|6|7|33|8|@]|9|@]|C|$]]|$1|V|3|W|5|6|7|34|8|@]|9|@]|C|$]]|$1|X|3|Y|5|O|7|35|8|@]|9|@$A|36|B|37|1|38]]|C|$]]|$1|Z|3|10|5|6|7|39|8|@$A|3A|B|3B|H|I]]|9|@]|C|$]]|$1|11|3|12|5|O|7|3C|8|@$A|3D|B|3E|H|I]]|9|@$A|3F|B|3G|1|3H]]|C|$]]|$1|13|3|-4|5|6|7|3I|8|@]|9|@]|C|$]]|$1|14|3|15|5|6|7|3J|8|@]|9|@]|C|$]]|$1|16|3|-4|5|6|7|3K|8|@]|9|@]|C|$]]|$1|17|3|18|5|G|7|3L|8|@$A|3M|B|3N|H|I]|$A|3O|B|3P|H|I]]|9|@$A|3Q|B|3R|1|3S]]|C|$]]|$1|19|3|-4|5|6|7|3T|8|@]|9|@]|C|$]]|$1|1A|3|-4|5|6|7|3U|8|@]|9|@]|C|$]]|$1|1B|3|1C|5|6|7|3V|8|@$A|3W|B|3X|H|I]|$A|3Y|B|3Z|H|I]|$A|40|B|41|H|I]]|9|@]|C|$]]|$1|1D|3|1E|5|6|7|42|8|@$A|43|B|44|H|I]]|9|@]|C|$]]|$1|1F|3|1G|5|O|7|45|8|@$A|46|B|47|H|I]|$A|48|B|49|H|1H]]|9|@]|C|$]]|$1|1I|3|-4|5|6|7|4A|8|@]|9|@]|C|$]]|$1|1J|3|-4|5|6|7|4B|8|@]|9|@]|C|$]]|$1|1K|3|1L|5|O|7|4C|8|@$A|4D|B|4E|H|I]|$A|4F|B|4G|H|I]|$A|4H|B|4I|H|1H]]|9|@]|C|$]]|$1|1M|3|-4|5|6|7|4J|8|@]|9|@]|C|$]]|$1|1N|3|-4|5|6|7|4K|8|@]|9|@]|C|$]]|$1|1O|3|1P|5|O|7|4L|8|@$A|4M|B|4N|H|1H]|$A|4O|B|4P|H|1H]|$A|4Q|B|4R|H|I]]|9|@]|C|$]]|$1|1Q|3|-4|5|6|7|4S|8|@]|9|@]|C|$]]|$1|1R|3|1S|5|6|7|4T|8|@$A|4U|B|4V|H|1H]|$A|4W|B|4X|H|I]|$A|4Y|B|4Z|H|I]]|9|@]|C|$]]|$1|1T|3|-4|5|6|7|50|8|@]|9|@]|C|$]]]|1U|$1V|$5|1W|1X|1Y|C|$1Z|20]]|21|$5|1W|1X|1Y|C|$1Z|22]]|23|$5|1W|1X|1Y|C|$1Z|24]]|25|$5|1W|1X|1Y|C|$1Z|26]]|27|$5|1W|1X|1Y|C|$1Z|22]]]]

The JLS (<a href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.2" rel="noreferrer">§5.2</a>) has special rules for assignment conversion with constant expressions:
<blockquote>
In addition, if the expression is a constant expression (<a href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.28" rel="noreferrer">§15.28</a>) of type <code>byte</code>, <code>short</code>, <code>char</code>, or <code>int</code>:
<ul>
<li>A narrowing primitive conversion may be used if the type of the variable is <code>byte</code>, <code>short</code>, or <code>char</code>, and the value of the constant expression is representable in the type of the variable.</li>
</ul>
</blockquote>
If we follow the link above, we see these in the definition of constant expression:
<blockquote>
<ul>
<li>Literals of primitive type and literals of type <code>String</code></li>
<li>The additive operators <code>+</code> and <code>-</code></li>
<li>Simple names (<a href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-6.html#jls-6.5.6.1" rel="noreferrer">§6.5.6.1</a>) that refer to constant variables (<a href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.12.4" rel="noreferrer">§4.12.4</a>).</li>
</ul>
</blockquote>
If we follow the second link above, we see that
<blockquote>
A variable of primitive type or type <code>String</code>, that is <code>final</code> and initialized with a compile-time constant expression (<a href="https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.28" rel="noreferrer">§15.28</a>), is called a constant variable.
</blockquote>
It follows that <code>foo + foo</code> can only be assigned to <code>fooFoo</code> if <code>foo</code> is a constant variable. To apply that to your cases:
<ul>
<li><code>byte foo = 1;</code> does not define a constant variable because it's not <code>final</code>.
</li>
<li><code>final byte foo = 1;</code> does define a constant variable, because it's <code>final</code> and initialized with a constant expression (a primitive literal).
</li>
<li><code>final byte foo = fooArray[0];</code> does not define a constant variable because it's not initialized with a constant expression.
</li>
</ul>
Note that whether <code>fooFoo</code> is itself <code>final</code> doesn't matter.

blocks|key|2856152|text|这确实是编译器在与final一起使用时在常量折叠中所做的事情，正如我们可以从字节码中看到的：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2856153|++++byte+f+=+1;
++++//+because+compiler+still+use+variable+'f',+so+`f+%2B+f`+will+
++++//+be+promoted+to+int,+so+we+need+cast
++++byte+ff+=+(byte)+(f+%2B+f);
++++final+byte+s+=+3;
++++//+here+compiler+will+directly+compute+the+result+and+it+know
++++//+3+%2B+3+=+6+is+a+byte,+so+no+need+cast
++++byte+ss+=+s+%2B+s;
++++//----------------------
++++L0
++++LINENUMBER+12+L0
++++ICONST_1+//+set+variable+to+1
++++ISTORE+1+//+store+variable+'f'
++++L1
++++LINENUMBER+13+L1
++++ILOAD+1+//+use+variable+'f'
++++ILOAD+1
++++IADD
++++I2B++++++++
++++ISTORE+2+//+store+'ff'
++++L2

++++LINENUMBER+14+L2
++++ICONST_3+//+set+variable+to+3
++++ISTORE+3+//+store+'s'
++++L3
++++LINENUMBER+15+L3
++++BIPUSH+6+//+compiler+just+compute+the+result+'6'+and+set+directly
++++ISTORE+4+//+store+'ss'|code-block|syntax|javascript|2856154|如果你把最后一个字节改成127，它也会报错：|2856155|++++final+byte+s+=+127;
++++byte+ss+=+s+%2B+s;|2856156|在这种情况下，编译器计算结果并知道它超出了限制，因此它仍然会抱怨它们是不兼容的。|2856157|更多信息：|2856158|here是关于字符串常量折叠的另一个问题：|2856159|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/24364465/differences-between-abc-de-and-abc-de-de-de-in-java^0|9|5|0|0|0|0|0|0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|19|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1A|8|@]|D|@$9|1B|A|1C|1|1D]]|E|$]]|$1|U|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]]]

It is indeed what compiler do in constant folding when used with <code>final</code>, as we can see from byte code:

<pre><code> byte f = 1;
 // because compiler still use variable 'f', so `f + f` will 
 // be promoted to int, so we need cast
 byte ff = (byte) (f + f);
 final byte s = 3;
 // here compiler will directly compute the result and it know
 // 3 + 3 = 6 is a byte, so no need cast
 byte ss = s + s;
 //----------------------
 L0
 LINENUMBER 12 L0
 ICONST_1 // set variable to 1
 ISTORE 1 // store variable 'f'
 L1
 LINENUMBER 13 L1
 ILOAD 1 // use variable 'f'
 ILOAD 1
 IADD
 I2B 
 ISTORE 2 // store 'ff'
 L2

 LINENUMBER 14 L2
 ICONST_3 // set variable to 3
 ISTORE 3 // store 's'
 L3
 LINENUMBER 15 L3
 BIPUSH 6 // compiler just compute the result '6' and set directly
 ISTORE 4 // store 'ss'
</code></pre>

And if you change your final byte to 127, it will also complain:

<pre><code> final byte s = 127;
 byte ss = s + s;
</code></pre>

in which cases, the compiler compute the result and know it out of limit, so it will still complain they are incompatible.

More:

And <a href="https://stackoverflow.com/questions/24364465/differences-between-abc-de-and-abc-de-de-de-in-java">here</a> is another question about constant folding with string:

blocks|key|107180|text|发生这种情况的原因是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|107181|byte+foo+=+1;
byte+fooFoo+=+foo+%2B+foo;|code-block|syntax|javascript|107182|foo+%2B+foo+=2将被回答，但2不是字节类型，因为java的默认数据类型是整型变量，它的类型是int。所以你需要强制告诉编译器答案必须是一个明确的字节类型。|107183|class+Example{
++++public+static+void+main(String+args[]){

++++++++byte+b1+=+10;
++++++++byte+b2+=+20;
++++++++byte+b1b2+=+(byte)(b1+%2B+b2);+

++++++++//~+b1+%2B=+100;++//+(%2B=)+operator+automaticaly+type+casting+that+means+narrow+conversion

++++++++int+tot+=+b1+%2B+b2;

++++++++//~+this+bellow+statement+prints+the+type+of+the+variable
++++++++System.out.println(((Object)(b1+%2B+b2)).getClass());++//this+solve+your+problem
++++}
}|107184|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This occurs because of 

<pre><code>byte foo = 1;
byte fooFoo = foo + foo;
</code></pre>

foo + foo = 2 will be answered but 2 is not byte type because of java has default data type to integer variables it's type is int. So you need to tell the compiler by force 
that answer must be a byte type explicitly.

<pre><code>class Example{
 public static void main(String args[]){

 byte b1 = 10;
 byte b2 = 20;
 byte b1b2 = (byte)(b1 + b2); 

 //~ b1 += 100; // (+=) operator automaticaly type casting that means narrow conversion

 int tot = b1 + b2;

 //~ this bellow statement prints the type of the variable
 System.out.println(((Object)(b1 + b2)).getClass()); //this solve your problem
 }
}
</code></pre>

Starting with the following code...

<pre><code>byte foo = 1;
byte fooFoo = foo + foo;
</code></pre>

When I try compiling this code I will get the following error...

<blockquote>
 Error:(5, 27) java: incompatible types: possible lossy conversion from int to byte
</blockquote>

... but if <code>foo</code> is final...

<pre><code>final byte foo = 1;
final byte fooFoo = foo + foo;
</code></pre>

the file will compile successfully.

Moving on to the following code...

<pre><code>final byte[] fooArray = new byte[1];
fooArray[0] = 1;

final byte foo = fooArray[0];
fooArray[0] = 127;

System.out.println("foo is: " + foo);
</code></pre>

... will print 

<pre><code>foo is: 1
</code></pre>

... which is fine. The value is copied to a final variable and it can not be changed any more. Playing with the value in the array does not change the value of the <code>foo</code> (as expected...).

Why does the following require a cast?

<pre><code>final byte[] fooArray = new byte[1];
fooArray[0] = 1;
final byte foo = fooArray[0];
final byte fooFoo = foo + foo;
</code></pre>

How is this different than the second example in this question? Why is the compiler giving me the following error?

<blockquote>
 Error:(5, 27) java: incompatible types: possible lossy conversion from int to byte
</blockquote>

How can this happen?

Why does Java require an explicit cast on a final variable if it was copied from an array?

编译器

从下面的代码开始...byte foo = 1;byte fooFoo = foo + foo;当我尝试编译这段代码时，我会得到以下错误...错误：(5，27) java:不兼容的类型:可能存在从整数到字节的有损转换..。但是如果foo是最终的..。final byte foo = 1;final byte fooFo...

问如果final变量是从数组中复制过来的，为什么Java需要对它进行显式转换？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如果final变量是从数组中复制过来的，为什么Java需要对它进行显式转换？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如果final变量是从数组中复制过来的，为什么Java需要对它进行显式转换？
EN