202105小白训练营-day04 流程控制

Posted 2021-06-05 长安紫薯

java数据结构

旧的程序：数据结构+算法，构建小型项目核心
新的程序：数据结构+算法+框架+架构，天生构建大型项目核心
数据结构目标，开发者合理利用资源（内存）计算数据

java提供两种的数据结构：
1）基本类型：它本身不属于面向对象概念，占用内存少，运行速度快（c语言面向过程）
2）引用类型（java/python语言面向对象，面向对象和生活很相近，面向对象成为开发主流方式），相对基本类型占用空间大，运行速度慢。好处：拥有额外方法，java底层写好，开发者事半功倍，开发效率高。

八种基本类型：
1）byte 字节，1个字节=8bit，-128~127，0 Byte
2）short，2个字节，-32768~32767，0 Short
3）int，4个字节，±21亿，0。默认（平衡） Integer
4）long，8个字节，0 Long
5）float，4个字节，0.0 Float
6）double,8个字节，0.0，默认（平衡） BigDecimal Double
7）char，2个字节（2~4个字节 ascii，unicode（utf-16、utf-8）） Character
8）boolean，true 1/false 0，1个字节 0000 0001,0000 0000 Boolean

8个基本类型如果和对象一起使用，不能直接使用，类型转换。
包装类型：把基本类型进行封装（包装），变成对象，有额外方法。
基本类型名字全小写，包装类型的名字按大驼峰规则，首字母大写。

基本类型和包装类型它们只能表达一个类型的一个值：int a = 10; a = “abc”; int b= 20;
不够灵活，生活中有表达一组值：学生成绩100,99,60
数组：它可以存储一个类型的多个值，它的内存空间是连续的

数组的两种声明的方式：
1）int[] arr = new arr[4]; //声明一个整型数组，数组4个元素，第一个元素下标0 arr[0]，最后一个 arr[ arr.length-1 ]
2）简洁，推荐：int[] arr = {100, 99, 60, 88 } 数组4个元素，arr[0]，
String[] s = new String[3]; 数组3个元素，s[0] 值null 空
String[] s = {“语文”，“数学”，“英语”}，数组3个元素，s[0] 语文

数组的缺点，只能一个类型。复杂生活物品抽象就无法使用数组来表达，在java中最强大，一等公民，对象
万物皆对象Object。

Student 学生对象
1）创建类 Student
2）创建属性（字段、成员变量）
no 学号，Integer
name 姓名，String
sex 性别，Boolean
birthday 出生年月，日期 java.util.Date 必须用它，java.sql.Date 数据库
school 毕业学校，String
salary 薪资，Float,Double

package cn.tedu.datatype;

import java.util.Date; //日期类型必须导包，必须到util工具类下的

//创建学生实体类
public class Student {
	//成员变量，属性，字段
	//4种：public公有、default不写，protected保护，private私有
	Integer no; // 学号
	String name; // 姓名
	Boolean sex; // 性别
	Date birthday; // 出生年月
	String school; // 毕业学校
	Double salary; // 薪资
}

package cn.tedu.datatype;

import org.junit.Test;
import java.util.Date;

public class TestStudent {
	@Test
	public void student() {
		// 1、创建实例
		Student student = new Student();

		// 2、对象的属性赋值
		student.no = 100;
		student.name = "陈强";
		student.sex = true;

		student.birthday = new Date(); // 创建一个当前时间，导包
		student.school = "北京大学";
		//Type mismatch: cannot convert from int to Double
		student.salary = 10000D; //1000.0、d、D 都是Double类型

		// 3、打印对象的属性值
		System.out.println( student.no );
		System.out.println( student.name );
		System.out.println( student.sex );
		
		System.out.println( student.birthday );
		System.out.println( student.school );
		System.out.println( student.salary );
	}
}

流程控制

1、顺序结构：从左向右执行，从上往下执行，每条语句都执行，执行一次
2、分支判断结构：部分代码执行，部分代码不执行
3、循环结构：反复执行一段代码（执行多次）

分支结构

1）if 单分支：if、if-else、多分支 else-if
需求：天晴晒被子
if（boolean表达式）{ 晒被子 }

package test;

import org.junit.Test;

//if分支判断语句（业务逻辑判断）
public class TestIf {
	// if语法
	@Test
	public void testIf() {
		// 需求：天晴晒被子
		boolean running = true; // 是否下雨布尔变量，判断的依据（条件）
		//取反代表天晴，它是一个条件，
		//条件true执行后面代码，条件false则不执行
		//if特殊，如果if语句代码体（代码段）如果里面只有一句话，大括号可以省略
		if( !running ) {   //好习惯，不论代码段中是否是一句话，都写上括号
			System.out.println("晒被子");
		}
		System.out.println("执行完成");
	}

	// if-else语法
	@Test //单独运行这个测试方法，双击方法名，右键运行
	public void testIfElse() {
		//需求：天晴晒被子，下雨收衣服（分支互斥，不会同时发生）
		boolean running = false;
		//判断条件true成立if后面代码段执行，
		//false不成立执行else后面的代码段
		if( running ) {
			System.out.println("下雨收衣服");
		}else {
			System.out.println("天晴晒被子");
		}
	}

	// else-if语法，多分支
	@Test
	public void testElseIf() {
		//需求：电话号码，110 警察,114 查号,119 火警,120 医院，根据不同电话输出不同身份
		//分支天生是互斥，所以只要有一次判断成功其它分支就不再判断
		int phone = 911;
		if(phone==110) {
			System.out.println("警察");
		}else if(phone==114) {
			System.out.println("查号");
		}else if(phone==119) {
			System.out.println("火警");
		}else if(phone==120) {
			System.out.println("医院");
		}else {	//上面多有分支都不成立，就执行else里的代码
			System.out.println("电话号码非法");
		}
	}
}

2）switch 多分支
和else if类似，语法结构不同的。
switch、case、default

package test;

import org.junit.Test;

//switch多分支判断语句
public class TestSwitch {
	@Test
	public void testSwitch() {
		//需求：电话号码，110 警察,114 查号,119 火警,120 医院
		int phone = 110;
		//不良现象，switch语句特性
		//如果有一个分支成立，这个分支后的所有的分支就不再判断，判断失效，它的代码直接执行
		//Cannot switch on a value of type long.
		//从小往大转char ,byte,short,int，没有精度损失；从大往小转long
		//Only convertible int values, strings or enum 枚举 variables are permitted
		switch(phone) {  
		case 1:	//判断：phone的值是否和case的相等
			System.out.println("警察");
			break;	//在每个分支后加此语句，跳出switch语句
		case 114:
			System.out.println("查号");
			break;
		case 119:
			System.out.println("火警");
			break;
		case 120:
			System.out.println("医院");
			break;
		default: //else作用
			System.out.println("电话号码非法");
			break;	//可加可不加，因为它已经是最后一个
		}
	}
}

模拟ATM机

package test;

import java.util.Scanner;	//导包别导错误

import org.junit.Test;

/*
 * 需求：输入一个数字对应去执行相应内容
 * 1，查询余额
 * 2，取款
 * 3，存款
 * 4，退出
 * 特点：用户去输入，根据用户输入进行判断，执行相应动作
 */

public class ATM {
	@Test
	public void atm() {
		//用户动态输入 Scanner类，他可以支持获取键盘的输入内容
		//它获取到内容，可以字符串，也可以它转换成整数
		//监控键盘输入，参数：键盘System.in
		//程序运行到这句话就停止：等待用户输入值，回车后输入结束
		//这个现象叫做阻塞
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入数字：");
		int n = scan.nextInt();	//获取键盘输入的数字
		switch(n) {
		case 1:
			System.out.println("查询");
			break;
		case 2:
			System.out.println("取款");
			break;
		case 3:
			System.out.println("存款");
			break;
		case 4:
			System.out.println("退出");
			break;
		}
		
		System.out.println("完成");
	}
}

一个类中有多个单元测试方法

1）执行所有的单元测试方法：在空白处鼠标右键执行，它会执行所有方法
注意：测试方法没有顺序，单元测试方法互相独立，互相之间没有关系，没有顺序要求！

2）只执行某一个单元测试方法：双击方法名（光标停留在这个方法上）

循环结构

1）while循环
2）do-while循环
3）for循环

package test;

import org.junit.Test;

//循环结构
//while和do循环差异：while可能一次都不执行，do最少执行一次
public class TestLoop {
	@Test
	public void whileLoop() {
		//判断条件成立就反复执行循环体内容，当条件不成立则退出循环
		int i = 0;
		while(i<5) {  //循环体，注意：在循环体内一定要改变判断条件
			System.out.println(i); //0 1 2 3 4
			i++;	//不能少，修改判断条件
		}
	}
	
	@Test
	public void doLoop() {
		int i = 0;
		do {
			System.out.println(i); //0 1 2 3 4
			i++;	//改变判断条件
		}while(i<5);
	}
	
	@Test
	public void forLoop() {
		//经典写法，小括号中3条java语句
		//第一条语句只执行一次
		//第二条语句判断语句
		//第三条语句：打印
		//第四条语句：i++
		for(int i=0; i<5; i++) {
			System.out.println(i); //0 1 2 3 4
		}
	}
}

死循环

package test;

import java.util.Scanner;	//导包别导错误

import org.junit.Test;

/*
 * 需求：输入一个数字对应去执行相应内容
 * 1，查询余额
 * 2，取款
 * 3，存款
 * 4，退出
 * 特点：用户去输入，根据用户输入进行判断，执行相应动作
 */

public class ATM {
	@Test
	public void atm() {
		//用户动态输入 Scanner类，他可以支持获取键盘的输入内容
		//它获取到内容，可以字符串，也可以它转换成整数
		//监控键盘输入，参数：键盘System.in
		//程序运行到这句话就停止：等待用户输入值，回车后输入结束
		//这个现象叫做阻塞
		//Resource leak 资源弱引用: 'scan' is never closed
		Scanner scan = new Scanner(System.in);
		
		//while(true) {	//死循环，退出条件
		for(;true;) {
			System.out.println("请输入数字：");
			int n = scan.nextInt();	//获取键盘输入的数字
			switch(n) {
			case 1:
				System.out.println("查询");
				break;
			case 2:
				System.out.println("取款");
				break;
			case 3:
				System.out.println("存款");
				break;
			case 4:
				System.out.println("退出");
				int a = 10;		//基本类型，在方法结束，自动释放空间
				scan.close();	//对复杂对象需要手动关闭
				return;  //方法的结束，程序结束
			}
		}
		
		
		
		//Unreachable code 不能在return后面写语句，无法执行
		//System.out.println("完成");
	}
}

退出循环

1）break; 跳出
2）continue; 跳过
3）return; 退出（退出方法）

package test;

import org.junit.Test;

//3种退出循环的方式
public class TestExitLoop {
	@Test
	public void exitLoop() {
		int i = 0;
		while(i<6) {
			i++;
			if(i==3) {
				//break;		//跳出
				//continue;	//跳过本次循环，继续下一次循环，continue后的语句就不执行
				return;		//退出，结束方法
			}
			System.out.println(i);
		}
		System.out.println("执行完成");
	}
}

小结

1）执行流程：
a. 顺序执行：从上往下，从左到右（赋值语句，先执行右边，然后赋值给左边）所有代码都执行
b. 分支判断执行：它是程序的灵魂。程序体现用户业务逻辑。（618商品促销活动，赠券VIP用户，不同折扣）
c. 循环执行：也是业务逻辑体现，反复执行多次，直到退出条件成立
2）分支执行
a. if语句（单分支）
if
if-else
else-if（多分支）
b. swtich语句（多分支）
switch-case
switch-case-default
两个特殊点：
a. 正常每个case后都应该跟break;语句
b. switch(n)，n的类型：char、byte、short、int、String、enum枚举；long不行转换由大往小转换，可能会有精度损失
3）循环
a. while
b. do-while
c. for
while和do的差异：while可能一次都不执行（先判断，条件不成立直接就不执行了），do最少执行一次（后判断，先执行了一次，才开始判断）

java的代码要经过编译，你看到的源代码和编译后的代码不一致。
for循环声明变量i，只在for循环内部有效，出了for循环这个简单类型变量就被释放，不能在使用。
4）死循环
a. while(true)
b. for( ; ; )、for(;true;)
5）退出循环
a. break 跳出
b. continue 跳过本次循环
c. return 结束方法