Java学习第三章-控制语句（仅做个人学习笔记用）

最新推荐文章于 2024-07-19 17:37:28 发布

Nlsrr

最新推荐文章于 2024-07-19 17:37:28 发布

阅读量215

点赞数

分类专栏： JAVA学习笔记文章标签： java

原文链接：https://www.sxt.cn/Java_jQuery_in_action/Java_Single_selection_structure.html

版权

JAVA学习笔记专栏收录该内容

5 篇文章 0 订阅

订阅专栏

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双选择结构

语法结构:

if(布尔表达式){

语句块1

}else{

语句块2

}

/**
 * 测试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多选择结构

语法结构：

if(布尔表达式1) {

语句块1;

} else if(布尔表达式2) {

语句块2;

}……

else if(布尔表达式n){

语句块n;

} else {

语句块n+1;

}

/**
 * 测试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多选择结构

语法结构：　

switch (表达式) {

case 值1:

语句序列1;

[break];

case 值2:

语句序列2;

[break];

… … … … …

[default:

默认语句;]

}

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循环

语法结构：　　

for (初始表达式; 布尔表达式; 迭代因子) {

循环体;

}

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;j<i/2;j++) {
				if(i%j==0) {
					continue outer;//不是质数，跳出去。进行下一次循环
				}
			}
			System.out.print(i+" ");
		}
	}

}

3.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	`int a(String str){}与 void a(String str){}`

不构成方法重载

3.只有形参的名称不同，不构成方法的重载

如：

1	`int a(String str){}与int a(String s){}`

不构成方法重载

/**
 * 测试方法的重载
 * @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;
	}
}

注意事项

任何能用递归解决的问题也能使用迭代解决。当递归方法可以更加自然地反映问题，并且易于理解和调试，并且不强调效率问题时，可以采用递归;

在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存。

第三章作业

Nlsrr

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习第三章-控制语句（仅做个人学习笔记用）

3.1.1if单选择结构语法结构：if(布尔表达式){ 语句块}Math类的使用 1.java.lang包中的Math类提供了一些用于数学计算的方法。 2.Math.random()该方法用于产生一个0到1区间的double类型的随机数，但是不包括1。 int i = (int) (6 * Math.random());...
复制链接

扫一扫