Java语言基础04-运算符、控制语句

Java语言中的运算符

• 算术运算符
• 关系运算符
• 逻辑运算符
• 字符串连接运算符
• 三元运算符
• 赋值类运算符

算术运算符

+	求和
-	相减
*	乘积
/	商
%	求余数【取模】
++	自加1
–	自减1

注意：一个表达式当中有多个运算符，运算符有优先级，不确定的加小括号，优先级得到提升。没有必要专门去记忆运算符的优先级。

public class OperatorTst01
{
	public static void main(String[] args){
	//以下以++为例，--预算符自学！
	//关于++运算符【自加1】
	int k = 10;
	//++运算符可以出现在变量后面【单目运算符】
	k ++;
	System.out.println(k);//11
	int y = 10;
	//++运算符可以出现在变量前面【单目运算符】
	++ y;
	System.out.println(y);//11
	
	//小结：
	//++运算符可以出现在变量前，也可以出现变量后，无论是变量前，还是变量后
	//只要++运算结束，该变量中的值一定会自加1！
	
	//++ 出现在变量后
	//规则：先做赋值运算，再对变量中保存的值自加1
	int a = 100;
	int b = a ++;
	System.out.println(a);//101
	System.out.println(b);//100
	
	//++ 出现在变量前
	//规则：先进行自加1运算，再进行赋值运算
	int m = 20;
	int n = ++ m;
	System.out.println(m);//21
	System.out.println(n);//21
	
	int xx = 500;
	System.out.println(xx ++);//500
	System.out.println(xx);//501
	/*println()源码如下：
	    public void println(int x) {
        synchronized (this) {
            print(x);
            newLine();
        }}
        因此println(xx ++)实质上为println(int x = xx ++),输出print(x)
    */
	int yy = 100;
	System.out.println(++ yy);//101
	System.out.println(yy);//101	
	System.out.pritnln(--yy);//100
	System.out.pritnln(yy++);//100
	System.out.pritnln(yy--);//101
	System.out.pritnln(yy--);//100
	System.out.pritnln(yy--);//99
	System.out.pritnln(yy);//98
	}
}

关系运算符

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

注意：
=是赋值运算符
== 是关系运算符
关系运算符的运算结果是一定是布尔类型:true/false

public class OperatorTest02
{
	public static void main(String[] args)
	{
		int a = 10;
		int b = 10;
		System.out.pritnln(a > b);//false
		System.out.pritnln(a >= b);//false
		System.out.pritnln(a == b);//true
		
	    关系运算符的运算原理：
		int a = 10；
		int b = 10;
		a > b 比较的时候，比较的是a中保存的10这个值和b中保存的10这个值之间的大小比较。 
	}
}

逻辑运算符

&	逻辑与【两边的算子都是true，结果才是true】
|	逻辑或【只要两边的算子有一个是true，结果就是true】
!	逻辑非【取反，!true就是false，!false就是true，这是一个单目运算符】
^	逻辑异或【两边的算子只要不一样，结果就是true】
&&	短路与
||	短路或

• 1.逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的结果也是一个布尔类型
• 2.短路与和逻辑与最终的运算结果是相同的，只不过短路与存在短路现象；
• 3.短路或和逻辑或最终的运算结果是相同的，只不过短路或存在短路现象；
• 4.什么情况下发生短路现象？
• 5.什么时候选择使用逻辑与运算符？什么时候使用短路与运算符？

public class OperatorTest03
{
	public static void main(String[] args)
	{
		//逻辑与和短路与的区别：
		int x = 10;
		int y = 8;
		//逻辑与
		System.out.println(x < y & ++x < y);
		System.out.println(x);//11
		
		//逻辑与和短路与的区别：
		int x = 10;
		int y = 8;
		//短路与
		//x < y结果是flase，整个表达式结果已经确定是false
		//所有后面的表达式没有再执行，这种现象被称为短路现象。
		//短路与才有短路现象，逻辑与是不会存在短路现象的
		System.out.println(x < y && ++x < y);
		System.out.println(x);//10
		/*
			从某个角度来看，短路与更智能，由于后面的表达式可能不执行，
			所以执行效率更高。这种方式在实际的开发中使用较多。
			短路与比逻辑与使用的更多，短路与更常用。
			但是，在某些特殊的业务逻辑当中，要求运算符两边的算子必须全部执行，
			此时必须使用逻辑与，不能使用短路与。使用短路与肯能导致右边表达式不执行。
		*/
		/*
			什么情况下发生短路或？
				第一个表达式执行结果是true，会发生短路或；
			什么情况下发生短路与？
				第一个表达式执行结果是false，会发生短路与。
		*/
	} 
}

赋值类运算符

• 基本的赋值运算符
  =
• 扩展的赋值运算符
  +=
  -=
  *=
  /=
  %=
  • 赋值类的运算符优先级，先执行等号右边的表达式，再将执行结果赋值给左边的变量
  • 注意以下代码：

byte i = 10;
i += 5;//等同于i = (byte)(i+5)

int k = 10;
k += 5;//等同于k = (int)(k+5)

long s = 100L;
int y = 20;
y += s;//等同于y = (int)(y+s)

-重要结论：扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是byte类型，无论怎么进行追加或追减，最终该变量的数据类型还是byte类型

public class OperatorTest04
{
	public static void main(String[] args)
	{
		int i = 20;
		//扩展的逻辑运算符
		i += 5;//等同于i = i + 5
		i -= 5;//等同于i = i - 5
		i *= 5;//等同于i = i * 5
		i /= 5;//等同于i = i / 5
		i %= 5;//等同于i = i % 5
		//--------------------------
		//10没有超出byte取值范围，可以直接赋值
		byte d = 10;
		//b = 15;//可以，编译通过，15没有超出byte取值范围，可以直接赋值
		//编译错误，编译器只检查语法，不运行程序，编译器发现b+5的类型是int类型，b变量的数据类型是byte
		//大容量向小容量转换需要加强制类型转换符，所以以下程序编译报错。
		//b = b + 5;
		//纠正错误
		b = (byte)(b + 5);

		byte x = 10;
		x += 5;//编译通过！！！等同于(byte)(x=x+5)，其实并不等同于x=x+5
		System.out.println(x);//15
		
		byte z = 0;
		z += 128;//等同于(byte)(z=z+128)
		System.out.println(z);//-128【强转，损失精度】
	}
}

字符串连接运算符

• 关于java中的"+"运算符
  • +运算符在java语言当中有两个作用：
    • 加法运算，求和
    • 字符串的连接运算
  • 当"+"运算符两边的数据都是数字的话，一定是进行加法运算
  • 当"+"运算符两边的数据只要有一个数据是字符串，一定会进行字符串连接运算。
    • 数字 + 数字 —> 数字【求和】
    • 数字 + “字符串” —>“字符串”【字符串连接】
  • 在一个表达式当中可以出现多个"+"，在没有添加小括号的前提之下，遵循自左向右的顺序依次运算。

public class OpratorTest01
{
	public static void main(String[] args)
	{
		System.out.println(10 + 20);//30
		System.out.println(10 + 20 + 30);//60
		System.out.println(10 + 20 + "30");//3030，自左向右的顺序依次运算，第一个括号是加法，第二个加法是字符串连接
		System.out.println(10 + (20 + "30"));//102030
		
		int a = 10;
		int b = 20;
		System.out.println(a + "+" + b + "=" + (a + b));//10 + 20 = 30
		
		//引用类型String
		//String是SUN在JavaSE当中提供的字符串类型
		//String.class字节码文件
		
		//int是基本数据类型，i是变量名，10是int类型的字面值
		//int i = 10;
		//String是引用数据类型，s是变量名,"abc"是String类型的字面值
		//String s = "abc"
		//String s = 10;//类型不兼容
		
		String username = "zhangsan"
		System.out.println("登录成功，欢迎"+username+"回来");
	}
}

三元运算符

• 三元运算符/三目运算符/条件运算符
  • 语法规则：
    布尔表达式？表达式1：表达式2
  • 执行原理 ：
    当布尔表达式的结果是true的时候，选择表达式1作为整个表达式的执行结果
    当布尔表达式的结果是false的时候，选择表达式2作为整个表达式的执行结果

public class OperatorTest01
{
	public static void main(String[] args)
	{
		//编译错误，不是一个完整的java语句
		//10；
		//编译错误，不是一个完整的java语句
		//'男'；
		
		boolean sex = false;
		//分析以下程序是否可以编译通过？
		//编译报错，因为它不是一个完整的java语句
		//sex ? '男':'女'
		
		char c = sex ? '男':'女'
		System.out.pritnln(c);//'女'
		
		//语法错误，编译报错，结果可能是String，也可能是char，但是前边不能用char来接收数据
		//sex = true;
		//char c1 = sex ? "男":'女';
		
		/*编译错误，类型不兼容
		sex = false;
		char c1 = sex ? "男":'女';
		*/
		
		//可以输出
		System.out.pritnln(sex?'"男":'女');
	}
}

Java语言中的控制语句

• 选择结构
  • if、if…else
  • switch
• 循环结构
  • for
  • while
  • do…while()
• 控制循环结构
  • break
  • continue

if语句

• if语句的语法结构：四种编写方式
• 重点：对于java语句中的if语句来说，只要有一个分支执行，整个if语句全部结束。

第一种：
	if(布尔表达式){
		java语句;
		java语句;
		...
	}
第二种：
	if(布尔表达式){
		java语句;
		java语句;
		...
	}else{
		java语句;
		java语句;
		...
	}
第三种：
	if(布尔表达式){
		java语句;
		java语句;
		...
	}else if(布尔表达式){
		java语句;
		java语句;
		...	
	}else if(布尔表达式){
		java语句;
		java语句;
		...	
	}else if(布尔表达式){
		java语句;
		java语句;
		...	
	}......
第四种：
	if(布尔表达式){
		java语句;
		java语句;
		...
	}else if(布尔表达式){
		java语句;
		java语句;
		...	
	}else if(布尔表达式){
		java语句;
		java语句;
		...	
	}else if(布尔表达式){
		java语句;
		java语句;
		...	
	}else{
	
	}
注意：以上的第二种编写方式和第四种编写方式都带有else分支，这两种方式可以100%保证有分支执行
所有控制语句都是可以嵌套使用的，只要合理嵌套就行。
分支中只有一条java语句，大括号可以省略

接收用户键盘输入

/*
	System.out.println();负责向控制台输出【从内存到控制台，输出的过程，这是从内存中出来了】
	接收用户键盘输入，从“键盘”到“内存”。【输入的过程，到内存中去】
*/

public class KeyInputTest
{
	public static void main(String[] args){
	
	//第一步：创建键盘扫描对象
	java.util.Scanner s = new java.util.Scanner(System.in);

	//第二步：调用Scanner对象的next()方法开始接收用户键盘输入
	//程序执行到这里会停下，等待用户的输入
	//当用户输入的时候，并且最终敲回车键的时候，键入的信息会自动赋值给userInputContent
	//接收文本【以字符串的形式接收】
	//String userInputContent = s.next();  //标识符的命名规范，见名知意

	//将内存中的数据输出到控制台
	//System.out.println("您输入的字符串是" + userInputContent);

	int num = s.nextInt();
	System.out.println("您输入的数字是" + num);

		
	}
}

举例1：

/*需求：
	假设系统给定一个人的年龄，根据年龄来判断这个人处于生命的哪个阶段，年龄必须在【0-150】
	【0-5】幼儿
	【6-10】少儿
	【11-18】青少年
	【19-35】青年
	【36-55】中年
	【56-150】老年
*/
public class OperatorTest02
{
	public static void main(String[] args)
	{
		//1,接收用户键盘输入：年龄【输入的时候必须输入数字】
		java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.print("请输入你的年龄：");//输出提示信息，要不然用户根本不知道这里要干嘛！
		int age = s.nextInt();//停下来等待用户的输入，赋值给age变量
		
		//2.根据需求进行业务逻辑判断
		String str = "老年";//给默认值
		if(age < 0 || age > 150){
			str = "你提供的年龄不合法，年龄值需要在【0-150】之间";
		}else if(age <= 5){
			str = "幼儿";
		}else if(age <= 10){
			str = "少年";
		}else if(age <= 18){
			str = "青少年";
		}else if(age <= 35){
			str = "青年";
		}else if(age <= 55){
			str  = "中年";
		}
		if(age < 0||age > 150){
			System.out.println("你提供的年龄不合法，年龄值需要在【0-150】之间");
		}else{
		System.out.println("你处于生命周期的" + str + "阶段");			
		}

	}
}

举例2：

/*
需求：
	判断当前的天气：
		当外面下雨的时候：
			带雨伞：
				判断性别：
					当性别为男，带一把大墨伞
					当性别为女，带一把小花伞
		当外边是晴天的时候：
			判断天气的温度：
				当天气温度在30度以上时：
					当性别为男，戴墨镜
					当性别为女，擦防晒霜
提示：
	1.一定会用到嵌套
	2.天气状况，温度、性别都需要从键盘输入
		天气状况：1表示下雨、0表示晴天
				温度直接使用数字即可
				性别：1表示男、0表示女	
*/

注意if简写语法形式：

1.int sex = true;
2.if(sex)
3.	System.out.println('男');
4.	System.out.println('呵呵');
5.else
6.	System.out.println('女');
//第5行语法错误，缺少配套if，第4行正常输出

swicth语句

• 1.switch语句也是选择结构，也是分支语句
• 2.switch语句的语法结构:

switch(int或String类型的字面值或者变量){
	case int或String类型的字面值或者变量:
		java语句;
		...
		break;
	case int或String类型的字面值或者变量:
		java语句;
		...
		break;
	case int或String类型的字面值或者变量:
		java语句;
		...
		break;
	...
	default:
		java语句;
		...
}

• 3.switch语句的执行原理：
  • switch后面的小括号当中的“数据”和case后面的“数据”进行一一匹配，匹配成功的分支执行；按照从上到下的顺序依次执行。
  • 匹配成功的分支执行，分支当中最后有“break;”语句的话，整个switch语句终止
  • 匹配成功的分支执行，分支当中没有“break;”语句的话，直接进入下一个分支执行（不进行匹配），这种现象被称为case穿透现象。【提供break;语句可以避免穿透】。
  • 所有case分支都没有匹配成功的话，执行default的分支语句。
  • switch后面和case后面只能是int或者String类型的数据，不能是其他类型
    • 当然byte,short,char也可以是直接写到switch和case后面，因为它们可以进行自动类型转换。byte,short,char可以自动转换成int类型。
    • JDK6，的switch和case后面只能探测int类型
    • JDK7之后包括7版本在内，引入新特性，switch和case后面可以探测int或者String类型的数据。
    • case可以合并，举例如下

int i = 10;
switch(i){
	case 1: case 2: case 3: case 10:
		System.out.println("Test code!");
}

public class SwicthTest01
{
	public static void main(String[] args){
		/*
		long a = 100L;
		int b = a;//编译报错
		*/
		/*
		long x = 100L;
		switch(x){}//编译报错，大容量向小容量转换，损失精度
		*/
		//解决编译错误
		long x = 100L;
		switch((int)x){}
		
		byte b = 10;
		swicth(b){}
		
		short s = 10;
		swicth(s){}

		char c = 'A';
		swicth(c){}
		
		char cc = 97;
		swicth(cc ){}
		
		//编译报错
		//switch(true){}

		String username = "zhangsan";
		switch(username){}
	}
}

for语句

• 语法结构：

for（初始化表达式:布尔表达式：更新表达式）{
	//是需要重复执行的代码片段【循环体：用java语句构成】
	}

• 执行原理：
  • 初始化表达式、布尔表达式、更新表达式都不是必须的！但是两个分号是必须的！
  • 初始化表达式先执行，并且在整个for循环中只执行一次
  • 布尔表达式必须是true、false，不能是其他值
• 执行顺序不考虑

while、do…whiel控制语句以及break、continue知识点语法规则已掌握，不再陈列，想尽快学习java语言特有性质

练习题1

寻找1-100之间的素数，素数只能被1和自身整除，不能被其他数整除

class A
{
	public static void main(String[] args){

		for(int i = 2;i <= 100;i ++){

			boolean isSuShu = true;

			for(int j = 2;j < i;j ++){

				if(i % j == 0){

					isSusu = false;//说明不是质数
					break;
				}
					
			}
			if(isSusu)//说明是质数
				System.out.println(i);
		}
	}
}