java学习笔记(5) 控制语句、键盘输入

控制语句

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);
}
};
}
}

上一篇:Android - 隐藏EditText弹出的软键盘输入(SoftInput)


下一篇:字符集编码与Python(一)编码历史