JAVA day01 变量和数据类型、运算符

变量

变量：是指在内存中开辟的存储空间，用于存放运算过程中需要用到的数据。

比如：int a = 12 这里的 a 就是变量

数据类型

java的数据类型分为两大类：

• 基本数据类型：整数、浮点数、字符、布尔
• 引用数据类型：类、数组、接口

基本数据类型 

整数：字节型（byte）、短整型（short）、整型（int）、长整型（long）

浮点数：单精度浮点数（float）、双精度浮点数（double）

提示：java中的默认类型：整数类型是int、浮点类型是double

代码说明

public class Deom01 {
	public static void main(String[] args) {
		//变量的定义/声明：数据类型  变量名 = 数据值; 
		/*说明：
		 * 1.变量必须先声明、赋值、再使用
		 * 2.变量都定义在其作用域内{}，在作用域内，它是有效的，换句话说出了作用域就失效了。
		 * 同一个作用域内，不可以声明两个同名的变量*/
		
		//整型（byte、short、int、long）
		byte a = -123;
		//byte a1 = 128;<-编译不成功，因为超过了byte的数值范围
		System.out.println(a);//打印结果，输出结果
		
		short b = 23;
		System.out.println(b);
		
		int c = 5;
		System.out.println(c);
		
		long d = 12356;//<-当数值在int默认值范围内可以输出
		//long d = 213412333333;<-当数值超过int默认值范围内就不可以输出了
		//则需要在数值后面加上L或l
		long d1 = 213412333333L;
		long d2 = 213412333333l;
		System.out.println(d1);
		
		//浮点类型 (float、double)
		//float跟上面long相似数值后面也需以F或f结尾
		float e = 0.363636F;
		System.out.println(e);
		//double 系统默认量
		double f = 0.3;
		
		//字符型（char）通常会用''，内部只能写一个字符
		char g =  'A';
		//char g =  'AB';<-这样的就编译不通过
		char g1 = '3';
		char g2 = '美';
		System.out.println(g2);
		
		//布林类型（boolean: true\false）
		boolean h = true;
		System.out.println(h);
		
	}
	
}

基本数据类型之间的转换规则

前提：只讨论7种基本数据类型变量之间的运算，不包含boolean类型。

1.自动类型提升：
  当容量小的数据类型的变量与容量大的变量做运算时，结果自动提升为容量大的数据类型。
  byte、char、short --> int --> long --> float --> double
  特别的：当byte、char、short三种类型做运算时，结果都为int型接收
2.强制类型转换：自动类型提升运算的逆运算。
  - 需要使用强转符：( )
  - 注意：强制类型转换，可能导致精度损失。

说明：此时的容量大小指的是，表示数的范围和大小而不是字节。比如：float容量要大于long的容量，因为它表示的数的范围要大于long。

代码说明

public class Deom02 {

	public static void main(String[] args) {
		//自动提升类型
		byte b1 = 2;
		int i1 = 123;
		//编译不通过 byte b2 = b1 + i1;因为i1是int类型，不能用byte接收
		int i2 = b1 + i1;//这里可以用int接收，结果直接将结果自动提升为int
		long l1 = b1 + i1;
		System.out.println(i2);//125
		System.out.println(l1);//125
		
		float f1 = b1 + i1;
		System.out.println(f1);//125.0
		short s1 = 125;
		double d1 = s1;
		System.out.println(d1);//125.0
		
		//++++++++++特别的++++++++++++
		char c1 = 'a';//97
		int i3 = 12;
		int i4 = c1 + i3;
		System.out.println(i4);//109
		short s2 = 23;
		int i5 = s2 + i3;
		System.out.println(i5);//35
		byte b2 = 3;
		int i6 = b2 + i3;
		System.out.println(i6);//15
		
		//强制转换类型
		double d3 = 12.9;
		//本来前面应该用double接收，但要是强制转换成int就必须加强制转换符()
		int i7 = (int)d3;//截断操作，取整数，小数点后都不要了
		System.out.println(i7);//12 有精度损失

        //没有精度损失
		long l2 = 123;
		short s3 = (short)l2;
		System.out.println(s3);//123

		int i8 = 128;
		byte b3 = (byte)i8;
		System.out.println(b3);//-128 有精度损失
		
	}

}

---

运算符

算数运算符

代码说明

public class AriTest {

	public static void main(String[] args) {
		        //除号：/
				int num1 = 12;
				int num2 = 5;
				int result1 = num1 / num2;
				System.out.println(result1);//2

				int result2 = num1 / num2 * num2;
				System.out.println(result2);//10

				double result3 = num1 / num2;//num1/num2时做的还是int类型，但结果赋值给double，所以变2.0
		        System.out.println(result3);//2.0
				
				double result4 = num1 / num2 + 0.0;//先int除法再变成double
				double result5 = num1 / (num2 + 0.0);//num2先变成double再与num1做除法
				double result6 = (double)num1 / num2;//num1强制转换成double再与num2做除法
				double result7 = (double)(num1 / num2);//先做完除法再强制转换为double
				System.out.println(result4);//2.0
				System.out.println(result5);//2.4
				System.out.println(result6);//2.4
				System.out.println(result7);//2.0


				//取余运算：%
				//结果的符号与被模数（被除数m）的符号相同
				//后面 % 也经常用来判断能否被除尽的情况
				int m1 = 12;
				int n1 = 5;
				System.out.println("m1 % n1" + m1 % n1);//2
				//中间的+为连接

				int m2 = -12;
				int n2 = 5;
				System.out.println("m2 % n2" + m2 % n2);//-2

		        int m3 = 12;
				int n3 = -5;
				System.out.println("m3 % n3" + m3 % n3);//2
				
				int m4 = -12;
				int n4 = -5;
				System.out.println("m4 % n4" + m4 % n4);//-2


				//(前)++ ：先自增1，后运算
				//(后)++ ：先运算，后自增1
				int a1 = 10;
				int b1 = ++a1;//先+1再赋值给b1
				System.out.println("a1 =" + a1 + ",b1 = " + b1);//11

				int a2 = 10;
				int b2 = a2++;//直接就赋值给b2没有+1
				System.out.println("a2 = " + a2 + ",b2 = " + b2);//10
		        
				int a3 = 10;
				++a3;//a3++ 输出一样的都是11
				int b3 = a3;

				//注意点：
				short s1 = 10;
				//s1 = s1 + 1; <--编译失败因为int转换为short有损失
				//s1 = (short)(s1 + 1);//编译正确
				s1++;//自增1不会改变本身变量的数据类型
				System.out.println(s1);//11

				//问题：
				byte bb1 = 127;
				bb1++;
				System.out.println("bb1 = " + bb1);//-128 自码 反码 补码来看

				//(前)-- ：先自减1，后运算
				//(后)-- ：先运算，后自减1
				int a4 = 10;
				int b4 = --a4;
				int a5 = 10;
				int b5 = a5--;
				System.out.println("a4 = " + a4 + ", b4 = " + b4);//9
				System.out.println("a5 = " + a5 + ", b5 = " + b5);//10
	}

}

赋值运算符

代码说明

public class SetValueTest {
	public static void main(String[] args) {
	//最基本的赋值符号：=
			int i1 = 10;
			int j1 = 10;
			System.out.println("i1 = " + i1 + ", j1 = " + j1);

			int i2,j2;
			//连续赋值
			i2 = j2 = 20;
			System.out.println("i2 = " + i2  + ", j2 = " + j2);

			int i3 = 30,j3 = 30;
			System.out.println("i3 = " + i3  + ", j3 = " + j3);
		    
			//*****************
			int num1 = 10;
			num1 += 2;//num1 = num1 + 2; //先+2再赋值
			System.out.println(num1);

			int num2 = 12;
			num2 %= 5;//num2 = num2 % 5;
			System.out.println(num2);

			//需注意
			short s1 = 10;
			//s1 = s1 + 2;//编译失败，int转换为short会有精度损失
			s1 += 2;//编译成功，说明不会改变变量本身的数据类型
			System.out.println(s1);
			

			//开发中，能实现+2的操作有几种方法？ （前提: int num = 10;）
			//方式一： num = num + 2 
			//方式二： num += 2;（推荐）


			//开发中，能实现+1的操作有几种方法？ （前提: int num = 10;）
			//方式一：num = num + 1;
			//方式二：num += 1;
			//方式三：num++;(推荐)


			//练习1
			int i = 1;
			i *= 0.1;
			System.out.println(i);//0
			i++;
			System.out.println(i);//1

			//练习2
			int m = 2;
			int n = 3;
			n *= m++;// n = n * m++; -->后++，所以这里的m=2 n=3*2=6
			System.out.println("m=" + m);//3
			System.out.println("n=" + n);//6
			
			//练习3
			int n1 = 10;
			n1 += (n1++) + (++n1);// n1 = n1 + (n1++) + (++n1); --> n1=10+10（后++）+12（前面后++ n1变成11 然后前++ 变成12）=32
			System.out.println(n1);//32
		}
	
}

比较运算符（关系运算符）

代码说明

public class CompareTest {
	public static void main(String[] args) {
		int i = 10;
		int j = 20;

		System.out.println(i == j);//false 判断i是否等于j
		System.out.println(i = j);//20 赋值运算

		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b2 == b1);//false
		System.out.println(b2 = b1);//true
	}

}

逻辑运算符

&(逻辑与) &&(短路与) |(逻辑或) ||(短路或) !(逻辑非) ^(逻辑异或)

代码说明

public class LogicTest {

	public static void main(String[] args) {
		        //区分：& 与 &&
				//相同点1：& 与 && 的运算结果相同
				//相同点2：当符号（& &&）左边是true时，二者都会执行符号右边的运算
				//不同点：当符号左边是false时，& 继续执行符号右边的运算，&&就不再执行符号右边的运算，直接输出或者进行下一步操作
				//开发中：推荐使用 &&
				boolean b1 = true;
				b1 = false;
				int num1 = 10;
				if (b1 & (num1++ > 0))
				{
					System.out.println("我现在很困");//1.(true)
				}else{
					System.out.println("我现在很饿");//2.(false)
				}

				System.out.println("num1 = " + num1);//1(true)11, 2.(false)11 

				
				
				boolean b2 = true;
				b2 = false;
				int num2 = 10;
				if (b2 && (num2++ > 0))
				{
					System.out.println("我现在很困");//1.(true)
				}else{
					System.out.println("我现在很饿");//2.(false)
				}

				System.out.println("num2 = " + num2);//1.(true)11, 2.(false)10
			
			    //区分：| 与 ||
				//相同点：| 与 || 的运算结果相同
				//相同点2：当符号左边是false时，二者都会执行符号右边的运算
				//不同点：当符号左边是true时，| 继续执行符号右边的运算，而 || 不再执行符号右边的运算
				//开发中：推荐使用 ||
				boolean b3 = false;
				b3 = true;
				int num3 = 10;
				if (b3 | (num3++ > 0))
				{
					System.out.println("我现在很困");//1.(true) 2.(true)
				}else{
					System.out.println("我现在很饿");//
				}

				System.out.println("num3 = " + num3);//1.(true)11, 2.(true)11
				
				
				boolean b4 = false;
				b4 = true;
				int num4 = 10;
				if (b4 || (num4++ > 0))
				{
					System.out.println("我现在很困");//1.(true) 2.(true)
				}else{
					System.out.println("我现在很饿");//
				}

				System.out.println("num4 = " + num4);//1.(true)11, 2.(true)10
				

	}

}

位运算符

代码说明

/*
结论：
1.位运算符操作的都是整型的数据
2. << :在一定范围内，每向左移一位，相当于 * 2
   >> :在一定范围内，每向右移一位，相当于 / 2
*/
public class BitTest {
		public static void main(String[] args) 
		{
			int i = 21;

			System.out.println("i << 2 :" + (i << 2));//84 21*2*2
			System.out.println("i << 3 :" + (i << 3));//168 21*2*2*2
			
			int m = 12;
			int n = 5;
			System.out.println("m & n :" + (m & n));//4
			System.out.println("m | n :" + (m | n));//13
			System.out.println("m ^ n :" + (m ^ n));//9 具体运算看图片

			//练习：交换两个变量的值
			int num1 = 10;
			int num2 = 20;
			System.out.println("num1 =" + num1 + ",num2 = " + num2);

			//方式一：定义临时变量
			int temp = num1;
			num1 = num2;
			num2 = temp;

			//方式二：好处：不用定义临时变量
			//坏处：1.相加操作可能超出存储范围 2.有局限性：只能适用于数值类型
			//num1 = num1 + num2; //num1=10+20
			//num2 = num1 - num2; //num2=30-20
			//num1 = num1 - num2; //num1=30-10
			
			//方式三：位运算符 png位运算符举例3
			//有局限性：只能适用于数值类型
			//num1 = num1 ^ num2;
			//num2 = num1 ^ num2;
			//num1 = num1 ^ num2;

			System.out.println("num1 =" + num1 + ",num2 = " + num2);



	}

}

三元运算符

代码说明

public class SanYuanTest {
	public static void main(String[] args) 
	{
		//获取两个整数的较大值
		int m = 12;
		int n = 5;
		int max = (m > n) ? m : n;
		System.out.println(max);// 12

		//(m > n) ? 2 : "n大";//编译错误，不同类型
		
		//******************
		n = 12;
		String maxStr = (m > n)?  "m大" : ((m == n)? "m和n相等" : "n大");
		System.out.println(maxStr);// m和n相等

		//*******************
		//获取三个数的最大值
		int n1 = 12;
		int n2 = 30;
		int n3 = -32;
		
		int max1 = (n1 > n2)? n1 : n2;
		int max2 = (max1 > n3)? max1 : n3;
		System.out.println("三个数中最大值为：" + max2);//30

	}
}