java基础学习3（数据类型转换、运算符）

java基础学习—基本数据类型知识,笔记来源于传智。

基本数据类型

整形相关:

1. byte : 8bit；
2. short : 16bit
3. int : 32bit
4. long : 64bit

浮点形相关:

1. float : 32bit；（保留7位小数）
2. double : 64bit （保留15位小数）

其他:
1. char : 16bit；
2. boolean(布尔): 32bit或8bit

注意:

1. 占用内存特殊的是布尔类型，单独声明一个boolean变量时占的是4个字节，但是当声明一个布尔数组时则数组中的元素占1个字节
2. 如果需要把该数据表示成一个long类型的数据，那么需要加数据后面加上L表示，L是不区分大小写的，但是建议使用大写。,可是我们经常会做一下操作

  		byte a = 10;

这里不报错的原因是java编译器在编译时可以识别常量的值，并判断是否超过有效值。但是编译时不会识别变量的值，如下：

 		int a = 10;
 		byte i = a;

3. 如果一个小数没有加上任何标识的时候，那么该小数默认是double类型的数据，如果需要表示成float类型，那么需要在小数的后面加上f表示。f不区分大小写的

类型转化

小数据类型转大数据类型 称为自动类型转换，大数据类型转小数据类型成为强制类型转换，在强制转化时格式如下否则会报错

int a = 5;
byte b = (byte)a;

不同类型数据运算

1. 凡是byte、short 、 char数据类型数据在运算的时候都会自动转换成int类型的数据再运算。

		byte a1 =1;
		byte a2 = 2;
		byte a3 = (byte)(a1+a2);//不强转会报错
		System.out.println(a3); //3 

2.两个不同数据类型的数据在运算的时候，结果取决于大的数据类型

int a = 100;
byte b = 5;
byte c = (byte)(b+a);

负数的存储

		int i = 128;  //4个字节
		byte b =(byte) i;  // 1个字节
		System.out.println(b);  // -128

注意：

1. 在计算机存储中首位为1的一定是负数，首位为0一定为整数。且负数存储的补码

补码的计算

1. 取绝对值
2. 取反
3. +1

这里输出的是-128，那么看下-128的由来
0000 0000 0000 0000 1000 0000
------------------------------强转时取8个字节得到
1000 0000 首位为1代表存的是负数，那我们计算下他代表的值

1000 0000
减去
0000 0001
得
0111 1111
取反

1000 0000 转为10精制为128加上负号就是-128

运算符

算术运算符:

+ (正数、加法、连接符)
连接符的作用： 让任何的数据都可以与字符串进行拼接。
如果+号用于字符串的时候，那么+号就是一个连接符，并不是 做加法功能了。
连接符要注意：任何类型的数据与字符串使用连接符连接，那么结果都是字符串类型的数据。
-
*
/ (除法)
%(取模、取余数)

class Demo3 {
	public static void main(String[] args){
		int i1 = 1;
		int i2 = 2;
		System.out.println(i1 +" world");  //1 world
		
		// 计算机每次运算的时候只能取两个 数据运算。
		System.out.println(1+2+3 +" world"+1+2+3); // 6world123
		
		int a= 12;
		int b = 7;
		System.out.println(a/b); //1

		//在java中做取模 运算的时，结果的正负号是取决于被除数。
		System.out.println("结果:"+(10%3));  // 1
		System.out.println("结果:"+(10%-3)); // 1
		System.out.println("结果:"+(-10%3)); // -1
		System.out.println("结果:"+(-10%-3)); //  -1
	}
}

++ （自增） :  自增就是相当于操作数+1.
前自增：++位于操作数的前面。  比如： ++a；
前自增：先自增，后使用。
后自增： 先使用，后自增。

class Demo4 
{
	public static void main(String[] args) 
	{
		int a = 0;
		int sum = ++a; //前自增。 a = a+1  ， sum = a
		int sum = a++; //后自增  sum = 0 , a = a+1
/*
	后自增在jvm的运行原理：
	
	因为后自增要使用 到没有+1之前 的值，那么jvm会先声明一个变量用于保存没有+1之前的值。
	
	int i = 0;
	i = temp;

	原理：
		1. int temp = i; // 声明了一个临时变量用于记录了i没有加1之前的值。
		2. 自增。  i = i+1;   i = 1;
		3. temp把用作了表达式 的结果。
	
	i的值发生了几次变化：
			i = 0 -----> 1----> 0
*/
		int i = 0;
		i = i++; // 后自增...  后自增要使用到没有+1之前的值。
		System.out.println("i= "+i);//0
	}
}

自减： 操作数-1.

前自减： 先自减，后使用。

后自减： 先使用，后自减。

class Demo5 
{
	public static void main(String[] args) 
	{	
		/*
		int i = 1;
		int sum = --i;  //前自减   i = i-1 , sum = i;
		int sum = i--; // 后自减   sum = i ; i = i-1;
		System.out.println("sum = "+ sum);  // 0  1 
		*/

		int num = 10;
		//int sum = 10* num++; //后自增
		int sum = 10* ++num; //前自增 
		System.out.println("sum = "+ sum);

	}
}

赋值运算符：

=  (赋值运算符)
+= 
-=
*=
/=
%=

class Demo6 
{
	public static void main(String[] args) 
	{
		
		int i = 10; // 把10赋予给i变量。
		i+=2;  // i = i+2; 
		System.out.println("i = "+i);
	
	
		byte b1 = 1;
		byte b2 = 2;
		//b2 = (byte)(b2+b1); //需要强制类型转换
		b2+=b1;  //b2 = b2+ b1;	 b2+=b1 在编译的时候，java编译器会进行强制类型转换，不需要我们手动转换了。
		System.out.println("b2 : "+ b2);
	}
}

比较运算符： 比较运算符的结果都是返回一个布尔值的。

== (判断是否等于)
==用于比较两个基本数据类型数据的时候，比较的是两个变量所存储的值是否一致.
==用于比较两个引用类型变量的数据时候，比较的是两个 引用类型变量所记录的内存地址是否一致. 


!= (不等于)
> (大于)
< (小于)
>= (大于等于)
<= (小于等于)

class Demo7 
{
	public static void main(String[] args) 
	{
		/*
		int a = 10;
		int b =10;
		System.out.println("10等于10吗？"+ (a==b));  
		System.out.println("10不等于1吗？"+ (10!=1) ); //true  
		*/
		
		byte b  = 10;
		long l = 30;
		System.out.println(l>b); //两个不同类型的数据是否可以比较呢.,可以的，但是两个不同类型的数据必须是兼用的数据。
		//这个比较的过程会先把b转换了long类型的数据，然后再进行比较 。

		System.out.println('a'>50);//true
	}
}

逻辑运算符 ：逻辑运算符的作用是用于连接布尔表达式的。

& （与,并且）

规律： 只有左右变量同时 为true，那么结果才是true，否则就为false。

|  (或,或者)

规律： 只要两边的布尔表达式有一边为true，那么结果就为true，只有两边同时为false 的时候，结果才是false.

^  (异或)

规律： 只要两边的布尔表达式 结果不一致，那么结果就为true，如果左右两边 的布尔表达式一致，那么就为false.

！ (非)

---

&& (短路与\双与)

短路与和单与符号的相同与不同点：

相同点： 短路与和单与运算 的结果是一样的。

不同点： 使用短路与的时候，如果左边的布尔表达式为false，则不会在运算右边的布尔表达式，从而提高了
效率。使用单与的时候，即使发现左边的布尔表达式为false，还是会运算右边的布尔表达式的。

只有左边的布尔表达式为false时，双与的效率才要高于单与的.

|| (短路或\双或)

短路或与单或的相同点与不同点：

相同点：运算的结果是一致 的。

不同点：使用短路或的时候，当发现左边的布尔表达式为true时，则不会运算右边的布尔表达式。
使用单或的时候 发现左边的布尔表达式为true，还是会运算右边布尔表达式。

位运算符：位运算符就是直接操作二进制位的。

& (与)
| (或)
^ (异或)
规律： 如果操作数A连续异或同一个操作数两次，那么结果还是操作数A。
应用： 对数据加密.
~  (取反)

class Demo9{
	public static void main(String[] args){
		System.out.println(6&3); // 2 
		System.out.println(6|3); // 7
		System.out.println(6^3); //  5
		System.out.println(~7);  // -8
	}
}

移位运算符：

<<(左移)

规律：一个操作数进行左移运算的时候，结果就是等于操作数乘以2的n次方，n就是左移 的位数.
3<<1 = 3 2(1) = 6;
3<<2 = 32(2) = 12
3<<3 = 3*2(3) = 24

>>(右移)

规律：一个操作数在做右移运算的时候，实际上就是等于该操作数除以2的n次方，n就是右移的位数。

3>>1 = 3 / 2(1) = 1
3>>2 = 3 / 2(2) = 0 。。


>>>(无符号右移) ：

无符号右移与右移的区别：进行右移运算的时候，如果操作数是一个正数，那么左边的空缺位使用0补，如果操作数是一个负数，那么左边的空缺位使用1补。而使用无符号右移的时候，不管是正数还是负数都统一使用0补。

三元运算符(三目运算符)

格式;
布尔表达式？值1:值2 ;

三元运算符要注意的细节：使用三元运算符的时候，一定要使用该表达式返回的结果，或者是定义一个变量接收该表达式返回的结果，否则报错。