java声明long型（java定义long类型）

本篇文章给大家谈谈java声明long型，以及java定义long类型对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

1、java语言有几种数据类型?怎样申明和赋值??2、Java中的Long和Double类型3、java如何定义long类型的变量4、java中 long a=10000000000; 为啥会报错5、Java：使用l和L声明long型有什么区别吗？

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〕，由于 r127，所以 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=ab;

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中的Long和Double类型

Java中的原子操作包括：

1）除long和double之外的基本类型的赋值操作

2）所有引用reference的赋值操作

3）java.concurrent.Atomic.* 包中所有类的一切操作。

但是java对long和double的赋值操作是非原子操作！！long和double占用的字节数都是8，也就是64bits。在32位操作系统上对64位的数据的读写要分两步完成，每一步取32位数据。这样对double和long的赋值操作就会有问题：如果有两个线程同时写一个变量内存，一个进程写低32位，而另一个写高32位，这样将导致获取的64位数据是失效的数据。因此需要使用volatile关键字来防止此类现象。volatile本身不保证获取和设置操作的原子性，仅仅保持修改的可见性。但是java的内存模型保证声明为volatile的long和double变量的get和set操作是原子的。（from

）

举个例子来说：（example is from

）

public class UnatomicLong implements Runnable {

private static long test = 0;

private final long val;

public UnatomicLong(long val) {

this.val = val;

}

@Override

public void run() {

while (!Thread.interrupted()) {

test = val;

//两个线程都试图将自己的私有变量val赋值给类私有静态变量test

}

}

public static void main(String[] args) {

Thread t1 = new Thread(new

UnatomicLong(-1));

Thread t2 = new Thread(new

UnatomicLong(0));

System.out.println(Long.toBinaryString(-1));

System.out.println(pad(Long.toBinaryString(0),

64));

t1.start();

t2.start();

long val;

while ((val = test) == -1

|| val == 0) {

//如果静态成员test的值是-1或0，说明两个线程操作没有交叉

}

System.out.println(pad(Long.toBinaryString(val), 64));

System.out.println(val);

t1.interrupt();

t2.interrupt();

}

// prepend 0s to the string to make it the target

length

private static String pad(String s, int targetLength) {

int n = targetLength – s.length();

for (int x = 0; x n; x++) {

s = “0” + s;

}

return s;

}

}

java如何定义long类型的变量

long是Java的关键字，直接使用long即可，比如：

long

a

=

100L;

而整数字面量后面加L或l表示这个整数是long类型，如果没有后缀，默认为int类型。

java中 long a=10000000000; 为啥会报错

正确的写法

long a=10000000000L; //将10000000000 这个整数常量，声明为long类型。

报错原因是：Java中整数类型的值默认成int类型，占4个字节，能表示的最大值是2的31次方减一，约2乘十的九次方。10 000 000 000不带L时，会被默认成int类型，但这个值远远超过int类型能表示的最大值，于是报错。

long类型占八个字节，能表示的最大值为2的63次方减一，约为9 乘十的十八次方，能表示的最小值是-2的63次方。10000000000这个值处在long类型的表示范围内，所以声明成一个long类型常量10000000000L不会出错。将long类型常量赋值给long类型变量，不存在数据类型转换的类型不兼容问题。

Java：使用l和L声明long型有什么区别吗？

JAVA中声明long型，使用l和L是没有区别的，实现的功能是一样的。

不过在编程中鼓励使用L来代表long型，因为l在很多时候会被人误解为是数字“1”，不利于代码的可阅读性。

关于java声明long型和java定义long类型的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。