当前位置： 代码迷 >> 综合 >> 006-控制语句（老杜）
  详细解决方案

006-控制语句（老杜）

热度：82   发布时间：2024-01-29 10:42:23.0

目录

BreakTest01.java

ContinueTest01.java

DoWhileTest01.java

ForTest01.java

ForTest02.java

ForTest03.java

ForTest04.java

ForTest05.java

ForTest06.java

Homework.java

Homework1.java

Homework2.java

Homework3.java

Homework4.java

Homework5.java

Homework6.java

Homework7.java

IfTest01.java

IfTest02.java

IfTest03.java

IfTest04.java

SwitchTest01.java

SwitchTest02.java

WhileTest01.java

BreakTest01.java

/*
break;语句：
1、break;语句比较特殊，特殊在：break语句是一个单词成为一个完整的java语句。
另外：continue也是这样，他俩都是一个单词成为一条语句。

        2、break 翻译为折断、弄断。

        3、break;语句可以用在哪里呢？
用在两个地方，其它位置不行
第一个位置：switch语句当中，用来终止switch语句的执行。
用在switch语句当中，防止case穿透现象，用来终止switch。

            第二个位置：break;语句用在循环语句当中，用来终止循环的执行。
用在for当中
用在while当中
用在do....while..当中。

4、以下程序主要是以for循环为例学习break转向语句。

        5、break;语句的执行并不会让整个方法结束，break;语句主要是用来终止离它最近
的那个循环语句。

        6、怎么用break;语句终止指定的循环呢？
第一步：你需要给循环起一个名字，例如：
a: for(){
b:for(){

}
}
第二步：终止：break a;
*/
public class BreakTest01{

    public static void main(String[] args){

        // 输出0-9
/*
for(int i = 0; i < 10; i++){
System.out.println("i = " + i);
}
*/

        for(int i = 0; i < 10; i++){
if(i == 5){
// break;语句会让离它最近的循环终止结束掉。
break; // break;终止的不是if，不是针对if的，而是针对离它最近的循环。
}
System.out.println("i = " + i); // 0 1 2 3 4
}

        // 这里的代码照常执行。break;的执行并不会影响这里。
System.out.println("Hello World!");

        // 这个for循环两次
for(int k = 0; k < 2; k++){ // 外层for
for(int i = 0; i < 10; i++){ // 内层for
if(i == 5){
break; // 这个break;语句只能终止离它最近的for
}
System.out.println("i ===> " + i); 
}
}

        System.out.println("------------------------------------------");

        // 以下讲解的内容，以后开发很少用。不要紧张。
// 这种语法很少用，了解一下即可。
a:for(int k = 0; k < 2; k++){ 
b:for(int i = 0; i < 10; i++){
if(i == 5){
break a; // 终止指定的循环。
}
System.out.println("i ===> " + i); 
}
}

        System.out.println("呵呵");

    }
}

/*
运行结果：
i = 0
i = 1
i = 2
i = 3
i = 4
Hello World!
i ===> 0
i ===> 1
i ===> 2
i ===> 3
i ===> 4
i ===> 0
i ===> 1
i ===> 2
i ===> 3
i ===> 4
------------------------------------------
i ===> 0
i ===> 1
i ===> 2
i ===> 3
i ===> 4
呵呵
*/

ContinueTest01.java

/*
continue;语句：
1、continue翻译为：继续
2、continue语句和break语句要对比着学习
3、continue语句的作用是：
终止当前"本次"循环，直接进入下一次循环继续执行。
for(){
if(){ // 当这个条件成立时，执行continue语句
continue; //当这个continue语句执行时，continue下面的代码不执行，直接进入下一次循环执行。
}
// 以上的continue一旦执行，以下代码不执行，直接执行更新表达式。
code1;
code2;
code3;
code4;
}

        4、continue语句后面可以指定循环吗？
可以的。
这里就不再讲了，自己测试以下。
a:for(;;更新表达式1){
b:for(;;更新表达式2){
if(){
continue a;
}
code1;
code2;
code3;
}
}
*/
public class ContinueTest01{
public static void main(String[] args){

        /*
i = 0
i = 1
i = 2
i = 3
i = 4
*/
for(int i = 0; i < 10; i++){
if(i == 5){
break;
}
System.out.println("i = " + i);
}

        System.out.println("----------------------------"); // ----------------------------

        /*
i = 0
i = 1
i = 2
i = 3
i = 4
i = 6
i = 7
i = 8
i = 9
*/
for(int i = 0; i < 10; i++){
if(i == 5){
continue;
}
System.out.println("i = " + i); // 输出i是4
}

    }
}

DoWhileTest01.java

/*
do..while循环语句的执行原理以及语法机制：
语法机制：
do {
循环体;
}while(布尔表达式);

        注意：do..while循环最后的时候别漏掉“分号”

        执行原理：
先执行循环体当中的代码，执行一次循环体之后，
判断布尔表达式的结果，如果为true，则继续执行
循环体，如果为false循环结束。

对于do..while循环来说，循环体至少执行1次。循环体的执行次数是：1~n次。
对于while循环来说，循环体执行次数是：0~n次。

*/
public class DoWhileTest01{
public static void main(String[] args){
//错误: 需要';'
/*
int i = 0;
do{
System.out.println(i);
i++;
}while(i < 10)
*/

/*
int i = 0;
do{
System.out.println(i); // 0 1 2 3 ... 8 9
i++;
}while(i < 10);
*/

        /*
int i = 0;
do{
System.out.println(i++); // 0 1 2 3 ... 8 9
}while(i < 10);
*/

        int i = 0;
do{
//System.out.println(++i); // 1 2 3 ... 8 9 10

            // 把上面那一行代码拆分为以下的两行代码。
int temp = ++i;
System.out.println(temp); // 程序执行到此处的时候i是10

        }while(i < 10);

        System.out.println("-----------------------------");
int k = 100;
System.out.println(++k); // 101
System.out.println(k); // 101

        int m = 10;
System.out.println(m++); // 10
System.out.println(m); // 11


// 至少执行1次循环体。
do{
System.out.println("Hello World!");
}while(false);

    }
}

/*
运行结果：
1
2
3
4
5
6
7
8
9
10
-----------------------------
101
101
10
11
Hello World!
*/

ForTest01.java

// 演示一下：为什么要使用循环
// 循环语句的出现就是为了解决代码的复用性。
public class ForTest01{
public static void main(String[] args){
// 要求在控制台上输出100个100
/*
System.out.println(100);
System.out.println(100);
System.out.println(100);
System.out.println(100);
System.out.println(100);
System.out.println(100);
System.out.println(100);
System.out.println(100);
System.out.println(100);
System.out.println(100);
System.out.println(100);
System.out.println(100);
*/
// .... 重复的代码太多了
// 简化一下以上的代码，可以使用循环
// 什么时候可以考虑使用循环呢？相同的代码重复出现的时候，可以使用循环语句。
for(int i = 0; i < 100; i++){
System.out.println(100);
}
}
}

ForTest02.java

/*
1、for循环的语法机制以及运行原理？
语法机制：
for(初始化表达式; 条件表达式; 更新表达式){
循环体; // 循环体由java语句构成
java语句;
java语句;
java语句;
java语句;
....
}
注意：
第一：初始化表达式最先执行，并且在整个循环中只执行一次。
第二：条件表达式结果必须是一个布尔类型，也就是：true或false
执行原理：
先执行初始化表达式，并且初始化表达式只执行1次。
然后判断条件表达式的结果，如果条件表达式结果为true，
则执行循环体。
循环体结束之后，执行更新表达式。
更新完之后，再判断条件表达式的结果，
如果还是true，继续执行循环体。

                直到更新表达式执行结束之后，再次判断条件时，条件为false，
for循环终止。

更新表达式的作用是：控制循环的次数，换句话说，更新表达式会更新
某个变量的值，这样条件表达式的结果才有可能从true变成false，从而
终止for循环的执行，如果缺失表达式，很有可能会导致死循环。

*/
public class ForTest02{
public static void main(String[] args){
// 最简练的for循环怎么写?
// 初始化表达式、条件表达式、更新表达式 其实都不是必须的！！！
/*
for(;;){
System.out.println("死循环");
}
*/

        // 最常见的for循环
// 循环10次，输出0~9
/*
i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9

            强调一下：对于以下的这个for循环，其中int i = 0;
最先执行，并且只执行一次，而且i变量属于for循环
的局部变量，for循环结束之后i的内存就释放了。
这个i变量只能在for循环中使用。
这个i变量属于for循环域。在main方法中没有办法直接使用。
*/
for(int i = 0;i < 10;i++){
System.out.println("i = " + i); // 0 1 2 3....9
}

        //错误: 找不到符号
//System.out.println(i);

        // i变量的作用域就扩大了。
int i = 0;
for(;i < 10;i++){
System.out.println("i --> " + i); // 0 1 2 3....9
}
System.out.println("这里的i可以访问吗？i = " + i); // 10

        // 变形
for(int k = 1; k <= 10; k++){
System.out.println("k --> " + k); // 1 2 ..... 9 10
}

        // 变形
for(int k = 1; k <= 10; ){
System.out.println("k --> " + k); 
k++;
}

        // 变形
for(int k = 1; k <= 10; ){
k++;
System.out.println("value --> " + k); // 2 3 4 5 6 7 8 9 10 11
}

    }
}

/*
运行结果：
i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9
i --> 0
i --> 1
i --> 2
i --> 3
i --> 4
i --> 5
i --> 6
i --> 7
i --> 8
i --> 9
这里的i可以访问吗？i = 10
k --> 1
k --> 2
k --> 3
k --> 4
k --> 5
k --> 6
k --> 7
k --> 8
k --> 9
k --> 10
k --> 1
k --> 2
k --> 3
k --> 4
k --> 5
k --> 6
k --> 7
k --> 8
k --> 9
k --> 10
value --> 2
value --> 3
value --> 4
value --> 5
value --> 6
value --> 7
value --> 8
value --> 9
value --> 10
value --> 11
*/

ForTest03.java

public class ForTest03{
public static void main(String[] args){

        // for的其它形式
for(int i = 10; i > 0; i--){
System.out.println("i = " + i); // 10 9 8 7 6 5 4 3 2 1
}

        // 变形
for(int i = 0; i < 10; i += 2){
System.out.println("value1 = " + i); // 0 2 4 6 8 
}

        //注意：1对3求余数结果还是1
/*
for(int i = 100; i > 0; i %= 3){
System.out.println("value2 = " + i); // 100 1 1... 1
}
*/
}
}

/*
运行结果：
i = 10
i = 9
i = 8
i = 7
i = 6
i = 5
i = 4
i = 3
i = 2
i = 1
value1 = 0
value1 = 2
value1 = 4
value1 = 6
value1 = 8
*/

ForTest04.java

/*
使用for循环，实现1~100所有奇数求和
至少给出两种解决方案。
*/
public class ForTest04{
public static void main(String[] args){

        //第一种方案：
// 思路：先找出1~100所有的奇数，然后再考虑求和的事儿。
// 第一步：先从1取到100，一个数字一个数字取出来。
// 第二步：既然可以得到每一个数字，那么我们进一步判断这个数字是否为奇数
// 奇数对2求余数，结果都是1
int sum = 0; // 初始值给0
for(int i = 1; i <= 100; i++){
// int sum = 0; // 不能在这个循环体中声明，这样会导致“计算器归0”
//for循环中嵌套了if语句。
if(i % 2 == 1){ // i为奇数的条件
//System.out.println("i = " + i);
sum += i; // 累加 (sum = sum + i;)
}
}
// 一定是在for循环全部结束之后，输出的sum就是最终的结果。
System.out.println("1~100所有奇数求和结果是：" + sum); // 2500

        //第二种方案：这种方案效率高，因为循环次数比较少。
// 之前的sum归0.重新求和。
sum = 0;
for(int i = 1; i < 100; i += 2){
//这样写可以保证每一次取出的值都是奇数。不需要判断。
//System.out.println(i);
sum += i;
}
System.out.println(sum);

}
}

/*
运行结果：
1~100所有奇数求和结果是：2500
2500
*/

ForTest05.java

/*
1、所有合法的“控制语句”都可以嵌套使用。
2、for循环嵌套一个for循环执行原理是什么？
提示一下：大家不要因为for循环中嵌套了一个for循环，就感觉
这个程序比较特殊，实际上大家可以这样看待：
for(){
//在分析外层for循环的时候，把里面的for就当做一段普通的java语句/代码.
for(){}
}
*/
public class ForTest05{
public static void main(String[] args){

        // 单层for循环
for(int i = 0; i < 10; i++){ 
System.out.println("i = " + i);
}

        for(int k = 0; k < 2; k++){ // 循环2次
System.out.println("k = " + k);
}

        for(int k = 0; k < 2; k++){ // 循环2次
//System.out.println("k ==> " + k);
for(int i = 0; i < 10; i++){ 
System.out.println("i ---> " + i);
}
}

/*
int i = 0;
for(int k = 0; k < 2; k++){
//System.out.println("k's value = " + k);
for(; i < 10; i++){ 
System.out.println("k's value = " + k);
System.out.println("value ---> " + i);
}
}
*/


for(int k = 0; k < 2; k++){
for(int i = 0; i < 10; i++){ 
System.out.println("k's value = " + k); 
System.out.println("value ---> " + i); 
}
}

        /*
// 第一遍
for(int i = 0; i < 10; i++){ 
System.out.println("i ==> " + i);
}

        // 第二遍
for(int i = 0; i < 10; i++){ 
System.out.println("i ==> " + i);
}
*/

    }
}

/*
运行结果：
i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9
k = 0
k = 1
i ---> 0
i ---> 1
i ---> 2
i ---> 3
i ---> 4
i ---> 5
i ---> 6
i ---> 7
i ---> 8
i ---> 9
i ---> 0
i ---> 1
i ---> 2
i ---> 3
i ---> 4
i ---> 5
i ---> 6
i ---> 7
i ---> 8
i ---> 9
k's value = 0
value ---> 0
k's value = 0
value ---> 1
k's value = 0
value ---> 2
k's value = 0
value ---> 3
k's value = 0
value ---> 4
k's value = 0
value ---> 5
k's value = 0
value ---> 6
k's value = 0
value ---> 7
k's value = 0
value ---> 8
k's value = 0
value ---> 9
k's value = 1
value ---> 0
k's value = 1
value ---> 1
k's value = 1
value ---> 2
k's value = 1
value ---> 3
k's value = 1
value ---> 4
k's value = 1
value ---> 5
k's value = 1
value ---> 6
k's value = 1
value ---> 7
k's value = 1
value ---> 8
k's value = 1
value ---> 9
*/

ForTest06.java

/*
九九乘法表

    1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

    各位，请找一下以上九九乘法表的特点？？？？？
第一个特点：共9行。
第二个特点：第1行1个。第2行2个。第n行n个。

最重要的是：不要慌，慢慢的把思路捋出来，再写代码。
*/
public class ForTest06{
public static void main(String[] args){

// 9行，循环9次。
for(int i = 1; i <= 9; i++){ // 纵向循环
//System.out.println(i); // i是行号（1~9）
// 负责输出一行的。（内部for循环负责将一行上的全部输出。）
for(int j = 1; j <= i; j++){ // i是行号
System.out.print(j + "*" + i + "=" + i * j + " ");
}
// 换行
System.out.println();
}
}
}

Homework.java

/*
根据指定月份，打印该月份所属的季节。
3,4,5 春季 
6,7,8 夏季 
9,10,11 秋季 
12, 1, 2 冬季

    if和switch各写一版
*/
class Homework1{
public static void main(String[] args){
java.util.Scanner s = new java.util.Scanner(System.in);
System.out.print("请输入合法的数字【该数字可以是：1 2 3 4 5 6 7 8 9 10 11 12】:");
int i = s.nextInt();

        // if版本
/*
String str = "输入的数字不合法";
if(i == 3 || i == 4 || i == 5){
str = "春季";
}else if(i == 6 || i == 7 || i == 8){
str = "夏季";
}else if(i == 9 || i == 10 || i == 11){
str = "秋季";
}else if(i == 12 || i == 1 || i == 2){
str = "冬季";
}
System.out.println(str);
*/

        // switch版本
String str = "输入的数字不合法";
switch(i){
case 3:case 4:case 5:
str = "春季";
break;
case 6:case 7:case 8:
str = "夏季";
break;
case 9:case 10:case 11:
str = "秋季";
break;
case 12:case 1:case 2:
str = "冬季";
}
System.out.println(str);

    }
}
/*
运行结果：（例）
请输入合法的数字【该数字可以是：1 2 3 4 5 6 7 8 9 10 11 12】:4
春季
*/


//从键盘接收一个数字，判断该数字的正负
class Homework2{
public static void main(String[] args){
java.util.Scanner s = new java.util.Scanner(System.in);
System.out.print("请输入一个数字，我可以判断正负哦：");
// 接收一个数字
//int value = s.nextInt();
double value = s.nextDouble();
// 判断该数字正负
/*
if(value < 0){
System.out.println("负数");
}else{
System.out.println("正数");
}
*/
System.out.println(value < 0 ? "负数" : "正数");
}
}
/*
运行结果：（例）
请输入一个数字，我可以判断正负哦：-3
负数
*/


//从键盘接收一个数字，判断该数字的奇偶。
class Homework3{
public static void main(String[] args){

//创建一次。
java.util.Scanner s = new java.util.Scanner(System.in);

        while(true){
System.out.print("请输入一个数字，可以判断奇数偶数哦（输入0表示退出系统）：");
int value = s.nextInt();
if(value == 0){
// 退出系统，结束程序
return; //后面讲。
}
System.out.println(value % 2 == 0 ? "偶数" : "奇数");
}
}
}
/*
运行结果：（例）
请输入一个数字，可以判断奇数偶数哦（输入0表示退出系统）：17
奇数
*/


/*
整数大小比较：输入两个整数，比较大小，
若x>y 输出 >
若x=y 输出 =
若x<y 输出 <
*/
class Homework4{
public static void main(String[] args){
java.util.Scanner s = new java.util.Scanner(System.in);
System.out.print("请输入第1个数字：");
int x = s.nextInt();
System.out.print("请输入第2个数字：");
int y = s.nextInt();
if(x > y){
System.out.println(x + ">" + y);
}else if(x == y){
System.out.println(x + "=" + y);
}else{
System.out.println(x + "<" + y);
}
// 同学们尝试一下使用多个三目运算符如何表述以上程序。
}
}
/*
运行结果：（例）
请输入第1个数字：5
请输入第2个数字：8
5<8
*/


/*
编写程序，由键盘输入三个整数分别存入变量num1,num2,num3中，对它们进行排序，
使用if-else结构，并按从小到大的顺序输出
*/
class Homework5{
public static void main(String[] args){
java.util.Scanner s = new java.util.Scanner(System.in);
System.out.print("请输入第1个数字：");
int x = s.nextInt();
System.out.print("请输入第2个数字：");
int y = s.nextInt();
System.out.print("请输入第3个数字：");
int z = s.nextInt();

        // 先判断三个值是否都相等
if(x == y && y == z){
System.out.println(x);
System.out.println(y);
System.out.println(z);
return; //终止掉程序，后面讲
}

        // 代码能够走到这里说明x y z不是都相等。
// x和y相等，但是和z不等 
if(x == y){
if(x > z){
System.out.println(z);
System.out.println(x);
System.out.println(y);
}else{
System.out.println(x);
System.out.println(y);
System.out.println(z);
}
}
// x和z相等，但是和y不等
if(x == z){ 
if(x > y){
System.out.println(y);
System.out.println(x);
System.out.println(z);
}else{
System.out.println(x);
System.out.println(z);
System.out.println(y);
}
}
// y和z相等，但是和x不等
if(y == z){ // x y z
if(y > x){
System.out.println(x);    
System.out.println(y);    
System.out.println(z);    
}else{
System.out.println(y);    
System.out.println(z);    
System.out.println(x);
}
}

        // 程序执行到这里说明 x y z 都不相等
/*
if(x > y){
if(y > z){
System.out.println(z);
System.out.println(y);
System.out.println(x);
}else{ 
if(x < z){
System.out.println(y);
System.out.println(x);
System.out.println(z);
}else{
System.out.println(y);
System.out.println(z);
System.out.println(x);
}
}
}else{
// x < y
// 50 < 100
}
*/

        // 不算相等的，一共有6种情况。
if(x > y && x > z){ // 假设x是最大的
if(y > z){
System.out.println(z);
System.out.println(y);
}else{
System.out.println(y);
System.out.println(z);
}
System.out.println(x);
}else if(y > x && y > z){ // 假设y是最大的
if(x > z){
System.out.println(z);
System.out.println(x);
}else{
System.out.println(x);
System.out.println(z);
}
System.out.println(y);
}else{ //假设z是最大的
if(x > y){
System.out.println(y);
System.out.println(x);
}else{
System.out.println(x);
System.out.println(y);
}
System.out.println(z);
}
}
}
/*
运行结果：（例）
请输入第1个数字：7
请输入第2个数字：2
请输入第3个数字：6
2
6
7
*/


/*
打车起步价8元（3KM以内）
超过3KM，超出的每公里1.2元
超过5KM，超出的每公里1.5元
请在键盘上接收公里数，得出总价。
*/
class Homework6{
public static void main(String[] args){
java.util.Scanner s = new java.util.Scanner(System.in);
System.out.print("请输入行驶的公里数：");
int dis = s.nextInt(); 
if(dis <= 3){
System.out.println("总价是：" + 8 + "元");
}else if(dis <= 5){
System.out.println("总价是：" + ((dis - 3) * 1.2 + 8) + "元");
}else{
// 公里超出5KM
System.out.println("总价是：" + ((8 + 2 * 1.2) + (dis - 5) * 1.5) + "元");
}
}
}
/*
运行结果：（例）
请输入行驶的公里数：17
总价是：28.4元
*/

Homework1.java

/*
应该怎么去编程？？？？？？？

    计算1000以内所有不能被7整除的整数之和
1、解决一个问题的时候，可以先使用汉语描述思路。（养成好习惯）
2、复杂的问题可以“一步一步”去实现，没必要一下全部实现。

把上面的题目可以拆分成几步去完成：

        第一步：从1开始循环，循环到1000，先保证每一个数字你都能取到。

        第二步：在以上第一步的循环过程中，一个数字一个数字筛查，判断该数字是否
是“不能被7整除的整数”。

编程思想/思路，都是一步一步分析，积累出来的。
编程最主要的是写汉语思路。思路有了，代码就不远了。

    把问题拆开，一个一个去解决一下。

    不断写代码，不断的积累编程“模型”。
*/
public class Homework1{

    public static void main(String[] args){

        // 在外部准备一个变量，用来存储求和的结果
int sum = 0;

        //循环的时候你能想起来for while do..while
for(int i = 1; i <= 1000; i++){ //第一步

            // 判断的时候你能想起来使用if
if(i % 7 != 0){ // 第二步
// 此时的i是不能被7整除的，这个i应该此时纳入求和/累加。
//sum += i;
sum = sum + i;
}

        }

        // 在for循环结束之后，结果才计算完成，所以在这里输出。
System.out.println("sum = " + sum); // sum = 429429
}
}

Homework2.java

// 计算 1+2-3+4-5+6-7....+100的结果
// 找规律：奇数时减法，偶数时加法。
// 第一种思路：(除1之外)所有的偶数求和，所有的奇数求和，然后偶数求和的结果减去奇数求和的结果。
// 第二种思路：循环过程中取出每个值，判断该数是偶数还是奇数，偶数就加，奇数就减。

//写代码养成好习惯是：写一步测试一步。
public class Homework2{
public static void main(String[] args){
// 第一步：先别着急着完成，先能从1取到100
int sum = 1; //sum的初始值不是0，而是1.
for(int i = 2; i <= 100; i++){ // i从2开始。
if(i % 2 == 0){ //偶数
sum += i;
}else{ // 奇数
sum -= i; 
}
}
System.out.println("结果=" + sum); // 结果=52
}
}

Homework3.java

//从控制台输入一个正整数，计算该数的阶乘。例如输入5，阶乘为 5*4*3*2*1
public class Homework3{
public static void main(String[] args){
//第一步：怎么从键盘上接收一个正整数。
java.util.Scanner s = new java.util.Scanner(System.in);
// 等待用户输入一个正整数。
System.out.print("请输入一个正整数：");
int num = s.nextInt();
// 计算该数的阶乘
// 5的阶乘：5*4*3*2*1
// 8的阶乘：8*7*6*5*4*3*2*1
// 第二步：先不用管乘法的事儿，先实现从8取到1.（递减的方式取）
//int jieGuo = 0; //初始值不能是0，是0的时候，乘积最后是0.
int jieGuo = 1; //结果的初始值给1.
for(int i = num; i > 1; i--){
jieGuo *= i; // jieGuo = jieGuo * i;
}
System.out.println("计算结果 = " + jieGuo);
}
}
/*
运行结果：（例）
请输入一个正整数：5
计算结果 = 120
*/

Homework4.java

/*
从控制台接收一个正整数，判断该数字是否为质数
质数（质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数）

因数是什么？
3 * 5 = 15
3和5都是15的因数。

2 3 4 5 6 7中：2 3 5 7都是质数。

重点题目：
主要练习，在外部打布尔标记。

*/
public class Homework4{
public static void main(String[] args){
// 从控制台接收一个正整数。
java.util.Scanner s = new java.util.Scanner(System.in);
System.out.print("请输入一个正整数：");
int num = s.nextInt(); // 假设输入的是8

        // 判断该数字是否为质数
// 怎么判断num是不是质数
// 怎么判断8是不是质数？
// 思路：8除以2看看能不能整除、8除以3看看能不能整除、8除以4看看能不能整除
// 一直除下去，直到发现有能够整除的，表示该数一定不是质数。
/*
假设输入的是7：
7 / 1 不用判断
7 / 2    需要判断
7 / 3    需要判断
7 / 4    需要判断（假设这个判断，发现可以整除，就没必要往下判断了。）
7 / 5    需要判断
7 / 6    需要判断
7 / 7 不用判断
*/

        //可以考虑在外边准备一个布尔类型的标记。
boolean zhiShu = true; // true表示是质数。

        for(int i = 2; i < num; i++){ // 假设输入的是100
//System.out.println(i);
if(num % i == 0){
// 循环没必要执行了，为了效率，这里要终止循环
//System.out.println("该数字"+num+"不是质数！");
zhiShu = false;
break;
}
}

        System.out.println(num + (zhiShu ? "是" : "不是") + "质数");
}
}
/*
运行结果：（例）
请输入一个正整数：66
66不是质数
*/

Homework5.java

/*
从键盘接收一个正整数，该正整数作为行数，输出以下图形
*
***
*****
*******
*********
例如：输入5，则打印如上图5行。

空格的规律：
第1行4个空格(5-1)
第2行3个空格(5-2)
第3行2个空格(5-3)
第4行1个空格(5-4)
第5行0个空格(5-5)

星号的规律：
第1行1个
第2行3个
第3行5个
第4行7个
.....

    行号 * 2 - 1
*/
public class Homework5{
public static void main(String[] args){
// 开发需要思路，实现这个功能需要一步一步来。
// 这个步骤是什么？
java.util.Scanner s = new java.util.Scanner(System.in);
System.out.print("请输入一个正整数作为行数：");
int rows = s.nextInt();

// 6行循环6次
// n行循环n次
for(int i = 1; i <= rows; i++){ // 外层循环控制的是总行数。

// 我在这里需要将一行全部输出
// 这里需要再使用循环，输出空格以及“*”
// 输出空格的循环
for(int j = 0; j < rows - i; j++){
System.out.print(" ");
}
// 输出星号*的循环
for(int k = 0; k < i * 2 - 1; k++){
System.out.print("*");
}

            // 以上两个for循环都结束之后，表示一行就结束了
// 在这里换行
System.out.println();
}

    }
}
/*
运行结果：（例）
请输入一个正整数作为行数：3
*
***
*****
*/

Homework6.java

/*
小芳的妈妈每天给她2.5元钱，她都会存起来，但是，每当这一天是存钱的第5天
或者5的倍数的话，她都会花去6元钱，请问，经过多少天，小芳才可以存到100元钱。

这个题目最主要练习是：
while循环 + 计数。
*/
public class Homework6{
public static void main(String[] args){

        // 小芳每一天肯定会有2.5元的收入。
// 小芳即使有一天花了6元，但是2.5元的收入还是有的。
// 经过分析：总钱数肯定需要是double类型。int类型不行。

        int day = 0; // 天数的默认初始值是0
double money = 0.0; // 钱的默认初始值是0

        /*
while(true){
day++; // 天数加1
money += 2.5; // 钱加2.5元
// 如果天数是5的倍数，那么花去6元
if(day % 5 == 0){
money -= 6.0;
}
// 什么时候循环结束呢？
// 当money >= 100.0的时候，循环结束。
if(money >= 100){
break;
}
}
*/

        // 改造之后的。
while(money < 100){
day++; // 天数加1
money += 2.5; // 钱加2.5元
// 如果天数是5的倍数，那么花去6元
if(day % 5 == 0){
money -= 6.0;
}
}

        //小芳通过74天存到了101.0元钱
System.out.println("小芳通过" + day + "天存到了" + money + "元钱");

    }
}
/*
运行结果：
小芳通过74天存到了101.0元钱
*/

Homework7.java

/*
一个数如果恰好等于它的因子之和，这个数就是完数，例如 6 = 1 + 2 + 3，编程
找出1000内所有的完数。

什么是完数？
一个数如果恰好等于它的因子之和，这个数就是完数。

那么因子怎么找？
10的因子？
10 % 1 == 0
10 % 2 == 0
10 % 5 == 0
不算10本身。
10的因子：
1 + 2 + 5 = 8

运行结果：
6
28
496
*/
public class Homework7{
public static void main(String[] args){
// 1不属于完数。从2开始判断
// 第一步：先从1到1000，每个数字都取出来
for(int i = 2; i <= 1000; i++){
// 第二步：在这里可以拿到i，那么此时应该判断i是否是一个完数。
// 这个数字有了，找这个数字的因子。
// 假设现在这个数字就是6，i等于6
int sum = 0;
for(int j = 1; j <= i / 2; j++){
//j取到的值是：1 2 3 4 5
//但实际上j取到哪儿就行了：1 2 3，取这几个数就行了。
//取到一半就行。
if(i % j == 0){
//此时j就是因子。
// 记得将因子j追加，累计。
sum += j;
}
}
// 以上for结束表示：所有因子求和完毕了。
if(i == sum){
//i是一个完数
System.out.println(i);
}
}
}
}

IfTest01.java

/*
if语句的语法结构以及运行原理？
if语句是分支语句，也可以叫做条件语句。
if语句的语法格式：
第一种写法：
int a = 100;
int b = 200;
if(布尔表达式){
java语句;
java语句;
}
这里的一个大括号{} 叫做一个分支。
if 这个单词翻译为如果，所以又叫做条件语句。
该语法的执行原理是：
如果布尔表达式的结果是true，则执行大括
号中的程序，否则大括号中代码不执行。

            第二种写法：
if(布尔表达式){  // 分支1
java语句;     
}else{            // 分支2
java语句;
}
执行原理：如果布尔表达式的结果是true，则执行
分支1，分支2不执行。如果布尔表达式的结果是false，
分支1不执行，执行分支2.
以上的这个语句可以保证一定会有一个分支执行。
else表示其它。

第三种写法：
if(布尔表达式1){ // 分支1
java语句;
}else if(布尔表达式2){ // 分支2
java语句;
}else if(布尔表达式3){
java语句;
}else if(布尔表达式4){
java语句;
}....
以上if语句的执行原理？
先判断“布尔表达式1”，如果“布尔表达式1”为true，则执行分支1，
然后if语句结束了。
当“布尔表达式1”结果是false，那么会继续判断布尔表达式2的结果，
如果布尔表达式2的结果是true，则执行分支2，然后整个if就结束了。

                    从上往下依次判断，主要看第一个true发生在哪个分支上。
第一个true对应的分支执行，只要一个分支执行，整个if结束。

第四种写法：
if(布尔表达式1){ // 分支1
java语句;
}else if(布尔表达式2){ // 分支2
java语句;
}else if(布尔表达式3){
java语句;
}else if(布尔表达式4){
java语句;
}else{
java语句; // 以上条件没有一个成立的。这个else就执行了。
}

        
注意：
1、对于if语句来说，在任何情况下只能有1个分支执行，不可能
存在2个或者更多个分支执行。if语句中只要有1个分支执行了，
整个if语句就结束了。（对于1个完整的if语句来说的。）

2、以上4种语法机制中，凡是带有else分支的，一定可以保证会有
一个分支执行。以上4种当中，第一种和第三种没有else分支，这样
的语句可能会导致最后一个分支都不执行。第二种和第四种肯定会有
1个分支执行。

            3、当分支当中“java语句;”只有1条，那么大括号{}可以省略，但为了
可读性，最好不要省略。（有的程序员在编写代码的时候，可能会故意
将大括号{}省略，你能看懂就行。）

            4、控制语句和控制语句之间是可以嵌套的，但是嵌套的时候大家最好
一个语句一个语句进行分析，不要冗杂在一起分析。
if(true){
//窍门：分析外面if语句的时候，里面的这个if语句可以看做是普通的一堆java代码。
if(true){
if(false){

}else{
....最终走这里了。
}
}else{

}
}else{

}

                if(){
// 窍门：分析外面if时，里面的for循环当做普通java代码来看。
for(){
if(){
for(){

}
}
}
}else{
while(){
if(){
for(){

}
}
}
}

*/
public class IfTest01{
public static void main(String[] args){

        // 定义一个布尔类型的变量，表示性别。
//boolean sex = true;
boolean sex = false;

        //业务：当sex为true时表示男，为false时表示女。
/*
if(sex == true){ // == 是关系运算符，不是赋值运算符，== 双等号是用来判断是否相等的。
System.out.println("男");
}else{
System.out.println("女");
}
*/

        // 改良。
sex = true;
if(sex){
System.out.println("男"); // 男
}else{
System.out.println("女");
}

        // 可以再进一步改良
// 可以使用三目运算符
sex = false;
System.out.println(sex ? "男" : "女"); // 女

        // 代码可以这样写吗？
// ()小括号当中最终取的值是sex变量的值。
// 而sex是布尔类型，所以这个可以通过。
sex = false;
if(sex = true){ // 以前sex不管是true还是false，走到这一行sex一定是true。
System.out.println("男"); // 男
}else{
// 虽然这种语法可以，但是会导致else分支永远不能执行。
System.out.println("女");
}

        int i = 100;
if(i == 100){
System.out.println("i是100"); // i是100
}

        /*
//错误: 不兼容的类型: int无法转换为boolean
if(i = 100){ // (i = 100)整体执行完之后是一个int类型，不是布尔类型。
System.out.println("i是100");
}
*/

        // 当分支中只有一条java语句的话，大括号可以省略。
if(sex) 
System.out.println("男"); // 男
else 
System.out.println("女");


// 判断以下程序会出现问题吗？会出什么问题？第几行代码报错？？？？
if(sex)
System.out.println("男"); // 男
System.out.println("HelloWorld!"); // HelloWorld!
/*
else // 这一行编译报错，因为else缺少if
System.out.println("女");
*/

    }
}

IfTest02.java

/*
业务要求：
1、从键盘上接收一个人的年龄。
2、年龄要求为[0-150]，其它值表示非法，需要提示非法信息。
3、根据人的年龄来动态的判断这个人属于生命的哪个阶段？
[0-5] 婴幼儿
[6-10] 少儿
[11-18] 少年
[19-35] 青年
[36-55] 中年
[56-150] 老年
4、请使用if语句完成以上的业务逻辑。
*/
public class IfTest02{
public static void main(String[] args){
java.util.Scanner s = new java.util.Scanner(System.in);
System.out.print("请输入年龄：");
int age = s.nextInt();
//System.out.println("测试以下，您输入的年龄是：" + age);
/*
if(age < 0 || age > 150){
System.out.println("对不起，年龄值不合法");
} else {
// 能够走到这个分支当中，说明年龄是合法的。
// 可以进一步使用嵌套的if语句进行判断。
//if(age >= 0 && age <= 5){}
// 当前先使用if嵌套的方式，当然，嵌套不是必须的。可以有其它写法。
//System.out.println("年龄值合法");
// 年龄值合法的情况下，继续判断年龄属于哪个阶段的！！！！
//if(age >= 0 && age <= 5){} // 这样写代码比较啰嗦了。
if(age <= 5){
System.out.println("婴幼儿");
} else if(age <= 10){
System.out.println("少儿");
} else if(age <= 18){
System.out.println("少年");
} else if(age <= 35){
System.out.println("青年");
} else if(age <= 55){
System.out.println("中年");
} else {
System.out.println("老年");
}
}
*/

        // 可以不嵌套吗？可以
/*
if(age < 0 || age > 150){
System.out.println("对不起，年龄值不合法");
} else if(age <= 5){
System.out.println("婴幼儿");
} else if(age <= 10){
System.out.println("少儿");
} else if(age <= 18){
System.out.println("少年");
} else if(age <= 35){
System.out.println("青年");
} else if(age <= 55){
System.out.println("中年");
} else {
System.out.println("老年");
}
*/

        // 进一步改良
String str = "老年"; // 字符串变量默认值是“老年”
if(age < 0 || age > 150){
System.out.println("对不起，年龄值不合法");
// 既然不合法，你就别让程序往下继续执行了，怎么终止程序执行
//return;
} 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 = "中年";
} 
System.out.println(str);

// 对于初学者来说可能代码会写成这样，这是正常的。
// 代码的经验需要一步一步的积累，慢慢的代码就会越来越漂亮了。
// 需要时间，需要积累代码经验。最好的代码是：最少的代码量，最高的效率。
/*
if(age >= 0 && age <= 5){

}else if(age >= 6 && age <= 10){

}else if.....
*/

    }
}
/*
运行结果：（例）
请输入年龄：17
少年
*/

IfTest03.java

/*
题目：
1、系统接收一个学生的考试成绩，根据考试成绩输出成绩的等级。

        2、等级：
优：[90~100]
良：[80~90) 
中：[70-80)
及格：[60~70)
不及格：[0-60)

        3、要求成绩是一个合法的数字，成绩必须在[0-100]之间，成绩可能带有小数。
*/
public class IfTest03{
public static void main(String[] args){
// 键盘扫描器对象
java.util.Scanner s = new java.util.Scanner(System.in);
System.out.print("请输入您的考试成绩：");
// 考试成绩带有小数
double score = s.nextDouble(); //程序到这里停下了，等待用户的输入。
// 判断考试成绩
String str = "优";
if(score < 0 || score > 100){
str = "成绩不合法!!!";
}else if(score < 60){
str = "不及格";
}else if(score < 70){
str = "及格";
}else if(score < 80){
str = "中";
}else if(score < 90){
str = "良";
}
System.out.println(str);
}
}
/*
运行结果：（例）
请输入您的考试成绩：88
良
*/

IfTest04.java

/*
题目：
业务：
从键盘上接收天气的信息：
1表示：雨天
0表示：晴天
同时从键盘上接收性别的信息：
1表示：男
0表示：女
业务要求：
当天气是雨天的时候：
男的：打一把大黑伞
女的：打一把小花伞
当天气是晴天的时候：
男的：直接走起，出去玩耍
女的：擦点防晒霜，出去玩耍

需要使用if语句以及嵌套的方式展现这个业务。

        可以在程序的开始，接收两个数据，一个数据是天气，一个数据是性别。
然后将这两个数据保存到变量中。
*/
public class IfTest04{
public static void main(String[] args){
// 接收用户键盘输入
java.util.Scanner s = new java.util.Scanner(System.in);
// 提示信息
System.out.print("请输入您的性别，输入1表示男，输入0表示女：");
// 程序停下来等待用户的输入
int gender = s.nextInt();
//System.out.println(gender);
// 提示信息
System.out.print("请输入当前的天气，1表示雨天，0表示晴天：");
// 等待用户的输入
int weather = s.nextInt();
// 开发要不断的进行测试，不要期望一次把程序写好。
//System.out.println(weather);
if(weather == 1){
//System.out.println("雨天");
if(gender == 1){
// 男
System.out.println("下雨了，小哥哥，出门的时候记得拿一把大黑伞哦！");
}else if(gender == 0){
// 女
System.out.println("下雨了，小姐姐，出门的时候记得带一把小花伞哦！");
}
}else if(weather == 0){
//System.out.println("晴天");
if(gender == 1){
// 男
System.out.println("外面的天气不错，老铁们出去玩耍吧！");
}else if(gender == 0){
// 女
System.out.println("外面的天气晴朗，小姐姐要保护好皮肤哦，擦点防晒霜！");
}
}
}
}
/*
运行结果：（例）
请输入您的性别，输入1表示男，输入0表示女：1
请输入当前的天气，1表示雨天，0表示晴天：0
外面的天气不错，老铁们出去玩耍吧！
*/

SwitchTest01.java

/*
switch语句：
1、switch语句也是选择语句，也可以叫做分支语句。
2、switch语句的语法格式

            switch(值){
case 值1:
java语句;
java语句;...
break;
case 值2:
java语句;
java语句;...
break;
case 值3:
java语句;
java语句;...
break;
default:
java语句;
}

            以上是一个完整的switch语句：
其中：break;语句不是必须的。default分支也不是必须的。

            switch语句支持的值有哪些？
支持int类型以及String类型。
但一定要注意JDK的版本，JDK8之前不支持String类型，只支持int。
在JDK8之后，switch语句开始支持字符串String类型。

                switch语句本质上是只支持int和String，但是byte,short,char也可以
使用在switch语句当中，因为byte short char可以进行自动类型转换。

                switch语句中“值”与“值1”、“值2”比较的时候会使用“==”进行比较。

        3、switch语句的执行原理
拿“值”与“值1”进行比较，如果相同，则执行该分支中的java语句，
然后遇到"break;"语句，switch语句就结束了。

            如果“值”与“值1”不相等，会继续拿“值”与“值2”进行比较，如果相同，
则执行该分支中的java语句，然后遇到break;语句，switch结束。

            注意：如果分支执行了，但是分支最后没有“break;”，此时会发生case
穿透现象。

            所有的case都没有匹配成功，那么最后default分支会执行。
*/
public class SwitchTest01{
public static void main(String[] args){

// 分析这个程序是否能够编译通过？
// switch只支持int和String类型。
// 错误: 不兼容的类型: 从long转换到int可能会有损失
/*
long x = 100L;
switch(x){

}
*/

        /*
long x = 100L;
switch((int)x){

}
*/

/*
byte b = 100;
switch(b){

}
*/

        /*
short s = 100;
switch(s){

}
*/

        /*
char c = 'a';
switch(c){

}
*/

        //switch也支持字符串String类型。
//switch("abc"){}

        // 写一个完整的switch语句
// 接收键盘输入，根据输入的数字来判断星期几。
// 0 星期日
// 1 星期一
// ....
// 假设输入的数字就是正确的。0到6
java.util.Scanner s = new java.util.Scanner(System.in);
System.out.print("请输入[0-6]的整数：");
int num = s.nextInt();

        /*
switch(num){
case 0:
System.out.println("星期日");
break;
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("星期六");
}
*/

        //case穿透现象
/*
switch(num){
case 0:
System.out.println("星期日");
break;
case 1:
System.out.println("星期一");
case 2:
System.out.println("星期二");
case 3:
System.out.println("星期三");
case 4:
System.out.println("星期四");
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
}
*/

        // 关于default语句，当所有的case都没有匹配上的时候，执行default语句。
/*
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;
default:
System.out.println("星期日");
}
*/

        // 关于case合并的问题
switch(num){
case 1: case 2: 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;
case 8:
System.out.println("星期六");
break;
default:
System.out.println("星期日");
}
}
}
/*
运行结果：（例）
请输入[0-6]的整数：5
星期三
*/

SwitchTest02.java

/*
题目：
1、系统接收一个学生的考试成绩，根据考试成绩输出成绩的等级。

        2、等级：
优：[90~100]
良：[80~90) 
中：[70-80)
及格：[60~70)
不及格：[0-60)

        3、要求成绩是一个合法的数字，成绩必须在[0-100]之间，成绩可能带有小数。

        必须使用switch语句来完成，你该怎么办？
*/
public class SwitchTest02{
public static void main(String[] args){
// 提示用户输入学生成绩
java.util.Scanner s = new java.util.Scanner(System.in);
System.out.print("请输入学生成绩：");
double score = s.nextDouble();
//System.out.println(score);
if(score < 0 || score > 100){
System.out.println("您输入的学生成绩不合法，再见！");
return; // 这个代码的执行，会让main结束。后面会讲。
}

        // 程序能够执行到这里说明成绩一定是合法的。
// grade的值可能是：0 1 2 3 4 5 6 7 8 9 10
// 0 1 2 3 4 5 不及格
// 6 及格
// 7 中
// 8 良
// 9 10 优

int grade = (int)(score / 10); // 95.5/10结果9.55，强转为int结果是9
String str = "不及格";
switch(grade){
case 10: case 9:
str = "优";
break;
case 8: 
str = "良";
break;
case 7:
str = "中";
break;
case 6:
str = "及格";
}
System.out.println("该学生的成绩等级为：" + str);
}
}
/*
运行结果：（例）
请输入学生成绩：95
该学生的成绩等级为：优
*/

WhileTest01.java

/*
while循环：
1、while循环的语法机制以及执行原理
语法机制：
while(布尔表达式){
循环体;
}
执行原理：
判断布尔表达式的结果，如果为true就执行循环体，
循环体结束之后，再次判断布尔表达式的结果，如果
还是true，继续执行循环体，直到布尔表达式结果
为false，while循环结束。

        2、while循环有没有可能循环次数为0次？
可能。
while循环的循环次数是：0~n次。
*/
public class WhileTest01{
public static void main(String[] args){
// 死循环
/*
while(true){
System.out.println("死循环");
}
*/

        // 本质上while循环和for循环原理是相同的。
/*
for(初始化表达式; 布尔表达式; 更新表达式){
循环体;
}

            初始化表达式;
while(布尔表达式){
循环体;
更新表达式;
}

            if switch属于分支语句属于选择语句。
for while do..while..这些都是循环语句。
可以正常互相嵌套。
*/
for(int i = 0; i < 10; i++){
System.out.println("i --->" + i);
}

/*
int i = 0;
while(i < 10){
System.out.println("i = " + i);
i++;
}
*/

        // for和while完全可以互换，只不过就是语法格式不一样。
for(int i = 0; i < 10; ){
i++;
System.out.println("i --->" + i); // 1 2 3 .. 9 10
}

        int i = 0;
while(i < 10){
i++;
System.out.println("i = " + i); // 1 2 3 .. 9 10
}
}
}
/*
运行结果：
i --->0
i --->1
i --->2
i --->3
i --->4
i --->5
i --->6
i --->7
i --->8
i --->9
i --->1
i --->2
i --->3
i --->4
i --->5
i --->6
i --->7
i --->8
i --->9
i --->10
i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9
i = 10
*/

 

  相关解决方案

代码迷 - 您身边的软件异常，代码异常，编程异常助手（发现，解决，分享）
Copyright © 2009-2013 DAIMAMI.COM. All rights reserved.