java基础进阶（语法，数据类型，运算，循环）

HTDiiii

已于 2024-07-14 13:48:21 修改

阅读量734

点赞数 6

分类专栏： Java开发学习文章标签： java 开发语言

于 2024-07-12 18:07:45 首次发布

本文链接：https://blog.csdn.net/HTDiiii/article/details/140385826

版权

Java开发学习专栏收录该内容

20 篇文章 0 订阅

订阅专栏

数据类型转换

1.1、自动类型转换

基本数据类型从小到大:
byte<short（char）<int<long<float<double
定义：从取值范围小的向取值范围大的赋值就是自动类型转换。

1.2、强制类型转换

定义：从取值范围大的向取值范围小的赋值就是强制类型转换。
格式:
数据类型取值范围小的变量名 = (取值范围小的数据类型)取值范围大的变量名;

public  class TypeDemo
{


	public static void main(String[] args)
	{
	
		//定义一个byte类型的变量b,并为其初始化
		byte  b = 2;
		//定义一个int类型的变量a,将变量b赋值给变量a,自动类型转换
		int a = b;
		//定义一个byte类型的变量b1,将变量a赋值给变量b1,强制类型转换
		byte b1 = (byte)a;
		int a1 = 123;
		char c = (char)a1;
		//所有的小数默认情况下都是double类型
		float f = 3.6f;
		double d = f;
		char c1 = 123;
		//输出的是char类型c1对应的ASCII码整数值是123的字符表示形式
		System.out.println("c1 = "+c1);
		//其他依此类推
	}

}

1.1、算术运算符

%取余或取模

public  class YsfDemo
{


	public static void main(String[] args)
	{
		//定义int类型的变量a,并初始化为6
		int a = 6;
		//定义int类型的变量b,并初始化为3
		int b = 3;
		
		//对变量a和b进行算术运算,并输出结果
		//加号+和字符串一起使用时,此时加号就是一个连接符
		System.out.println(a+" + "+b+" = "+(a+b));
		System.out.println(a+" % "+b+" = "+(a%b));
		
	}

}

1.2、算术运算的数据类型转换

byte/short/char/int在进行算术运算时的结果都是int类型，
当进行算术运算时，如果取值范围最大的是long类型，那么结果就是long类型，
当进行算术运算时，如果取值范围最大的是float类型，那么结果就是float类型，
当进行算术运算时，如果取值范围最大的是double类型，那么结果就是double类型。

public  class YsfDemo1
{


	public static void main(String[] args)
	{
		//定义byte类型的变量b,并初始化为6
		byte b = 6;
		//定义byte类型的变量b1,并初始化为3
		byte b1 = 3;
		
		//将变量b和b1进行算术运算,运算完成以后的结果赋值给byte类型的b2
		//此处的b+b1的结果是int类型,要将int赋值给byte要进行强制类型转换
		byte b2 = (byte)(b + b1);
		//short/char/int在进行算术运算时的结果都是int类型。
		//定义long类型变量g,并为其初始化为12
		long  g = 12;
		//将变量g和b1进行算术运算,计算以后赋值给byte类型的变量b3
		byte b3 = (byte)(g + b1);
		//定义int类型的变量a,并初始化为13
		int  a  = 13;
		//将变量g和a进行算术运算,计算以后赋值给int类型的变量a1
		int a1 = (int)(g + a);
		
	}

}

1.3、双目运算符

+= -= *= /= %=
例如:
a+=b—>a = a + b;

public  class YsfDemo2
{


	public static void main(String[] args)
	{
		
		//定义int类型的变量a,并初始化为3
		int a = 3;
		//定义int类型的变量b,并初始化为6
		int b = 6;
		
		a+=b;//a = a + b;
		System.out.println("a = "+a);//因此此处的结果是9
		System.out.println("b = "+b);//b的值还是6
		
		
	}

}

1.4、位运算符

1.4.1、位与运算符&

运算符规则：将十进制的值转换成二进制，然后只有全部是1时，结果才为1，否则都为0。
例如:
3&6
0011
0110 &

0010 = 2

1.4.2、位或运算符|

运算符规则：将十进制的值转换成二进制，然后只有全部是0时，结果才为0，否则都为1。
例如:
3|6
0011

0110
0111 = 7

1.4.3、异或运算符^

运算符规则：将十进制的值转换成二进制，然后只有全部相同时，结果才为0，否则都为1。
例如:
3^6
0011
0110 ^

0101 = 5

public  class WeiDemo
{


	public static void main(String[] args)
	{
		
		//定义int类型的变量a,并初始化为3
		int a = 3;
		//定义int类型的变量b,并初始化为6
		int b = 6;
		
		//将变量a和变量b进行与位运算
		System.out.println(a+" & "+b+" = "+(a&b));
		//将变量a和变量b进行或位运算
		System.out.println(a+" | "+b+" = "+(a|b));
		//将变量a和变量b进行异或位运算
		System.out.println(a+" ^ "+b+" = "+(a^b));
		
		
	}

}

1.4.4、按位取反~

将十进制的值转换成二进制后进行计算；二进制最高位表示符号位，如果最高位是1表示负数，如果最高位是0表示正数；正数取反后减-1，负数取反后加+1。
例如：12按位取反
~12
0000 1100 12
0111 0011 将12的二进制进行取反,此时最高位，不参加运算
0111 0010 正数取反后减-1，此处是减-1以后的二进制值
1000 1101 将减-1以后的二进制值进行取反，此时最高位参加运算，最终结果就是负数 -13
-12按位取反
~-12
1000 1100 -12
1111 0011 将-12的二进制进行取反,此时最高位，不参加运算
1111 0100 负数取反后加+1，此处是加+1以后的二进制值
0000 1011 将加+1以后的二进制值进行取反，此时最高位参加运算，最终结果就是正数 11

public  class WeiDemo1
{


	public static void main(String[] args)
	{
		
		//定义int类型的变量a,并初始化为12
		int a = 12;
		//定义int类型的变量b,并初始化为-12
		int b = -12;
		
		//将变量a按位取反
		System.out.println(" ~ "+a+" = "+(~a));
		//将变量b按位取反
		System.out.println(" ~ "+b+" = "+(~b));
		
		
	}

}

1.4.5、>>右移位

运算规则：运算符左边的数，除以2的位移次方数，就是结果。

1.4.6、<<左移位

运算规则：运算符左边的数，乘以2的位移次方数，就是结果。

public  class WeiDemo2
{


	public static void main(String[] args)
	{
		
		//定义int类型的变量a,并初始化为12
		int a = 12;
		
		//将变量a右移2位后的结果是,运算规则:12>>2---> 12/2^2--->12/4 = 3
		System.out.println(a+" >> 2 = "+(a>>2));
		//将变量a右移3位后的结果是,运算规则:12>>3---> 12/2^3--->12/8 = 1
		System.out.println(a+" >> 3 = "+(a>>3));
		//将变量a右移4位后的结果是,运算规则:12>>4---> 12/2^4--->12/16 = 0
		System.out.println(a+" >> 4 = "+(a>>4));
		
		System.out.println("-------------------");
		
		//将变量a左移2位后的结果是,运算规则:12<<2---> 12*2^2--->12*4 = 48
		System.out.println(a+" << 2 = "+(a<<2));
		//将变量a左移3位后的结果是,运算规则:12<<3---> 12*2^3--->12*8 = 96
		System.out.println(a+" << 3 = "+(a<<3));
		//将变量a左移4位后的结果是,运算规则:12<<4---> 12*2^4--->12*16 = 192
		System.out.println(a+" << 4 = "+(a<<4));
		
		
	}

}

1.5、单目运算符

++ 加1
– 减1
只能处理变量，不能用于常量或常数。

public  class DanDemo
{


	public static void main(String[] args)
	{
		
		//定义int类型的变量a,并初始化为12
		int a = 12;
		int b = a++;//b=12  a=13
		int c = ++a;//c=14  a=14
		int d = a--;//d=14  a=13
		int e = --a;//e=12  a=12
		
		//final int  b = 6;
		
		//此处编译出错,因为++或--不能操作常量或常数
		//System.out.println(b++);
		//System.out.println(12++);
		
		System.out.println("a = "+a);//12
		System.out.println("b = "+b);//12
		System.out.println("c = "+c);//14
		System.out.println("d = "+d);//14
		System.out.println("e = "+e);//12
		
		
	}

}

1.6、三目运算符

格式：
boolean表达式？boolean表达式为true时返回的数据：boolean表达式为false时返回的数据
public class SanDemo
{

public static void main(String[] args)
{
	
	//定义int类型的变量a,并初始化为12
	int a = 12;
	//定义int类型的变量b,并初始化为6
	int b = 6;
	
	/*
	如果a>b位true,则将字符串"a > b"赋值给变量s,否则将字符串"a <= b"
	赋值给变量s
	*/
	String s = a > b ? "a > b" : "a <= b";
	
	System.out.println("s = "+s);
	
	
}

}

1.7、逻辑运算符

&&逻辑与短路与当&&左边的结果为false时，则不会对&&右边的数据进行计算，此时发生短路，当&&左边的结果为true时，此时会对&&右边的数据进行计算，如果为true则整个结果就为true，否则就为false。
||逻辑或短路或当||左边的结果为true时，则不会对||右边的数据进行计算了，此时发生短路，当||左边的结果为false时，此时会对||右边的数据进行计算，如果为true则整个结果就为true,否则就我false。
这两个运算符用于判断，而上面的位与&和位或|用于位运算，不推荐用于判断。

分支语句

if语句
ifelse语句
if elseif else语句
switch语句
1.1、if语句
格式:
if(boolean表达式)
{
当boolean表达式为true时，执行这里的代码，否则不执行;
}

1.2、ifelse

格式:
if(boolean表达式)
{
当boolean表达式为true时，执行这里的代码;
}
else
{
当boolean表达式为false时，执行这里的代码;
}

1.3、if elseif else

格式：
if(boolean表达式1)
{
当boolean表达式为true时，执行这里的代码;
}
else if(boolean表达式2)
{
当boolean表达式2为true时，执行这里的代码;
}
…
else if(boolean表达式N)
{
当boolean表达式N为true时，执行这里的代码;
}
else
{
当所有的boolean表达式都是false时，执行这里的代码；
}

//帮助当前的代码找到所需要使用的Scanner
import java.util.Scanner;
public  class IfDemo
{


	public static void main(String[] args)
	{
		
		//定义int类型的变量a,并初始化为12
		//int a = 12;
		//定义int类型的变量b,并初始化为6
		//int b = 6;
		Scanner   s = new Scanner(System.in);
		System.out.println("请输入一个整数值:");
		int a = s.nextInt();
		System.out.println("请再输入一个整数值:");
		int b = s.nextInt();
		
		/*
		如果a>b位true,则输出字符串"a > b",否则什么也不输出
		*/
		if(a > b)
		{
			System.out.println("a > b");
		}
		
		if(a < b)
		{
			System.out.println("a < b");
		}
		else
		{
			System.out.println("a >= b");
		}
		
		
		if(a < b)
		{
			System.out.println("a < b");
		}
		else if(a > b)
		{
			System.out.println("a > b");
		}
		else
		{
			System.out.println("a == b");
		}
		
	}

}

1.4、Switch语句

格式:
switch(表达式)
{
case value1:
value1的执行语句;
break;
…
case valueN:
valueN的执行语句;
break;
default:
default的执行语句;
break;
}

备注：

1、表达式处可以编写能够自动转换成int类型的表达式，或字符串。
2、value必须是常数值。
3、break用于结束当前的switch语句。
4、case语句可以有0~n个。
5、default语句可以有0~1个，可以写在switch语句中任意一个合法的位置，始终最后执行，建议写在最后。

import  java.util.Scanner;
public class Test2
{

	/**
	练习2：
	现学期成绩已经出榜,根据分数输出不同的结果,如果分数是A输出优秀,如果分数B输出良好,如果分数C输出及格,如果分数是D输出不及格,否则输出输入的成绩无效。

	*/
	public static void main(String[] args)
	{
		Scanner  s = new Scanner(System.in);
		System.out.println("请输入您的分数:");
		char score = (char)s.nextInt();
		switch(score)
		{
			
			case 'A':
				System.out.println("优秀");
				break;
			case 'B':
				System.out.println("良好");
				break;
			case 'C':
				System.out.println("及格");
				break;
			case 'D':
				System.out.println("不及格");
				break;
			default:
				System.out.println("成绩无效");
				break;
		}
		
		
		/*String score = s.next();
		switch(score)
		{
			case "A":
				System.out.println("优秀");
				break;
			case "B":
				System.out.println("良好");
				break;
			case "C":
				System.out.println("及格");
				break;
			case "D":
				System.out.println("不及格");
				break;
			default:
				System.out.println("成绩无效");
				break;
		}*/
		

	}


}

循环语句

1.1、循环语句定义
当满足一定的条件时，一直被执行的语句就是循环，直到不满足条件才停止下来/结束循环。
1.2、循环组成部分
1、初始化部分，就是循环条件用到的变量初始定义并赋值的
2、循环条件部分，就是用于判断是否满足条件。
3、迭代部分，就是为了让循环停止下来的。
4、循环体部分，当满足条件时一直被执行的代码。
1.3、for循环语句
格式:
[初始化部分1;]
for([初始化部分2];循环条件部分;迭代部分)
{
循环体部分
}

备注：

1、for循环中的分号一定不能少。
2、当初始化部分的变量，不但在for循环中使用，还要在for循环之外使用，此时在初始化部分1处进行初始化；当初始化部分的变量，只在for循环中使用，此时在初始化部分2处进行初始化。

public class ForDemo
{

	public static void main(String[] args)
	{
		
		//初始化部分
		int  i = 1;
		//   循环条件部分;迭代部分
		for(;i < 10;i++)
		{
			//循环体部分
			System.out.println("i = "+i);
			
		}
		
		//for循环语句之外
		System.out.println("i === "+i);
		
		
		
		//初始化部分;循环条件部分;迭代部分
		for(int  j = 1;j < 10;j++)
		{
			//循环体部分
			System.out.println("j = "+j);
			
		}
		
		//for循环语句之外,由于j是一个块级变量,只能在for循环语句中使用,此处编译出错。
		//System.out.println("j === "+j);
		


	}



}