控制语句：
java控制可以分为7种：
*控制选择结构语句：
*if if else
*switch
*控制循环结构语句：
*for
*while
*do while
*改变控制语句顺序：
*break
*continue
if控制语句：
/*
关于java语言当中的if语句，属于选择结构，if语句又被称为分支语句/条件控制语句；
1、if语句的运发结构：包含4中编写方式
第一种：
if(布尔表达式){java语句;...};
第二种：
if(布尔表达式){
java语句;...
}else{
java语句;...
}
第三种：
if(布尔表达式){
java语句;...
}else if(布尔表达式){
java语句;...
}...
第四种：
if(布尔表达式){
java语句;...
}else if(布尔表达式){
java语句;...
}else{
java语句;...
}
重点：只要有一个if分支执行，整个if语句结束；
注意：所有控制语句都是可以互相嵌套的。
注意：嵌套使用的时候，代码格式要保证完美。
注意：if语句中，只有一条java语句的话，大括号可以省略；
if(true/false){java语句;}
if(true/false) java语句;//但是不推荐使用，这种代码风格不好。不容易看清。
*/ public class ifTest01{
public static void main(String[] args){
// 需求，所在位置的5公里范围内有肯德基的话，去KFC吃午饭。
// 公里数
double distance = 6.0;//单位KM
// 判断语句
if(distance<=5){
System.out.println("走着去KFC吃午饭");
}else if(distance<=7.0&&distance>5){
System.out.println("跑着去KFC吃午饭");
}else{
System.out.println("在附近吃别的");
} }
}
接收用户键盘输入：
/*
System.out.println() 负责向控制台输出，【从内存到控制台，输出的过程，这是从内存中出来了】
接收用户键盘输入，从"键盘"到"内存"。【输入的过程，到内存汇总去】 */ public class ifTest01{
public static void main(String[] args){
// 创建键盘扫描器对象
java.util.Scanner s = new java.util.Scanner(System.in);
// 第二部：调用Scanner对象的next()方法开始接收用户键盘输入
// 程序执行到这里，会停下来，等待用户输入
// 当用户输入的时候，并且最终敲回车键的时候，键入的信息会自动赋值给userInputContent
// 程序执行到这里，用户输入的信息已经到内存中了 // 接收文本【以字符串的形式接收】
// String userInputContent = s.next();
// 将内存中的数据输出到控制台
// System.out.println("您输入了："+userInputContent); // 接收数字【以整数型的形式接收】
int num = s.nextInt();
System.out.println("您输入的数字是："+num); }
}
/*
if控制语句练习：
需求：假设系统给定一个人的年龄（这个年龄需要从键盘输入），
根据年龄来判断这个人处于生命的哪个阶段。年龄必须在[0-150]
[0-5]幼儿
[6-10]少儿
[11-18]青少年
[19-35]青年
[36-55]中年
[56-150]老年
*/ public class ifTest01{
public static void main(String[] args){
// 1、接收键盘输入：年龄【输入的时候必须输入数字】 // 创建键盘扫描器对象
java.util.Scanner s = new java.util.Scanner(System.in);
// 提示信息
System.out.println("请输入您的年龄");
int age = s.nextInt();//停下来等待用户输入，回车后赋值给age，然后往下执行
System.out.println("age="+age); // 2、根据需求进行业务逻辑判断
String str = "老年";
if( age < 0 || age > 150 ){
str = "您提供的年龄不合法，年龄需要在[0-150]";
}else if(age <= 5){
str = "幼儿";
}else if(age <= 10){
str = "少儿";
}else if(age <= 18){
str = "青少年";
}else if(age <= 35){
str = "青年";
}else if(age <= 55){
str = "中年";
}else if(age <= 105){
str = "老年";
}
System.out.println("您处于生命周期的"+str+"阶段"); }
}
/*
if控制语句练习：需求
判断当前的天气：
当外边下雨的时候：
带雨伞：
男生：带一把大黑伞
女生：带一把小黑伞
当外边晴天的时候：
判断天气的温度：
当温度在30度以上：
男生：戴墨镜
女生：搽防晒霜 提示：
1、一定要用到嵌套
2、天气状况、性别、温度都需要从键盘输入
天气状况：1表示下雨、0表示晴天
性别：1表示男、0表示女
温度直接用数字表示即可
*/ public class ifTest01{
public static void main(String[] args){
java.util.Scanner s= new java.util.Scanner(System.in); System.out.println("欢迎使用本系统,您通过本系统可以完成一些简单的判断");
System.out.println("说明1：1表示男、0表示女");
System.out.println("说明2：1表示下雨、0表示晴天");
System.out.println("说明3：用数字表示温度"); // 接收性别
System.out.println("请输入性别：");
int sex = s.nextInt();
// 接收天气状况
System.out.print("请输入当前天气：");
int weather = s.nextInt();
// 判断天气状况
if(weather == 1){
// 下雨天
System.out.println("下雨天");
if(sex == 1){
System.out.println("带一把大黑伞");
}else if(sex == 0){
System.out.println("带一把小花伞");
}else{
System.out.println("请输入正确的性别");
}
}else if(weather == 0){
//晴天
System.out.println("晴天");
// 接收温度
System.out.println("请输入温度：");
int tem = s.nextInt();
if(tem > 30){
if(sex == 1){
System.out.println("带墨镜");
}else if(sex == 0){
System.out.println("查防嗮爽");
}else{
System.out.println("请输入正确的性别");
}
}else{
System.out.println("今天天气良好，可以自由出行");
}
}else{
System.out.println("您输入的天气有误，需要输入1或者0");
}; }
}
switch语句
/*
关于switch语句：
1、switch语句也属于选择结构，也属于分支语句
2、switch语句的语法结构
一个完整的switch语句应该这样编写：
switch(int或String类型的字面值或变量){
case int或String类型的字面值或变量:
java语句;
...
break;
case int或String类型的字面值或变量:
java语句;
...
break;
default :
java语句;
...
};
3、switch语句执行原理：
switch后面小括号当中的"数据"和case后面的"数据"，进行一一匹配，匹配成功的分支执行。
按照从上到下的顺序依次匹配。
4、匹配成功的分支执行，分支当中最后有break语句，整个switch语句终止。
5、匹配成功的分支执行，分支当中最后没有break语句的话，直接进入下一个分支执行（不进行匹配）。
这种现象被称为case穿透现象。【提供break;语句可以避免穿透】
6、所有分支如果都没有匹配成功，如果有default语句的话，会执行default分支当中的语句。
7、switch后面和case后面只能是int或String类型的数据，不能探测其它类型！
*当然，byte、short、char也可以直接写到switch和case后面，因为他们可以进行自动类型转换。
byte、short、char可以自动转换为int类型。
*JDK6版本的话，switch和case后面只能探测int类型。
*JDK7以后版本包括JDK7版本，引入新特性，switch和case后面可以探测int或String类型的数据。
8、case可以合并：
int i = 10;
switch(i){
case 1: case 2: case 3: case 10:
java语句;
...
break;
default:
java语句;
} */
public class Switch01{
public static void main(String[] agrs){
/*类型错误
long a = 100L;
int b = a;
*/
// 和上面的报错原因相同
// long x = 100L;
// switch(x){} // 解决编译错误
long x = 100L;
switch((int)x){}; byte b = 10;
switch(b){}; short s = 20;
switch(s){}; char c = 'A';
switch(c){}; char cc = 97;
switch(cc){}; // switch(true){}; 编译错误 不兼容的类型 无法转换为int String username = "张三";
switch(username){}; /*
较完整的switch语句
*/
// 接收用户的输入：
// 输入1：星期一
// 输入2：星期二
// ...
// 输入7：星期日 java.util.Scanner o = new java.util.Scanner(System.in);
System.out.print("请输入数字1-7：");
int num = o.nextInt();
switch(num){
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("您输入的啥都不是");
} System.out.println("======================");
//case穿透
switch(num){
case 1:
System.out.println("星期一");
// break; 输入1、2都会穿透到3的分支
case 2:
System.out.println("星期二");
// break; 输入1、2都会穿透到3的分支
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("您输入的啥都不是");
}; System.out.println("======================");
//case合并
switch(num){
case 1: case 2: case 3: case 4: case 5:
System.out.println("工作日");
break;
case 6: case 7:
System.out.println("休息日");
break;
default:
System.out.println("您输入的啥都不是");
}; }
}
/*
switch确实可以探测String类型，这是java7的新特性。
*/
public class Switch01{
public static void main(String[] agrs){ java.util.Scanner s = new java.util.Scanner(System.in); System.out.print("请输入汉字的星期几："); String str = s.next();
switch(str){
case "星期一":
System.out.println(1);
break;
case "星期二":
System.out.println(2);
break;
case "星期三":
System.out.println(3);
break;
case "星期四":
System.out.println(4);
break;
case "星期五":
System.out.println(5);
break;
case "星期六":
System.out.println(6);
break;
case "星期日":
System.out.println(7);
break;
default:
System.out.println("您输入有误");
}
}
}
/* */
public class Switch01{
public static void main(String[] agrs){ char c = 'A';
switch(c){
case 'A':
System.out.println("高级");
break;
case 'B':
System.out.println("中级");
break;
case 'C':
System.out.println("低级");
break;
default:
System.out.println("级别太低了");
}
switch(c){
case 65://'A'对应的int类型是65
System.out.println("高级");
break;
case 'B':
System.out.println("中级");
break;
case 'C':
System.out.println("低级");
break;
default:
System.out.println("级别太低了");
}
}
}
/*
需求：实现计算机中的加、减、乘、除、取余数
实现思路：
1、选择所有数据从键盘输入
2、使用switch语句进行判断
3、需要从控制台输入三次
*第一个数字
*运算符
*第二个数字 */
public class Switch01{
public static void main(String[] agrs){ java.util.Scanner s = new java.util.Scanner(System.in);
System.out.print("请输入第一个数字");
int a = s.nextInt();
System.out.print("请输入运算符");
String str = s.next();
System.out.print("请输入第二个数字");
int b = s.nextInt(); switch(str){
case "+":
System.out.println(a+" + "+b+" = "+(a + b));
break;
case "-":
System.out.println(a+" - "+b+" = "+(a - b));
break;
case "*":
System.out.println(a+" * "+b+" = "+(a * b));
break;
case "/":
System.out.println(a+" / "+b+" = "+(a / b));
break;
case "%":
System.out.println(a+" % "+b+" = "+(a % b));
break;
default:
System.out.println("计算有误");
}
}
}
循环语句
for循环
/*
1、循环结构
在程序当中，总有一些需要反复的/重复执行的代码，假设没有循环结构，
那么这段需要重复执行的代码自然是需要重复编写的。代码无法得到重复
使用。所以多数变成语言都是支持训话结构的。将来把需要重复执行的代码
片段放到"循环体"，再联合"计数器"，共同控制这段需要重复执行的代码。
2、基本上所有的变成语言支持的循环包括三种：
*for循环
*while循环
*do...while循环
3、接下来主要介绍for循环：
for循环的语法结构是什么呢？
for(初始化表达式;布尔表达式;更新表达式){
// 需要重复执行的代码片段【循环体：由java与语句构成】
}
4、for循环的执行过程/执行原理：
4.1:初始化表达式、布尔表达式、更新表达式都不是必须的！【但是 两个分号 是必须的】
4.2:初始化表达式最先执行，并且在整个for循环当中只执行一次。
4.3:布尔表达式的执行结构必须是true/false,不能是其它值。
4.4:for的执行过程：
*先执行初始化表达式，并且该表达式只执行一次
*判断布尔表达式的执行结构是true/false：
- 布尔表达式true：
*执行循环体
*执行更新表达式
*判断布尔表达式的结构是true/false
- 布尔表达式true：
*执行循环体
*执行更新表达式
*判断布尔表达式的结构是true/false
...
-布尔表达式false：
*循环结束
- 布尔表达式false：
*循环结束
*/ public class For01{
public static void main(String[] args){
// 需求：输出数字1-10
for(int i = 1; i <= 10; i++){
System.out.println(i);
}; // 死循环
// for( ; ; ){
// System.out.println("我是死循环");
// } // 需求：
// 找出1-100所有奇数
// 方案1：从1开始，每次递增2，这样每一个数字一定是奇数
for(int i = 1; i<= 100; i+=2){
System.out.println(i);
}
// 方案2：从1开始，每次都递增1，每次判断是否为奇数，如果是再输出。
for(int i = 1; i<= 100; i++){
if((i % 2) != 0){
System.out.println(i);
}
} // 计算1-100所有奇数的和
int sum = 0;
for(int i = 1;i <= 100; i+=2){
sum += i;
}
System.out.println("sum = " + sum); // for循环的嵌套使用
// 内层循环中的变量名不能和外层循环中的变量名重复
for(int i = 0; i < 10; i++){
for(int j = 0; j < 3; j++){
System.out.println(j);//0、1、2执行10遍
}
} // 写一个九九乘法表
String str = "";
for(int i = 1;i < 10; i++){
str = "";
for(int j = 1;j <= i;j++){
str += (i + " * " + j + " = "+(i * j)+ "; ");
}
System.out.println(str);
}
}
}
public class For01{
public static void main(String[] args){
// 编写for循环，找出1-100中所有的素数
// 素数又被称为质数，只能被1和本身整除
int count = 0;//计数 被整除的次数
int num = 0;//计数 打印的次数
System.out.println(2);
for(int i = 3;i < 100;i++){
count = 0;
for(int j = 1;j <= i;j++){
if(i % j == 0){
count++;
}
}
if(count == 2){
System.out.println(i);
}
}
// 升级版
// 编写for循环找出1-10000中所有的素数
// 要求每8个换一行输出
for(int i = 3;i < 10000;i++){
count = 0;
for(int j = 1;j <= i;j++){
if(i % j == 0){
count++;
}
}
if(count == 2){
num++;
if(num % 8 == 0){
System.out.print("\n");
}
System.out.print(i +" ");
}
}
}
}
public class Continue{
public static void main(String[] args){
// 打印出1-100的素数
boolean issushu = true;
// 1不是素数，所以直接从2开始
for(int i = 2;i <= 100;i++){
issushu=true;//初始化一下issushu的值
for(int j = 2;j < i;j++){
if(i % j == 0){
issushu = false;//除了1和本身外能够被其它数整除，代表不是素数
break;//加上break，大大提高执行效率
}
};
if(issushu){
System.out.println(i);
}
};
// 升级版
// 找出1-10000的素数
// 每8个换一行
int count = 0;
for(int i = 2;i <= 10000;i++){
issushu=true;
for(int j = 2;j < i;j++){
if(i % j == 0){
issushu = false;
break;
};
};
if(issushu){
System.out.print(i+" ");
count++;
if(count % 8 == 0){
System.out.println();//换行
}
}
};
}
}
while循环
/*
1、while循环的语法结构：
while(布尔表达式){
循环体;
}
2、while循环的执行原理：
-先判断布尔表达式结果：
*true：
-执行循环体
-判断布尔表达式
*true：
-执行循环体
-判断布尔表达式
...
*false：
-循环结束
*false：
-循环结束
3、while循环的循环次数：
0 ~ N次；
注意：如果while循环的循环体有可能一次都不执行 */ public class While01{
public static void main(String[] args){
// 写个死循环
// while(true){
// System.out.println("死循环");
// }
// 编译器检测到死循环后面的语句永远都执行不到 编译器真牛逼
// System.out.println("死循环后面的语句"); int i = 10;
int j = 3;
while(i < j){
System.out.println("永远都执行不到");
} // while(i > j){//这样写虽然是死循环，但是编译器不会报错 [后面的语句执行不到],因为变量的内存空间时在运行期开辟的
// System.out.println("死循环");
// }
// 编译通过
// System.out.println("在死循环后面的语句"); // while(10 > 3){//这样写 后面的语句执行不到 会编译报错
// System.out.println("死循环");
// }
// System.out.println("写在死循环后面的语句执行不到，编译器会报错"); }
}
/*
*/ public class While01{
public static void main(String[] args){
// while循环输出1-10
int i = 1;
while(i <= 10){
System.out.println(i);
i++;
}
System.out.println("------------------");
// while循环输出10-1
int j = 10;
while(j > 0){
System.out.println(j--);
System.out.println("--->"+j);
} int k = 10;
while(k >= 0){
System.out.println(--k);//输出 9到-1
} }
}
dowhile循环：
/*
do..while循环
1、do..while循环的语法结构：
do{
循环体;
}while(布尔表达式);
2、do..while循环的执行原理：
先执行循环体，再执行判断布尔表达式，若果为假，循环结束，如果为真，再执行循环体。以此类推。
3、do..while循环的执行次数：
1-N次，也就是循环体执行一次
4、使用do..while循环的注意事项：
do..while循环最终有一个分号，别丢了。
*/
public class DoWhile{
public static void main(String[] args){
int i = 10;
do{
System.out.println(i);
}while(i > 100);//条件为假 会执行一次
System.out.println("----------------------------");
while(i > 100){//条件为假 一次都不执行
System.out.println(i);
};
System.out.println("-----------------------");
int a = 1;
do{
System.out.println(a);
a++;
}while(a <= 10);
}
}
控制循环的语句：
break;
/*
关于java控制语句当中的break语句：
1、break是java语言中的关键字，被翻译为"中断/折断".
2、break + ";",可以成为单独的java语句：break;
3、break语句使用在switch语句中，用来终止switch语句。
4、break语句同样可以使用在for循环中，用来终止循环。
5、break终止那个循环呢？
6、break;使用在for、while、do..while循环中，用来跳出循环，终止循环的执行。
因为当循环执行到某个条件的时候，后面的循环没必要再执行了，再执行也是耗费资源。
所以可以终止循环，这样可以提高循环的执行效率。
7、以下以for循环为例，讲解break;
8、在默认情况下，break;终止的是离他最近的循环；当然也可以指定终止某个循环，
需要给循环起名，采用这种语法：break 循环名称; */
public class DoWhile{
public static void main(String[] args){
for(int i = 0;i < 10;i++){//0，1，2，3，4这段代码打印到4就不再执行了
if(i == 5){
break;
}
System.out.println(i);
};
// 这里的程序和for循环无关,以下程序照样执行
System.out.println("hello world"); System.out.println("------------------");
// break;终止的是当前循环，不影响外层循环
for(int j = 0;j < 3;j++){
for(int i = 0;i < 10;i++){
if(i == 5){
break;
}
System.out.println(i);
};
};
// 在来看看以下代码
System.out.println("--------------------------");
// 以下语法使用较少，但需要会用
// 给for循环起名叫for1
for1:for(int j = 0;j < 3;j++){
// 给for循环起名叫for2
for2:for(int i = 0;i < 10;i++){
if(i == 5){
break for1;//在这里终止的是for1循环
}
System.out.println(i);
};
}; }
}
continue：
/*
continue语句：
1、continue表示：继续/go on/下一个
2、continue也是一个continue关键字加一个分号构成一个单独的完整的java语句，
出现在循环语句当中，用来控制循环的执行。
3、break和continue的区别：
*break表示循环不执行了。终止循环。
*continue表示直接跳出当前"本次"循环，进入下一个循环继续执行。
4、continue也有这样的语法：
continue 循环名称;【了解即可，用的不多】
*/ public class Continue{
public static void main(String[] args){
// break
for(int i = 0;i < 10;i++){//0、1、2、3、4
if(i == 5){
break;
}
System.out.println("i = "+i);
};
System.out.println("-------------------------");
// continue
for(int i = 0;i < 10;i++){//0、1、2、3、4、(跳过5)、6、7、8、9
if(i == 5){
continue;
}
System.out.println("i = "+i);
};
System.out.println("-------------------------");
// continue 循环名称;
for1:for(int i = 0;i < 5;i++){//总共执行4次，因为中间跳过一次
for2:for(int j = 0;j < 5;j++){
if(i == 3){
continue for1;//当i==3时，跳出for1外层的这一次循环，继续执行
};
System.out.println(i+"---"+j);
}
};
}
}
。
