java給short賦值

1. 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);

2. 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出一塊空間，然後把你要賦值的數值轉化成二進制，這時，如果你賦值的數值超過這個類型的變數的數值范圍，就會放不下，所以編譯就會報錯。

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

3. 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。
注意問題:強制類型轉換通常都會存儲精度的損失，所以使用時需要謹慎。

4. java變數類型

1）選項c
short a = 300 ;
a = (byte)(a+3);
這句話就是將a(short)+3(int)的結果int類型的303強制轉換為byte類型的a
byte類型類型的最大值為127， 303溢出，高位截掉後輸出47
但不會報語法錯誤。
2 a =（short）a+3 會報編譯錯誤

Java語法中數據常量默認類型為int， 所以3是int類型的整數類型常量。
(short)a +3(int) 的類型為int ，將int類型（64位）的303賦值給short類型（32位）的a，在編譯時報錯
所以 a =（short）a+3 系統編譯會報錯
正確的語法 應為 a = (short)(a+3)。
你明白了嗎？

5. java 向文件中寫入short類型的數，怎麼寫

importjava.io.DataInputStream;
importjava.io.DataOutputStream;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;

/*
*可以讀寫基本數據類型的數據
*數據輸入流：DataInputStream
*			DataInputStream(InputStreamin)
*數據輸出流：DataOutputStream
*			DataOutputStream(OutputStreamout)
*/
publicclassDataStreamDemo{
	publicstaticvoidmain(String[]args)throwsIOException{
		//寫
		//write();

		//讀
		read();
	}

	privatestaticvoidread()throwsIOException{
		//DataInputStream(InputStreamin)
		//創建數據輸入流對象
		DataInputStreamdis=newDataInputStream(
				newFileInputStream("dos.txt"));

		//讀數據
		byteb=dis.readByte();
		shorts=dis.readShort();
		inti=dis.readInt();
		longl=dis.readLong();
		floatf=dis.readFloat();
		doubled=dis.readDouble();
		charc=dis.readChar();
		booleanbb=dis.readBoolean();

		//釋放資源
		dis.close();

		System.out.println(b);
		System.out.println(s);
		System.out.println(i);
		System.out.println(l);
		System.out.println(f);
		System.out.println(d);
		System.out.println(c);
		System.out.println(bb);
	}

	privatestaticvoidwrite()throwsIOException{
		//DataOutputStream(OutputStreamout)
		//創建數據輸出流對象
		DataOutputStreamdos=newDataOutputStream(newFileOutputStream(
				"dos.txt"));

		//寫數據了
		dos.writeByte(10);
		dos.writeShort(100);
		dos.writeInt(1000);
		dos.writeLong(10000);
		dos.writeFloat(12.34F);
		dos.writeDouble(12.56);
		dos.writeChar('a');
		dos.writeBoolean(true);

		//釋放資源
		dos.close();
	}
}

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

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

7. 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 中也有相關的一些說明，有興趣的可以去看看

8. java的問題,關於short類型的

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

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

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

9. java簡單運算-short類型與int類型

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

10. java 怎麼直接寫short類型的數

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

short a = 1;

void method(a){}

或者

void method((short)1){}

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

(10)java給short賦值擴展閱讀：

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

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