变量和数据类型_当变量i赋值为1200283721l时变量i的数据类型应该是-CSDN博客

本文链接：https://blog.csdn.net/qq_28401077/article/details/46490159

2.1变量和数据类型

2.1 变量的概念：

内存中的一个存储区域,该区域有自己的名称 (变量名) 和类型(数据类型) ,该区域的数据可以在同一类型范围内不断变化。

2.2 为什么定义变量：用来不断的存放同一类型的常量，并可以重复使用。

2.3 使用变量注意：变量的作用范围(一对｛｝之间有效)

定义变量的格式:

数据类型变量名 = 初始化值

Int a = 1;

整数赋值中默认 int 类型，如果赋值过大编译时报错， long 类型在后面加L ，float 后面加F

在定义Long或者Float类型变量的时候，要加L或者f。整数默认是int类型，浮点数默认是double。

　变量的类型

l byte

l short

l int

l long

l float

l double

l char

l boolean

2 数据类型：限制初始化值的大小.变化

System.out.println(“5+5=”+5+5); //”5+5=”55

System.out.println(5+5+”=5+5”); //10+”=5+5”

1. 什么是常量：

（程序运行时，不能改变的量就是常量）

2. 常量介绍：

整数常量：1.2.100都是整数常量，但1.0就不是，是无限的。

小数常量：1.0 2.3 3.145都是小数常量也是无限的

Boolean ：只有两个值，true false .

定义变量的格式：

Int a ;

Int 表示变量类型

A 表示变量名

2.2 运算符

.1 赋值运算符

“=”就是赋值运算符

A+b=10 ; //等号左边，只能是一个变量，不能是两个变量，才叫做赋值。

Ø 左值的特性

　　等号左边的值叫左值，它必须是单一的变量！

Ø 复合赋值运算符

+=、-=、*=、/=、%=、&=、|=、<<=、>>=

short s1 = 10;

s1 += 10;//编译器不做检查，但要小心，可能会溢出

s1 = s1 + 10;//编译器要做检查，所以编译不通过。因为s1 + 10的结果类型为int。

　　右结合性！

Ø 赋值表达式一样有值

A + b，这个表达式有值，a = b这个表达式有值没有呢？有值！

其值就是左值的值！

.2 算术运算符

/和%的区别:

/取整。 % 取余

++和--的应用：

A++; B--; 先去赋值，后去++ -- ；

++A ； --B ；先++ -- ，后赋值

单独使用效果相同参与运算使用，在操作数的前后效果不同

System.out.println(3+4); //7

System.out.println(3-4); //-1

System.out.println(3*4); //12

System.out.println(3/4); //0 整数运算结果只能是整数

System.out.println(3.0/4); 0.75

System.out.println(3%4); //0 余数 3

//演示 ++ --运算符

int x =3;

int y =4;

//x++;

//y--;

++x;

--y;

System.out.println(x); // 4

System.out.println(y); // 3

System.out.println("------------");

int a =3;

int b =4;

//int c = a++;

//int d = b--;

int c = ++a;

int d = --b;

System.out.println("c:"+c); // 3 4

System.out.println("d:"+d); // 4 3

// 扩展:

// += -= *= /= %=

int x =3;

int y =4;

//x+=y; 7

//x-=y; //-1

System.out.println(x+=y); // 7

System.out.println("x:"+x+"y:"+y); // 7

System.out.println(x-=y); // -1

System.out.println("x:"+x+"y:"+y);

System.out.println(x*=y); // 12

System.out.println("x:"+x+"y:"+y);

System.out.println(x/=y); // 0

System.out.println("x:"+x+"y:"+y);

System.out.println(x%=y); // 3

System.out.println("x:"+x+"y:"+y);

.3 数据类型转换

Byte .short .char-->int-->long-->float-->double

顺序从小到大.向上提升，隐式转换

Boolean 不参与类型转换，只有true false

.4 强制转换--(显示转换)

数据类型变量名 =(目标数据类型)(被转换的数据)

Int x =3;

Byte y =4;

//强转

Byte z = （byte）（x+y）;

Byte b1 =3 , b2=4,b;

B= b1+b2 ; //变量会自动提升默认int 类型

B=3+4; //常量做运算不涉及

在使用强转会隐含了可能损失精度

什么叫类型转换

　　当两个变量的类型不同时，他们在一起运算需要把类型低的提升到高的。

1 类型的大小顺序

浮点型>整型

浮点型中：float、double

整型：byte、short、int、long

3　自动类型转换

当把小的类型赋给大的类型时，叫自动类型转换。

int i = 10;

long l = i;

强制类型转换

当把大的类型赋给小的类型时，需要强制类型转换。

long l = 1;

int i = l;//编译出错

int i =(int)l;//可以了。

4　最小运算类型

我们知道整型常量只有int和long。1 + 2的结果int类型。

byte b = 10;//可以的，因为10是常量，编译器知道他的大小！虽然它是int类型，编译器查看它是否在-128~127之内，如果是这个范围就可以赋值。

为了保证精度，java中最小的运算空间为int类型，也就是说两个byte类型的变量做运算，其结果int类型。

2.2.5 关系运算符

² >, < , >=, <= 是赋值的，(数据类型)

² ！=， == ， (是任意类型)

它们都是双目运算符。

前四种的运算量可以是数值类型。

后两种的运算来了可以是任意类型。

表达式结果为boolean类型。

前四种优先级大于后两种。

l &&：逻辑与（断路式）！我读他为“并且”！当左右两边都是true，那么结果为true；否则为false。断路式：当左边的结果为false时，表达式的结果就已经确定了，所以就不在去运算右边了。

l &：逻辑与（傻瓜式）！与&&相同，但无论左边的结果是什么，都会去运算右边！（很少用）

l ||：逻辑或（断路式）！我读他为“或者”！当左右两边都是false，那么结果为false；否则为true。有一方为真，结果就是真，后面的就不用看了。。。

l 断路式：当左边的结果为true时，表达式的结果就已经确定了，所以就不在去运算右边了。

l |：逻辑或（傻瓜式）！与||相同，但无论左边的结果是什么，都会去运算右边。（很少用）

l !：逻辑非：单目的。非真则假；非假则真！boolean a = true; a = !!a;

l ^：逻辑异或！很少用！左右两边不相同结果为true；否则结果为false。

Int a =20;

Int b= 201;

Boolean b1= a !=b ; // =和== 有什么区别？ =是赋值，==是比较。

System.out.println(“b1 =”+b1);

{输出结果为： b1 = true }

Ø || 一个true 就是 true。。&& 一个false 就是 false。

int a = 10;

int b = 20;

int c = 30;

boolean flag = (a > b) & (a < c);//左右两边都是true，结果才为true；只要有一个是false那么结果就是false。

//&&：JVM发现了左边为false时，右边就不在运算了。断路式！

//&：无论左边是不是false，都会去运算右边！！非断路式

int a =10 ;

int b =20;

int c =30;

boolean boo =(a < b) || ( a > c );

System.out.println(boo);

//结果为true . 左边是true 右边是false那么就为true .

Ø ! 是非运算符。

就是把 true 变化成 false，false 变成true

！b 整体是一个值，b 还是 b。。。

boolean b1 =false;

boolean b2= !b1;

System.out.println("b1="+b1+"\t"+"b2="+b2);

//结果b1=falseb2=true

boolean b1 =true

boolean b2= !b1;

System.out.println("b1="+b1+"\t"+"b2="+b2);//结果b1 =true b2 =false

Ø ^：逻辑异或！很少用！左右两边不相同结果为true；否则结果为false。

boolean b1 = false;

boolean b2 = true;

boolean b3 = b1 ^ b2;

System.out.println(b3); // true

Ø || 一个true 就是 true。。&& 一个false 就是 false。

Ø && 当左右两边都是true，那么结果为true；否则为false。断路式：当左边的结果为false时，表达式的结果就已经确定了，所以就不在去运算右边了。

boolean b1 = false;

boolean b2 = true;

boolean b3 = true;

boolean b4 = b1 && b2 ^ b3;

System.out.println(b4); //输出结果为false

2.关系运算符结果类型： boolean

3,关系运算符的优先级：前四种大于后两种。

4.关系运算符的运算量类型：前四种是数值类型，后两种是任意类型

Ø 　条件运算符的运算法则

v 唯一的三目运算符！

v 格式：a?b:c

v 其中a、b、c就是三个运算量，而?和:是条件运算符的符号！

v a – 必须是boolean类型

v b和c – 任意类型。

v 运算法则：当a为true时，表达式的结果为b，即冒号左边的值；当a为false时，表达式的结果为c，即冒号右边的值。

表达式是：

Int a = 10;

Int b =20;

Int c = (boolean)? (整型)：（整型）

True false

// 求两个数中最大值

int a = 30;

int b = 20;

int c = a > b ? a : b;

System.out.println("c = " + c);

// 为true时。：就把值赋给左边的a了

//求n 的绝对值

int n =10;

int nn =n <0?-n:n;

System.out.println("n=" +nn);

//n大于10为false,所以赋给了冒号的右边就是n n就等于10，

// 所以输出为n=10

int a = 10;

int b;

int c = (b=a++);

System.out.println("a = " + a + ", b = " + b + ", c = " + c);

//a=10, a赋值给b.a在自身加1，a=11,b=10,c=10;

int a = 10;

a += 5;//a = a + 5

//a -= 5;//a = a - 5;

System.out.println("a="+a); //输出 a =15

short s1 = 32767;

s1 += 10;//直接在s1那么运算，通过的！编译器不管，但可能存在危险！

s1 = s1 + 10;//在临时空间中运算，然后还要去赋值。编译不通过！

变量和数据类型

变量的类型

Ø 左值的特性

Ø 复合赋值运算符

Ø 赋值表达式一样有值

什么叫类型转换

1 类型的大小顺序

3 自动类型转换

4 最小运算类型

Ø 条件运算符的运算法则

　变量的类型

3　自动类型转换

4　最小运算类型

Ø 　条件运算符的运算法则