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风格的隐式声明。这些严格的要求保证编译程序能捕捉调用错误，这就导致更可靠的程序。