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出一块空间，然后把你要赋值的数值转化成二进制，这时，如果你赋值的数值超过这个类型的变量的数值范围，就会放不下，所以编译就会报错。

数值是没有类型的，只有变量才有类型