Java学习第三章-控制语句（仅做个人学习笔记用）
3.1.1if单选择结构
语法结构：
if(布尔表达式){
语句块
}
Math类的使用
1.java.lang包中的Math类提供了一些用于数学计算的方法。
2.Math.random()该方法用于产生一个0到1区间的double类型的随机数，但是不包括1。
int i = (int) (6 * Math.random()); //产生：[0，5]之间的随机整数
/**
* 测试if单选择结构
* @author
*
*/
public class TestIf {
public static void main(String[] args) {
double d = Math.random();//返回【0,1）之间的随机数
System.out.println(d);
int h = (int)(6*Math.random()+1);//返回0-6之间的整数
System.out.println(h);
if(h<=3) {
System.out.println("小");
}
System.out.println("############");
//通过掷三个骰子看看今天的手气如何？
int i = (int)(6*Math.random())+1;
int j = (int)(6*Math.random())+1;
int k = (int)(6*Math.random())+1;
int count = i+j+k;
//如果三个骰子之和大于15，则手气不错
if(count>15) {
System.out.println("今天手气不错");
}
//如果三个骰子之和在10到15之间，则手气一般
if(count>=10 && count<=15) {//错误写法10<=count<=15
System.out.println("今天手气很一般");
}
//如果三个骰子之和小于10，则手气不怎么样
if(count<10) {
System.out.println("今天手气不咋地");
}
System.out.println("得了"+count+"分");
}
}3.1.2ifelse双选择结构
语法结构:
| 1 2 3 4 5 |
|
/**
* 测试ifelse双选择结构
* @author
*
*/
public class TestIfElse {
public static void main(String[] args) {
int h = (int)(6*Math.random())+1;
System.out.println(h);
if(h<=3) {
System.out.println("小");
}else {
System.out.println("大");
}
System.out.println("###########");
//随机产生一个【0,4.0）区间的半径，并根据半径求圆的面积和周长
double r = 4*Math.random();
//Math.pow(r,2)求半径r的平方
double area = Math.PI*Math.pow(r, 2);
double circle = 2*Math.PI*r;
System.out.println("半径为："+r);
System.out.println("面积为："+area);
System.out.println("周长为"+circle);
//如果面积>=周长，则输出“面积大于等于周长”，否则，输出“周长大于面积”
if(area>=circle) {
System.out.println("面积大于等于周长");
}else {
System.out.println("周长大于面积");
}
}
}
3.1.3 if-else if-else多选择结构
语法结构：
| 1 2 3 4 5 6 7 8 9 10 |
|
/**
* 测试ifelseifelse多选择结构
* @author
*
*/
public class TestIfElseIfElse {
public static void main(String[] args) {
int age = (int)(100*Math.random());
System.out.println("年龄是"+age+",属于");
if(age<15) {
System.out.println("儿童，喜欢玩！");
}else if(age<25) {
System.out.println("青年，要学习");
}else if(age<45) {
System.out.println("中年，要工作");
}else if(age<65) {
System.out.println("中老年，要补钙");
}else if(age<85) {
System.out.println("老年，多运动！");
}else {
System.out.println("老寿星，古来稀");
}
}
}
3.1.4switch多选择结构
语法结构：
| 1 2 3 4 5 6 7 8 9 10 11 |
|
switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者是switch语句的末尾。如果表达式的值与任一case值不匹配，则进入default语句(如果存在default语句的情况)。
根据表达式值的不同可以执行许多不同的操作。switch语句中case标签在JDK1.5之前必须是整数(long类型除外)或者枚举，不能是字符串，在JDK1.7之后允许使用字符串(String)。
大家要注意，当布尔表达式是等值判断的情况，可以使用if-else if-else多选择结构或者switch结构，如果布尔表达式区间判断的情况，则只能使用if-else if-else多选择结构。
/**
* 测试switch语句
* 遇到多值判断的时候，使用switch。当然switch完全可以使用ifelseifelse代替！
* @author niu
*
*/
public class TestSwitch {
public static void main(String[] args) {
int month = (int)(1+12*Math.random());
System.out.println("月份："+month);
switch(month) {
case 1:
System.out.println("一月份！过新年了");
break;
case 2:
System.out.println("二月份！开春了");
break;
default:
System.out.println("我是其他月份");
break;
}
System.out.println("################");
char c = 'a';
int rand = (int)(26*Math.random());//0-25
char c2 = (char)(c+rand);//'a'+(0-25)
System.out.print(c2+":");//不会换行，下面输出信息直接在c2后面
switch(c2) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
System.out.println("元音");
break;
case 'y':
case 'w':
System.out.println("半元音");
break;
default:
System.out.println("辅音");
}
}
}3.2.1While循环
循环结构分两大类，一类是当型，一类是直到型。
当型：
当布尔表达式条件为true时，反复执行某语句，当布尔表达式的值为false时才停止循环，比如：while与for循环。
直到型：
先执行某语句， 再判断布尔表达式，如果为true，再执行某语句，如此反复，直到布尔表达式条件为false时才停止循环，比如do-while循环。
while循环
while (布尔表达式) {
循环体;
}/**
* 测试While循环
* @author
*
*/
public class TestWhile {
public static void main(String[] args) {
//计算1+2+3+4+...+100的累加和，5050
int i = 0;
int sum = 0;
while(i<=100) {
sum = sum+i;
i++;
}
System.out.println(sum);//5050
}
}
while:先判断再执行；
do-while:先执行再判断；
3.2.3for循环
语法结构：
| 1 2 3 |
|
for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式;随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环;最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。
A. 初始化部分设置循环变量的初值
B. 条件判断部分为任意布尔表达式
C. 迭代因子控制循环变量的增减
for循环在执行条件判定后，先执行的循环体部分，再执行步进。
/**
* 测试for循环
* @author
*
*/
public class Testfor {
public static void main(String[] args) {
int sum = 0;
for(int i=0;i<=100;i++) {//计算0-100的累加和
sum = sum+i;
}
System.out.println(sum);
//for循环中","的应用
for(int i=1,j=i+10;i<5;i++,j=i*2) {
System.out.println("i="+i+"j="+j);
}
//无限循环
for(;;) {//相当于while（true）
System.out.println("这是个无限循环");
}
}
}
逗号运算符
Java里能用到逗号运算符的地方屈指可数，其中一处就是for循环的控制表达式。在控制表达式的初始化和步进控制部分，我们可以使用一系列由逗号分隔的表达式，而且那些表达式均会独立执行。
//for循环中","的应用
for(int i=1,j=i+10;i<5;i++,j=i*2) {
System.out.println("i="+i+"j="+j);
}1. 无论在初始化还是在步进部分，语句都是顺序执行的。
2. 尽管初始化部分可设置任意数量的定义，但都属于同一类型。
3. 约定:只在for语句的控制表达式中写入与循环变量初始化，条件判断和迭代因子相关的表达式。
无限循环
初始化部分、条件判断部分和迭代因子可以为空语句，但必须以“;”分开。
//无限循环
for(;;) {//相当于while（true）
System.out.println("这是个无限循环");
}编译器将while(true)与for(;;)看作同一回事，都指的是无限循环。
在for语句的初始化部分声明的变量，其作用域为整个for循环体，不能在循环外部使用该变量。
3.2.4嵌套循环
/**
* 测试嵌套循环
* @author niu
*
*/
public class TestWhileQiantao {
public static void main(String[] args) {
for(int i=1;i<=5;i++) {
for(int j=1;j<=5;j++) {
System.out.print(i+"\t");
}
System.out.println();
}
//打印九九乘法表
System.out.println("###############");
for(int i=1;i<=9;i++) {
for(int j=1;j<=i;j++) {
System.out.print(j+"*"+i+"="+(i*j)+"\t");
}
System.out.println();
}
//用while循环分别计算100以内的奇数及偶数的和，并输出
int sum01=0;
int sum02=0;
for(int i=0;i<=100;i++) {
if(i%2==0) {//偶数
sum01+=i;//sum01=sum01+i;
}else {//奇数
sum02+=i;
}
}
System.out.println("偶数和："+sum01);//2550
System.out.println("奇数和："+sum02);//2500
//用while循环或其它循环输出1-1000之间能被5整除的数，且每行输出5个
int h=0;
for(int i=1,j=1;i<=1000;i++) {
if(i%5==0) {
System.out.print(i+"\t");
h++;
if(h==5) {
h=0;
System.out.println();
}
}
}
}
}3.2.5break语句和continue语句
break
break用于强行退出循环，不执行循环中剩余的语句。
/**
* 测试循环语句中的break
* @author
*
*/
public class TestBreak {
public static void main(String[] args) {
int total = 0;//定义计数器
System.out.println("Begin");
while(true) {
total++;//每循环一次计数器加1
int i = (int)(100*Math.random());
System.out.println(i);
//当i=88时，退出循环
if(i==88) {
break;
}
}
//输出循环的次数
System.out.println("Game over,used"+total+"times.");
}
}
continue
continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
注意事项
1. continue用在while，do-while中，continue 语句立刻跳到循环首部，越过了当前循环的其余部分。
2. continue用在for循环中，跳到for循环的迭代因子部分。
/**
* 测试continue
* continue用于结束本次循环，继续循环下一次
* @author
*
*/
public class TestContinue {
public static void main(String[] args) {
int count = 0;//定义计数器
for(int i=100;i<150;i++) {
//如果是3的倍数，则跳过本次循环，继续进行下一次循环
if(i%3==0) {
continue;
}
//否则（不是3的倍数），输出该数
System.out.print(i+"、");
count++;//每输出一个数，计数器加1
//根据计数器判断每行是否已经输出了5个数
if(count%5==0) {
System.out.println();
}
}
}
}
3.2.6带标签的break和continue
goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字，但并未在Java语言中得到正式使用;Java没有goto语句。然而，在break和continue这两个关键字的身上，我们仍然能看出一些goto的影子---带标签的break和continue。
“标签”是指后面跟一个冒号的标识符，例如：“label:”。对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。
在 “goto有害”论中，最有问题的就是标签，而非goto， 随着标签在一个程序里数量的增多，产生错误的机会也越来越多。 但Java标签不会造成这方面的问题，因为它们的活动场所已被限死，不可通过特别的方式到处传递程序的控制权。由此也引出了一个有趣的问题：通过限制语句的能力，反而能使一项语言特性更加有用。
带标签break和continue：控制嵌套循环跳转(打印101-150之间所有的质数)
/**
* 带标签的Break和Continue
* @author
*
*/
public class TestLabelContinue {
public static void main(String[] args) {
//打印101-150之间所有的质数
outer:for(int i=101;i<150;i++) {
for(int j=2;j3.4方法
方法就是一段用来完成特定功能的代码片段，类似于其它语言的函数。
方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。
方法的调用方式：
对象名.方法名(实参列表)
方法的详细说明
1. 形式参数：在方法声明时用于接收外界传入的数据。
2. 实参：调用方法时实际传给方法的数据。
3. 返回值：方法在执行完毕后返还给调用它的环境的数据。
4. 返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void。
注意事项
1. 实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。
2. return 语句终止方法的运行并指定要返回的数据。
3. Java中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)：
4. 基本类型传递的是该数据值的copy值。
5. 引用类型传递的是该对象引用的copy值，但指向的是同一个对象。
/**
* 测试方法的基本使用
* @author
*
*/
public class TestMethod {
public static void main(String[] args) {
//通过对象调用普通方法
TestMethod tm = new TestMethod();
tm.printSxt();
int c = tm.add(30, 40, 50)+1000;
System.out.println(c);
}
void printSxt() {
System.out.println("北京");
System.out.println("上海");
System.out.println("广州");
}
int add(int a,int b,int c) {
int sum = a+b+c;
System.out.println(sum);
return sum;//return两个作用：1、结束方法的运行。2、返回值
}
}
3.5方法的重载（overload）
方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会根据不同的参数自动匹配对应的方法。
雷区
重载的方法，实际是完全不同的方法，只是名称相同而已!
构成方法重载的条件：
1.不同的含义：形参类型、形参个数、形参顺序不同
2.只有返回值不同不构成方法的重载
如：
| 1 |
|
不构成方法重载
3.只有形参的名称不同，不构成方法的重载
如：
| 1 |
|
不构成方法重载
/**
* 测试方法的重载
* @author
*
*/
public class TestOverload {
public static void main(String[] args) {
System.out.println(add(3,5));//8
System.out.println(add(3,5,10));//18
System.out.println(add(3.0,5));//8.0
System.out.println(add(3,5.0));//8.0
}
/*求和的方法*/
public static int add(int n1,int n2) {
int sum = n1+n2;
return sum;
}
//方法名相同，参数个数不同，构成重载
public static int add(int n1,int n2,int n3) {
int sum = n1+n2+n3;
return sum;
}
//方法名相同，参数类型不同，构成重载
public static double add(double n1,int n2) {
double sum = n1+n2;
return sum;
}
//方法名相同，参数顺序不同，构成重载
public static double add(int n1,double n2) {
double sum = n1+n2;
return sum;
}
}
//只有返回值不同，不构成方法的重载
//只有参数名称不同，不构成方法的重载
3.6递归结构
递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。
利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺塔、快排等问题。
递归结构包括两个部分：
1.定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。
2.递归体。解答：什么时候需要调用自身方法。
/**
* 测试递归
* @author
*
*/
public class TestRecursion01 {
public static void main(String[] args) {
a();
}
static int count = 0;
static void a() {
System.out.println("a");
count++;
if(count<10) {//递归头
a();//递归体
}else {
return;
}
}
}
递归的缺陷
简单的程序是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。
递归：计算n!
/**
* 测试递归，阶乘
* @author
*
*/
public class TestRecursion02 {
public static void main(String[] args) {
long d1 = System.currentTimeMillis();
System.out.printf("%d阶乘的结果：%s%n",10,factorial(10));
long d2 = System.currentTimeMillis();
System.out.printf("递归费时：%s%n",d2-d1);//耗时65ms
factotialLoop(10);
}
/**求阶乘的方法*/
static long factorial(int n) {
if(n==1) {
return 1;//递归头
}else {
return n*factorial(n-1);//n!=n*(n-1)!
}
}
/**使用普通循环求递归*/
static long factotialLoop(int a) {
long d3 = System.currentTimeMillis();
long result = 1;
while(a>1) {
result*=a*(a-1);
a-=2;
}
long d4 = System.currentTimeMillis();
System.out.println(result);
System.out.printf("普通循环费时：%s%n",d4-d3);//普通循环费时：0
return result;
}
}
注意事项
任何能用递归解决的问题也能使用迭代解决。当递归方法可以更加自然地反映问题，并且易于理解和调试，并且不强调效率问题时，可以采用递归;
在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存。
第三章作业