流程控制语句
顺序结构
顺序结构语句是Java程序默认的执行流程，按照代码的先后顺序，从上到下依次执行
这是默认的结构
分支结构
if语句
第一种格式（单条件判断）
if(关系表达式){
语句体;
}例如：
if(酒量>2){
System.out.println("小伙子，不错");
}执行流程:
1.首先计算关系表达式的值
2.如果关系表达式的值为true就执行语句体
3.如果关系表达式的值为false就不执行语句体
4.继续执行后面的其他语句
package demo1;
import java.util.Scanner;
public class Test1 {
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.如果对一个布尔类型的变量进行判断，不要用==号，建议直接把变量写在小括号里即可
package demo1;
public class Test1 {
public static void main(String[] args) {
boolean flag = false;
if(flag) {
System.out.println("flag的值true");
}
}
}
练习：
小红:如果你这次考试全班第一，我就做你女朋友，同学们为了成全都交了白卷
package demo1;
public class Test1 {
public static void main(String[] args) {
//小红:如果你这次考试全班第一，我就做你女朋友。
int ranking = 1;
if (ranking == 1) {
System.out.println("小红成为小明的女朋友");
}
}
}
绿灯亮，车辆可以通行
package demo1;
public class Test1 {
public static void main(String[] args) {
boolean isLightGreen = true;
boolean isLightYellow = false;
boolean isLightRed = false;
if (isLightGreen){
System.out.println("绿灯亮，车可以通过");
}
if (isLightYellow){
System.out.println("黄灯亮，车等一等");
}
if (isLightRed){
System.out.println("红灯亮，车不可以通过");
}
}
}
第二种格式（双条件判断）
if (关系表达式) {
语句体1；
}else{
语句体2；
}执行流程:
1.首先计算关系表达式的值
2.如果关系表达式的值为true就执行语句体1
3.如果关系表达式的值为false就执行语句体2
4.最后继续执行后面的其他语句
练习:
吃饭
键盘录入一个整数，表示身上的钱。
如果大于等于100块，就是网红餐厅。
否则，就吃经济实惠的沙县小吃。
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.println("请输入身上所有的钱：");
Scanner sc = new Scanner(System.in);
int money = sc.nextInt();
if(money >= 100){
System.out.println("吃网红餐厅");
}else{
System.out.println("吃沙县小吃");
}
}
}
商品付款
在实际开发中，如果要根据两种不同的情况来执行不同的代码，就需要用到if的第二种格式。需求:
假设，用户在超市实际购买，商品总价为:600元。
键盘录入一个整数表示用户实际支付的钱。
如果付款大于等于600，表示付款成功。否则付款失败。
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.println("用户实际支付的金额是：");
Scanner sc = new Scanner(System.in);
int money = sc.nextInt();
if(money >= 600){
System.out.println("支付成功");
}else{
System.out.println("支付失败");
}
}
}
影院选座：
在实际开发中，电影院选座也会使用到if判断。假设某影院售卖了100张票，票的序号为1~100。其中奇数票号坐左侧，偶数票号坐右侧。键盘录入一个整数表示电影票的票号。根据不同情况，给出不同的提示:如果票号为奇数，那么打印坐左边如果票号为偶数，那么打印坐右边。
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.println("录入一个整数表示电影票的票号：");
Scanner sc = new Scanner(System.in);
int tickeNumber = sc.nextInt();
int ticketNumberNow = tickeNumber % 2;
if(tickeNumber>=0 && tickeNumber<=100){
if(ticketNumberNow == 0){
System.out.println("偶数票号，做右边");
}else{
System.out.println("奇数票号，做左边");
}
}else{
System.out.println("这是一张假的票");
}
}
}这是if的嵌套的写法
第三种格式（多条件判断）
if(关系表达式1){
语句体1；
}else if(关系表达式2){
语句体2；
}
......
else{
语句体n+1;
}执行流程:
1.首先计算关系表达式1的值
2.如果为true就执行语句体1;如果为false就计算关系表达式2的值
3.如果为true就执行语句体2;如果为false就计算关系表达式3的值
4.如果所以关系表达式结果都为false，就执行语句体n+1。
从上往下依次进行判断 ，只有要有一个判断为真，就执行对应的语句体，如果所有的判断都为假，就执行else的语句体
练习：
根据不同的分数送不同的礼物。如果是95~100分，送自行车一辆
如果是90~94分，游乐场玩一天
如果是80~89分，送变形金刚一个。
如果是80分以下，揍一顿。
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.println("考试分数：");
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
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.print("数据不合法");
}
}
}
商品价格
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
int price = 1000;
System.out.println("会员级别：");
Scanner sc = new Scanner(System.in);
int vip = sc.nextInt();
if(vip == 1) {
System.out.println("会员级别1，价格为：" + (price * 0.9));
}else if(vip == 2){
System.out.println("会员级别2，价格为：" + (price * 0.8));
}else if(vip == 3){
System.out.println("会员级别3，价格为：" + (price * 0.7));
}else{
System.out.println("非会员，价格为：" + price);
}
}
}
switch语句
switch语句格式
switch(表达式){
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
...
default:
语句体n+1;
break;
}执行流程:
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给出的值不允许重复
练习：
兰州拉面、武汉热干面、北京炸酱面、陕西油泼面
定义变量记录我心里想吃的面
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
String noodles = "北京炸酱面";
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;
}
}
}
运动计划
键盘录入星期数，显示今天的减肥活动。
周一:跑步
周二:游泳
周三:慢走
周四:动感单车
周五:拳击
周六:爬山
周日:好好吃一顿
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.println("请输入星期数：");
Scanner sc = new Scanner(System.in);
String week = sc.next();
switch(week){
case "周一":
System.out.println("跑步");
break;
case "周二":
System.out.println("游泳");
break;
case "周三":
System.out.println("慢走");
break;
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;
}
}
}
switch其他知识点
default的位置和省略
**位置：**defaule不一定是写在最下面的，我们可以写在任意位置。只不过习惯会写在最下面
**省略：**defaule可以省略，语法不会有问题，但是不建议省略。
位置并不影响正常的运行
将defaule省略掉也是不影响运行，只不过在所有的case后面的值和表达式的值都不匹配时没有备用答案返回，只会没有反应如
case穿透
产生的原因是：语句体中没有写break导致的
执行流程:
首先还是会拿着小括号中表达式的值跟下面每一个case进行匹配。
如果匹配上了，就会执行对应的语句体，如果此时发现了break，那么结束整个switch语句。
如果没有发现break，那么程序会继续执行下一个case的语句体，一直遇到break或者右大括号为止。
使用场景:
如果多个case的语句体重复了，那么我们考虑利用case穿透去简化代码。
switch新特性
这个特性是JDK12才有的，在此之前的都是没有的
package demo1;
public class Test1 {
public static void main(String[] args) {
int number = 1;
switch(number){
case 1 -> {
System.out.println("number的值为1");
}
case 50 -> {
System.out.println("number的值为50");
}
case 100 -> {
System.out.println("number的值为100");
}
default -> {
System.out.println("number的值不在1、50、100中");
}
}
}
}使用{}来简化掉了break
还可以简化成这样
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
int number = 1;
switch(number){
case 1 -> System.out.println("number的值为1");
case 50 -> System.out.println("number的值为50");
case 100 -> System.out.println("number的值为100");
default -> System.out.println("number的值不在1、50、100中");
}
}
}switch和if第三种格式的各自的使用场景
if的第三种格式:一般用于对范围的判断
switch:把有限个数据一一列举出来，让我们任选其一
if的第三种格式比如小明的礼物
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.println("考试分数：");
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
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.print("数据不合法");
}
}
}switch:把有限个数据一一列举出来，让我们任选其一，比如吃面的练习
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
String noodles = "北京炸酱面";
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;
}
}
}练习
休息日和工作日
需求:
输出工作日、休息日。键盘录入星期数
(1-5)工作日,(6-7)休息日。
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.println("请输入星期数：");
Scanner sc = new Scanner(System.in);
int week = sc.nextInt();
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;
}
}
}
也可以简化成：
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.println("请输入星期数：");
Scanner sc = new Scanner(System.in);
int week = sc.nextInt();
switch(week){
case 1,2,3,4,5:
System.out.println("工作日");
break;
case 6,7:
System.out.println("休息日");
break;
default:
System.out.println("输入的星期数有误");
break;
}
}
}
还可以简化成：
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.println("请输入星期数：");
Scanner sc = new Scanner(System.in);
int week = sc.nextInt();
switch(week){
case 1,2,3,4,5 -> System.out.println("工作日");
case 6,7 -> System.out.println("休息日");
default -> System.out.println("输入的星期数有误");
}
}
}
用户选择
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.println("请输入按键：");
Scanner sc = new Scanner(System.in);
int key = sc.nextInt();
switch(key){
case 1:
System.out.println("机票查询");
break;
case 2:
System.out.println("机票预订");
break;
case 3:
System.out.println("机票改签");
break;
case 4:
System.out.println("退出服务");
break;
default:
System.out.println("退出服务");
break;
}
}
}
进行简化
循环结构
什么是循环
重复的做某件事情
具有明确的开始和停止标记
循环的分类
for循环
格式：
for(初始化语句;条件判断语句;条件控制语句) {
循环体语句;
}例如：
for (int i= 1;i <= 10;i++){
System.out.println("HelloWorld");
}执行流程:
1.执行初始化语句
2.执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，执行循环体语句
3.执行条件控制语句
4.回到步骤2继续执行条件判断语句
初始化语句只会执行一次
判断语句为true，循环继续
判断语句为false，循环结束
练习
打印五次HelloWorld
package demo1;
public class Test1 {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
System.out.println("HelloWorld");
}
}
}
打印1-5
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
}
}
打印5-1
package demo1;
public class Test1 {
public static void main(String[] args) {
for (int i = 5; i >= 1; i--) {
System.out.println(i);
}
}
}
断线重连
在实际开发中，需要重复执行的代码，会选择循环实现。
比如:如左图所示。玩游戏的时候，如果网不好那么会经常断线重连。
那么断线重连这个业务逻辑就需要重复执行。
假设现在公司要求断线重连的业务逻辑最多只写5次。
请用代码实现。
备注:断线重连的业务逻辑可以用输出语句替代。
package demo1;
public class Test1 {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
System.out.println("断线重连");
}
}
}
package demo1;
public class Test1 {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
System.out.println("第"+ i+"断线重连");
}
}
}
求和
package demo1;
public class Test1 {
public static void main(String[] args) {
int sum =0;
for(int i=1;i<=5;i++){
System.out.println(i);
sum += i;
}
System.out.println("1到5的和是：" + sum);
}
}
扩展小点
1.求和的变量不能定义在循环的里面，因为变量只在所属的大括号中有效
2.如果我们把变量定义在循环的里面，那么当前变量只能在本次循环中有效。
当本次循环结束之后，变量就会从内存中消失。
第二次循环开始的时候，又会重新定义一个新的变量。
**结论:**如果以后我们要写累加求和的变量。可以把变量定义在循环的外面。
求和
需求:在实际开发中，如果要获取一个范围中的每一个数据时，会用到循环。
但是此时，大多情况下，不会获取所有的数据，而是获取其中符合要求的数据。
此时就需要循环和其他语句结合使用了。
求1-100之间的偶数和
package demo1;
public class Test1 {
public static void main(String[] args) {
//定义用来累加的变量sum
int sum =0;
for(int i=1;i<=100;i++){
if(i%2==0){
sum+=i;
//sum=sum+i;
}
}
System.out.println(sum);
}
}
键盘录入两个数字，表示一个范围。统计这个范围中。
既能被3整除，又能被5整除数字有多少个?
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入两个整数：");
int a = sc.nextInt();
int b = sc.nextInt();
//定义一个统计变量
int count =0;
for(int i =a;i<=b;i++){
if(i%3==0 && i%5==0){
count++;
//count++：等价于count = count + 1，找到一个符合条件的数，统计个数就加 1。
}
}
System.out.println(count);
}
}
while循环
格式
初始化语句;
while(条件判断语句) {
循环体语句;
条件控制语句;
}
初始化语句只执行一次
判断语句为true，循环继续
判断语句为false，循环结束
练习：
需求：利用while循环打印1~100
package demo1;
public class Test2 {
public static void main(String[] args){
int i = 1;
while(i<=100){
System.out.println(i);
i++;
}
}
}
for 和while的对比
**相同点:**运行规则都是一样的
for和while的区别：
for循环中，控制循环的变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
while循环中，控制循环的变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
**for循环中:**知道循环次数或者循环的范围
**while循环:**不知道循环的次数和范围只知道循环的结束条件。
练习：
需求:世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米）假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
**分析:**折纸张:每一次折叠纸张的厚度都是原先的两倍
double a = 0.1;
a=a*2;或者a*=2
1.定义一个变量用来记录山峰的高度
2.定义一个变量用来记录纸张的初始厚度
3.定义一个变量用来统计次数
4.循环折叠纸张，只要纸张的厚度小于山峰的高度，那么循环就继续，每折叠一次，统计次数就要++
此时我们不知道循环的次数也不知道循环的范围，只知道循环的结束条件，所以用while循环
package demo1;
public class Test2 {
public static void main(String[] args){
double height = 8844430;
double paper = 0.1;
int count = 0;
while(paper < height){
paper*=2;
count++;
}
System.out.println(count);
}
}
回文数
需求:给你一个整数x。
如果x是一个回文整数，打印true，否则，返回false。
解释:回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。
例如，121是回文，而123不是。
**核心思路：**是将数字倒过来和原来的数字进行比较如果一样就是回文数
1.定义一个整数x
2.定义一个变量yuan，将定义的整数赋值给变量yuan
3.判断x是不是回文整数，使用if语句
4.使用循环语句将数字拆分再倒过来拼接在一起，这时需要定义一个变量num用来存储倒过来的数字，这里使用的是while语句，因为我们不知道整数的范围，不知到这是几位数字
5.使用if语句来判断yuan和num的值是否相等，如果相等就返回该整数是回文整数
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
int x = sc.nextInt();
int yuan = x;
int num=0;
if(x<0){
System.out.println("该整数不是回文整数");
return; //直接结束程序，无需后续反转
}
while(x!=0){
int ge=x%10;
num =num*10+ge;
x=x/10;
}
System.out.println(num);
if(num==yuan){
System.out.println("该整数是回文整数");
}else{
System.out.println("该整数不是回文整数");
}
}
}
求商和余数
给定两个整数，被除数和除数都是正数，且不超过int的范围，将两数相除，要求不使用乘法除法和%运算符。得到商和余数。
1.定义变量来记录被除数
2.定义变量来记录除数
3.定义一个变量来记录商其初始值为0
-
直到余数小于除数，循环结束，此时的余数就是最终余数。
package demo1;
public class Test2 {
public static void main(String[] args){
//定义变量来记录被除数
int dividend = 10;
//定义变量来记录除数
int divisor = 3;
//定义变量来记录商其初始值为0
int quotient = 0;
//定义变量来记录余数其初始值为被除数
int remainder = dividend;
//判断除数不能为0
if(divisor==0){
System.out.println("除数不能为0");
return;
}
//结束是余数小于除数
while(remainder>=divisor){
remainder=remainder-divisor;
quotient++;
}
//输出商和余数
System.out.println("商为："+quotient);
System.out.println("余数为："+remainder);
}
}
do...while循环
格式
初始化语句;
do {
循环体语句;
条件控制语句;
}while(条件判断语句);
先执行后判断
题目
题目1
李雷想买一个价值7988元的新手机，她的旧手机在二手市场能卖1500元，而手机专卖店推出以旧换新的优惠，把她的旧手机交给店家，新手机就能够打8折优惠。为了更省钱，李雷要不要以旧换新？请在控制台输出。
package demo1;
public class Test2 {
public static void main(String[] args){
//方案1，不参与以旧换新的情况
int oldPrice = 1500;
int newPrice = 7988;
int spendNew1 = newPrice - oldPrice;
//方案2，参与以旧换新的情况
double spendNew2 = newPrice * 0.8;
if(spendNew1>spendNew2){
System.out.println("李雷要以旧换新");
}else{
System.out.println("李雷不要以旧换新");
}
}
}
题目2
让用户依次录入三个整数，求出三个数中的最小值，并打印到控制台
方案一：使用的是三元运算
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个整数：");
int number1 = sc.nextInt();
System.out.println("请输入第二个整数：");
int number2 = sc.nextInt();
System.out.println("请输入第三个整数：");
int number3 = sc.nextInt();
int tmp = number1 < number2 ? number1 : number2;
int min = tmp < number3 ? tmp :number3;
System.out.println("最小值："+ min);
}
}
方案二：使用if的第三种格式
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个整数：");
int number1 = sc.nextInt();
System.out.println("请输入第二个整数：");
int number2 = sc.nextInt();
System.out.println("请输入第三个整数：");
int number3 = sc.nextInt();
if(number1<=number2 && number1<=number3){
System.out.println("最小值:"+number1);
}else if(number2<=number3 && number2<=number1){
System.out.println("最小值："+number2);
}else{
System.out.println("最小值："+number3);
}
sc.close();
}
}
题目3
某银行推出了整存整取定期储蓄业务，其存期分为一年、两年、三年、五年，到期凭存单支取本息。存款年利率表如下：
存期 年利率（%）
一年 2.25
两年 2.7
三年 3.25
五年 3.6
请存入一定金额（1000起存），存一定年限（四选一），计算到期后得到的本息总额。
提示：
存入金额和存入年限均由键盘录入
本息计算方式：本金+本金×年利率×年限
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请存入本金：");
double principal = sc.nextDouble();
System.out.println("请输入存期：");
int depositTerm = sc.nextInt();
//定义一个变量记录本息和
double principalAndInterest = 0;
if(principal>=1000){
if(depositTerm == 1){
principalAndInterest=principal+principal*2.25 / 100 * 1;
System.out.println("存款一年的本息："+principalAndInterest);
}else if(depositTerm==2){
principalAndInterest=principal+principal*2.7 / 100 * 2;
System.out.println("存款二年的本息："+principalAndInterest);
}else if(depositTerm==3){
principalAndInterest=principal+principal*3.25 / 100 * 3;
System.out.println("存款三年的本息："+principalAndInterest);
}else if(depositTerm==5){
principalAndInterest=principal+principal*3.6 / 100 * 5;
System.out.println("存款五年的本息："+principalAndInterest);
}
}else{
System.out.println("本金不够1000");
}
}
}
题目4
某商场购物可以打折，具体规则如下：
普通顾客购不满100元不打折，满100元打9折；
会员购物不满200元打8折，满200元打7.5折；
不同打折规则不累加计算。
请根据此优惠计划进行购物结算，键盘录入顾客的类别（0表示普通顾客，1表示会员）和购物的折前金额（整数即可），输出应付金额（小数类型）。
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("顾客类别：");
int customer = sc.nextInt();
if(customer != 0 && customer != 1) {
System.out.println("错误：顾客类别只能输入0或1！");
return; // 终止程序
}
System.out.println("折前金额：");
double originalAmount = sc.nextDouble();
if(originalAmount<0){
System.out.println("错误：金额不能为负数！");
return;
}
double payableAmount = 0;
if(customer == 0 && originalAmount < 100){
System.out.println("实际应付金额："+originalAmount);
} else if (customer == 0 && originalAmount >= 100) {
payableAmount = originalAmount *0.9;
System.out.println("实际应付金额："+payableAmount);
}else if (customer == 1 && originalAmount <200){
payableAmount = originalAmount *0.8;
System.out.println("实际应付金额："+payableAmount);
} else if (customer == 1 && originalAmount >= 200) {
payableAmount = originalAmount *0.75;
System.out.println("实际应付金额："+payableAmount);
}
}
}
题目5
2019年1月1日起，国家推出新的个人所得税政策，起征点上调值5000元。也就是说税前工资扣除三险一金（三险一金数额假设是税前工资的10%）后如果不足5000元，则不交税。如果大于5000元，那么大于5000元的部分按梯度交税，具体梯度比例如下：
0 ~ 3000元的部分，交税3%
3000 ~ 12000元的部分，交税10%
12000 ~ 25000的部分 ， 交税20%
25000 ~ 35000的部分，交税25%
35000 ~ 55000的部分，交税30%
55000 ~ 80000的部分，交税35%
超过80000的部分，交税45%
比如：黑马某学员入职一家企业后，税前工资是15000，则他每月该交个税的部分是15000-1500-5000=8500元，个税缴纳数额是3000×3%+5500×10%=640元。税后工资12860元。
请完成一个个税计算程序，在用户输入税前工资后，计算出他对应的纳税数额，以及税后工资为多少？
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("税前工资：");
double preTaxSalary = sc.nextDouble();
if(preTaxSalary<0){
System.out.println("错误，工资不能为负数");
return;
}
//定义一个变量计算该交个税的部分
double taxableIncome =preTaxSalary-preTaxSalary*0.1-5000;
//对应的纳税数额
double tax=0;
double netPay =0;
if(taxableIncome<=0){
tax=0;
netPay=preTaxSalary-preTaxSalary*0.1-tax;
} else if (taxableIncome>0 && taxableIncome<=3000) {
tax=taxableIncome*0.03;
netPay = preTaxSalary-preTaxSalary*0.1-tax;
}else if(taxableIncome>3000 && taxableIncome<=12000){
tax=3000*0.03+(taxableIncome-3000)*0.1;
netPay = preTaxSalary-preTaxSalary*0.1-tax;
}else if(taxableIncome>12000 && taxableIncome<=25000){
tax=3000*0.03+9000*0.1+(taxableIncome-12000)*0.2;
netPay = preTaxSalary-preTaxSalary*0.1-tax;
}else if(taxableIncome>25000 && taxableIncome<=35000){
tax =3000*0.03+9000*0.1+13000*0.2+(taxableIncome-25000)*0.25;
netPay = preTaxSalary-preTaxSalary*0.1-tax;
}else if(taxableIncome>35000 && taxableIncome<=55000){
tax =3000*0.03+9000*0.1+13000*0.2+10000*0.25+(taxableIncome-35000)*0.3;
netPay = preTaxSalary-preTaxSalary*0.1-tax;
}else if(taxableIncome>55000 && taxableIncome<=80000){
tax=3000*0.03+9000*0.1+13000*0.2+10000*0.25+20000*0.3+(taxableIncome-55000)*0.35;
netPay = preTaxSalary-preTaxSalary*0.1-tax;
}else{
tax = 3000 * 0.03 + 9000 * 0.1 + 13000 * 0.2 + 10000 * 0.25 + 20000 * 0.3 + 25000 * 0.35 + (taxableIncome - 80000) * 0.45;
netPay = preTaxSalary-preTaxSalary*0.1-tax;
}
System.out.println("纳税数额:"+tax);
System.out.println("到手工资："+netPay);
}
}
题目6
模拟计算器功能，对键盘录入的两个int类型的数据进行加、减、乘、除的运算，并打印运算结果。
要求：
请输入第一个整数: 30
请输入第二个整数: 40
请输入您要进行的运算(1:表示加法,2:表示减法,3:表示乘法,4:表示除法): 1
控制台输出:30+40=70
package demo1;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("输入第一个整数：");
int number1 = sc.nextInt();
System.out.println("请输入第二个整数：");
int number2 = sc.nextInt();
System.out.println("请输入您要进行的运算(1:表示加法,2:表示减法,3:表示乘法,4:表示除法):");
int type = sc.nextInt();
switch (type) {
case 1:
System.out.println("第一个整数+第二个整数："+(number1+number2));
break;
case 2:
System.out.println("第一个整数-第二个整数："+(number1-number2));
break;
case 3:
System.out.println("第一个整数*第二个整数："+(number1*number2));
break;
case 4:
System.out.println("第一个整数除于第二个整数："+(number1/number2));
break;
default:
System.out.println("您输入的运算类别有误");
break;
}
}
}
题目7：
已知2019年是猪年，请在控制台输出从1949年到2019年中所有是猪年的年份。
package demo1;
public class Test2 {
public static void main(String[] args){
int starYear = 1949;
int endYear = 2019;
System.out.println("所有是猪年的年份：");
for(int i = starYear; i <= endYear; i++){
if(i%12==3){
System.out.println(i);
}
}
}
}
题目8
中国有闰年的说法。闰年的规则是：四年一闰，百年不闰，四百年再闰。（年份能够被4整除但不能被100整除算是闰年，年份能被400整除也是闰年）。请打印出1988年到2019年的所有闰年年份。
package demo1;
public class Test2 {
public static void main(String[] args){
int starYear = 1988;
int endYear = 2019;
System.out.println("所有闰年年份：");
for(int i = starYear; i <= endYear; i++){
if(i % 4==0 && i % 100!=0 || i % 400 == 0){
System.out.println(i);
}
}
}
}