3.流程控制语句

最新推荐文章于 2024-04-07 11:11:40 发布

不戴眼镜的眼镜男

最新推荐文章于 2024-04-07 11:11:40 发布

阅读量253

点赞数

分类专栏： Java笔记文章标签：顺序结构选择结构循环结构跳转结构方法定义调用重载

本文链接：https://blog.csdn.net/BossHAO/article/details/103929709

版权

Java笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

3.流程控制语句

• 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。

• 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：顺序结构、分支结构和循环结构，如下图所示：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sV3ANRrh-1578655732619)(D:\Java笔记\3.流程控制语句\image-20200110183551742.png)]$

if 语句

/**
 * 测试if单选择结构
 * @author lh
 *
 */
public class TestIf {
	public static void main(String[] args) {
		double d = Math.random();//生成【0，1）之间的随机数
		double f = Math.random();
		double g = Math.random();
		int h = (int)(6*d+1);
		int j = (int)(6*d+1);
		int k = (int)(6*d+1);
		int count =  h+j+k;
		if(count >15) {
			System.out.println("手气好！");
		}
		if(count >=10&&count<=15) {
			System.out.println("手气一般！");
		}
		if(count<10) {
			System.out.println("手气差！");
		}
	}
}

if-else双分支选择结构

• 当条件表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分

/**
 * 测试双选择结构
 * @author lh
 *
 */
public class TestIfElse {
	public static void main(String[] args) {
		double r = 4*Math.random();
		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("周长大于面积");
		}
	}
}

If-else if-else多分支选择结构

/**
 * 测试ifelseiflese多选择结构
 * @author lh
 *
 */
public class TestIfElesIfElse {
	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("老寿星");
		}
		
	}
}

switch多分支选择结构

1.switch语句会根据表达式的值从相匹配的执行，一直执行到break标签处开始ak语句处或者是switch语句的末尾。与任一case值不匹配，则进入default语句(如果有的话)
2.只能处理等值条件判断的情况，且表达式必须为byte，short，int或char类型，不能是 String或double,float.
3.常量值必须是与表达式类型兼容的特定的一个常量
4.不允许有重复的case值
5.default子句为可选

/**
 * 
 * @author lh
 *
 */
public class TestSwtich {
	public static void main(String[] args) {
		char c = 'a';
		int rand = (int)(26*Math.random());
		char c2 = (char)(c+rand);
		System.out.print(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("辅音");
		}
	}
}

while循环

• 在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。

• 语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。

/**
 * 测试While for循环
 * @author lh
 *
 */

public class TestWhile {
	public static void main(String[] args) {
		int i=1;
		int sum = 0;
		int sum1 = 0;
		while(i<=100) {
			sum=sum+i;
			i++;
		}
		System.out.println(sum);
		
		for(int j=1,k=5;j<=100;j++) {
			sum1 =sum1+j;
		}
		System.out.println(sum);
		for(;;) {
			System.out.println("789");
		}
	}
}

do-while循环

• do-while:

• 先执行，后判断。

• while:
• 先判断，后执行。

for循环

• for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构

• 语法形式

• for (初始表达式;布尔表达式;步进) {

• 循环体；

• }

• 注意事项

• for循环在执行条件测试后，先执行程序部分，再执行步进。

• 在for语句的初始化部分声明的变量，其作用域为整个for循环体

• “初始化”和“循环条件表达式”部分可以使用逗号来执行多个操作 • 如果三个部分都为空语句（分号不能省），相当于一个无限循环

跳转语句—break和continue

• 在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。(break语句还可用于多支语句switch中)

• continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

跳转语句—return

• return语句从当前方法退出，返回到调用该方法的语句处，并从该语句的下条语句处继续执行程序。

• 返回语句的两种格式（具体到方法时详细讲解）

• 1、return expression

• 返回一个值给调用该方法的语句。

• 返回值的数据类型必须和方法声明中的返回值类型一致或是精度低于声明的数据类型。

• 2、return

• 当方法声明中用void声明返回类型为空时，应使用这种返回类型，它不返回任何值。

/**
 * 测试循环语句中的break continue
 * 
 * @author lh
 *
 */
public class TestBreak {
	public static void main(String[] args) {
		int total = 0;
		System.out.println("Begin");
		while (true) {
			total++;
			int i = (int) (100 * Math.random());
			System.out.println(i);
			if (i == 88) {
				break;
			}
		}
		System.out.println("Game Over!,used" + total + "times");
		int k = 0;
		for (int j = 100; j < 150; j++) {
			if (j % 3 == 0) {
				continue;
			}
			System.out.print(j+ " ");
			k++;
			if (k % 5 == 0) {
				System.out.println();
			}
		}
	}
}
/**
 * 测试带标签的Continue
 * @author lh
 *
 */
public class TestLabelContinue {
	public static void main(String[] args) {
		outer:for(int i =101;i<=105;i++) {
			for(int j=2;j<i/2;j++) {
				if(i%j==0) {
					continue outer;
				}
			}
			System.out.println(i+" ");
		}
	}
}

多重循环

• 多重循环（循环嵌套） • 一个循环体内又包含另一个完整的循环结构 • 任何两种循环都可以相互嵌套 • 可以任意层次循环，但是一般不超过3层 • 多重循环执行过程 • 外层循环变量变化一次，内层循环变量要变化一遍

/**
 * 测试嵌套循环
 * @author lh
 *
 */
public class TestWhileQiaotao {
	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();
		}*/
		for(int i=1;i<=9;i++) {
			for(int j=1;j<=i;j++) {
				System.out.print(i+"*"+j+"="+i*j+"\t");
			}
			System.out.println();
		}
		int k = 1;
		int sum1 = 0;
		int sum2 = 0;
		for(int i =1;i<=100;i++) {
			if(i%2==0) {
				sum1++;
			}
			else {
				sum2++;
			}
		}
		System.out.print("sum1="+sum1+"sum2="+sum2);
		for(int v=1,o=0 ;k<=1000;k++) {
			if(k%5==0) {
				o++;
				System.out.print(k+"\t");
				if(o%5==0)
					System.out.print("\n");
			}
		}
	
	}
}

方法

• 什么是方法 • 封装在一起来执行操作语句的集合，用来完成某个功能操作
• 在某些语言中称为函数或者过程
• 特殊的方法main，程序执行的入口
• public static void main(String [ ] args){

• 实现功能的语句

• }
• 不可能所有的功能都放到main中，需要定义其他方法完成指定功能，需要时调用方法即可

• 定义方法

• [修饰符]   方法返回值类型   方法名(形参列表 ) { 

• 方法体

  return 返回值；

 • } 

• public static  int add(int a, int b, int c) { 

• int k = a + b + c; 

• return k; 

• }

• 修饰符：封装性时再讲，决定了方法的工作范围

• 返回值类型：必选，如果没有返回值，须写void。方法只能返回一个值

• 方法名：

• 参数列表：可以0个、1个、多个，需要同时说明类型。称为形式参数

• 方法体：完成具体功能。如果有返回值，必须有return语句；如果没有返回值，默认最后一条语句是return，可以省略。

• 方法调用

$**[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cASekTxO-1578655732621)(D:\Java笔记\3.流程控制语句\image-20200110185158218.png)]**$

• 方法重载

• 一个类中可以定义有相同的名字，但参数不同的多个方法

 • 调用时，会根据不同的参数表选择对应的方法。

• 判断依据

• 同一个类

• 同一个方法名

• 不同：参数列表不同(类型，个数，顺序不同)

• 注意

• 只有返回值不同不构成方法的重载（

• int a(String str){},

• void a{String i},

• 调用：a()，谁能告诉我是调哪个方法?

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

/**
 * 测试方法的基本使用
 * 
 * @author lh
 *
 */
public class TestMethod {
	public static void main(String[] args) {
		TestMethod tm = new TestMethod();
		tm.printXx();
		// int cg = 12 + tm.add(11, 11, 12);
		// System.out.println(cg);
		System.out.println(add(1.0, 5));
		System.out.println(add(5, 2.0));
		
	}

	void printXx() {
		System.out.println("嘿嘿");
	}

	public static int add(int a, int b, int c) {
		int sum = a + b + c;
		System.out.println(sum);
		return sum;
	}

	public static int add(int a, int b) {
		int sum = a + b;
		System.out.println(sum);
		return sum;
	}

	public static int add(double a, int b) {
		int sum = (int) (a + b);
		System.out.println(sum);
		return sum;
	}

	public static int add(int a, double b) {
		int sum = (int) (a + b);
		System.out.println(sum);
		return sum;

	}
	//只有返回值不同，不构成方法的重载
//	public static double add(int a, double b) {
//		int sum = (int) (a + b);
//		System.out.println(sum);
//		return sum;
//
//	}
	//只有参数名不同，不构成方法的重载
//	public static int add(int c, double d) {
//		int sum = (int) (c + d);
//		System.out.println(sum);
//		return sum;
//
//	}

//	public static int add(int a, int b, int c，int d) {
//		int sum = a + b + c + d;
//		System.out.println(sum);
//		return sum;
//	}
}

递归

/**
 * 测试递归
 * 
 * @author lh
 *
 */
public class TestRecursion {
	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("递归时长：%d%n", d2 - d1);
		factorialLoop(10);
	}

	static long factorial(int n) {
		if (n == 1) {
			return 1;
		} else {
			return n * factorial(n - 1);
		}
	}

	static long factorialLoop(int a) {
		long d3 = System.currentTimeMillis();
		long result = 1;
		while (a > 1) {
			result *= a * (a - 1);
			a -= 2;
		}
		long d4 = System.currentTimeMillis();
		System.out.printf("普通循环时长：%d%n", d4 - d3);
		return result;
	}
}

ong d2 = System.currentTimeMillis();
System.out.printf(“递归时长：%d%n”, d2 - d1);
factorialLoop(10);
}

static long factorial(int n) {
	if (n == 1) {
		return 1;
	} else {
		return n * factorial(n - 1);
	}
}

static long factorialLoop(int a) {
	long d3 = System.currentTimeMillis();
	long result = 1;
	while (a > 1) {
		result *= a * (a - 1);
		a -= 2;
	}
	long d4 = System.currentTimeMillis();
	System.out.printf("普通循环时长：%d%n", d4 - d3);
	return result;
}

}