**

2-5-2 if-else结构

/*
分支结构中的if-else （条件判断结构）


一。三种结构

第一种：if(条件表达式){
执行表达式
}

第二种：二选一
if(条件表达式){
执行表达式1
}
else{
执行表达式2
}

第三种：多选一
if(条件表达式){
执行表达式1
} else if（条件表达式）{
执行表达式2
} else if（条件表达式）{
执行表达式3
}
…….
else{
执行表达式n}
*/
package day04;
public class IfTest {
public static void main(String[] args) {

//例1
int heartBeats = 79;
if(heartBeats<60 || heartBeats>100){
System.out.println(“需要做进一步检查”);
}
System.out.println(“检查结束”);

//例2
int age =23;
if(age <18){
System.out.println(“你可以多看看动画片！”);
}else{
System.out.println(“你可以看看成人电影了”);
}


//例3
if(age<0){
System.out.println(“您输入的数据非法！”);
}else if(age<18){
System.out.println(“青少年时期”);
}else if(age<35){
System.out.println(“青壮年时期”);
}else if(age <60){
System.out.println(“中年时期”);
}
else if(age<120){
System.out.println(“老年时期”);
}else{
System.out.println(“你是要成仙啊！”);
}


}
}


/**/

/*
如何从键盘获取不同类型的变量，需要使用Scanner类

具体实现步骤：
1。导包：import java.util.Scanner;
2.Scanner的实例化 Scanner scan =new Scanner(System.in);
3.调用Scanner类的相关方法（next()/nextXxx()），来获取指定类型的变量

注意：
需要根据相应的方法，来输入指定类型的值，如果输入端数据类型与要求的类型不匹配时
系统会报出异常：InputMismatchException
*/
package day04;
import java.util.*;
public class ScanfTest {
public static void main(String[] args) {

Scanner scan =new Scanner(System.in);
System.out.println(“请输入你的姓名：”);
String name =scan.next();
System.out.println(name);

System.out.println(“请输入你的芳龄：”);
int age =scan.nextInt();
System.out.println(age);

System.out.println(“请输入你的体重：”);
double weigh=scan.nextDouble();
System.out.println(weigh);

System.out.println(“你是否相中我了？（true or false）”);
boolean islove=scan.nextBoolean();
System.out.println(islove);

//对于char类型的获取，Scanner没有提供相关的方法，只能获取一个字符串
System.out.println(“请输入你的性别：（男/女）”);
String gender =scan.next();//男
char genderChar =gender.charAt(0);//获取索引位置为1上的字符
System.out.println(genderChar);

}
}
/**/**

/*
岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆BMW；
成绩为(80，99]时，奖励一台iphone xs max；
当成绩为[60,80]时，奖励一个 iPad；
其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断

说明：
1. else 结构是可选的
2.针对于条件表达式：
如果多个条件表达式之间是“互斥”关系（或没有交集的关系）
3.
*/
package day04;
import java.util.*;
public class IFText2 {
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
System.out.println(“请输入岳小鹏的成绩：（0~100）”);
int score =scan.nextInt();

if(score==100){
System.out.println(“奖励一辆BWM”);
} else if(score>80&score<=99){
System.out.println(“奖励一台iphone xs max”);
} else if(score>=60&score<=80){
System.out.println(“奖励一个ipad”);
} else{
System.out.println(“什么奖励都没有！”);
}
}
}
/、**
/*
大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出
一定的条件：高：180cm以上；富：财富1千万以上；帅：是。
如果这三个条件同时满足，则：“我一定要嫁给他!!!”
如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则：“不嫁！”

*/
package day04;
import java.util.*;
public class iftest4 {
public static void main(String[] args) {
Scanner scan =new Scanner(System.in);

System.out.println(“请输入你的身高：（cm）”);
int height =scan.nextInt();
System.out.println(“请输入你的财富：（千万）”);
double money=scan.nextDouble();


/*
方式一、
System.out.println(“请输入你是否帅：（true or flase）”);
boolean isHandsome=scan.nextBoolean();

if(height>=180&&money>=1&&isHandsome){
System.out.println(“我一定要嫁给他！！！”);
}else if(height>=180||money>=1||isHandsome){
System.out.println(“比上不足，比下有余！”);
}else {
System.out.println(“不嫁！”);
}
*/

//方式二、
System.out.println(“请输入你是否帅：（是 /否）”);
String isHandsome=scan.next();
if(height>=180&&money>=1&&isHandsome.equals(“是”)){
System.out.println(“我一定要嫁给他！！！”);
}else if(height>=180||money>=1||isHandsome.equals(“是”)){
System.out.println(“比上不足，比下有余！”);
}else {
System.out.println(“不嫁！”);
}

}
}

2-5-3 switch-case

/*
分支结构之二：switch case

1.格式
switch（表达式）{
case 常量1：
执行语句1；
//break;

case 常量2：
执行语句2；
//break;

………
default:
执行语句n：
//break；
}

2.说明：

①根据Switch表达式中的值，依次匹配各个case中的常量，一旦匹配成功
则进入相应的case结构中，计算执行。当调用完执行语句后，则仍然向下执行其他case
结构中的执行语句，知道遇到break关键字或者到Switch的结尾

②break，可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构

③switch 结构中的表达式，只能是如下的6中数据类型之一：
byte short char int 枚举类型（jdk5.0之后） String （JDK7.0之后）
④case 之后只能声明常量，不能声明范围。

⑤break关键字是可选的

⑤default 就是相当于if-else结构中的else
default结构是可选的，而且位置是灵活的，可以随意存在switch结构的任意一行
*/
package day04;
public class SwitchCaseTestt {
public static void main(String[] args) {
int number =2;
switch (number){
case 0:
System.out.println(“zero”);break;
case 1:
System.out.println(“one”);break;
case 2:
System.out.println(“two”);break;
case 3:
System.out.println(“three”);break;
default:
System.out.println(“other”);
}

}
}
/**
/*
从键盘分别输入年、月、日，判断这一天是当年的第几天
注：判断一年是否是闰年的标准：
1）可以被4整除，但不可被100整除
或 2）可以被400整除

说明：
1.凡是可以是用switch-case的结构，都可以转换为if-else，反之，不成立

2.我们写分支结构时，当发现既可以使用switch-case，又可以使用if-else，
我们优先选择使用switch-case。 原因：switch-case的执行效率较高。
*/
package day04;
import java.util.*;
public class Switchcase2 {
public static void main(String[] args) {

Scanner scan =new Scanner(System.in);
System.out.println(“请输入年份year：”);
int year =scan.nextInt();
System.out.println(“请输入月份month：”);
int month=scan.nextInt();
System.out.println(“请输入日期day：”);
int day =scan.nextInt();


//定义一个变量来保存总天数
int sumday =0;
switch(month){
case 12:
sumday+=30;
case 11:
sumday+=31;
case 10:
sumday+=30;
case 9:
sumday+=31;
case 8:
sumday+=31;
case 7:
sumday+=30;
case 6:
sumday+=31;
case 5:
sumday+=30;
case 4:
sumday+=31;
case 3:
// sumday+=30;
if (year%4==0&&year%100!=0||year%400==0){
sumday+=29;
}else{
sumday+=28;
}
case 2:
sumday+=31;
case 1:
sumday+=day;
}
System.out.println(year+”年”+month+”月”+day+”是第”+sumday+”天”);

}
}
/*/**

2-5-4 for循环结构

/*
For循环结构的使用
一、循环结构的4个要素
①初始化条件
②循环条件
③循环体
④迭代条件

二、for循环的结构

for(①；②；④){
③
}


*/
package day04;
public class recle1 {
public static void main(String[] args) {

for(int i=1;i<=50;i++){
System.out.println(“我喜欢你！！”);
}

//练习：
int num=1;
for(System.out.print(‘a’);num<=3;System.out.print(‘c’),num++){
System.out.print(‘b’);
}
System.out.println();
//遍历100以内的偶数,
int sum=0;
System.out.println(“100以内的偶数有：”);
for(int i=1;i<=100;i++){
if(i%2==0){
sum+=i;
System.out.println(i +” “);
}

}

System.out.println(“100以内的偶数总和为：”+sum);
}
}

/**/**

2-5-5 while循环

/*语法格式
①初始化部分
while(②循环条件部分)｛
③循环体部分;
④迭代部分;
} 
执行过程：
①-②-③-④-②-③-④-②-③-④-…-②
说明：
注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。 for循环和while循环可以相互转换
for循环和while循环是可以相互转换的！
区别：for循环和while循环打初始化条件部分的作用范围不同。
*/
package day05;
public class whiletest {
public static void main(String[] args) {
int i=1;
while(i<=100){
if(i%2==0){
System.out.println(i);

}
i++;

}
System.out.println(i);
}
}
/*

2-5-6 do-while循环

**
/*语法格式
①初始化部分;
do{
③循环体部分
④迭代部分
}while(②循环条件部分); 
执行过程：
①-③-④-②-③-④-②-③-④-…②
说明：
do-while循环至少执行一次循环体。
*/
package day05;
public class doWhiletest {
public static void main(String[] args) {

//遍历100以内的偶数,并计算所有偶数的和以及偶数的个数
int sum=0;
int count=0;
int num=1;
do{
if(num%2==0){
System.out.println(num);
sum+=num;
++count;
}
num++;
}while(num<=100);
System.out.println(“sum=”+sum);
System.out.println(“count=”+count);
}
}
/**
/*
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入
为0时结束程序。
说明：
1.不在循环条件部分闲置次数的结构：for(;;)或者while(true)
2.结束循环有几种方式？
方式一、循环条件部分返回flase
方式二、在循环体中实行break；
*/
package day05;
import java.util.*;
public class ForWhiletest {
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);

int positiveNumber=0;//记录正数的个数
int negativeNumber=0;//记录负数的个数

while(true){
int num=scan.nextInt();
if(num>0){
positiveNumber++;
} else if(num<0){
negativeNumber++;
}else{
break;
}
}
System.out.println(“positiveNumer=”+positiveNumber);
System.out.println(“negativeNumber=”+negativeNumber);

}

}
/**

2-5-7 嵌套循环

/*
将一个循环放在另一个循环体内，就形成了嵌套循环。
其中，for ,while ,do…while均可以作为外层循环或内层循环。 
实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的
循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开
始下一次的循环。

设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行mn次。/
/*
**
*
**
*
*/
package day05;
public class forfortest {
public static void main(String[] args) {
for(int j=4;j>=1;j—){
for(int i=j;i>=1;i—)
System.out.print(“*”);
System.out.println();

}

}
}
/*/

/*
九九乘法表：
1*1=1
21=2 22=4
31=3 32=6 3*3=9
41=4 42=8 43=12 44=16
51=5 52=10 53=15 54=20 5*5=25
61=6 62=12 63=18 64=24 65=30 66=36
71=7 72=14 73=21 74=28 75=35 76=42 7*7=49
81=8 82=16 83=24 84=32 85=40 86=48 87=56 88=64
91=9 92=18 93=27 94=36 95=45 96=54 97=63 98=72 9*9=81
*/
package day05;
public class NineNineTable {
public static void main(String[] args) {
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++)
System.out.print(i+”“+j+”=”+ij+” “);
System.out.println();
}
}
}
/*/
/输出100以内的质数
质数：素数，只能被1和他本身整除的自然数
/
package day05;
public class PrimeNumber {
public static void main(String[] args) {

//获取当前时间距离1970-01-01 00:00:00的毫秒数
long start =System.currentTimeMillis();

for(int i=2;i<=5000;i++){
boolean isflag=true;//判断的flag需要进行重置
for(int j=2;j<=Math.sqrt(i);j++){//优化二：将i-1改为Math.sqrt(i)；
if(i%j==0){
isflag=false;
break; //优化一
}

}

if(isflag==true)
System.out.println(i);
}

//获取当前时间距离1970-01-01 00:00:00的毫秒数
long end =System.currentTimeMillis();
System.out.println(“所花费的时间：”+(end-start));
//优化前花费的时间为：25000
//优化一后所花费的时间：2800
//优化一+二之后所花费的时间为233
}
}**

2-5-8 特殊关键字 break continue

/*
break he1continue关键字的使用
适用范围 循环中使用的作用 相同点
break: switch-case 关键字后面不能声明执行语句
循环结构中 结束当前循环
continue: 循环结构中 结束当次循环 关键字后面不能声明执行语句

*/
package day05;
public class BreakContinueTest {
public static void main(String[] args) {

for(int i=1;i<=10;i++){
if(i%4==0){
//break;//运行结果：123
continue;//运行结果：123567910
}
System.out.print(i);

}
System.out.println();
//*
/*111
222
333
444
*/

label: for(int i=1;i<=4;i++){
for(int j=1;j<=10;j++){
if(j%4==0){
//break;//默认跳出包裹此关键字最近的一层循环
//continue;
break label;//结束指定表示的一层循环结构
}
System.out.print(j);
}
System.out.println();
}
}
}