1.顺序结构:顺序结构的语句是java程序默认的执行流程,按照代码的先后顺序,从上到下依次执行.
2.分支结构:
1.if语句(在程序中就是用来进行判断的)
2.switch语句(表示选择)
3.循环结构
1.if语句
if语句的第一种格式:
if(关系表达式){ if(酒量>2){
语句体; System.out.println("小伙子,不错哟!!");
} }
执行流程:
1.首先计算关系表达式的值;
2.如果关系表达式的值为true就执行语句体;
3.如果关系表达式的值为false就不执行预聚体;
4.继续执行后面的其他语句
import java.util.Scanner;
public class Summary1 {
public static void main(String[] args) {
//需求:键盘录入女婿的酒量,如果大于两斤,老丈人给出回应,反之不回应
Scanner sc = new Scanner(System.in);
System.out.println("请输入女婿的酒量");
int wine = sc.nextInt();
//对酒量进行判断
if (wine>2){
System.out.println("小伙子,不错哟!!");
}
}
}if的注意点: 1.大括号的开头可以另起一行书写,但是建议写在第一行的末尾 2.在语句体中,如果只有一句代码,大括号可以省略不写,个人建议,大括号还是不要省略. 3.如果对一个布尔类型的变量进行判断,不要用==号,直接写在小括号中
public class Summary2 {
public static void main(String[] args) {
boolean flag = true;
if (flag){
System.out.println("flag的值为true");
}
}
}相关练习1
public class Summary2Test1 {
public static void main(String[] args) {
//小红:如果这次你全班成绩第一,我就做你女朋友
//分析:
//1.定义变量记录小明的名次
int ranking = 1;
//2.对小明的名次进行判断
if (ranking==1){
System.out.println("小明交到小红");
}
}
}相关练习2
//自动驾驶
public class Summary2Test2 {
public static void main(String[] args) {
//汽车无人驾驶会涉及到大量的判断
//当汽车行驶的过程中遇到红绿灯,就会进行判断
//如果红灯亮,就停止
//如果黄灯亮,就减速
//如果绿灯亮,就gogogo!!
//1.定义三个变量表示灯的状态
boolean islightred = false;
boolean islightyellow = false;
boolean islightgreen = true;
//2.判断
//如果红灯亮,就停止
//如果黄灯亮,就减速
//如果绿灯亮,就gogogo!!
if (islightred){
System.out.println("stop!!");
}
if (islightyellow){
System.out.println("slow!!");
}
if (islightgreen){
System.out.println("gogogo!!");
}
}
}if语句
if语句的第二种格式:
if(关系表达式){
语句体1;
} else {
语句体2;
}
执行流程:
1.首先计算关系表达式的值;
2.如果关系表达式的值为true就执行语句体1;
3.如果关系表达式的值为false就执行语句体2;
4.继续执行后面的其他语句
//吃饭
import java.util.Scanner;
public class Summary3 {
public static void main(String[] args) {
/*需求:键盘录入一个整数,表示身上的钱,
如果大于等于100块钱,就吃网红餐厅,
否则就吃经济实惠的网红餐厅
*/
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数表示身上的钱");
int money = sc.nextInt();
//对钱进行判断(二选一)
if (money >= 100){
System.out.println("去吃网红餐厅");
} else {
System.out.println("去吃沙县小吃");
}
}
}相关练习3
//商品付款
import java.util.Scanner;
public class Summary3Test1 {
public static void main(String[] args) {
/*
需求:假设,用户在超市实际购买,商品总价格:600元.
键盘录入一个整数表示用户实际支付的钱,
如果付款大于等于600,表示付款成功,反之付款失败
*/
Scanner sc = new Scanner(System.in);
System.out.println("用户实际支付的钱");
int money = sc.nextInt();
if (money >= 600){
System.out.println("付款成功");
} else{
System.out.println("付款失败");
}
}
}相关练习4
//购买电影票
import java.util.Scanner;
public class Summary3Test2 {
public static void main(String[] args) {
/*在实际开发中,电影院选座也会用到if开发,
假设某电影院售卖了100张电影票,票的序号为1~100,
其中基数票坐左侧,偶数票坐右侧,
键盘录入一个整数表示电影票的序号,
根据不同的情况,给出不同的提示,
如果票号为基数,那么打印坐左边,
如果票号为偶数,那么打印坐右边.
*/
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的电影票的序号");
int ticket = sc.nextInt();
//只有当ticket在0~100之间,才是真实有效的票
if (ticket >= 1 && ticket <= 100){
if (ticket % 2 == 1){
System.out.println("坐左边");
}else{
System.out.println("坐右边");
}
}
}
}if语句
if语句的第三种格式:
if(关系表达式1){
语句体1;
}else if(关系表达式2){
语句体2;
}
...
else{
语句体 n + 1;
}
执行循序:
1.首先计算表达式1的值
2.如果为true就执行语句体1,如果为false就计算关系表达式2的值
3.如果为true就执行语句体2,如果为false就计算关系表达式3的值
4. ........
5.如果所有关系表达式的结果都为false,就执行语句体 n + 1.
(从上往下依次进行判断,只要有一个判断为真,就执行对应的语句体,如果所以的判断都为假,那就执行else语句体.)
import java.util.Scanner;
public class Summary4 {
public static void main(String[] args) {
/*根据不同的分数送不同的礼物,
如果是95~100分,送自行车一辆;
如果是90~94分,游乐场畅玩一天;
如果是80~89分,送变形金刚一个;
如果是80分,揍一顿.
*/
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数表示小明的分数");
int score = sc.nextInt();
//对异常数据进行判断校验
//0~100合理数据
if (score >= 0 && score <= 100){
if (score >= 95 && score <= 100){
System.out.println("送自行车一辆");
}else if (score >= 90 && score <= 94){
System.out.println("游乐场畅玩一天");
}else if (score >= 80 && score<= 89){
System.out.println("送变形金刚一个");
}else {
System.out.println("揍一顿");
}
}else {
System.out.println("当前录入的成绩不合法");
}
}
}相关练习5
import java.util.Scanner;
public class Summary4Test1 {
public static void main(String[] args) {
/*在实际开发中,多种情况判断时,会用到if的第三种格式
需求:
商场都会有VIP制度,根据不同的会员会有不同的折扣,
假设商品总价为1000,
键盘录入会员级别,并计算出实际支付的钱;
会员1级,打九折.
会员2级,打八折.
会员3级,打七折.
非会员,不打折.
*/
//分析:
//1.定义变量记录商品总价;
int prise = 1000;
//2.键盘录入会员的级别
Scanner sc = new Scanner(System.in);
System.out.println("请输入会员的级别");
int vip = sc.nextInt();
//根据级别来计算实际要支付的钱
if (vip == 1){
System.out.println("实际支付" + (prise*1.9));
}else if (vip ==2){
System.out.println("实际支付" + (prise*0.8));
}else if (vip == 3){
System.out.println("实际支付" + (prise*0.7));
}else{
System.out.println("实际支付" + prise);
}
}
}
相关练习6
//自动驾驶2.0
public class Summary4Test2 {
public static void main(String[] args) {
//汽车无人驾驶会涉及到大量的判断
//当汽车行驶的过程中遇到红绿灯,就会进行判断
//如果红灯亮,就停止
//如果黄灯亮,就减速
//如果绿灯亮,就gogogo!!
//定义三个变量表示灯的状态
// true亮 false灭
boolean islightred = false;
boolean islightyellow = false;
boolean islightgreen = true;
//判断
if (islightred){
System.out.println("stop!!");
}else if (islightyellow){
System.out.println("slow!!");
}else if (islightgreen){
System.out.println("gogogo!!");
}
}
}2.switch语句
switch语句格式
switch(表达式){
case 值1:
语句体1;
break; ---中断调出的意思
case 值2:
语句体2;
breake;
...
default:
语句体n;
break; ---跟if语句中的else相当类似
}
执行流程
1.首先计算表达式的值
2.依次和case后面的值进行比较,如果有对应的值,就执行相应的语句体,
在执行的过程中,遇到break就会结束
3.如果所以case后面的值和表达式的值都不匹配,就会执行default后面的语句体,
然后结束整个switch语句
格式说明:
1.表达式:(将要匹配的值)取值为byte short int char,
JDK5以后可以是枚举,JDK7以后可以是String
2.case:后面跟的是要和表达式进行比较的值(被匹配的值)
3.break表示中断,结束的意思,用来结束switch语句
4.default:表示所有情况都不匹配的时候,就执行该处的内容,和if语句中else相似
5.case后面只能是字面量,不能是变量
6.case给出的值不能重复
public class Summary1 {
public static void main(String[] args) {
//兰州拉面 武汉热干面 北京炸酱面 陕西油泼面
//1.定义变量记录我心中想吃的面
String noodles = "海鲜龙虾面";
//2.拿着这个面利用switch跟四种面相匹配
switch (noodles){
case "兰州拉面":
System.out.println("吃兰州拉面");
break;
case "武汉热干面":
System.out.println("吃武汉热干面");
break;
case "北京炸酱面":
System.out.println("吃北京炸酱面");
break;
case "陕西油泼面":
System.out.println("吃陕西油泼面");
break;
default:
System.out.println("吃康师傅泡面");
break;
}
}
}相关练习7
//运动计划
import java.util.Scanner;
public class Summary1Test1 {
public static void main(String[] args) {
/*需求:键盘录入星期数,表示今天的减肥活动
周一:跑步
周二:游泳
周三:慢走
周四:动感单车
周五:拳击
周六:爬山
周日:好好吃一顿
*/
Scanner sc = new Scanner(System.in);
System.out.println("请录入今天的星期数");
int week = sc.nextInt();
//利用switch对星期进行匹配
switch (week){
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("没有这个星期");
break;
}
}
}switch的其他知识点
1.default的位置和省略
2.case的穿透
3.switch的新特性
4.switch和if的第三种的格式各自使用的场景
1.default的位置和省略
1.位置:default不一定写在最下面,我们可以写在任意位置,,只不过我们会习惯写在最下面
2.省略:default可以省略,语法也不会有问题,但不建议省略
public class summary2 {
public static void main(String[] args) {
int number = 20;
switch (number){
case 1:
System.out.println("number的值为1");
break;
case 10:
System.out.println("number的值为10");
break;
case 100:
System.out.println("number的值为100");
break;
/*default:
System.out.println("number的值既不是1,10,也不是100");
break;*/
}
}
}
case穿透:
就是语句体中没有写break所导致的
执行流程:
首先还是会拿着小括号里面表达式的值跟下面每一个case进行匹配,
如果匹配上了,就会执行相应的语句体,如果此时发现了break,就会结束整个switch语句.
如果没有发现break,那么程序就会执行下一个语句体,一直到break或者右大括号为止.
使用场景:
如果case的语句体重复了,那么我考虑使用case穿透去简化代码
public class Summary3 {
public static void main(String[] args) {
int number = 10;
switch (number){
case 1:
System.out.println("number的值为1");
break;
case 10:
System.out.println("number的值为10");
//break;
case 100:
System.out.println("number的值为100");
break;
default:
System.out.println("number的值既不是1,10,也不是100");
//break;
}
}
}switch新特性
JDK12
public class Summary4 {
public static void main(String[] args) {
//需求：
// 1 2 3 一 二 三
int number = 1;
switch (number) {
case 1:
System.out.println("一");
break;
case 2:
System.out.println("二");
break;
case 3:
System.out.println("三");
break;
default:
System.out.println("没有这种选项");
break;
}
/*int number = 1;
switch (number){
case 1 ->{
System.out.println("一");
}
case 2 ->{
System.out.println("二");
}
case 3 ->{
System.out.println("三");
}
default -> {
System.out.println("没有这种选项");
}
}*/
//当{}里面只有一行代码的时候
/* int number = 1;
switch (number){
case 1 -> System.out.println("一");
case 2 -> System.out.println("二");
case 3 -> System.out.println("三");
default -> System.out.println("没有这种选项");
}*/
}
}switch和if的第三种格式各自使用的场景
if的第三种格式,一般用于对范围的判断
switch:把有限个数据一一列举出来的,让我们任选其一
public class Summary5 {
public static void main(String[] args) {
//范围的判断
int score = 100;
if (score >= 90 && score <= 100){
System.out.println("送自行车一辆");
}
}
}相关练习8
//工作日和休息日
import java.util.Scanner;
public class Summary5Test1 {
public static void main(String[] args) {
/*需求:键盘录入星期数,输出工作日,休息日
(1-5)工作日,(6-7)休息日
*/
Scanner sc = new Scanner(System.in);
System.out.println("请输入星期数");
int week = sc.nextInt();
//利用switch语句来进行选择
switch (week){
case 1: //case 1,2,3,4,5:
case 2: // System.out.println("工作日");
case 3: // break;
case 4:
case 5:
System.out.println("工作日");
break;
case 6:
case 7:
System.out.println("休息日");
break;
default:
System.out.println("没有这个星期");
break;
}
}
}
相关练习9
//用户选择
import java.util.Scanner;
public class Summary5Test2 {
public static void main(String[] args) {
/*在实际开发中,如果我们需要在多种情况下选择其中一个,就可以使用switch语句.
当我们拨打了某些服务电话时,一般都会有按键选择.
假设现在我们拨打了一个机票预订电话.
电话中语音提示:
1.机票查新
2.机票预订
3.机票改签
4.退出服务
其他按键也是退出服务,请用switch模拟该业务逻辑.
*/
Scanner sc = new Scanner(System.in);
System.out.println("请输入你的按键选择");
int choose = sc.nextInt();
switch (choose){
case 1:
System.out.println("机票查询");
break;
case 2:
System.out.println("机票预订");
break;
case 3:
System.out.println("机票改签");
break;
default:
System.out.println("退出服务");
break;
}
}
}
//利用JDK的新特性进行代码的简写优化3.循环结构
什么是循环?
1.重复的做某件事
2.具有明确的开始和停止标记
循环的分类:
1.for
2.while
3.do...while(了解即可)
// 1.for循环 其中:变量i控制循环的次数,表示循环从1开始,到10就结束了
格式: eg:
for(初始化语句;条件判断语句;条件控制语句){ for(int = 1 ; i <=10 ; i++){
循环语句体; System.out.println("HelloWorld");
} }
执行流程:
1.执行初始化语句(初始化语句只执行一次)
2.执行条件判断语句,看其结果是true还是false,
如果为false,循环结束,继续执行后面的其他语句
如果为true,执行循环体语句
3.执行条件控制语句
4.回到2,继续执行条件判断语句(直到执行条件判断为false了循环才会结束)
public class Summary6 {
public static void main(String[] args) {
//需求:打印五次HelloWorld
for (int i = 1;i <= 5;i++){
System.out.println("HelloWorld");
}
}
}相关练习10
//输出数字 倒着输出数字
public class Summary6Test1 {
public static void main(String[] args) {
//需求1:打印1-5
//需求2:打印5-1
for (int i = 1;i <= 5;i++){
//第一次循环: i = 1;
//第二次循环: i = 2;
// i : 1 2 3 4 5
System.out.println(i);
}
for (int i = 5;i >=1;i--){
System.out.println(i);
}
}
}相关练习11
//断线重连
public class Summary6Test2 {
public static void main(String[] args) {
/*需求:在实际开发中,需要重复执行的代码,会选择循环出现.
比如:玩游戏的时候,如果网络不好那么会经常断线重连.
那么断线重连这个业务逻辑需要重复执行.
假设现在公司要求,断线重连的业务逻辑最多只写5次.
请用代码实现.
备注:断线重连的业务逻辑可以用输出语句替代
*/
//分析:
//1.因为我们需要重复执行某段代码,所以需要用循环解决
//循环的次数5次
//开始条件:1
//结束条件:5
for (int i = 1;i <= 5;i++){
System.out.println("第" + i + "次断线重连的业务逻辑");
}
}
}
相关练习12
//求和
public class Summary6Test3 {
public static void main(String[] args) {
//需求:在实际开发中,如果要获取一个范围中的每一个数据时,也会用到循环.
//比如求1-5之间的和
//分析:
//1.循环1-5得到里面的每一个数字
//开始条件:1
//结束条件:5
//用来进行累加的
int sum = 0;
for (int i = 1;i <= 5;i++){
//System.out.println(i);
//可以把得到的每一个数字累加到变量sum当中
sum = sum + i; //sum += i;
}
//当循环结束后,表示已经把1-5累加到变量sum当中了
System.out.println(sum);
}
}扩展小点: 1.求和的变量不能定义在循环里面,因为变量只在所属的大括号中有效 2.如果我们把变量定义在循环里面,那么当前变量只能在本次循环中有效, 当本次循环结束后,变量就会从内存中消失 第二次循环开始的时候,又会重新定义一个新的变量. 结论:如果以后我们要求写累加求和变量,可以把变量定义在求和的外边.
相关练习13
//求和
public class Summary6Test4 {
public static void main(String[] args) {
//需求:需求:在实际开发中,如果要获取一个范围中的每一个数据时,也会用到循.
// 但是此时,大多情况下不会获取所以数据,而是获取其中符合要求的数据,
//此时就需要循环和其他语句结合使用了
//比如:1-100之间的偶数和
//分析:
//1.获取1-100中的每一个数
int sum = 0;
for (int i = 1;i <= 100;i++){
//2.累加求和(先判断,后求和)
if (i % 2 ==0){
sum = sum + i;
}
}
//打印sum
System.out.println(sum);
}
}相关练习14
//求和
public class Summary6Test4 {
public static void main(String[] args) {
//需求:需求:在实际开发中,如果要获取一个范围中的每一个数据时,也会用到循.
// 但是此时,大多情况下不会获取所以数据,而是获取其中符合要求的数据,
//此时就需要循环和其他语句结合使用了
//比如:1-100之间的偶数和
//分析:
//1.获取1-100中的每一个数
int sum = 0;
for (int i = 1;i <= 100;i++){
//2.累加求和(先判断,后求和)
if (i % 2 ==0){
sum = sum + i;
}
}
//打印sum
System.out.println(sum);
}
}
while循环
格式:
初始化语句; 1.初始化语句只执行一次
while(条件判断语句){ 2.判断语句为true,循环继续
循环体语句; 2.判断语句为false,循环结束
条件控制语句;
}
循环下面的其他语句
public class Summary7 {
public static void main(String[] args) {
//需求:利用while循环打印1-100
//分析:
//开始条件:1
//结束条件:100
int i = 1;
while (i <= 100){
System.out.println(i);
i++;
}
}
}for和while的对比
相同点:运行规则都是一样的
for和while的区别:
for循环中,控制循环的变量,因为归属for循环的语法结构中,在for循环结束后,就不能再次被访问到
while循环中,控制循环的变量,对于while循环来说不归属其语法结构中,在while循环结束后,该变量
还可以继续使用
for(int i = 1;i < 4;i++){ int i = 1; int i = 1;
System.out.println(i); while (i < 4){ for(;i < 4;i++){
} i++; System.out.println(i);
} }
System.out.println(i);
从实际开发的角度这两种循环的区别,在语法当中,能用for循环的地方一定能用while循环去进行改写;
能用while循环的地方一定也能用for循环去进行改写
for循环和while循环的区别(从实际开发的角度)
for循环中:知道循环的次数或者循环的范围
while循环中:不知道循环的次数和范围,只知道循环的结束条件
相关练习15
//打印折纸的次数
public class Summary7Test1 {
public static void main(String[] args) {
/*需求:世界上最高峰是珠穆朗玛峰(8844.43米=8844430毫米),假如我有一张足够大的纸,它的的厚度是0.1毫米,
请问,我需要折多少次,才能达到珠穆朗玛峰的高度.
*/
//分析:折叠纸张,每一次折叠纸张的厚度是原先的2倍
// double a = 0.1;
// a = a * 2;
// a *= 2;
//1.定义一个变量来记录山峰的高度
int hight = 8844430;
//2.定义一个变量用来记录纸张的初始厚度
double paper = 0.1;
//3.定义一个变量用来统计次数
int count = 0;
//4.循环折叠纸张,只要纸张的厚度小于山峰的高度,那么循环就继续
//每折叠一次,统计次数就要++
//选择while利用,此时我们不知道循环的次数,也不知道循环的范围,只知道循环的结束条件,所以用while
while (paper < hight){
//折叠纸张,
paper *= 2;
//折叠一次,++一次
count++;
}
System.out.println(count);
}
}
相关练习16
//回文数
public class Summary7Test2 {
public static void main(String[] args) {
/*需求:给你一个整数x
如果x是一个回文整数,打印true,否则,返回false.
解释:回文数是指正数(从左向右)和倒叙(从右向左)读都是一样的整数.
例如:121是回文数,而123不是.
*/
//核心思路:把数字倒过来跟原来的数字进行比较
//1.定义数字
int x = 121;
//定义一个临时变量用来记录x原来的值
int temp = x;
int num = 0;
//2.利用循环开始从右往左获取每一位数字
while (x != 0) {
//1.从右往左获取每一位数字
int ge = x % 10;
//2.修改一下记录的值
x = x / 10;
//3.把当前获取的数字拼接到最右边
num = num * 10 + ge;
}
//3.打印num
System.out.println(num);//121
//System.out.println(x);//0
//4.比较
System.out.println(num == temp);
/* //1.定义数字
int x =12;
//2.获取个位
int ge = x%10;//2
//3.获取百位
int shi = x/10%10;//1
//拼接
int result = ge*10 + shi;
System.out.println(result);
*/
}
}
相关练习17
public class Summary7Test3 {
public static void main(String[] args) {
/*需求:给点两个整数,被除数和除数(都是正数,且不超过int的范围).
将两数相除,要求不使用乘法,除法和%运算符.
得到商和余.
*/
//分析:
// 被除数/除数=商 ... 余数
// int a = 100;
// int b = 10;
// 100 - 10 = 90;
// 90 - 10 = 80;
// 80 - 10 = 7 ;
// ...
// 10 - 10 = 0 (余数) 减到余数小于10
//1.定义变量记录被除数
int dividend = 100;
//2.定义变量记录除数
int divisor = 10;
//3.定义一个变量用来统计相减了多少次
int count = 0;
//3.循环while
//在循环中,不断的用被除数 - 除数
//只要被除数是大于等于除数的,那么久一直循环
while (dividend >=divisor){
dividend = dividend - divisor;
//只要减一次,那么统计变量就自增一次
count++;
}
//4.当循环结束之后,divident变量记录的就是余数
System.out.println(dividend);
//5. 当循环结束之后,count记录的值就是商
System.out.println(count);
}
}
197
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
