【小白学java】java流程控制+异常（day04）

对象练习：学生 students

学号 id，Integer

姓名 name，String

性别 sex，Boolean

出生年月，birthday，Date

籍贯 location，String

毕业学校 school，String

期望薪资 solary，Integer

package cn.tedu.obj;

import java.util.Date;		//必须使用util工具包

//实现一个学生类
public class Student {
     
	//成员变量，属性property，字段field
	Integer id;			//学号
	String name;		//姓名
	Boolean sex;		//性别：true男/false女
	Date birthday;		//出生年月
	String location;	//籍贯
	String school;		//毕业学校
	Integer solary;		//期望薪资
	
	@Override			//通知java，我覆盖父类的toString方法，打印时优先调用自己类的方法
	public String toString() {
     
		return "Student [id=" + id + ", name=" + name + ", sex=" + sex + ", birthday=" + birthday + ", location="
				+ location + ", school=" + school + ", solary=" + solary + "]";
	}	
}
package cn.tedu.obj;

import java.util.Date;

import org.junit.Test;

//测试类
public class TestStudent {
     
	@Test
	public void stu() {
     
		//创建对象实例
		Student stu = new Student();
		
		//对属性进行初始化
		stu.id = 007;		//展示7
		stu.name = "詹姆士邦德";
		stu.sex = true;  //代表男
		stu.birthday = new Date();
		stu.location = "英国.伦敦";
		stu.school = "军情六处";
		stu.solary = 1000000;
		
		//打印，自定义toString()方法，eclipse 自动产生
		//目标：直接打印对象，看到对象每个属性值
		//默认Object父类toString()；写死：类@hashcode() 可以理解内存地址
		
		//cn.tedu.obj.Student@e2144e4
		//两个方法冲突了，java就近原则。如果自己没有就去找父类，如果自己有就使用自己的
		System.out.println( stu );	//有两个，父类Object.toString()，自身toString() 
	}
}

流程控制分类

实际开发中，代码核心，或者说业务核心实现就体现在 流程控制的代码中！

分类有3种：

1）顺序结构：从上向下，从左到右执行

特点：每句代码都执行

2）分支结构：要么要么

要么天晴，要么下雨

要么你是男的，要么你是女的

特点：互斥，不会同时发生，有部分代码执行，有部分代码不执行。程序出现分叉。

有了分支这个特点，程序就灵活了，它可以根据用户当前情况，去做不同的事情！

分支就是程序灵魂！业务的核心！

3）循环结构：上课、日期

循环就是程序灵魂！业务的核心！

特点：重复执行一段代码。循环不退出死循环。专门处理死循环方案：break; continue; return;

分支判断

1）if 单分支 else/elseif

package cn.tedu.flow;

import org.junit.Test;

//测试if分支语句，包括它的变种else/else if
public class TestIf {
     
	@Test
	public void testIf() {
     
		// 需求：天晴晒被子，下雨收衣服
		// 语法：if(布尔表达式){ 代码体 }
		// 布尔表达式结果true，执行代码体，如果false，不执行，直接执行if后面代码

		boolean rainning = false; // 判断标识，代表是否下雨
		// 如果代码段中一条语句可以去掉大括号，这种缩写不易读程，java支持
		if (rainning) {
     
			System.out.println(" 下雨收衣服 ");
		}
		System.out.println("if 语句结束了");
	}
	
	@Test
	public void testIfElse() {
     
		//需求：天晴晒被子，下雨收衣服
		//格式：if(){ ... }else{ ... } 
		//条件成立执行前面代码段，不执行后面的代码段
		//条件不成立执行后面代码段，不执行前面的代码段
		boolean rainning = true;
		
		if( !rainning ) {
     
			System.out.println("天晴晒被子");
		}else {
     
			System.out.println("下雨收衣服");
		}
	}
	
	@Test
	public void testElesIf() {
     
		/*
		 * 格式：if(){ ... }else if(){ ... }else if(){ ... }else{ ... }
		 * 一旦判断成立，后面的所有的判断都不进行了，直接结束
		 * 如果有多个else if结构（多分支）
		 * 按顺序进行判断，前面不成立就继续下面判断
		 * 如果所有判断都不成立，执行else中的代码
		 */
		//需求：电话号码 110,120,119,911，判断电话号码，打印中文
		int phone = 110;		//判断条件
		if( phone == 110 ) {
     
			System.out.println("警察");
		}else if( phone == 120 ) {
     
			System.out.println("医生");
		}else if( phone == 119 ) {
     
			System.out.println("消防");
		}else if( phone == 911 ) {
     
			System.out.println("美国警察");
		}else {
     
			System.out.println("查无此号");
		}
	}
}

2）switch 多分支 case/default/break

package cn.tedu.flow;

import org.junit.Test;

//多分支switch语句
public class TestSwitch {
     
	@Test
	public void testSwitch() {
     
		//格式：switch(变量值){ case 110: ... case 120: .... default: ... }
		//它语法很奇葩，break和配合
		//case对应值和小括号n是否相等，如果相等就执行分支里的语句
		//它如果没有break，当某个条件成立，后面所有判断失效，而且其代码都执行
		
		//支持变量类型：char/int/byte/short支持，long不支持
		//Cannot switch on a value of type long.  switch的变量不能为long类型
		//它的值必须能转换成int类型，字符串类型，或者枚举，才被允许
		//Only convertible int values, strings or enum variables are permitted
		char n = 2;
		switch(n) {
     
		case 1:			//判断n=1才执行
			System.out.println("1");
			break;		//打断，跳出switch语句
		case 2:
			System.out.println("2");
			break;
		case 3:
			System.out.println("3");
			break;
		case 4:
			System.out.println("4");
			break;
		default:
			System.out.println("default");
			break;	//习惯和上面统一，写不写都不影响结果
		}
	}
	
	@Test
	public void phone() {
     
		int phone = 999;
		switch(phone) {
     
		case 110:
			System.out.println("警察");
			break;
		case 120:
			System.out.println("医生");
			break;
		case 119:
			System.out.println("消防");
			break;
		case 911:
			System.out.println("美国警察");
			break;
		default:
			System.out.println("查无此号");
			break;
		}
	}
}

循环迭代

for循环

package cn.tedu.flow;

import org.junit.Test;

//for循环
public class TestFor {
     
	@Test
	public void forNormal() {
     
		//格式：for(int i=0; i<6; i++){ ... }
		/*
		 * for里面由4部分构成，初始化只声明变量i,j,k,m,n
		 * i<6是一个判断条件，结果true执行循环体
		 * 结果false结束for循环
		 * 4部分执行顺序：1。2。4。3
		 * i++后面不要画蛇添足分号，写了错了
		 */
		//需求：打印1~6，
		for(int i=0; i<6; i++) {
     
			System.out.print( i+1 );
		}
		
		System.out.println("");	//换行
		
		for(int j=0; j<6; j++) {
     
			System.out.print(j+1);
		}
	}
	
	@Test	//双层嵌套for循环，两重1~9，怎么把下面的改成99乘法表
	public void for2() {
     
		for(int i=1; i<=9; i++) {
     			//外层for循环
			//j的变化跟着i的值变化而变化，i是当前值是几，就打印几次
			for(int j=1; j<=i; j++) {
     		//内层for循环
				System.out.print( i + "*" + j +"="+i*j+"\t");	//\代表转义\t代表tab键，大点空白
			}
			System.out.println(); //变量一次j，打印空行
		}
	}
}

while循环

do-while循环

package cn.tedu.flow;

import org.junit.Test;

//while循环，do循环
/*
 * while和do的区别？
 * while 它可能一次都不执行。先判断后执行
 * do 最少执行一次。先执行一次后才开始判断
 */
public class TestWhile {
     
	@Test
	public void testWhile() {
     
		//需求：打印1~6
		int i = 0;
		while( true ) {
     		//条件成立，执行循环体中代码
			System.out.println( i+1 );	//i=0，不会被改变
			i++;	//改变i
		}
	}
	
	@Test
	public void testDo() {
     
		//需求：打印1~6
		int i=0;
		do {
     
			System.out.println(i+1);
			i++;
		}while(i<6);
	}
}

退出循环3种方式

package cn.tedu.flow;

import org.junit.Test;

/*
 * 跳出循环，3种方式
 * 1）break
 * 2）continue
 * 3）return
 */
public class TestBreakLoop {
     
	@Test
	public void loop() {
     
		int i = 0;
		while(i<6) {
     
			i++;
			if(i==3) {
     
				//break;	//跳出while循环，执行后面的语句
				//continue;	//跳过本次循环，不执行continue后面的语句，直接去判断
				return;		//结束方法
			}
			System.out.println( i );
		}
		System.out.println("执行完成");
	}
}

异常处理

常见的异常

package cn.tedu.flow;

import org.junit.Test;

/*
 * java开发中遇到两种错误：
 * 1）系统级别的错误，致命错误。这是操作系统自身问题，这些不是我们能控制的
 * 2）程序的逻辑错误，代码可以控制。
 * 
 * 常见3个异常：
 * a. 空指针
 * b. 被0除（数学异常）
 * c. 数组越界
 */
public class TestError {
     
	String[] a;		//数组没有进行初始化
	
	@Test	//空指针异常 NullPointException
	public void nullErr() {
     
		//创建一个对象，对象没有初始化，调用对象方法或者属性就报错
		//空指针，对象没有分配内存空间
		System.out.println(a.length);
	}
	
	@Test	//数学，除数不能是0，ArithmeticException: by zero
	public void arith() {
     
		int i = 10/0;
		System.out.println(i);
	}
	
	@Test	//数组越界，ArrayIndexOutOfBoundsException
	public void arrays() {
     
		int[] a = {
     1,2,3,4,5};		//定义了数组，有5个元素
		System.out.println( a[0] );
		System.out.println( a[5] );  //范围0~4，超出范围就是越界
	}
}

异常的处理

package cn.tedu.flow;

import org.junit.Test;

/*
 * java提供异常处理
 * 1）try 试图
 * 2）catch 捕获异常
 * 3）finally 死活都执行
 * 4）throw 抛出异常
 * 5）throws 接收异常
 */
public class TestException {
     
	/*
	 * 处理异常方法
	 * 可能出现错误的代码必须使用try+catch包裹
	 * 出错也好，不出错也好，都执行finally中的内容（释放资源）
	 * 
	 * 不要直接报错，而可以把错误信息打印控制台，用户看不到
	 */
	@Test	//处理数组越界异常，不能给用户发出“乱码”错误
	public void arrayErr() throws Exception{
     		//这个方法接收异常，抛给JUnit系统，报错
		int[] a = {
     1,2,3,4,5};
		
		try {
     
			//可能出现异常
			//这里代码出错自动跳转catch中，如果不出错，不执行catch，继续执行
			System.out.println( a[10] );
		}catch(Exception e) {
     		//全局错误，e错误实例名，如果有错误，就把错误信息存放在e对象中
			System.out.println("出错啦：");
			System.out.println( e.getMessage() );
			//e.printStackTrace();		//把错误信息打印控制台，用户看不到，开发者可以看到
			
			//出错自己处理不了，抛出异常。抛出错误就必须有人接收错误，它去处理。你这个方法调用者
			//Unhandled exception type Exception 这个错误需要去处理（接盘)
			throw new Exception("程序出错了，快来救我!");
		}finally {
     	//不论是否出错都执行这里面的代码，释放资源
			System.out.println("死活我都执行");
		}
		
	}
}