javashort賦值

⑴ java的問題,關於short類型的

首先看制「s = s + 1」為什麼錯。

Java編譯器認為一個像「1」這樣的直接數是一個int型。Java的自動類型轉換是一個佔用空間少的類型可以自動轉換成佔用空間大的類型，反之則必須強制類型轉換，否則報錯。「s + 1」這個表達式因為是short型和int型相加，因此自動轉換成了int型，此時再用「s = s + 1」賦值給一個short型而沒有強制類型轉換那麼自然報錯。

而至於為什麼 s += 1 沒有錯我認為沒有必要深入研究，你既然發現了這個事實，那麼知道就行了，也許Java的設計者當初對它做了特殊處理。

⑵ java簡單運算-short類型與int類型

因為short b=1中的1其實是int型，
然而這種賦值編譯器會自動將int型轉成short型，前提是編譯時，稿源如果是運行時就不會自動轉了哦！
也就是後面的b=b+1,其中"小差攜類型"與"大類型"計算，結果是大類型，也就是(b+1)是int型，int型賦給short型虛敬伏，且是運算中，那麼就會編譯不通過呀

⑶ java 怎麼直接寫short類型的數

不能直接setVal(1)這樣，會報錯，setVal((Short)1)這樣也報錯，short直接可以用，只要范圍在：-32768 到 32767即可專。long也可以不屬寫L的，直接賦值就可以。

short a = 1;

void method(a){}

或者

void method((short)1){}

原因：如果不轉換或者聲明short的話，默認為int類型。

(3)javashort賦值擴展閱讀：

Java原來是用作編寫消費類家用電子產品軟體的語言，所以它是被設計成寫高可靠和穩健軟體的。Java消除了某些編程錯誤，使得用它寫可靠軟體相當容易。

Java是一個強類型語言，它允許擴展編譯時檢查潛在類型不匹配問題的功能。Java要求顯式的方法聲明，它不支持C風格的隱式聲明。這些嚴格的要求保證編譯程序能捕捉調用錯誤，這就導致更可靠的程序。

⑷ Java中整型字面值常量為什麼可以賦值給short

整型有來32個位數據，源short有16位數據，當聲明一個short變數直接賦值時，賦值區間在 －32768〜32767之間是可以直接賦值（－32768〜32767轉換成二進制剛好占滿16位），當一個整型變數（或常量）直接強制賦值給short時，系統會截取後面16位賦給short，這可能會造成部分數據丟失

⑸ javashort怎麼-1

註：如未特別說明，Java語言規范 jls 均基於JDK8，使用環境是 eclipse4.5 + win10 + JDK 8
本篇的知識點，主要是涉及到 Java 中一些比較答橡雹常見的默認窄化處理(Java編譯器自動添加的)，這里將從一個問題開始，據說這也是一道常見的筆試題/面試題：

為什麼 short i = 1; i += 1; 可以正確編譯運行而 short i = 1; i = i + 1; 會出現編譯錯誤？

其他說法：都放在一起編譯會出現有什麼結果，哪一行報錯？為什麼？

筆者註：其實這其中會涉及到一些編譯優化和底層的知識，限於知識面，本篇不涉及，如有需要，可自行搜索。

本文的目錄結構如下：

1、結論

關於開篇提出的問題，這里先直接給出結論：

Java語言規范規定基礎數據類型運算默認使用32位精度的int類型

只要是對基本類型做窄化處理的，例如 long -> int -> short -> char，都需要做強制轉換，有些是Java編譯器默認添加的，有的則是代碼中顯式做強制轉換的。

short i = 1; i += 1;可以正確編譯運行是因為Java編譯器自己添加了強制窄化處理，即對於任何的T a; X b; a += b;等價於T a; X b; a = (T) (a + b);Java編譯器會默認做這個顯式強制轉換(盡管有時候會出現精度問題，例如 b 是 float 、 double 類型，強烈建議不要有這樣的操作)。前面的i += 1其實就等價於i = (int) (i + 1)，即便將數字1換成是double類型的1.0D也是如此。

short i = 1; i = i + 1;編譯不通過的原因就很明顯了：無論是代碼中，還是Java編譯器，都沒有做強制轉換，int 類型直接賦給 short ，因此編譯出錯。

對於常量(數字常量、常量表達式、final常量等)，Java編譯器同樣也可以做默認的強制類型轉換，只要常量在對應清帆的數據范圍內即可。

2、詳如殲解

接下來講詳細分析為什麼 short i = 1; i += 1; 可以正確編譯而 short i = 1; i = i + 1; 則會編譯失敗。先列一下搜出來的一些令人眼前一亮(or 困惑)的代碼

public static voidmain(String[] args) {//注:short ∈ [-32768, 32767]

{/** 1、對於 +=, -=, *=, /=, Java編譯器默認會添加強制類型轉換，

* 即 T a; X b; a += b; 等價於 T a; X b; a = (T) (a + b);*/

//0是int類型的常量，且在short范圍內，被Java編譯器默認強制轉換的

short i = 0;

i+= 1; //等價於 i = (short) (i + 1);

System.out.println("[xin01] i=" + i); //輸出結果: 1

i = (short) (i + 1);

System.out.println("[xin02] i=" + i); //輸出結果: 2

/** 下面這2行都會有編譯報錯提示：

* Exception in thread "main" java.lang.Error: Unresolved compilation problem:

* Type mismatch: cannot convert from int to short

* [注]錯誤: 不兼容的類型: 從int轉換到short可能會有損失

* Eclipse 也會有提示： Type mismatch: cannot convert from int to short*/

//i = i + 1;//i = 32768;

i= 0;

i+= 32768; //等價於 i = (short) (i + 32768); 下同

System.out.println("[xin03] i=" + i); //輸出結果: -32768

i += -32768;

System.out.println("[xin04] i=" + i); //輸出結果: 0

i= 0;long j = 32768;

i+=j;

System.out.println("[xin05] i=" + i); //輸出結果: -32768

i= 0;float f = 1.23F;

i+=f;

System.out.println("[xin06] i=" + i); //(小數位截斷)輸出結果: 1

i= 0;double d = 4.56D;

i+=d;

System.out.println("[xin07] i=" + i); //(小數位截斷)輸出結果: 4

i= 10;

i*= 3.14D;

System.out.println("[xin08] i=" + i); //輸出結果: 31

i= 100;

i/= 2.5D;

System.out.println("[xin09] i=" + i); //輸出結果: 40

}

{/** 2、常量表達式和編譯器優化: 常量折疊*/

//2 * 16383 = 32766//(-2) * 16384 = -32768//都在 short 范圍內，常量表達式在編譯優化後直接用對應的常量結果，然後編譯器做強制轉換

short i = 2 * 16383; //等價於 short i = (short) (2 * 16383);

short j = (-2) * 16384;//2 * 16384 = 32768,超過 short 范圍，編譯器不會做轉換//Type mismatch: cannot convert from int to short//short k = 2 * 16384;//常量表達式在編譯優化後直接用對應的常量結果，然後編譯器做強制轉換

short cThirty = 3 * 10;short three = 3;short ten = 10;//Type mismatch: cannot convert from int to short//short thirty = three * ten;

final short fTthree = 3;final short fTen = 10;//常量表達式在編譯優化後直接用對應的常量結果，然後編譯器做強制轉換

short fThirty = fTthree *fTen;final short a = 16384;final short b = 16383;//常量表達式在編譯優化後直接用對應的常量結果，然後編譯器做強制轉換

short c = a +b;

}

}

接下來根據代碼羅列的兩部分分別進行說明：

2.1、對於 +=, -=, *=, /=, Java編譯器默認會添加強制類型轉換，即 T a; X b; a += b; 等價於 T a; X b; a = (T) (a + b);

A compound assignment expression of the formE1 op= E2is equivalent toE1 = (T) ((E1) op (E2)), whereTis the type ofE1, except thatE1is evaluated only once.

For example, the following code is correct:

short x = 3;

x+= 4.6;

and results in x having the value 7 because it is equivalent to:

short x = 3;

x= (short)(x + 4.6);

筆者註：

實際上，直接加上強制類型轉換的寫法，也是大家都熟悉且理解起來最清晰的方式，可以避免可能潛在的類型不匹配時出現的精度損失問題，使用的時候需要注意。當然，筆者認為這些方式都沒有好壞之分，正確地使用即可。

Java從語言規范層面對此做了限制。有興趣的還可以通過 class文件和 javap -c 反匯編對所使用的位元組碼作進一步的研究。

知道了Java語言相關的規范約定，我們就可以看出，與之對應的是以下這種出現編譯錯誤的寫法(報錯提示：Type mismatch: cannot convert from int to short)：

short i = 1;//i + 1 是 int 類型，需要強制向下類型轉換

i = i + 1;

2.2、常量表達式和編譯器優化: 常量折疊

需要注意的是，前面的示例short x = 3;中的3其實默認是 int 類型，但是卻可以賦值給short類型的x。這里涉及到到的其實是 常量表達式。

In addition, if the expression is a constant expression (

A narrowing primitive conversion may be used if the type of the variable is byte, short, or char, and the value of the constant expression is representable in the type of the variable.

A narrowing primitive conversion followed by a boxing conversion may be used if the type of the variable is:

Byte and the value of the constant expression is representable in the type byte.

Short and the value of the constant expression is representable in the type short.

Character and the value of the constant expression is representable in the type char.

對於常量表達式，其結果是可以自動做窄化處理的，只要是在對應的數據類型範圍內，Java編譯器就進行做默認強制類型轉換。

Some expressions have a value that can be determined at compile time. These are constant expressions (

true(short)(1*2*3*4*5*6)

Integer.MAX_VALUE/ 2

2.0 *Math.PI"The integer " + Long.MAX_VALUE + " is mighty big."

A constant variable is a final variable of primitive type or type String that is initialized with a constant expression (

通過常量表達式賦值的final變數都是常量，這種也是編譯期可以確認最終值，會通過編譯優化直接賦予最終值，而且可以直接依靠編譯器做窄化處理。

對於這一塊，其實對應的是一個比較基礎的編譯器優化：常量折疊(Constant Folding)，有興趣的可以自行搜索。stackoverflow 上由相關的討論，參考[9]、[10]、[11]

筆者註：

盡管常量表達式最終都被編譯器優化為直接值，但是為了清晰，提高可讀性、可維護性，代碼中沒必要對常量直接換算，例如一天 24 * 60 * 60 秒，其實可以分別用可讀性更強的final常量來表示。

Bloch大神的 Java Puzzlers 中也有相關的一些說明，有興趣的可以去看看

⑹ java中：short的取值范圍是為什麼呢

1. SHORT的取值范圍-32768~32767，SHORT長度16。

   Java的類型：

2. boolean型

   取值為true和false的變數，這種變數稱為boolean型變數。

3. char型

   char型是用來表示字母的，它僅能表示一個單一的字母。通常char型常量必須使用單引號括起來，以與數字區分開來。

   char型在Java語言中並不是很常用，因為如果要存儲字元的話，一般使用擴展的數據類型string。

4. 整型

   在Java語言中，提供了多種整型數據類型：byte、short、int、long。它們都是定義了一個整數，唯一的區別就是它們能夠表示數據的范圍。

   能夠表示數據的范圍越大，佔用的內存空間也就越大，因此，在程序設計中應該選擇最合適的類型來定義整數。

5. 浮點型

   存儲小數的變數數據類型---浮點數。在Java語言中有兩種浮點數類型：float、double。

   其中float是單精度型，佔用32位內存空間，而double是雙精度型，佔用64位內存空間。

⑺ Java 賦值語句short x=1，y=2，z; z=x+y;為什麼是錯的

short類型的數據，在運算時，會被先轉換為int類型的數據老此譽，然後進行運算。
z=x+y;
相當侍段於
z=(int)x+(int)y;
結果也是int類型的，再賦值給short類扒碰型的z時，就會發生錯誤；所以，要加強制轉換。
z=(sort)(x+y);

⑻ java, short s=100; 可以。但是 int i=100; short s=i;就不行為什麼

類型的 強制轉換問題：
向上轉換（自動轉換，隱式轉換）：
short s=100；
int i = s；
這個是沒問題的

向下轉換（需強制）
int i=100; short s=(short)i;

-------------------------------------------------
自動類型轉換
自動類型轉換，也稱隱式類型轉換，是指侍虧不需要書寫代碼，由系統自動完成的老野神類型轉換。由於實際開發中這樣的類型轉換很多，所以 Java 語言在設計時，沒有為該操作設計語法，而是由 JVM 自動完成。

轉換規則：從存儲范圍小的類型到存儲范圍大的類型。
具體規則為：byte→short(char)→int→long→float→double
也就是說 byte 類型的變數可以自動轉換為 short 類型，示例代碼：
byte b = 10;

short sh = b;這里在賦值時，JVM 首先將 b 的值轉換為 short 類型，然後再賦值給 sh。
在類型轉換時可以跳躍。示例代碼：
byte b1 = 100;
int n = b1;

注意問題:在整數之間進行類型轉換時，數值不發生改變，而將整數類型，特別是比較大的整數類型轉換成小數類型時，由於存儲方式不同，有可能存在數據精度的損失。

強制類型轉換
強制類型轉換，也稱顯式類型轉換，是指必須書寫代碼才能完成的類型轉換。該類類型轉換很可能存在精度的損失，所以必須書寫相應的代碼，並且能夠忍受該種損失時才進行該類型的轉換。
轉換規則:從存儲范圍大的類型到存儲范圍小的類型。
具體規則為：double→float→long→int→short(char)→byte
語法格式為：(轉換到的類型)需要轉換的值
示例代碼：
double d = 3.10;
int n = (int)d;

這里將 double 類型的變數 d 強制轉換成 int 類型，然後賦值給變數 n。需要說明的是小數強制轉換為整數，採用的是「去 1 法」，也就是無條件的舍棄小數點的所有數字，則以上轉換出的結果是 3。整數強制轉換為整數時取數字的低位，例如 int 類型的變數轉換為 byte 類型時，則只去 int 類型的低 8 位(也就是最後一個位元組)的值。
示例代碼：
int n = 123;
byte b = (byte)n;
int m = 1234;
byte b1 = (byte)m;

則 b 的值還是 123，而 b1 的值為-46。b1 的計算方法如下：m 的值轉換為二進制是10011010010，取該數字低8位的值作為b1的值，則b1的二進制值是11010010，按照機器數的規定，最高位是符號位，1 代表負數，在計算機中負數存儲的是補碼，則該負數的原碼是 10101110，該值脊絕就是十進制的-46。
注意問題:強制類型轉換通常都會存儲精度的損失，所以使用時需要謹慎。

⑼ java語言有幾種數據類型怎樣申明和賦值

一、基本數據類型
整型：byte、short、int、long （在計算機中以二進制補碼格式存儲）

浮點型：float、double （在計算機中以IEEE754格式存儲）

字元型：char （在計算機中以unicode碼格式存儲）

布爾型：boolean （只有true和false兩個值）

二、 1.長整型：long

定義：long a=100；int b＝a； （編譯出錯）

給a重新賦值：long a＝2147483648； （編譯出錯）

定義：long a＝2147483648L；（正確，說明此時可以是long型的取值范圍）

說明在long型的數據後不加L/l時，數據仍為long型，但其取值范圍卻是int型的取值范圍；數據後加L/l時，取值范圍才是long型的取值范圍。

2.浮點型：long

定義：float a=19； 輸出a時為19.0

定義：float a=19.1； （編譯出錯）

定義：float a=19.1f； （正確）

說明在 float型的數據後不加F/f，則數據不能有小數位，但輸出時，能夠輸出一位小數；若在float型的數據後加上F/f，則數據可以有小數位；

三、類型轉換（註：boolean型不會發生類型轉換，基本類型和復合類型不能相互轉換）

1.自動轉換

1）賦值轉換：用於短位元組的數據類型轉換成長位元組的數據類型（byte型的數據不能轉換成char型，short型和char型數據也不能相互轉換）

2）單目運算符提升

++、——運算符不會自動提升，+（正）、-（負）會將byte、short、char型的數據自動轉換成int型的數據

3）雙目運算符提升

如果有一個操作數是double型的，則把另一個轉換成double型；否則如果有一個操作數是float型的，則把另一個轉換成float型；否則 如果有一個操作數是long型的，則把另一個轉換成long型；否則兩個操作數都轉換成int型。

4）三目運算符<op1> ? <op2> : <op3>其中op1必須是boolean型的，而op2和op3兩操作數必須是能夠自動轉換成相同類型的數據，op2和op3會自動提升為兩操作數中位元組較長的一個，並且結果為提升後的類型。

如：byte a1=20；

short a2=10；

boolean b=true；

short c = b ？

a1 ： a2；

結果為short型的數據c

2.強制轉換

例子：

int a；

byte b=（byte）a；

定義：a=-126；

（分析：int形的數據有4個位元組，而byte形的數據只有1個位元組，所以只取int型數據的最後一個位元組）

a的原碼： 10000000，00000000，00000000，01111110

補碼： 11111111，11111111，11111111，10000010

法一：r＝（10000010）＝130 （此時將 10000010 看成是純的二進制數去計算，而不考慮它的符號位）； byte型數據范圍〔－128，127〕，由於 r>127，所以 r＝r－M （若整型數據值域[-L，R]，則M＝L＋R＋1），如果r還不在byte型數據的取值范圍內，則繼續 r＝r－M 直至r在其取值范圍內，取得r後，即為byte型的 b .此處r＝－126，所以輸出b為－126.

法二：直接將int型數據的最後一個位元組看成是byte型數據的補碼形式，在將補碼轉換成原碼，即得到 b

四、邏輯運算符

1.&&和|| （&&的優先順序要高於||的）

特點：只要左操作數已經得出整個表達式的值，就不再計算右操作數的之值，左右操作數必須為boolean型的。

例子：

boolean test1= ++x==-1 && ++x==1 || ++x=2;
boolean test2= ++y==-1 || ++y==1 && ++y=2;
System.out.println(x+" "+test1);
System.out.println(y+" "+test2);
結果：1 false
2 true

2.&和| (邏輯位運算符)

特點：先把兩個操作數的值計算出來，然後再進行邏輯運算

int x=-1,y=-1;
boolean test1= ++x==-1 & ++x==1 | ++x=2;
boolean test2= ++y==-1 | ++y==1 & ++y=2;
System.out.println(x+" "+test1);
System.out.println(y+" "+test2);
結果： 2 false
2 true

五、移位運算

<< （左移）高位丟失、低位以0填充

>> (右移) 低位丟失、高位以符號位填充

>>> (無符號位右移) 低位丟失、高位以0填充

此運算符不會對左右兩操作數作算術提升，但會對左操作數進行單獨提升，若為byte、short、char、int型，則得到結果為int型，若為long型，則結果為long型，但左右操作數均不能為浮點型，否則出錯。

當左操作數為int型時，右操作數的低5位才有用，這樣可以防止移位超過int型所具有的位數，當左操作數為long型時，右操作數的低6位才有用。

例子：

int a=-2;
short b=-10;
int c=a>>b;

b的補碼：11111111，11111111，11111111，11110110

取b的最後5位， r=（10110）=22；

a的補碼：11111111，11111111，11111111，11111110

將a向右移動22位，再在高位補上1，得到 11111111，11111111，11111111，11111111 ，轉換成原碼得到 c＝-1

六、賦值運算

1.簡單賦值運算

表達式： <變數>＝<表達式>

左操作數可以事先沒有賦值

表達式的類型必須和變數的類型相同，或能賦值轉換成變數的類型，

2.組合賦值運算

表達式：<變數> op= <表達式>

int a＝10；

double b＝23.3；

a*=b；

左操作數事先一定要賦值

左邊的類型和右邊的類型不一定要相同，此處a＊b得到的是double型的，組合運算符會自動把double型的值轉換成int型的值存入變數a中。

⑽ java賦值問題int long short

你有java 2 參考大全 這本書嗎？？
那上面有關於這個的解釋

我看過記不大清楚了

說一點我自己的看法 可能不太對

我認為你第一個語句是少加了L，才報的錯，這是語法的問題吧，不加後綴，系統會認為你要去賦值給一個int型變數，就會報錯

第三個語句不報錯，那是因為，short型的變數取值范圍在0——255之內，這個范圍裡面的數可以直接賦值給short。你可以試試把266賦值給short變數，或者你可以試試這樣 int a =5,short b = a ,這樣也通不過，需要強制轉換，
short b =(int)a,這時沒問題，因為5不超過0--255這個范圍。但是你試試這樣
int a =265,short b = （int）a，也不報錯，但是你列印出來b，就會發現損失精度了

java是這樣，當你聲明一個變數後，系統就在棧里存儲了這個變數，變數的實際存儲空間在堆棧里，只有你給這個變數賦值（實例化）時，系統才會在堆棧里new出一塊空間，然後把你要賦值的數值轉化成二進制，這時，如果你賦值的數值超過這個類型的變數的數值范圍，就會放不下，所以編譯就會報錯。

數值是沒有類型的，只有變數才有類型