语言基础第三四五天：运算符和分支结构(if/if...else) | 扫描仪sc、分支(if.else/swith.case)、循环(while/do.while)、循环结构、嵌套循环、数组

已于 2022-06-20 12:27:52 修改
阅读量271 收藏
点赞数
分类专栏： Java语言基础 文章标签： java
于 2022-01-06 16:57:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59404863/article/details/122348026
版权
本文详细介绍了Java的8种基本数据类型，变量的概念及赋值，以及运算符的使用，包括算术、关系、逻辑、赋值、字符串连接和条件运算。还涵盖了分支结构如if、if…else及switch…case的实例演示。
摘要由CSDN通过智能技术生成

​

语言基础第三天：

回顾：

0.Java的8种基本数据类型是什么？

8种基本数据类型包括: byte,short,int,long,float,double,boolean,char

  byte:字节型，用于存储整数的，占用1个字节，范围-128到127

*char:字符型，采用Unicode字符编码格式，存储单个字符，占用2个字节

*short:短整型，用于存储整数的，占用2个字节，范围-32768到32767

  int:最常用的整型，用于存储整数的，占用4个字节，范围-2^31到231-1

  long:长整型，用于存储较大的整数的，占用8个字节，范围-2^63到2^63-1

  float:单精度浮点型，用于存储小数的，占用4个字节，不能表示精确的值

  double:双精度浮点型，最常用的存储小数的类型，占用8个字节，不能表示精确的值

  boolean:布尔型，存储true或false，占用1个字节

1.变量：存数的

   int a;  int b,c;

   int a = 5;  int a; a=5;

   int b = a+10;  System.out.println(a);

   a = a+10; //在a本身基础之上增10

2.八种基本数据类型：byte,short,int,long,float,double,boolean,char

   - int：整型，4个字节，5,10,10000000...

   - long：长整型，8个字节，5L,100000000000000L...

   - double：浮点型，８个字节，3.14,54.0,5.678...

   - boolean：布尔型，1个字节，true,false

   - char：字符型，2个字节，'你','y','4','*'...

3.类型间的转换：

两种方式：自动/隐式、强制  (要转换成为的数据类型)变量

两点规则：
shorts1=5;
shorts2=6;
shorts3=(short)(s1+s2);

笔记：

1.运算符：运算的符号

(1)算术：+，-，*，/，%，++，

 - %:取模/取余，余数为0即为整除
 - ++/--：自增1/自减1，可在变量前也可在变量后
   - 单独使用时，在前在后都一样
   - 被使用时，在前在后不一样
     - a++的值为a--------(a--的值为a)
     - ++a的值为a+1------(--a的值为a-1)                    

 ```java
 //%的演示
 System.out.println(8%2); //0，商4余0----整除
 System.out.println(5%2); //1，商2余1
 System.out.println(2%8); //2，商0余2
 
 //++单独使用:
 int a=5,b=5;
 a++; //相当于a=a+1
 ++b; //相当于b=b+1
 System.out.println(a); //6
 System.out.println(b); //6
 
 //++被使用:
 int a=5,b=5;
 int c = a++; //1)保存a++的值5  2)a自增1变为6  3)将第1步保存的值5赋值给c--底层运算过程
 //---粗暴记法:a++的值为5，c就是5
 int d = ++b; //1)保存++b的值6  2)b自增1变为6  3)将第1步保存的值6赋值给d--底层运算过程
 //---粗暴记法:++b的值为6，d就是6
 System.out.println(a); //6
 System.out.println(b); //6
 System.out.println(c); //5
 System.out.println(d); //6
 
 //--单独使用:
 int a=5,b=5;
 a--; //相当于a=a-1
 --b; //相当于b=b-1
 System.out.println(a); //4
 System.out.println(b); //4
 
 //--被使用:
 int a=5,b=5;
 int c = a--; //a--的值为5，所以c的值为5
 int d = --b; //--b的值为4，所以d的值为4
 System.out.println(a); //4
 System.out.println(b); //4
 System.out.println(c); //5
 System.out.println(d); //4
 ```

(2)关系运算符：>，<，>=，<=，==，!

 - 关系运算的结果为boolean型，
    关系成立则为true，关系不成立则为false

 ```java
 int a=5,b=10,c=5;
 boolean b1 = a>b;
 System.out.println(b1);   //false
 System.out.println(c<b);  //true
 System.out.println(a>=c); //true
 System.out.println(a<=b); //true
 System.out.println(a==c); //true
 System.out.println(a!=c); //false
 
 System.out.println(a+c>b);  //false
 System.out.println(a%2==0); //false
 System.out.println(c++>5);  //false-------c自增1变为6
 System.out.println(c++>5);  //true--------c自增1变为7
 ```

(3)逻辑运算符：&&，||，!

&&：短路与(并且)，两边都为真则为真，见false则false

> 当第1个条件为false时，发生短路(后面的不执行了) 

||：短路或(或者)，有真则为真，见true则true

> 当第1个条件为true时，发生短路(后面的不执行了)

!：逻辑非(取反)，非真则假，非假则真




   int a=5,b=10,c=5;
     //&&的演示:
     boolean b1 = b>=a && b<c;
     System.out.println(b1);          //true&&false=false
     System.out.println(b<=c && b>a); //false&&true=false
     System.out.println(a==b && c>b); //false&&false=false
     System.out.println(b!=c && a<b); //true&&true=true
     int age = 25;
     System.out.println(age>=18 && age<=50); //看age是否在18到50之间
     
     //||的演示:
     System.out.println(b>=a || b<c); //true||false=true
     System.out.println(b<=c || b>a); //false||true=true
     System.out.println(b!=c || a<b); //true||true=true
     System.out.println(a==b || c>b); //false||false=false
     int score = 89;
     System.out.println(score<0 || score>100); //看score是否不合法
     
     //!的演示
     boolean b2 = !(a<b);
     System.out.println(b2);     //!true=false
     System.out.println(!(a>b)); //!false=true
     
     //短路的演示
     int a=5,b=10,c=5;
     boolean b3 = a>b && c++>2;
     System.out.println(b3); //false
     System.out.println(c);  //5，发生短路了
     
     boolean b4 = a<b || c++>2;
     System.out.println(b4); //true
     System.out.println(c);  //5，发生短路了

(4)赋值运算符：=，+=，-=，*=，/=，%

 简单赋值运算符：=

扩展赋值运算符：+=，-=，*=，/=，%=

> 注：扩展赋值自带强转功能


     int a = 5;
     a += 10; //相当于a=(int)(a+10)
     System.out.println(a); //15
     a *= 2; //相当于a=(int)(a*2)
     System.out.println(a); //30
     a /= 6; //相当于a=(int)(a/6)
     System.out.println(a); //5
     
     //小面试题:
     short s = 5;
     //s = s+10; //编译错误，需强转: s=(short)(s+10);
     s += 10; //相当于s=(short)(s+10)

(5)字符串连接：+

- 和 +：
- 若两边为数字，则做加法运算
- 若两边出现了字符串，则做字符串连接
- 任何类型与字符串相连，结果都会变为字符串类型----同化作用


     //字符串拼接演示
     int age = 38;
     System.out.println("age="); //age=
     System.out.println(age);    //38
     System.out.println("age="+age); //age=38
     System.out.println("我的年龄是"+age); //我的年龄是38
     System.out.println("我今年"+age+"岁了"); //我今年38岁了
     
     String name = "WKJ";
     System.out.println("name="+name); //name=WKJ
     System.out.println("大家好，我叫"+name); //大家好，我叫WKJ
     System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); //大家好，我叫WKJ，今年38岁了
     
     //同化作用演示
     System.out.println(10+20+30+""); //60---------String
     System.out.println(10+20+""+30); //3030-------String
     System.out.println(""+10+20+30); //102030-----String

(6)条件/三目：?:

语法：  boolean?数1:数2

执行过程：   注：整个表达式是有值的，它的值要么是?号后的数1，要么是:号后的数2

计算boolean的值：
- 若为true，则整个表达式的值为?号后的数1
- 若为false，则整个表达式的值为:号后的数2

     int num = 5;
     int flag = num>0?1:-1;
     System.out.println(flag); //1
     
     int a=8,b=55;
     int max = a>b?a:b;
     System.out.println("max="+max);

2.分支结构：基于条件执行某语句

(1)if结构：1条路

语法：
if(boolean){
	语句块
}   

执行过程：
判断boolean的值:
    若为true，则执行语句块1(if整个结束)
    若为false，则if直接结束



     //1)偶数的判断:
     int num = 5;  //带数(6,5)
     if(num%2==0){
         System.out.println(num+"是偶数");
     }
     System.out.println("继续执行...");
     
     //2)满500打8折:
     double price = 300.0; //消费金额  带数(600.0,300.0)
     if(price>=500){ //满500
         price *= 0.8; //打8折
     }
     System.out.println("最终结算金额为:"+price);
     
     //3)判断年龄是否在18到50之间，若满足则输出:"满足条件"
     int age = 88;  //带数(25,5,88)
     if(age>=18 && age<=50){
         System.out.println("年龄满足条件");
     }
     System.out.println("继续执行...");

(2)if…else结构：2条路

语法：
if(boolean){
	语句块1
}else{
	语句块2
}


执行过程：

判断boolean的值:
    若为true，则执行语句块1(整个结束)
    若为false，则执行语句块2(整个结束)
     - 说明：
       ​  语句块1和语句块2，必走其中之一------------2选1



    //1)偶数、奇数的判断:
     int num = 5;  //带数(6,5)
     if(num%2==0){
         System.out.println(num+"是偶数");
     }else{
         System.out.println(num+"是奇数");
     }
     System.out.println("继续执行...");
     
     //2)满500打8折，不满500打9折:
     double price = 300.0;  //带数(600.0,300.0)
     if(price>=500){ //满500
         price *= 0.8;
     }else{ //不满500
         price *= 0.9;
     }
     System.out.println("最终结算金额为:"+price);
     
     //3)判断成绩是否合法，合法则输出"该成绩合法"，否则输出"该成绩不合法":
     int score = 560; //带数(95,-90,560)
     if(score<0 || score>100){
         System.out.println("该成绩不合法");
     }else{
         System.out.println("该成绩合法");
     }
     System.out.println("继续执行...");

精华笔记：

  1. 运算符：运算的符号

    • 算术：+，-，*，/，%，++，–

    • 关系：>，<，>=，<=，==，!=

    • 逻辑：&&，||，！

    • 赋值：=，+=，-=，*=，/=，%=

    • 字符串连接：+

    • 条件/三目：?:

  2. 分支结构：基于条件执行某语句

    • if结构：1条路
    • if…else结构：2条路

补充：

  1. &为不短路与，|为不短路或
  2. 任何复杂的程序逻辑都可以通过三种结构来实现：
    • 顺序结构：从上往下逐行执行，每句必走
    • 分支结构：有条件的执行某语句，并非每句必走
    • 循环结构：明天讲

语言基础第三天作业：

  1. 运算符的练习：算术、关系、逻辑、赋值、字符串连接、条件运算符
  2. if的练习：
    • 偶数的判断
    • 满500打8折
    • 年龄在18到50之间
  3. if…else练习：
    • 偶数、奇数的判断
    • 满500打8折、不满500打9折
    • 成绩合法性判断

1、运算符的练习：算术、关系、逻辑、赋值、字符串连接、条件运算符。 完整代码：
//运算符的演示
public class OperDemo {
public static void main(String[] args) {
/*
1.算术运算符:+,-,*,/,%,++,–
1)%:取模/取余，余数为0即为整除
2)++/–:自增1/自减1，可在变量前也可在变量后
2.1)单独使用时，在前在后都一样
2.2)被使用时，在前在后不一样
a++的值为a----------(a–的值为a)
++a的值为a+1--------(–a的值为a-1)
/
/
System.out.println(5%2); //1，商2余1
System.out.println(8%2); //0，商4余0----整除
System.out.println(2%8); //2，商0余2
/
/
int a=5,b=5;
a++; //相当于a=a+1
++b; //相当于b=b+1
System.out.println(a); //6
System.out.println(b); //6
/
/
int a=5,b=5;
int c = a++; //1)将a++的值5赋值给c 2)a自增1变为6
int d = ++b; //1)将++b的值6赋值给d 2)b自增1变为6
System.out.println(a); //6
System.out.println(b); //6
System.out.println©; //5
System.out.println(d); //6
*/

       /*
       int a=5,b=5;
       a--; //相当于a=a-1
       --b; //相当于b=b-1
       System.out.println(a); //4
       System.out.println(b); //4
       */
       /*
       int a=5,b=5;
       int c = a--; //1)将a--的值5赋值给c  2)a自减1变为4
       int d = --b; //1)将--b的值4赋值为d  2)b自减1变为4
       System.out.println(a); //4
       System.out.println(b); //4
       System.out.println(c); //5
       System.out.println(d); //4
       */
       
       /*
         2.关系运算符:
           1)>(大于),<(小于)
             >=(大于或等于),<=(小于或等于)
             ==(等于),!=(不等于)
           2)关系运算的结果为boolean型，
             关系成立则为true，关系不成立则为false
        */
       /*
       int a=5,b=10,c=5;
       boolean b1 = b>a;
       System.out.println(b1);   //true
       System.out.println(c<b);  //true
       System.out.println(a>=c); //true
       System.out.println(b<=a); //false
       System.out.println(b==c); //false
       System.out.println(a!=c); //false

       System.out.println(a+c>10); //false
       System.out.println(b%2==0); //true
       System.out.println(c++>5);  //false------c自增1变为6
       System.out.println(c++>5);  //true-------c自增1变为7
       */
       
       /*
         3.逻辑运算符:
           1)&&:短路与(并且)，两边都为真则为真，见false则false
                ---当第1个条件为false时，则发生短路(后面的不执行了)
             ||:短路或(或者)，有真则为真，见true则true
             　　---当第1个条件为true时，则发生短路(后面的不执行了)
              !:逻辑非(取反)，非真则假，非假则真
           2)逻辑运算是建立在关系运算的基础之上的，
             逻辑运算的结果也是boolean型
        */
       /*
       boolean b1 = b>=a && b<c;
       System.out.println(b1);          //true&&false=false
       System.out.println(b<=c && b>a); //false&&true=false
       System.out.println(a==b && c>b); //false&&false=false
       System.out.println(b!=c && a<b); //true&&true=true

       System.out.println(b>=a || b<c); //true||false=true
       System.out.println(b<=c || b>a); //false||true=true
       System.out.println(b!=c || a<b); //true||true=true
       System.out.println(a==b || c>b); //false||false=false

       boolean b2 = !(a<b);
       System.out.println(b2);     //!true=false
       System.out.println(!(a>b)); //!false=true
       */
       /*
       int a=5,b=10,c=5;
       boolean b3 = a>b && c++>2;
       System.out.println(b3); //false
       System.out.println(c);  //5，发生短路了

       boolean b4 = a<b || c++>2;
       System.out.println(b4); //true
       System.out.println(c);  //5，发生短路了
       */
       
       /*
         4.赋值运算符:
           1)基本赋值运算符:=
           2)扩展赋值运算符:+=,-=,*=,/=,%=
             ---扩展赋值运算符自带强转功能
        */
       /*
       int a = 5;
       a += 10; //相当于a=(int)(a+10)
       System.out.println(a); //15
       a *= 2; //相当于a=(int)(a*2)
       System.out.println(a); //30
       a /= 6; //相当于a=(int)(a/6)
       System.out.println(a); //5
       
       short s = 5;
       //s = s+10; //编译错误，需强转，改为: s=(short)(s+10);
       s += 10; //相当于s=(short)(s+10)
       */
       
       /*
         5.字符串连接运算符:
           1)+:
             1.1)若两边为数字，则做加法运算
             1.2)若两边出现了字符串，则做字符串连接
        */
       /*
       int age = 38;
       System.out.println("age="); //age=
       System.out.println(age);    //38
       System.out.println("age="+age); //age=38
       System.out.println("我的年龄是"+age); //我的年龄是38
       System.out.println("我今年"+age+"岁了"); //我今年38岁了

       String name = "WKJ";
       System.out.println("name="+name); //name=WKJ
       System.out.println("大家好，我叫"+name); //大家好，我叫WKJ
       System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); //大家好，我叫WKJ，今年38岁了

       System.out.println(10+20+""+30); //3030---------String
       System.out.println(""+10+20+30); //102030-------String
       System.out.println(10+20+30+""); //60-----------String
       */
       
       /*
         6.条件/三目运算符:
           1)语法:
               boolean?数1:数2
           2)执行过程:
               整个条件运算的值，要么是?号后的数1，要么是:号后的数2
               计算boolean的值:
                 若为true，则整个条件运算的结果为?号后的数1
                 若为false，则整个条件运算的结果为:号后的数2
        */
       int num = 5;
       int flag = num>0?1:-1;
       System.out.println(flag); //1

       int a=8,b=5;
       int max = a>b?a:b;
       System.out.println("max="+max);
   }

}

2、if的练习：

  • 偶数的判断

  • 满500打8折

//if结构的演示
public class IfDemo {
public static void main(String[] args) {
//1)偶数的判断:
int num = 6; //带数(6,5)
if(num%2==0){
System.out.println(num+“是偶数”);
}
System.out.println(“继续执行…”);

         //2)满500打8折
         //带数(600.0,300.0)
         double price = 300.0; //消费金额
         if(price>=500){ //满500
             price*=0.8; //打8折
         }
         System.out.println("最终结算金额为:"+price);
     }
 }

3、if…else的练习：

  • 偶数、奇数的判断

  • 满500打8折，不满500打9折

//if…else结构的演示
public class IfElseDemo {
public static void main(String[] args) {
//1)偶数、奇数的判断:
int num = 5; //带数(6,5)
if(num%2==0){
System.out.println(num+“是偶数”);
}else{
System.out.println(num+“是奇数”);
}
System.out.println(“继续执行…”);

         //2)满500打8折，不满500打9折:
         double price = 300.0; //带数(600.0,300.0)
         if(price>=500){ //满500，打8折
             price*=0.8;
         }else{ //不满500，打9折
             price*=0.9;
         }
         System.out.println("最终结算金额为:"+price);
     }
 }

​

语言基础第四天：

在这里插入图片描述

回顾：

  1. 运算符：
    • 算术：+，-，*，/，%，++，–
    • 关系：>，<，>=，<=，==，!= boolean
    • 逻辑：&&，||，! boolean
    • 赋值：=，+=，-=，*=，/=，%=
    • 字符串连接：+
    • 条件/三目：boolean?数1:数2
  2. 分支结构：基于条件执行的语句
    • if结构：1条路
    • if…else结构：2条路

笔记：

1、Scanner接收用户输入的数据：共3步，不需要理解，先背下来

  • 在package下：

    ​ import java.util.Scanner;

  • 在main中：

    ​ Scanner scan = new Scanner(System.in);

  • 在第2步之下：

    ​ System.out.println(“请输入年龄:”);
    ​ int age = scan.nextInt();
    ​ System.out.println(“请输入商品价格:”);
    ​ double price = scan.nextDouble();

package day04;
   import java.util.Scanner; //1.导入一个扫描仪
   //Scanner的演示
   public class ScannerDemo {
       public static void main(String[] args) {
           Scanner scan = new Scanner(System.in); //2.新建一个扫描仪
           System.out.println("请输入年龄:");
           int age = scan.nextInt(); //3.扫描一个整数给age
           System.out.println("请输入商品价格:");
           double price = scan.nextDouble(); //3.扫描一个小数给price
           System.out.println("年龄为:"+age+"，价格为:"+price);
       }
   }

2、分支结构：

  • if…else if结构：多条路

    • 语法：

      if(boolean-1){
      语句块1
      }else if(boolean-2){
      语句块2
      }else if(boolean-3){
      语句块3
      }else{
      语句块4
      }

    • 执行过程：

      判断boolean-1，若为true则执行语句块1(结束)，若为false则
      再判断boolean-2，若为true则执行语句块2(结束)，若为false则
      再判断boolean-3，若为true则执行语句块3(结束)，若为false则 执行语句块4(结束)

    • 说明：

      语句块1/2/3/4，只能执行其中之一------------多选1

public class ScoreLevel {
         public static void main(String[] args) {
             Scanner scan = new Scanner(System.in);
             System.out.println("请输入成绩:");
             double score = scan.nextDouble();
     
             //带数(-25,888,95,85,65,45)
             if(score<0 || score>100){
                 System.out.println("成绩不合法");
             }else if(score>=90){ //合法
                 System.out.println("A-优秀");
             }else if(score>=80){
                 System.out.println("B-良好");
             }else if(score>=60){
                 System.out.println("C-中等");
             }else{
                 System.out.println("D-不及格");
             }
         }
     }

3、switch…case结构：多条路

  • 优点：效率高、结构清晰
  • 缺点：只能对整数判断相等
  • break：
    • 若case中有break：打印对应的case语句后，直接跳出switch
    • 若case没有break：从对应命令的case开始往下贯穿打印每一句话
default：可以写在switch中的任何地方；写不写都可以；
         若写了:在case没有匹配参数时会按顺序执行(此时不执行case，因为都未匹配成功先执行default再贯穿剩余case)；
              :在case匹配了参数时不会执行default
         若没写：会按顺序执行case匹配到的语句；若没有匹配的则全部执行
         
常见面试题：switch可以作用于什么类型的数据上
  ----byte,short,int,char,String,枚举类型

package ooday6.day04.switch0_0;
import java.util.Scanner;
/**
 * //命令解析程序
 * 创建commandBySwitch类 要求：接收用户输入的命令command(int),并输出
 * 
 * switch…case结构：多条路  只能对整数进行判断
 * 优点：效率高、结构清晰
 * 缺点：只能对整数判断相等
 *
 * break：
 * 若case中有break：打印对应的case语句后，直接跳出switch
 * 若case没有break：从对应命令的case开始往下贯穿打印每一句话
 *
 * default：可以写在switch中的任何地方；写不写都可以；
 *         若写了:在case没有匹配参数时会按顺序执行(此时不执行case，因为都未匹配成功先执行default再贯穿剩余case)；
 *              :在case匹配了参数时不会执行default
 *         若没写：会按顺序执行case匹配到的语句；若没有匹配的则全部执行
 */
public class CommandBySwitch {
    public static void main(String[] args) {


//        System.out.println("请选择功能：1.取款 2.存款 3.查询余额");//-----注意：要想打印这句话，需放在扫描数的上边。
//        Scanner scanner = new Scanner(System.in);
//        int command = scanner.nextInt();

//        System.out.println("请选择功能：1.取款 2.存款 3.查询余额 4.退卡操作");
//        int command = new Scanner(System.in).nextInt();
//        switch (command) { //byte,short,int,char,String,枚举类型
//            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("操作错误...");
//        }


        int num = 5;
        switch (num) {
            case 3:
                System.out.println("555");
            case 6:
                System.out.println("8888");
            default://default：可以写在switch中的任何地方；写不写都可以；
                // 若写了:在case没有匹配参数时会按顺序执行；
                //      :在case匹配了参数时不会执行default
                //若没写:会按顺序执行case匹配到的语句；若没有匹配的则全部执行
                System.out.println("11");
                //break;//若有break，直接跳出switch；若没有break，则贯穿执行全部输出语句
            case 0:
                System.out.println("22");
        }
    }
}

4、 循环：反复多次执行一段相同或相似的代码

循环三要素：

  • 循环变量的初始化

  • 循环的条件(以循环变量为基础)

  • 循环变量的改变(向着循环的结束变)

    循环变量：在整个循环过程中所反复改变的那个数

//跑3圈:
   循环变量:所跑圈数count
   1)int count=0;
   2)count<3
   3)count++;
     count=0/1/2/ 3时结束
   
                        圈数为0
   够3圈吗？ 不够  跑一圈  圈数为1
   够3圈吗？ 不够  跑一圈  圈数为2
   够3圈吗？ 不够  跑一圈  圈数为3
   够3圈吗？ 够了
   
   //打印机打印6份简历:
   循环变量:所打份数num
   1)int num=0;
   2)num<6
   3)num++;
     num=0/1/2/3/4/5/ 6时结束
                         份数为0
   够6份吗？ 不够  打印一份  份数为1
   够6份吗？ 不够  打印一份  份数为2
   够6份吗？ 不够  打印一份  份数为3
   够6份吗？ 不够  打印一份  份数为4
   够6份吗？ 不够  打印一份  份数为5
   够6份吗？ 不够  打印一份  份数为6
   够6份吗？ 够了

5、循环结构：

  • while结构：先判断后执行，有可能一次都不执行

    • 语法：

      while(boolean){
      语句块-------------反复执行的代码
      }

    • 执行过程：

      ​ 判断boolean的值，若为true则执行语句块，
      ​ 再判断boolean的值，若为true则再执行语句块，
      ​ 再判断boolean的值，若为true则再执行语句块，
      ​ 如此反复，直到boolean的值为false时，while循环结束

    • 代码演示：

//1)输出5次"行动是成功的阶梯":
       int times = 0;  //1)循环变量的初始化
       while(times<5){ //2)循环的条件
           System.out.println("行动是成功的阶梯");//反复干的事必须放在第三要素之前
           times++;    //3)循环变量的改变
       }
       System.out.println("继续执行...");
       
       /*
         执行过程:----带数
                       times=0
           true  输出  times=1
           true  输出  times=2
           true  输出  times=3
           true  输出  times=4
           true  输出  times=5
           false while循环结束
           输出继续执行...
        */
       
       //2)输出9的乘法表:
       int num = 1;     //3*9=27
       while(num<=9){
           System.out.println(num+"*9="+num*9);
           num++;  //num+=2;
       }
       System.out.println("继续执行...");

6、猜数字小游戏代码：

package day04;
import java.util.Random;
import java.util.Scanner;
/** 猜数字小游戏 */
public class Guessing {
    public static void main(String[] args) {
        /*
        int num = (int)(Math.random()*1000+1); //1到1000
        Math.random()--------------0.0到0.9999999999999999...
        *1000----------------------0.0到999.99999999999999...
        +1-------------------------1.0到1000.9999999999999...
        (int)----------------------1到1000
         */
        
        Scanner scanner = new Scanner(System.in);
//        int num = 250;//定死的数
        int num = (int)(Math.random()*1000+1);//1~1000的随机数
        System.out.println(num);//作弊 直接将生成的随机数显示在控制台
        
        System.out.println("猜吧");
        int guess = scanner.nextInt();
        while(guess!=num){
            if(guess>num){
                System.out.println("猜大了！继续猜");
            }else{
                System.out.println("猜小了！继续猜");
            }
            guess = scanner.nextInt();
        }
        System.out.println("猜对了");
    }
}

7、do…while结构：先执行后判断，至少执行一次

要素1与要素3相同时，首选do…while

语法：

   do{
      语句块
    }while(boolean);

执行过程：
先执行语句块，再判断boolean的值，若为true则
再执行语句块，再判断boolean的值，若为true则
再执行语句块，再判断boolean的值，若为true则
再执行语句块，如此反复，直到boolean的值为false，则 do…while结束

猜数字小游戏代码：

public class Guessing {
           public static void main(String[] args) {
               Scanner scan = new Scanner(System.in);
               int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
               System.out.println(num); //作弊
       
               //假设num=250
               //300(大),200(小),250(对)
               int guess;
               do{
                   System.out.println("猜吧!");
                   guess = scan.nextInt(); //1+3
                   if(guess>num){
                       System.out.println("太大了");
                   }else if(guess<num){
                       System.out.println("太小了");
                   }else{
                       System.out.println("恭喜你猜对了");
                   }
               }while(guess!=num); //2
           }
       }

补充：

  1. 变量的作用域/范围：

    • 从变量的声明开始，到包含它最近的大括号结束

  2. 生成随机数：

    int num = (int)(Math.random()*1000+1); //1到1000

Math.random()--------------0.0到0.9999999999999999...
*1000----------------------0.0到999.99999999999999...
+1-------------------------1.0到1000.9999999999999...
(int)----------------------1到1000

  3. 任何复杂的程序逻辑都可以通过三种结构来实现：

    • 顺序结构：从上往下逐行执行，每句必走

    • 分支结构：有条件的执行某语句一次，并非每句必走

    • 循环结构：有条件的执行某语句多次，并非每句必走

精华笔记：

  1. Scanner接收用户输入的数据：共3步，不需要理解，先背下来

  2. 分支结构：

    • if…else if结构：多条路

    • switch…case结构：多条路

      优点：效率高、结构清晰

      缺点：只能对整数判断相等

      break：跳出switch

      常见面试题：switch可以作用于什么类型的数据上

      -------------------------byte,short,int,char,String,枚举类型

  3. 循环：反复多次执行一段相同或相似的代码

  4. 循环三要素：

    • 循环变量的初始化

    • 循环的条件(以循环变量为基础)

    • 循环变量的改变(向着循环的结束变)

      循环变量：在整个循环过程中所反复改变的那个数

  5. 循环结构：

    • while结构：先判断后执行，有可能一次都不执行

    • do…while结构：先执行后判断，至少执行一次

      要素1与要素3相同时，首选do…while

语言基础第四天作业：

1、ScoreLevel成绩等级判断
2、CommandBySwitch命令解析程序
3、Guessing猜数字之while版
4、Guessing猜数字之do…while版

1、ScoreLevel成绩等级判断。完整代码：

package day04;
import java.util.Scanner;
//成绩等级判断
public class ScoreLevel {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入成绩:");
        double score = scan.nextDouble();

        //带数(888,-45,95,85,65,45)
        if(score<0 || score>100){
            System.out.println("成绩不合法");
        }else if(score>=90){ //合法
            System.out.println("A-优秀");
        }else if(score>=80){
            System.out.println("B-良好");
        }else if(score>=60){
            System.out.println("C-中等");
        }else{
            System.out.println("D-不及格");
        }

    }
}

2、CommandBySwitch命令解析程序。完整代码：

package day04;
import java.util.Scanner;
//命令解析程序
public class CommandBySwitch {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请选择功能: 1.取款  2.存款  3.查询余额  0.退卡");
        int command = scan.nextInt();

        switch(command){
            case 1:
                System.out.println("取款操作...");
                break;
            case 2:
                System.out.println("存款操作...");
                break;
            case 3:
                System.out.println("查询余额操作...");
                break;
            case 0:
                System.out.println("退出成功");
                break;
            default:
                System.out.println("输入错误");
        }
    }
}

3、Guessing猜数字之while版。完整代码：

package day04;
import java.util.Random;
import java.util.Scanner;
/** 猜数字小游戏 */
public class Guessing {
    public static void main(String[] args) {
        /*
        int num = (int)(Math.random()*1000+1); //1到1000
        Math.random()--------------0.0到0.9999999999999999...
        *1000----------------------0.0到999.99999999999999...
        +1-------------------------1.0到1000.9999999999999...
        (int)----------------------1到1000
         */
        
        Scanner scanner = new Scanner(System.in);
//        int num = 250;//定死的数
        int num = (int)(Math.random()*1000+1);//1~1000的随机数
        System.out.println(num);//作弊 直接将生成的随机数显示在控制台
        
        System.out.println("猜吧");
        int guess = scanner.nextInt();
        while(guess!=num){
            if(guess>num){
                System.out.println("猜大了！继续猜");
            }else{
                System.out.println("猜小了！继续猜");
            }
            guess = scanner.nextInt();
        }
        System.out.println("猜对了");
    }
}

4、Guessing猜数字之do…while版。。完整代码:

package day04;
import java.util.Scanner;
//猜数字小游戏
public class Guessing {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = (int)(Math.random()*1000+1); //1到1000之内
        System.out.println(num); //作弊

        //假设num=250
        //300(大),200(小),250(对)
        int guess;
        do{
            System.out.println("猜吧!");
            guess = scan.nextInt(); //1+3
            if(guess>num){
                System.out.println("太大了");
            }else if(guess<num){
                System.out.println("太小了");
            }else{
                System.out.println("恭喜你猜对了");
            }
        }while(guess!=num); //2
    }
}

语言基础第五天：

在这里插入图片描述

回顾：

  1. Scanner接收用户的数据：共3步

  2. 分支结构：

    • if…else if结构：多条路

    • switch…case结构：多条路

      优点：效率高、结构清晰

      缺点：只能对整数判断相等

      break：跳出switch

  3. 循环：反复多次执行一段相同或相似的代码

  4. 循环三要素：

    • 循环变量的初始化

    • 循环的条件(以循环变量为基础)

    • 循环变量的改变(向着循环的结束变)

      循环变量：在整个循环过程中所反复改变的那个数

  5. 循环结构：

    • while结构：先判断后执行，有可能一次都不执行

    • do…while结构：先执行后判断，至少执行一次

      要素1与要素3相同时，首选do…while

笔记：

  1. 循环结构：

    • for结构：应用率高、与次数相关的循环

      • 语法：

        ​ // 1 2 3

        ​ for(要素1;要素2;要素3){

        ​ 语句块/循环体----------------反复执行的代码 4

        ​ }

      • 执行过程：

        ​ 1243243243243243243…2

      • 代码演示：

        //for循环中的循环变量i，作用域仅在当前for中
for(int i=1;i<=9;i++){
    System.out.println(i+"*9="+i*9);
}
for(int i=1;i<=9;i+=2){
    System.out.println(i+"*9="+i*9);
}
for(int i=9;i>=1;i--){
    System.out.println(i+"*9="+i*9);
}

for(int times=0;times<5;times++){
    System.out.println("行动是成功的阶梯");
}
System.out.println("继续执行...");
/*
执行过程:
times=0  true  输出
    times=1  true  输出
    times=2  true  输出
    times=3  true  输出
    times=4  true  输出
    times=5  false for循环结束
    输出继续执行...
*/

//for的特殊格式:----------了解
int i=1;
for(;i<=9;i++){	//可以把上边那句省略，此行变为： for(int i=1;i<=9;i++)
    System.out.println(i+"*9="+i*9);
}
for(int i=1;i<=9;){
    System.out.println(i+"*9="+i*9);
    i++;
}
for(;;){ //没有条件的循环就是一个死循环
    System.out.println("我要学习...");
}

for(int i=1,j=5;i<=5;i+=2,j-=2){
}
/*
  i=1,j=5  true
  i=3,j=3  true
  i=5,j=1  true
  i=7,j=-1 false
 */

  2. 三种循环结构的选择规则：

    • 先看循环是否与次数相关：
      • 若相关----------------------------直接上for
      • 若无关，再看要素1与要素3是否相同：
        • 若相同------------------------直接上do…while
        • 若不同------------------------直接上while

  3. break：跳出循环

    for(int i=1;i<=9;i++){
    if(i==4){ //在某种特定条件下，提前结束循环
        break;
    }
    System.out.println(i+"*9="+i*9);
}
/* 
  i=1  true  1*9=9
  i=2  true  2*9=18
  i=3  true  3*9=27
  i=4  true
*/

    continue：跳过循环体中剩余语句而进入下一次循环

    //输出9的乘法表，只要不能被3整除的
for(int i=1;i<=9;i++){
    if(i%3!=0){
        System.out.println(i+"*9="+i*9);
    }
}


//输出9的乘法表，跳过能被3整除的
for(int i=1;i<=9;i++){
    if(i%3==0){
        continue; //跳过循环体中剩余语句而进入下一次循环
    }
    System.out.println(i+"*9="+i*9);
}
/*
    i=1  1*9=9
    i=2  2*9=18
    i=3
    i=4  4*9=36
    i=5  5*9=45
    i=6
    i=7  7*9=63
    i=8  8*9=72
    i=9
    i=10
*/

  4. 随机加法运算器案例：

    package day05;
import java.util.Scanner;
//随机加法运算器
public class Addition {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int score = 0; //总分
        for(int i=1;i<=10;i++) { //10次
            int a = (int)(Math.random()*100); //加数a，0到99之间
            int b = (int)(Math.random()*100); //加数b
            int result = a+b; //存正确答案
            System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题

            System.out.println("算吧!----输入-1可提前结束");
            int answer = scan.nextInt(); //2)答题

            if(answer==-1){ //3)判题
                break;
            }
            if(answer==result){
                System.out.println("答对了");
                score += 10; //答对1题，加10分
            }else{
                System.out.println("答错了");
            }
        }
        System.out.println("总分为:"+score);
    }
}

  5. 嵌套循环：

    • 循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
    • 执行过程：外层循环走一次，内层循环走所有次
    • 建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层，若业务必须通过三层以上的循环才能解决，说明你的设计有问题
    • break只能跳出当前一层循环
    for(int num=1;num<=9;num++){ //控制行
    for(int i=1;i<=num;i++){ //控制列
        System.out.print(i+"*"+num+"="+i*num+"\t");
    }
    System.out.println(); //换行
}
/*
  执行过程:
    num=3
      i=1  1*3=3
      i=2  2*3=6
      i=3  3*3=9
      i=4  false
      换行
    num=2
      i=1  1*2=2
      i=2  2*2=4
      i=3  false
      换行
    num=1
      i=1  1*1=1
      i=2  false
      换行
 */

  6. 数组：

    • 是一种数据类型(引用类型)

    • 相同数据类型元素的集合

    • 定义：

      //声明int型数组arr，包含10个元素，每个元素都是int型，默认值为0
int[] arr = new int[10];

    • 初始化：给数组中的元素做初始化

      int[] arr = new int[3]; //0,0,0
int[] arr = {1,4,7}; //1,4,7
int[] arr = new int[]{1,4,7}; //1,4,7
int[] arr;
//arr = {1,4,7}; //编译错误
 int[] arr2;
arr2 = new int[]{1,4,7}; //正确

    • 访问：访问的是数组中的元素

      • 通过(数组名.length)可以获取数组的长度(元素的个数)

        int[] arr = new int[3];
System.out.println(arr.length); //3

      • 通过下标/索引来访问数组中的元素

        下标从0开始，最大到(数组的长度-1)

        int[] arr = new int[3];
arr[0] = 100; //给第1个元素赋值为100
arr[1] = 200; //给第2个元素赋值为200
arr[2] = 300; //给第3个元素赋值为300
System.out.println(arr[arr.length-1]); //输出最后一个元素的值

    • 遍历/迭代：从头到尾挨个走一遍

      int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ //遍历arr数组
    //arr[i]代表arr中的每一个元素
    //给每个元素赋值为0到99之间的随机数
    arr[i] = (int)(Math.random()*100); 
    System.out.println(arr[i]); //输出每个元素的值
}

精华笔记：

  1. 循环结构：

    • for结构：应用率高、与次数相关的循环

  2. 三种循环结构的选择规则：

    • 先看循环是否与次数相关：
      • 若相关----------------------------直接上for
      • 若无关，再看要素1与要素3是否相同：
        • 若相同------------------------直接上do…while
        • 若不同------------------------直接上while

  3. break：跳出循环

    continue：跳过循环体中剩余语句而进入下一次循环

  4. 嵌套循环：

    • 循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
    • 执行过程：外层循环走一次，内层循环走所有次
    • 建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层，若业务必须通过三层以上的循环才能解决，说明你的设计有问题
    • break只能跳出当前一层循环

  5. 数组：

    • 是一种数据类型(引用类型)

    • 相同数据类型元素的集合

    • 定义：

    • 初始化：给数组中的元素做初始化

    • 访问：访问的是数组中的元素

      • 通过(数组名.length)可以获取数组的长度(元素的个数)

      • 通过下标/索引来访问数组中的元素

        下标从0开始，最大到(数组的长度-1)

    • 遍历/迭代：从头到尾挨个走一遍

补充：

  1. 变量的同名问题：
    • 作用域重叠时，变量不能同名的
  2. \t：水平制表位，固定占8位
  3. ArrayIndexOutOfBoundsException数组下标越界异常
    • 数组下标范围为0到(数组长度-1)，超出范围则发生如上的异常

语言基础第五天作业：

1、Addition随机加法运算器
2、MultiTable九九乘法表
3、数组小代码：声明、初始化、访问、遍历

1、Addition随机加法运算器。完整代码：

package day05;
import java.util.Scanner;
//随机加法运算器
public class Addition {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int score = 0; //得分
        for(int i=1;i<=10;i++){ //10次    (1)25+36=?
            int a = (int)(Math.random()*100); //加数a(0到99的随机数)
            int b = (int)(Math.random()*100); //加数b(0到99的随机数)
            int result = a+b; //存正确答案
            System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题
            System.out.println("算吧!");
            int answer = scan.nextInt(); //2)答题
            if(answer==-1){ //3)判题
                break;
            }
            if(answer==result){
                System.out.println("答对了");
                score+=10; //答对1题加10分
            }else{
                System.out.println("答错了");
            }
        }
        System.out.println("总分为:"+score);
    }
}

2、MultiType九九乘法表。完整代码：

package day05;
//九九乘法表
public class MultiTable {
    public static void main(String[] args) {
        for(int num=1;num<=9;num++){ //控制行
            for(int i=1;i<=num;i++){ //控制列
                System.out.print(i+"*"+num+"="+i*num+"\t");
            }
            System.out.println(); //换行
        }

		 /*
         int num = 9;//----1/2/3/4/5/6/7/8/9
         for (int i=1;i<=num;i++) {
             System.out.print(i+"*"+num+"="+i*num+"\t");
         }

        执行过程：
        num=1:  1*1=1
        num=2:  1*2=2	2*2=4
        num=3:  1*3=3	2*3=6	3*3=9
        num=4:  1*4=4	2*4=8	3*4=12	4*4=16
        num=5:  1*5=5	2*5=10	3*5=15	4*5=20	5*5=25
           .
           .
           .
        num=9:  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
         */
    }
}

3、数组小代码练习：声明、初始化、访问、遍历。 完整代码：

package day05;
//数组的演示
public class ArrayDemo {
    public static void main(String[] args) {
        /*
        //1)数组的定义:
        //声明整型数组arr，包含10个元素，每个元素都是int型，默认值为0
        int[] arr = new int[10];

        //2)数组的初始化:--初始化的是数组中的数据
        int[] arr1 = new int[3]; //0,0,0
        int[] arr2 = {2,5,8}; //2,5,8
        int[] arr3 = new int[]{2,5,8}; //2,5,8
        int[] arr4;
        //arr4 = {2,5,8}; //编译错误，此方式只能声明同时初始化
        arr4 = new int[]{2,5,8}; //正确
        */
        
        /*
        //3)数组的访问:--访问的是数组中的数据
        int[] arr = new int[3];
        System.out.println(arr.length); //3，输出arr的长度
        arr[0] = 100; //给arr中第1个元素赋值为100
        arr[1] = 200; //给arr中第2个元素赋值为200
        arr[2] = 300; //给arr中第3个元素赋值为300
        //arr[3] = 400; //运行时发生ArrayIndexOutOfBoundsException数组下标越界异常
        System.out.println(arr[arr.length-1]); //输出最后一个元素的值
        */

        //4)数组的遍历:
        int[] arr = new int[10];
        for(int i=0;i<arr.length;i++){ //遍历arr数组
            arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99的随机数
            System.out.println(arr[i]); //输出每个元素的值
        }
    }
}

***常见面试题：

面试题1、2、3：

		//面试题1：
        System.out.println("is"+20+3);//is 203    从左往右碰到字符串参与 后面都为字符模式
        System.out.println(20+3+" is");//23 is   从左往右先算加法23
        System.out.println("is "+(20+3));//is 23  从左往右，但是先算括号里边的
        
        //面试题2：
        int result = 0;
        int i = 2;
        switch(i){
            case 1:
                result = result+i;
            case 2:
                result = result+i*2;
            case 3:
                result = result+i*3;
        }
        System.out.println(result);//10
        
        //面试题3：
        ①do...while先执行再判断
        int a=0,b=0;
        do{
            --b;    //b-1=0-1=-1
            a--;    //a-1=0-1=-1
        }while(a>0);
        System.out.println(b);//-1
        ②先判断再执行...
        int a=0,b=0;
        while(a>0){
            --b;
            a--;
        }
        System.out.println(b);

        面试题3:
        int a=0,b=0;
        do{
            a--;    //a-1=0-1=-1
            --b;    //b-1=0-1=-1
        }while(a>0);
        System.out.println(a);//-1   a--;表达式： a先输出(输出本身的值0)，再自减1(0-1等于-1)，最后输出为-1
        System.out.println(b);//-1   --b;表达式： b先自减1(本身为0,0-1等于-1)，再输出为-1
pingpang砰砰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值