day03

婷婷学java

于 2021-05-06 16:48:59 发布

阅读量78

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/weixin_46046848/article/details/116457472

版权

java基础专栏收录该内容

24 篇文章 1 订阅

订阅专栏

day03

一、运算符

算术运算符

+ - * / %

+的作用：
	1. 表示正数
	2. 表示相加
	3. 表示拼接

/的作用：求整
	如何用 / 得到小数结果：
		将其中任何一个数强制转换为小数即可
			1. 强转为float或者double类型
			2. 直接乘以1.0
			
%的作用：求余

class Demo {
	
	public static void main(String[] args) {
		
		int a = 3;
		int b = 5;
		
		System.out.println(a + b);	 //8
		System.out.println(a - b);	 //-2
		System.out.println(a * b);	 //15
		System.out.println((double)a / b);	 //0.6
		System.out.println(a*1.0 / b);	 	 //0.6
		System.out.println(a % b);	 //3
	
	}
}

自增自减运算符

++ --

++和--参与运算的时候：
	++和--在前：
		先自增1或者自减1，然后再赋值
	++和--在后：
		先赋值，然后自增1或者自减1

++和--不参与运算的时候：
	++和--无论是在前或者在后，都是自增1或者自减1

class Demo {
	
	public static void main(String[] args) {
	
		int a = 3;
		
		/*
		int b = a++;
	
		System.out.println(a);  //4
		System.out.println(b);  //3
		*/
		
		int b = ++a;
		
		System.out.println(a);  //4
		System.out.println(b);  //4
			
	}
}

赋值运算符

基本的：
	=

扩展的：
	+=
	-=
	*=
	/=
	%=
    
注意：扩展的赋值运算符，默认带有强制的数据类型转换功能

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9GF896Yb-1620290841281)(img/image-20210408100730741.png)]

class Demo2 {
	
	public static void main(String[] args) {
	
		/*
		int a = 3;
		int b = 5;
		
		a += b; //左边的变量a和右边的变量b相加，结果又赋值给了左边的变量a
		*/
		
		/*
		byte a = 3;
		byte b = 5;
		
		a += b; //a = (byte)(a + b);
	
		System.out.println(a);	 //8
		System.out.println(b);	 //5
		*/
		
		byte a = 3;
		byte b = 5;
		
		a -= b; //a = (byte)(a - b);
		
		System.out.println(a);	 //-2
		System.out.println(b);	 //5
	}
}

比较运算符

> < == != >= <= 

结果都是boolean类型

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

		System.out.println(3 > 5);	  //false
		System.out.println(3 >= 5);   //false
		System.out.println(3 < 5);	  //true
		System.out.println(3 <= 5);   //true
		System.out.println(3 == 5);	  //false
		System.out.println(3 != 5);	  //true
			
	}
}

逻辑运算符

&& || ! ^

注意：
	1. 两边放的是boolean结果的表达式
	2. 结果为boolean类型

class Demo {
	
	public static void main(String[] args) {
	
		/*
			&&与：
				两边都为true的时候才为true，
				两边只要有一个为false就为false
		*/
		System.out.println(true && true);    //true
		System.out.println(true && false);   //false
		System.out.println(false && true);	 //false
		System.out.println(false && false);  //false
		System.out.println("---------------"); 
			
		/*
			||或：
				两边都为false的时候才为false，
				两边只要有一个为true就为true
		*/
		System.out.println(true || true);    //true
		System.out.println(true || false);   //true
		System.out.println(false || true);	 //true
		System.out.println(false || false);  //false
		System.out.println("---------------"); 
		
		/*
			!非：
				如果为true，那么结果是false
				如果是false，那么结果为true
		*/
		System.out.println(!false);    //true
		System.out.println(!true);     //false
		System.out.println("---------------"); 
		
		/*
			^异或：
				两边一样的时候，为false
				两边不一样的时候，为true
		*/
		System.out.println(true ^ true);    //false
		System.out.println(true ^ false);   //true
		System.out.println(false ^ true);	//true
		System.out.println(false ^ false);  //false
		
	}
}

位移运算符

>> 右移：  每右移一位，都会在原来数字的基础之上除以2
<< 左移：  每左移一位，都会在原来数字的基础之上乘以2
>>> 无符号右移： 每右移一位，都会在原来数字的基础之上除以2（只作用于正数）

class Demo {
	
	public static void main(String[] args) {
	
		int a = -16;
	
		System.out.println(a<<1);	 //-32
			
	}
}

三元运算符

同时操作三个数据的运算符

格式

条件表达式 ? 表达式1 : 表达式2

解释：
	1. 条件表达式的结果必须为boolean类型
			如果是true的话，那么执行表达式1
			如果是false的话，那么执行表达式2
			
对三元表达式的处理：
				方案1. 直接输出
				方案2. 赋值再输出

class Demo {
	
	public static void main(String[] args) {
	
		//条件表达式 ? 表达式1 : 表达式2
		int a = 6;
		
		/*
			对三元表达式的处理：
				方案1. 直接输出
				方案2. 赋值再输出
		*/
		//方案1. 直接输出
		//System.out.println(a % 2 == 0 ? "是偶数" : "是奇数");	
		
		//方案2. 赋值再输出
		String s = a % 2 == 0 ? "是偶数" : "是奇数";
		System.out.println(s);		
	}
}

二、键盘录入

键盘录入可以从外界接收数据，实现数据的动态录入，很方便。

键盘录入需要用到一个类：java.util包下的Scanner类

如何使用其它包下的类

只需要通过关键字import将所用类的包导入即可。

格式如下：
	import 包名.类名;
	
如： import java.util.Scanner;

注意：使用import的时候，一定要放在所有类的最上方，但是要放在package的下方

2.1 步骤

1. 导包  		import java.util.Scanner;
2. 创建对象	   Scanner sc = new Scanner(System.in);
3. 接收数据    int x = sc.nextInt();
4. 处理数据    System.out.println(x);

//1. 导包  	
import java.util.Scanner;
class Demo {
	
	public static void main(String[] args) {
	
		//2. 创建对象	
		Scanner sc = new Scanner(System.in);
		//3. 接收数据
		System.out.println("请输入一个数据：");
		int x = sc.nextInt();
		//4. 处理数据
		System.out.println(x);	
			
	}
}

/*
	键盘录入一个数，并判断这个数是奇数还是偶数
*/
import java.util.Scanner;
class Demo2 {
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);

		System.out.println("请输入一个数据：");
		int x = sc.nextInt();

		String s = x % 2 == 0 ? "是偶数" : "是奇数";
		System.out.println(x + s);
			
	}
}

三、随机数

需要用到一个类：java.util的Random类

用此类中的nextInt方法可以生成指定范围的随机数

3.1 步骤

1. 导包  		import java.util.Random
2. 创建对象    Random r = new Random();
3. 生成随机数  int x = r.nextInt(参数);
		注意：参数为一个int类型的数据，比如参数为5， 那么就会生成0-5范围内的整数（包括0，不包括5）

//1. 导包
import java.util.Random;
class Demo {
	
	public static void main(String[] args) {
		
		//2. 创建对象
		Random r = new Random();
		
		//3. 生成随机数		
		System.out.println(r.nextInt(5));	 //因为传入了参数5，所以可以随机生成0 1 2 3 4这些整数
	}
}

练习：
	随机生成1-100范围内的整数

/*
	随机生成1-100范围内的整数
*/
import java.util.Random;
class Test {
	
	public static void main(String[] args) {
		
		Random r = new Random();
		
		int x = r.nextInt(100) + 1;
		
		System.out.println(x);	
	}
}

四、控制流程

根据具体的语法结构，可以执行不同的内容

顺序结构：是程序默认的执行流程，是从上到下，从左到右执行的。
分支结构：程序在执行过程中，根据不同的条件执行不同的内容。
循环结构：对某些代码进行重复性的执行。

4.1 顺序结构

class Demo {
	
	public static void main(String[] args) {
		
		System.out.println("start");	
		System.out.println("run");	
		System.out.println("end");	
	}
}

4.2 分支结构

分类

if语句：有三种格式
switch语句：有一种格式

4.3 if语句

第一种格式

if(条件表达式){
	语句体;
}

执行流程：
	1. 条件表达式的结果必须为boolean类型，要么是true，要么是false
			如果是true的话，就执行语句体
			如果是false的话，就不执行语句体

练习：
	某公司规定，入职满5年的员工，可以加薪5000，如果不满5年，那么不加钱。薪资和入职时间由键盘录入

/*
	某公司规定，入职满5年的员工，可以加薪5000，如果不满5年，那么不加钱。
	薪资和入职时间由键盘录入
*/
import java.util.Scanner;
class Test {
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		System.out.println("请录入您的入职年份儿：");
		int year = sc.nextInt();
		System.out.println("请输入您的薪水：");			
		int salary = sc.nextInt();
		
		if(year >= 5) {
			
			System.out.println("您调整后的薪水为：" + (salary + 5000));
		}
			
	}
}

第二种格式

if(条件表达式) {
	语句体1;
}else {
	语句体2;
}

执行流程：
	1. 条件表达式的结果必须为boolean类型，要么是true，要么是false
			如果是true的话，就执行语句体1
			如果是false的话，就执行语句体2;

练习：
	某公司规定，入职满5年的员工，可以加薪5000，如果不满5年，那么加3000。薪资和入职时间由键盘录入

/*
	某公司规定，入职满5年的员工，可以加薪5000，如果不满5年，那么加3000。
	薪资和入职时间由键盘录入
*/
import java.util.Scanner;
class Test2 {
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		System.out.println("请录入您的入职年份儿：");
		int year = sc.nextInt();
		System.out.println("请输入您的薪水：");			
		int salary = sc.nextInt();
		
		if(year >= 5) {
			
			System.out.println("您调整后的薪水为：" + (salary + 5000));
		}else {
			
			System.out.println("您调整后的薪水为：" + (salary + 3000));
		}
			
	}
}

第三种格式

if(条件表达式1) {
	语句体1;
}else if(条件表达式2) {
	语句体2;
}else if(条件表达式3) {
	语句体3;
}
...
else {
	语句体n;
}

执行流程：
	1. 先看条件表达式1的结果是true还是false
			如果是true，那么执行语句体1
			如果是false，那么就看条件表达式2的结果是true还是false
				如果条件表达式2的结果是true，那么执行语句体2
				如果条件表达式2的结果是false，那么接着看条件表达式3的结果是true还是false
					如果条件表达式3的结果是true，那么执行语句体3
					如果条件表达式3的结果是false，那么继续往下看
					...
					
					如果都不符合，那么最后执行else中的语句体n

练习：
	某公司规定，
		入职1-3年的的员工，可以加薪2000
		入职3-5年的员工，可以加薪3000
		入职5-10年的员工，可以加薪5000
		入职超过10年的员工，可以加薪10000
		薪资和入职时间由键盘录入

/*
	某公司规定，
		入职1-3年的的员工，可以加薪2000
		入职3-5年的员工，可以加薪3000
		入职5-10年的员工，可以加薪5000
		入职超过10年的员工，可以加薪10000
		薪资和入职时间由键盘录入
*/
import java.util.Scanner;
class Test3 {
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请录入您的入职年份儿：");
		int year = sc.nextInt();
		System.out.println("请输入您的薪水：");			
		int salary = sc.nextInt();
		
		if(year >= 1 && year < 3){
			
			System.out.println("您调整后的薪水为：" + (salary + 2000));
		}else if(year >= 3 && year < 5){
			
			System.out.println("您调整后的薪水为：" + (salary + 3000));
		}else if(year >= 5 && year < 10){
			
			System.out.println("您调整后的薪水为：" + (salary + 5000));
		}else if(year >= 10){
			
			System.out.println("您调整后的薪水为：" + (salary + 10000));
		}else{
			
			System.out.println("入职时间太短！！！");
		}
		
	}
}

4.4 switch语句

格式

switch (表达式){
	case 值1 :
		语句体1;
		break;
	case 值2 :
		语句体2;
		break;
	case 值3 :
		语句体3;
		break;
	...
	default :
		语句体n;
		break;
}

格式的解释：
    1. 表达式最后肯定会得到一个准确的值
    2. 我们会拿得到的值和case后面的值进行比较，如果相等的话，执行case后面的语句体，并通过break退出
    3. 如果所有case都匹配不上的话，那么就会执行default后面的语句体，并通过break退出

注意事项

1. 表达式的值？
		byte、short、int、char、String、枚举
2. case后面的值必须为常量
3. break可以省略，但是会发生穿透现象
4. default可以放到任何位置，但是建议放在最后
5. default可以省略的

class Demo {
	
	public static void main(String[] args) {
		
		int a = 2;
		
		switch (a){
			case 1 :
				System.out.println("1...");
				break;
			case 2 :
				System.out.println("2...");
				break;
			case 3 :
				System.out.println("3...");
				break;
			default :
				System.out.println("匹配不上，并执行了default中的语句");
				break;
			
		}
		
	}
}

练习：
	键盘录入整数1-7，然后根据录入的数字，输出指定的内容
		1-5， 输出“工作日”
		6-7， 输出“休息日”

/*
	键盘录入整数1-7，然后根据录入的数字，输出指定的内容
		1-5， 输出“工作日”
		6-7， 输出“休息日”
*/
import java.util.Scanner;
class Test4 {
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入1-7之间的整数：");
		int week = sc.nextInt();
		
		switch(week){
			case 1:		
			case 2:
			case 3:
			case 4:
			case 5:
				System.out.println("工作日");
				break;
			case 6:
			case 7:
				System.out.println("休息日");
				break;
			default:
				System.out.println("您输入的数据有误");
				break;
			
		}
		
	}
}

五、循环结构

/*
	在dos窗口打印5遍helloworld
*/
class Demo {
	
	public static void main(String[] args) {
		
		System.out.println("helloworld");	
		System.out.println("helloworld");	
		System.out.println("helloworld");	
		System.out.println("helloworld");	
		System.out.println("helloworld");	
	}
}

问题：发现代码的重复度太高。
解决：Java中使用循环结构来对重复性的代码进行优化

在Java中，对于某些相同或者相似的重复性代码，用特定的结构进行简化。

5.1 分类

for循环       【常用】
while循环
do...while循环

5.2 for循环

格式

for(初始化语句; 条件表达式; 初始化语句的改变){
	
	循环体语句;
}

格式的解释：
	初始化语句：就是定义一个变量，这个变量后续会进行相应的变化。此语句只在开始的时候执行一次
	条件表达式：其结果必须为boolean类型，要么是true，要么是false
	初始化语句的改变：这个改变可增可减，但无论增或减，最后肯定是向着循环结束的方向改变的
	循环体语句：需要重复执行的代码，可以是一句或者多句

练习：
	用for循环改进引入案例：

/*
	用for循环改进引入案例
*/
class Demo2 {
	
	public static void main(String[] args) {
		
		for(int i = 0; i < 5; i++){
	
			System.out.println("helloworld");		
		}
		
	}
}

执行流程

a. 执行初始化语句
b. 执行条件表达式，看其结果是true还是false	
		如果是false，那么结束for循环
		如果是true，那么执行循环体语句，并进入下一步
c. 执行初始化语句的改变
d. 回到b

5.3 while循环

格式

初始化语句;
while(条件表达式){

	循环体语句;
	初始化语句的改变;
}

练习：
	用while循环改进引入案例

class Demo3 {
	
	public static void main(String[] args) {
		
		int i = 0;
		while(i < 5){

			System.out.println("helloworld");
			i++;
		}
		
	}
}

练习：
	现在有一张可以无限对折的纸，纸厚度为0.01m，珠穆朗玛峰的高度为8848米，问这张纸折叠多少次后才可以超过珠穆朗玛峰。

class Test {
	
	public static void main(String[] args) {
		
		//纸的厚度
		double paper = 0.01;
		//高度
		double height = 8848.0;
		
		//定义一个变量，用来统计一共折叠了多少次
		int count = 0;
		
		while(paper <= height){
			
			paper *= 2;
			
			count++;
			System.out.println("第" + count + "次折叠，目前厚度为" + paper);
		}
		
		System.out.println("一共折叠了" + count + "次，目前厚度为" + paper);
		
	}
}

/*
打印结果：
    第1次折叠，目前厚度为0.02
    第2次折叠，目前厚度为0.04
    第3次折叠，目前厚度为0.08
    第4次折叠，目前厚度为0.16
    第5次折叠，目前厚度为0.32
    第6次折叠，目前厚度为0.64
    第7次折叠，目前厚度为1.28
    第8次折叠，目前厚度为2.56
    第9次折叠，目前厚度为5.12
    第10次折叠，目前厚度为10.24
    第11次折叠，目前厚度为20.48
    第12次折叠，目前厚度为40.96
    第13次折叠，目前厚度为81.92
    第14次折叠，目前厚度为163.84
    第15次折叠，目前厚度为327.68
    第16次折叠，目前厚度为655.36
    第17次折叠，目前厚度为1310.72
    第18次折叠，目前厚度为2621.44
    第19次折叠，目前厚度为5242.88
    第20次折叠，目前厚度为10485.76
    一共折叠了20次，目前厚度为10485.76
*/

5.4 do…while循环

初始化语句;
do {

	循环体语句;
	初始化语句的改变;
}while(条件表达式);

练习：
	用do...while循环改进引入案例

class Demo4 {
	
	public static void main(String[] args) {
		
		int i = 0;
		do {

			System.out.println("helloworld");
			i++;
		}while(i < 5);
		
	}
}

5.5 死循环

一直执行，不停止的循环

for的死循环

for(;;) {

	语句体;
}

while的死循环

while(true) {
	
	语句体;
}

class Demo5 {
	
	public static void main(String[] args) {
		
		/*
		for(;;) {
			
			System.out.println("Helloworld!!!");
		}
		*/
		
		while(true) {
			
			System.out.println("Helloworld!!!");
		}
		
	}
}

5.6 跳转语句

break		用在switch及循环中，用来结束switch或循环
continue    用在循环结构中，用来跳出当次循环并进入下一次循环
return		用来结束方法

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

		for(int i = 0; i < 5; i++){
			
			if(i == 2) {
				
				//break;
				continue;
			}
			
			System.out.println("HelloWorld!!!");
		}		
	}
}

初始化语句的改变;
}while(条件表达式);

练习：
用do…while循环改进引入案例


```java
class Demo4 {
	
	public static void main(String[] args) {
		
		int i = 0;
		do {

			System.out.println("helloworld");
			i++;
		}while(i < 5);
		
	}
}

5.5 死循环

一直执行，不停止的循环

for的死循环

for(;;) {

	语句体;
}

while的死循环

while(true) {
	
	语句体;
}

class Demo5 {
	
	public static void main(String[] args) {
		
		/*
		for(;;) {
			
			System.out.println("Helloworld!!!");
		}
		*/
		
		while(true) {
			
			System.out.println("Helloworld!!!");
		}
		
	}
}

5.6 跳转语句

break		用在switch及循环中，用来结束switch或循环
continue    用在循环结构中，用来跳出当次循环并进入下一次循环
return		用来结束方法

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

		for(int i = 0; i < 5; i++){
			
			if(i == 2) {
				
				//break;
				continue;
			}
			
			System.out.println("HelloWorld!!!");
		}		
	}
}