java回到switch循环开头 java中switch循环

Switch的语法结构：
java1.7之前只能操作整型，1.7开始还可以操作字符串，不能使用范围。

switch(整型/字符串){
	case '值':
		代码;
		break;
	case '值';
		代码;
		break;
	default:
		代码;
}
// case合并，相当于或
switch(整型/字符串){
	case '值':case '值':
		代码;
		break;
}

每个分支都需要以break结尾，用于结束循环（如果是嵌套循环，结束最近的），否则会出现case穿透的情况。
break应用场景，在一堆数据中找一个数据，找到之后，循环就可以停止了，不用再比较了。
可以通过给外层循环起名字，然后break外层循环。

outerFor: for(int i=0;i<5;i++){
	for(int j=0;j<5;j++){
		if(i==3){
			break outerFor;
		}
		System.out.print(j+"");
	}
	System.out.println();
}

continue是跳过当前次循环，继续下一次（碰到continue，直接执行表达式三）。

for(int i=0;i<5;i++){
	if(i==3){
		continue;
	}
	System.out.println(i);//输出是0124
}

/**
 * 
 */
package comSwitch;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Random;

/**
 * @author SkyMei
 *
 * @Date 2021年3月24日 上午9:44:13
 *
 */
public class SwitchTestOne {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 生成0.0-1.0的随机数
		Random random = new Random();
		double scoreOne = random.nextDouble();
		// 生成0.0-100.0的随机数
		double score = scoreOne*100;
		// 取两位小数
		BigDecimal bd = new BigDecimal(score);
		bd = bd.setScale(2,RoundingMode.HALF_UP);
		System.out.println(bd+"\n");
		switch((int)score/10){
			case 10:case 9:
				System.out.println("优秀");
				break;
			case 7:case 8: 
				System.out.println("良好");
				break;
			case 6:
				System.out.println("及格");
				break;
			default:
				System.out.println("不及格");
				break;
		}
	}

}

循环结构

循环分为for，do-while，while三种循环。
循环三要素：初始值，终止条件和步长。
for循环也叫计数循环，在某个次数循环中，重新做某件事。

// 语法结构 条件可以不写，分号必须有，这种情况进入无限循环的状态。
for(表达式1;表达式2;表达式3){
	重复代码;
}

先执行表达式一，并且只执行一次，执行表达式二，根据结果进行处理，如果是true就执行循环体，否则就终止，执行完循环体执行表达式三，然后执行表达式二…
嵌套循环，循环体中还有一个循环，双重嵌套可以模拟二维表格，可以把外层循环当作行，内存循环当作列。

/**
 * 
 */
package comFor;

/**
 * @author SkyMei
 * 九九乘法表
 * @Date 2021年3月24日 上午10:42:38
 *
 */
public class ForTestOne {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for(int i =1;i<10;i++){
			for(int j =1;j<=i;j++){
				System.out.print(j+"*"+i+"="+(i*j)+" ");
			}
			System.out.println("");
		}
	}

}

while循环称为真假循环，某个条件为真的时候执行。

// while语法
while(boolean表达式){
	java代码;
}

do-while循环保证代码至少执行一次，先执行再判断是不是要执行。

// do-while语法
do{
	java代码;
}while(boolean表达式);

控制语句类型：选择结构语句（if，if else，else if，switch）；循环结构语句（for，while，do while）；改变语句执行序（break，continue）。

• 用while和do while循环变量在循环体前初始化，而for是在第一句进行初始化。
• while和for循环都是先判断表达式，然后执行循环体，do-while则是先执行循环体然后判断表达式。
• 三种循环都可以用break语句跳出循环，用continue语句结束本次循环。

package comTask;

/**
 * 有,大马,中马,小马共100匹(每种马最少1匹),有100块砖头
 * 
 * 大马一次驮 3块砖头 , 中马一次驮2块砖头,三匹小马一次驮1块砖头
 * 
 * 刚好一次驮完, 问 大马,中马,小马 各多少匹
 * 
 * 
 * @author SkyMeis
 * @Date 2021年3月24日
 */
public class HorseQuestion {

	public static void main(String[] args) {
		int brick = 100;
		int num = 0;
		// int allHorse = 100;
		// int bigHorse,meHorse,smallHorse;
		// bigHorse+meHorse+smallHorse=allHorse;
		// bigHorse*3+meHorse*2+smallHorse/3=100;
		for(int bigHorse=0;bigHorse<99;bigHorse++){
			for(int meHorse=0;meHorse<99;meHorse++){
				for(int minHorse=0;minHorse<99;minHorse++){
					if(bigHorse!=0&&meHorse!=0&&minHorse!=0
							&&bigHorse+meHorse+minHorse==100
							&&minHorse%3==0&&bigHorse*3+meHorse*2+minHorse/3==brick){
								System.out.println("大马数量是"+bigHorse+"匹，中马数量是,"+meHorse+"匹,小马数量是"+minHorse+"匹");
								num++;			
					}
				}
			}
		}
		System.out.println("一共"+num+"种情况");
	}
}

方法（method）

方法就是一堆代码的集合，使程序简洁清晰，有利于维护，提高开发效率，提高代码重用性。
函数在类之外，和类平级，使用函数不需要二次引用，可以直接使用。
方法在类中，使用的时候需要加前缀才能找到它。
方法和函数是一个东西，只是因为位置不同，叫法不同，调用的方式也不同。
Java中只有方法。
方法的声明：
【修饰符列表】 返回值类型 方法名 （参数列表）{方法体}
修饰符可有可无，可一可多：权限控制（public，private，protected，默认，四选一）；其他（static，final，abstract，synchronized（final和abstract二选一））
返回值类型：完成功能后是否需要返回结果，如果不需要就写void，如果需要，就写返回数据对应的类型即可；十一种类型中任意一种或者void。
方法名符合命名规范。
方法名和变量名首字母建议小写，类名建议首字母大写。
参数列表：可有可无，没有只写（）；多个用逗号隔开，调用方法的时候，需要传递的数据。
形参：方法声明的时，规定应该传入的数据的类型。
实参：调用方法的时候实际传递的值。
方法体：Java编码，执行的功能。

public static int m1(int a,int b){
	return a+b;
}

方法分为静态方法，成员方法和构造方法。
使用static修饰的方法是静态方法，是类级别的；成员方法没有static修饰，构造方法用来创建对象。
静态方法调用的时候：类名.静态方法名(参数)；类名.静态方法名()；成员方法调用对象.成员方法名(参数)；构造方法：new。
方法不调用不执行，调用才执行，并把结果返回到调用处，编写方法的时候不需要考虑先后，先调用先执行。
特殊方法main，入口程序，由JVM调用，不能改，参数列表中的args可以改。

public static vioid main(String[] args){}

Java程序可以理解为只会执行main方法，所有代码的开始和结束都依赖于main方法。

Return

• 可以终止方法的运行
• 返回数据

如果方法没有返回值，那么方法体中可以没有return，return不能写任何数据，return只有终止方法运行的作用；如果方法有返回值，那么必须有return，而且return后要写上返回值类型对应的数据；因为return有终止方法的作用，所以return后不能写代码。

package comTask;

/**
 * 作业 : 
 * 		1 计算1~100的累加加和
 * 		2 计算 1~100的偶数和
 * 		3 计算1~100的奇数和 
 * 
 * @author SkyMei
 * @Date 2021年3月24日
 */
public class For_04 {

	public static void main(String[] args) {
		/**
		 * 计算零到一百的和
		 */
		int i;
		int numAdd = 0;
		for(i=0;i<=100;i++){
			numAdd = numAdd+i;
		}
		System.out.println(numAdd);
		/**
		 * 计算零到一百的偶数和
		 */
		numAdd=0;
		for(i=0;i<=100;i+=2){
			numAdd = numAdd+i;
		}		
		System.out.println(numAdd);
		/**
		 * 计算零到一百的奇数和
		 */
		numAdd=0;
		for(i=1;i<=100;i+=2){
			numAdd = numAdd+i;
		}
		System.out.println(numAdd);
		/**
		 * 使用方法求两个整数之间数值的和
		 */
		numAdd = addNum(0,100);
		System.out.println(numAdd);
		/**
		 * 使用方法求两个整数之间偶数的和
		 */
		For_04.addEvenNum(3, 100);
		/**
		 * 使用方法求两个整数之间奇数的和
		 */
		numAdd = addOddNum(2,99);
		System.out.println(numAdd);
	}
	/**
	 * 计算任意两个整数之间数值和的方法
	 */
	public static int addNum(int a,int b){
		int c = a;
		for(;a<=b;a++){
			c+=a;
		}
		return c;
	}
	/**
	 * 计算两个整数之间偶数和的方法
	 */
	public static void addEvenNum(int a,int b){
		int c;
		if(a%2==0){
			c=a;
			for(;a<=b;a+=2){
				c+=a;
			}
			System.out.println(c);
		}else{
			c=0;
			a=a+1;
			for(;a<=b;a+=2){
				c+=a;
			}
			System.out.println(c);
		}
	}
	/**
	 * 计算两个整数之间奇数和的方法
	 */
	public static int addOddNum(int a,int b){
		int c;
		if(a%2==1){
			c=a;
			for(;a<=b;a++){
				c+=a;
			}
			return c;
		}else{
			c=0;
			a=a+1;
			for(;a<=b;a+=2){
				c+=a;
			}
			return c;
		}
	}
}

方法唯一性（通过唯一确定一个方法）：方法名；参数列表（个数不同，类型不同）
方法重载：方法名相同，参数列表不同。（应用场景：功能类似）优点：美观，调用方便，记忆方便，不是为了减少代码复用。