Java 基本语句介绍

一 输入与输出

1. 输出：

​ 1） 语句结构

   System.out.println("hello word");

​ 2） 输出与转义字符的使用

 System.out.println("姓名\t  性别\t籍贯\n唐执兴\t男\t山东");

输出结果 ：
    姓名	  性别	籍贯
    唐执兴	  男	     山东

2. 输入：

1）语法结构

public class input {
    public static void main(String [] args){
        // 输入
        Scanner myScanner = new Scanner(System.in);
       
        System.out.println("请输入名字");
        String name = myScanner.next();
        
        System.out.println("请输入年龄");
        int age = myScanner.nextInt();
        
        //char 类型写法略有不同
        char ch = myScanner.next().charAt(0);
        
        // 总结 ：1. 先调用Scanner 类  ：  import java.util.Scaaner;
        //       2.再写 Scanner myScanner = new Scanner(System.in);
        //       3.System 变量名 +  =  myScanner.next+ 数据类型 + （）
        //       4.注意根据所需变量的数据类型



    }
}

二 分支结构

一 if-else分支结构

1）单分支

//基本语法：
    if（条件表达式）{
    执行代码块;  (不限一条语句)
}
// 条件表达式为 true 执行;  否则不执行

2）双分支

//基本语法：
    if（条件表达式）{
    执行代码块1;  
}
     else{
         执行代码块2；
     }
    

3 ) 多分支

//基本语法：
      if（条件表达式1）{
    执行代码块1;  
}
     else if(条件表达式2){
          执行代码块2；
     }

   ......
       
     else{
         执行代码块n；
     } 
// 也可以没有最后的else
    
    

//分支结构案例：
     马保国的信用分
        Scanner myScanner = new Scanner(System.in);
        System.out.print("请输入马保国的信用分：");
        int score =myScanner.nextInt();
        if (score >=0 && score <= 100) {
            if (score == 100) {
                System.out.println("信用极好");

            } else if (score > 80 && score < 100) {
                System.out.println("信用优秀");
            } else if (score >= 60 && score <= 80) {
                System.out.println("信用良好");
            } else {
                System.out.println("马保国被揍了");
            }

        }
        else {
            System.out.println("马保国成神了");
        }

4）嵌套分支

 ~~~java
 //基本介绍： 在一个分支结构中又完整的嵌套了另外一个完整的分支结构，里面的分支结构称为内层分支，外面的叫做外层分支。 最好不要超过三层。
     
 基本语法：
     if（）{
     if (){
         // if else ......
     }
     else {
         // if else ......
     }
     
 }
 ~~~

//嵌套分支案例：
     Scanner myScanner = new Scanner(System.in);
        System.out.print("请输入你的比赛成绩：");
        int score =myScanner.nextInt();
        System.out.print("请输入你性别：");
        char gender =myScanner.next().charAt(0);
        if(score > 8){
            System.out.println("恭喜你进入决赛！");
            if(gender == '男'){
                System.out.println("你被分到了男子组！");
            }
            else{
                System.out.println("你被分到了女子组！");
            }
        }
        else{
            System.out.println("sorry你没有进入决赛！");
        }

二 switch 分支结构

1）switch 分支

// switch 语句结构
         switch（表达式）
        {
            case 常量1:
                语句一；
                break；
                ......
                ......
             case 常量n;
                 语句n;
         
            default:
                default语句块
                        break;
        }
  // *** 细节讨论
        //1.表达式数据类型 应和 case 后的常量类型一样 或者是 可以相互自动转换成相互比较的类型 例如int short char || String -> char
        //2.switch()表达式里面的返回值必须是（byte short int char String enum)
        //3.case 子句里面的值必须是常量
        //4.default 可以没有

// switch分支案例：
        Scanner myScanner = new Scanner(System.in);
        System.out.print("请输入月份：-");
        int month = myScanner.nextInt();
        switch(month){
            case 3:
            case 4:
            case 5:
                System.out.print("是春天");
                break;
            case 6:
            case 7:
            case 8:
                System.out.print("是夏天");
                break;
            case 9:
            case 10:
            case 11:
                System.out.print("是秋天");
                break;
            case 12:
            case 1:
            case 2:
                System.out.print("是冬天");
                break;

            default:
                System.out.print("是爱你的每一天");
        }

三 循环结构

1. for循环

// 语句结构：
        for(循环变量初始化;循环条件;循环变量迭代)
        {
            代码块；
        }
//执行顺序：循环变量初始化->循环条件->代码块->循环变量迭代->：循环变量初始化->循环条件(当不符合循环条件退出循环)-> ......
            
            // for 细节
        //  1.循环条件是返回一个布尔值的表达式
        //2.for循环的变量的初始化;变量迭代可以写到其他位置  ** 但是;不可以省略
        //        int i = 1;
        //        for (;i < 11;){
        //
        //            System.out.println("酷盖" + i);
        //            i++;
        //
        //        }
        //        // 当上面为假时进行下下面的操作
        //        System.out.println( i);  // 11

        // **  死循环
        //       for (;;){
        //        System.out.println("奶盖");
        //        }
        //3.循环标量初始化可以有多条初始化语句，但要求类型一样，并且中间要用逗号隔开,
        //      变量迭代也可以有多条迭代语句，中间用逗号隔开
         

// for循环控制习题
        // 1.打印1-100之间所有是9的倍数的整数，统计个数和总和
        int i =1;
        int count = 0;
        int sum = 0;
        for (i = 1;i < 101;i++)
        {
            if (i % 9 ==0)
            {

                count++;
                sum += i;
                System.out.println("i = " + i + " count = "+ count + " sum = " + sum);
                //最后i的值为恰好符合循环条件的值

            }

        }

        System.out.println("i = " + i + " count = "+ count + " sum = " + sum); 
               // count sum值不变 i变(i的值为恰好不符合循环条件的值)

2. while循环

// 语句结构
         循环变量初始化;
           while （循环条件）{
                  循环语句;
                循环变量迭代;
           }
// 1.while循环和for循环四要素相同，只是位置不同。
// 2.执行循序也相同

//while循环案例：
       输出40-200的偶数
        int i = 40;
        while (i < 201){
            if (i % 2 == 0)
            {
                System.out.println("偶数i= " + i);
            }
            i++;
        }

3. do while 循环

//  语句结构：
         循坏变量初始化；
        do{
            循环语句;
            循环变量迭代;


        }while(循环条件);  
//   1.执行顺序不同，先判断在执行   ** 至少执行一次
//   2.do while循环和for循环四要素相同，只是位置不同。

//1. 1 - 200 能被5整除不能被3整除
        int i = 1;
        int count = 0;
        do{
            if (i % 5 ==0 && i % 3 != 0)
            {
                count++;
                System.out.println("i = " + i + " count = "+ count);

            }
            i++;
        }while(i < 201);

 // 2.还钱
        char answer;
        do{

            System.out.println("旋风三连踢");
            System.out.println("松鼠还钱");
            System.out.println("是否还钱 Y/N");

            answer = myScanner.next().charAt(0);
            System.out.println("他的回答是" + answer);



        }while(answer != 'y');
        System.out.println("松鼠还钱了");
// 与别的循环想比，do while 先执行（在该程序中先揍再问有钱吗没有继续揍）

4. 多重循环控制 （重点）

//基本介绍：
    1.将一个循环放在另外一个循环体内，就形成了嵌套循环。其中for while do while 都可以当作外层循环和内层循环。 （一般使用两层，否则可读性不高。）
    2.嵌套循环就是把内层循环当作外层循环的循环体，当内层循环条件为false 在执行下一次外层循环    
 基本语法：
        for (1. int i = 0; 2. i < 4; 3.i++){
            for (4.int j = 0; 5.j < 3; 6.j++){
               7. System.out.println("j = " + j);
            }
        }
      // **  执行顺序 1-> 2(判断是否符合外循环条件，不符合结束循环)->4->5(判断是否符合内循环条件，不符合跳出内循环执行->3->1->2同上。若符合内循环条件)->7->6->4->5(直到内循环条件不符合跳入外循环)

 //嵌套循环习题
      //练习1   三个班，每班五人，输入每班成绩，输出总成绩，及格人数
        int i = 1;
        int j = 1;
        int count = 0;
        double totalSum = 0;
        for (j = 1;j < 4 ; j++) {  // 三个班循环三次
            double sum = 0;
            for (i = 1; i < 6; ++i) {    每班五人 循环输入五次
                System.out.println("请输入第"+ j+"个班级第" + i + "个人的成绩");  // 输入每班五个人成绩
                int score =  myScanner.nextInt();
                if (score > 6)
                   ++count;
                sum += i;

            }
            totalSum += sum;
            System.out.println("第"+j+"个班的总成绩 =" + sum + " 平均成绩 = " + sum / 5.0);

        }
        System.out.println(j+"个班的总成绩 = "+totalSum);
        System.out.println("及格的人数 = " + count);


        // 练习2. 99乘法表

        int i = 1;
        int j = 1;
        int result = 0;
        for (i = 1;i < 10;++i) {  // 打印九次
            for (j = 1; j <= i; ++j) { //每一行公式的个数恰好与行数相等
                result = i * j;
                System.out.print(i + "*" + j + " = " + result + "\t");
            } System.out.println(); // 换行


        }

// 经典例题
// 金字塔 与 空心金字塔
//化繁为简  分析：
//              个数                    空格
//    *      第一层  1                     4
//   ***     第二层  3                     3
//  *****    第三层  5   2 * 层数 -1        2    5-层数
// *******   第四层  7                     1
//*********  第五层  9                     0

        int i = 1; //i 代表层数
        int j = 1;
        System.out.println("请输入金字塔有多少层：");
        int n = myScanner.nextInt();


         for (i = 1;i<=n;i++ ) {
             for (int k = 1;k <= n - i;k++)     // 每层""个数  分析见上图
             {
                 System.out.print(" ");
             }
             for (j = 1; j <= 2 * i - 1; j++) {  // 每层*个数
                 System.out.print("*");
             }
             System.out.println();

         }


        // 空心金字塔
        // 化繁为简  个数
//    *      第一层  1
//   * *     第二层  3
//  *   *    第三层  5
// *     *   第四层  7
//*********  第五层  9

        int i = 1; //i 代表层数
        int j = 1;
        System.out.println("请输入金字塔有多少层：");
        int n = myScanner.nextInt();


        for (i = 1;i<=n;i++ ) {
            for (int k = 1;k <= n - i;k++)
            {
                System.out.print(" ");
            }
            for (j = 1; j <= 2 * i - 1; j++) {

                if (j == 1||j == 2*i-1 || i == n) {   //  ** 只输出每行第一个和最后一个 还有最后一行
                    System.out.print("*");
                }
                else {
                    System.out.print(" ");  // 其他情况输出空格
                }
            }
            System.out.println();

        }