java基本语法

1.标识符

标识符的使用：

凡是自己可以起名字的地方都叫标识符。

比如：类名、变量名、方法名、接口名、包名....

标识符的命名规则：

  • 由26个英文字母大小写，0-9，_或者$组成

  • 数字不可以开头

  • 不可以使用关键字和保留字，但能包含关键字和保留字

  • java中严格区分大小写，长度无限制

  • 标识符不能包含空格

java中的名称命名规范

  • 包名：多单词组成时，所有字母都小写：xxxyyyzzz

  • 类名、接口名：多单词组成时，所有单词的首字母有大写：XxxYyyZzz

  • 变量名、方法名：多单词组成时，第一个字母首字母小写第二个单词开始每个单词首字母大写：xxxYyyZzz

  • 常量名：所有字母都大写，多个单词组成时每个单词用下划线连接：XXX_YYY_ZZZ

2.变量

变量的使用：

  1. java定义变量的格式：数据类型 变量名 =变量值；

    1 //变量的定义
2 int age=12;
3 //变量的声明
4 int number;
5 //变量的赋值
6 number=200;

  2. 说明：

    • 变量必须先声明，再使用

    • 变量都定义在其作用域内，超出作用域变量失效

    • 同一个作用域内，不可以声明两个同名的变量

3.基本数据类型

一、按照数据类型划分

基本数据类型：

整型：byte \ short \ int \ long

浮点型：float \ double

字符型：char

布尔型：boolean

引用数据类型：

类（class）

接口（interface）

数组（array）

二、按照在类中声明的位置划分

成员变量 \ 局部变量

1.整型：byte（1字节=8bit） \ short（2字节） \ int（4字节） \ long（8字节）

  • byte范围：-128 ~ 127
1 byte b1=12;
2 byte b2=-128;
3 b2=128;//编译不通过

  • 声明long型变量，必须以“l”或“L”结尾

  • 通常，定义整型变量时使用int型
1 short s1=128;
2 int i1=1234;
3 long l1=283938474940l;

2.浮点型：float（4字节） \ double（8字节）

  • 浮点型，表示带小数点的数值

  • float表示数值的范围比long大

  • 定义float类型变量时，变量要以“f”或“F”结尾

  • 通常，定义浮点型变量时，使用double型
1 double d1=123.1;
2 float f1=12.3f;

3.字符型：char(1字符=2字节)

  • 定义char类型变量，通常使用一对' '，内部只能写一个字符

1 char c1='a';
2 char c2='ab';//编译不通过
3 char c3='1';
4 char c4='中';

  • 表示方式：1.声明一个字符 2.转义字符 3.直接使用unicode值来表示字符型常量

1 char c5='\n';//换行符
2 char c6='\t';//制表符
3 System.out.print("hello"+c5);
4 System.out.print("world"+c5);
5 /**输出效果
6   hello
7   world*/
8 char c7='\u0043';//使用unicode值
9 //输出结果  C

4.布尔型：boolean

  • 只能取两个值之一：1.true 2.false

1 boolean bb1=true;

  • 常常在条件判断、循环结构中使用

1 boolean isMarried=true;
2 if(isMarried){
3   System.out.println("你就不能参加单身party了，很遗憾！");
4 }else{
5   System.out.println("你可以多谈谈女朋友！");
6 }

三、基本数据类型之间的运算规则

前提：布尔型：boolean不包含在内。

1.自动类型提升：

结论：当容量小的数据类型变量与容量大的数据类型变量做运算时，结果自动提升为容量大的数据类型。

byte、char、short --> int --> long --> float--> double

注意：当byte、char、short做运算时，结果是int型

 1 byte b1=2;
 2 int i1=129;
 3 //编译不通过
 4 //byte b2=b1+i1;
 5 int i2=b1+i1;
 6 long l1=b1+i1;
 7 System.out.println(i2);//131
 8 
 9 float f=b1+i1;
10 System.out.println(f);//131.0
11 
12 short s1=123;
13 double d1=s1;
14 System.out.println(d1);//123.0
15 *************************************
16 char c1='a';//97
17 int i3=10;
18 int i4=c1+i3;
19 System.out.println(i4);//107
20 
21 short s2=10;
22 //char c2=c1+s2;//编译不通过
23 
24 byte b2=10;
25 //char c3=b2+c1;//编译不通过
26 
27 //short s4=b1+b2;//编译不通过

2.强制类型转换：自动类型提升运算的逆运算。

  • 需要使用强转符：（）

  • 注意点：强制类型转换，可能导致精度损失。

 1 double d1=12.9;
 2 //精度损失举例1
 3 int i1=(int)d1;//截断操作
 4 System.out.println(i1);//12
 5 
 6 //没有精度损失
 7 long l1=123;
 8 short s2=(short)l1;
 9 //精度损失举例2
10 int i2=128；
11 byte b=(byte)i2;
12 System.out.println(b);//-128

四、String类型变量的使用

1.String属于引用数据类型，翻译为：字符串

2.声明String类型变量时，使用一对“ ”

3.String可以和8中数据类型变量做运算，且运算只能是连接运算：+

4.运算结果仍然是String类型

1 String s1="a";
2 String s1=" ";
3 ****************************
4 int number=12;
5 String str="学号：";
6 String info=number+str;//+：连接运算
7 System.out.println(info);//学号：12
8 boolean b1=true;
9 String info1=info+b1;//+：连接运算

练习题1：

1 char c='a';
2 int num=10;
3 String str="hello";
4 System.out.println(c+num+str);//107hello
5 System.out.println(c+str+num);//ahello10
6 System.out.println(c+(num+str));//a10hello
7 System.out.println((c+num)+str);//107hello
8 System.out.println(str+num+c);//hello10a

练习题2：

1 //输出*  *
2 System.out.println("*  *");
3 System.out.println('*'+'\t' +'*');//93
4 System.out.println('*'+"\t" +'*');
5 System.out.println('*'+'\t' +"*");//51*
6 System.out.println('*'+('\t' +"*"));

4.运算符

一、算数运算符

+、-、*、/、%（前）++、（后）++、（前）--、（后）--

  • 取余运算：结果的符号与模数符号相同

  • 开发中，经常使用%来判断能否被除尽的情况

  • (前)++:先自增1，然后再运算

  • (后)++：先运算，后自增1

  • (前)--：先自减1，然后再运算

  • (后)--：先运算，后自减1

     1 // /:除法运算
 2 int num1=12;
 3 int num2=5;
 4 int result=num1/num2;
 5 System.out.println(result);//2
 6 
 7 int result2=num1/num2*num2;
 8 System.out.println(result2);//10
 9 
10 double result3=num1/num2;
11 System.out.println(result3);//2.0
12 
13 double result4=num1/num2+0.0;//2.0
14 double result5=num1/(num2+0.0);//2.4
15 double result6=(double)num1/mum2;//2.4
16 double result7=(double)(num1/num2);//2.0
17 
18 ****************************************
19   
20  //%:取余运算
21 int m1=12;
22 int n1=5;
23 System.out.println(m1%n1);
24 
25 int m1=-12;
26 int n1=5;
27 System.out.println(m1%n1);
28 
29 int m1=12;
30 int n1=-5;
31 System.out.println(m1%n1);
32 
33 int m1=-12;
34 int n1=-5;
35 System.out.println(m1%n1);
36 
37 *********************************
38   
39  //(前)++
40  //(后)++
41 int a1=10;
42 int b1=++a1;
43 System.out.println(a1 b1);//a1=11,b1=11
44 
45 int a2=10;
46 int b2=a2++;
47 System.out.println(a2 b2);//a2=11,b2=10
48 
49 int a3=10;
50 ++a3;
51 int b3=a3;//a3=11,b3=11
52 
53 //注意点：
54 short s1=10;
55 //s1=s1+1;//编译失败，1为int型
56 //s1=(short)(s1+1);//编译成功
57 s1++;//自增1不会改变变量本身的数据类型
58 
59 *****************************************
60  
61  //(前)--
62  //(后)--
63 int a4=10;
64 int b4=--a4;
65 System.out.println(a4 b4); // a4=9,b4=9
66 
67 int a4=10;
68 int b4=a4--;
69 System.out.println(a4 b4); // a4=9,b4=10

    练习题：随意给出一个三位数整数，打印显示它的个位数，十位数，百位数的值。

    例如：数字153的情况下：

    个位数：3

    十位数：5

    百位数：1

    1 int num=153;
2 int bai=num/100;
3 int shi=num%100/10;//int shi=num/10%10;
4 int ge=num%10;
5 System.out.println("百位为："+bai);
6 System.out.println("十位为："+shi);
7 System.out.println("个位为："+ge);

    二、赋值运算符

    =、+=、-=、*=、/=、%=

 1 //赋值符号：=
 2 int j1=10;
 3 int i1=10;
 4 
 5 int i2,j2;
 6 //连续赋值
 7 i2=j2=10;
 8 int i3=10,j3=20;
 9 
10 ************************
11   
12 int num1=10;
13 num1+=2;//num1=num1+2;
14 System.out.println(num1);//12
15 
16 int num2=12;
17 num2%=5;//num2=num2%5;
18 System.out.println(num2);//2
19 
20 short s1=10;
21 s1+=2;//不会改变变量本身的数据类型
22 System.out.println(s1);//12

  • 开发中，如果希望实现+2操作，有几种方法？(前提：int num=10;)

1 //方式一：num=num+2;
2 //方式二：num+=2;

  • 开发中，如果希望实现+1操作，有几种方法？(前提：int num=10;)

1 //方式一：num=num+1;
2 //方式二：num+=1;
3 //方式三：num++;

练习1：

1 int i=1;
2 i*=0.1;
3 System.out.println(i);//0
4 i++;
5 System.out.println(i);//1

练习2：

1 int m=2;
2 int n=3;
3 n*=m++;//n=n*m++;
4 System.out.println(m);//3
5 System.out.println(n);//6

练习3：

1 int n=10;
2 n+=(n++)+(++n);//n=n+(n++)+(++n);
3 System.out.println(n);//32

三、比较运算符

==、！=、<、>、<=、>=、instanceof

  • 比较运算符的结果是boolean类型

1 int i=10;
2 int j=20;
3 System.out.println(i==j);//false
4 System.out.println(i=j);//20
5 
6 boolean b1=true;
7 boolean b2=false;
8 System.out.println(b1==b2);//false
9 System.out.println(b2=b1);//true

四、逻辑运算符

&、|、！、&&、||、^

  • 逻辑运算符操作的都是boolean型变量

  • 区分&与&&

 1 boolean b1=false;
 2 int num1=10;
 3 if(b1&(num1++>0)){
 4   System.out.println("我现在在北京");
 5 }else{
 6    System.out.println("我现在在南京");
 7 }
 8  System.out.println(num1);//11
 9 
10 boolean b2=false;
11 int num2=10;
12 if(b2&&(num2++>0)){
13   System.out.println("我现在在北京");
14 }else{
15    System.out.println("我现在在南京");
16 }
17  System.out.println(num2);//10

相同点：1.&与&&的运算结果相同

2.当符号左边为true时，二者都会执行符号右边的运算

不同点：当符号左边为false时，&会继续执行符号右边的运算，&&不再执行符号右边的运算

开发中，推荐使用&&

  • 区分|与||

 1 boolean b3=true;
 2 int num3=10;
 3 if(b3|(num3++>0)){
 4   System.out.println("我现在在北京");
 5 }else{
 6    System.out.println("我现在在南京");
 7 }
 8  System.out.println(num3);//11
 9 
10 boolean b4=true;
11 int num4=10;
12 if(b4||(num4++>0)){
13   System.out.println("我现在在北京");
14 }else{
15    System.out.println("我现在在南京");
16 }
17  System.out.println(num4);//10

相同点：1.|与||的运算结果相同

2.当符号左边为false时，二者都会执行符号右边的运算

不同点：当符号左边为true时，|会继续执行符号右边的运算，||不再执行符号右边的运算

开发中，推荐使用||

五、位运算符

<<、>>、>>>、&、|、^、~

  • 位运算符操作的都是整型数据

  • <<：在一定范围内，每向左移1位，相当于*2；>>:在一定范围内，每向右移1位，相当于/2

面试题：最高效方式的计算2*8？

2<<3或8<<1

练习：交换两个变量的值

 1 int num1=10;
 2 int num2=20;
 3 //方式一：定义临时变量的方式
 4 int temp=num1;
 5 num1=num2;
 6 num1=temp;
 7 //方式二：
 8 num1=num1+num2;
 9 num2=num1-num2;
10 num1=num1-num2;
11 //方式三：使用位运算符
12 num1=num1^num2;
13 num2=num1^num2;
14 num1=num1^num2;

六、三元运算符

  • 结构：（条件表达式）？表达式1：表达式2

  • 条件表达式的结果为boolean类型

  • 根据条件表达式真或假，决定执行表达式1，还是表达式2

  • 如果表达式为true，执行表达式1

  • 如果表达式为false，执行表达式2

  • 表达式1和表达式2要求是一致的

  • 三元运算符可以嵌套使用

  • 凡是可以使用三元运算符的地方，都可以改写为if-else，反之不成立

  • 如果程序既可以使用三元运算符，又可以使用if-else，那么选择三元运算符。

 1 //获取两个整数的较大值
 2 int m=12;
 3 int n=5;
 4 int max=(m>n)?m:n;
 5  System.out.println(max);
 6 
 7 double num=(m>n)?2:1.0;
 8 //(m>n)?2:"n大";//编译错误
 9 
10 ******************************
11   
12  String maxStr=(m>n)?"m大":"n大";
13  System.out.println( maxStr);
14 
15 *******************************
16   
17  //获取三个数的最大值
18 int n1=12;
19 int n2=30;
20 int n3=-31;
21 int max1=(n1>n2)?n1:n2;
22 int max2=(max1>n3)?max1:n3;
23  System.out.println( max2);
24 int max3=(((n1>n2)?n1:n2)>n3)?((n1>n2)?n1:n2):n3;
25  System.out.println( max3);

5.程序流程控制

  • 顺序结构

  • 分支结构

  • 循环结构

一、分支结构

1.if-else结构

if-else三种结构：

  • 第一种：

if（条件表达式）{

执行表达式

}

1 int age=14;
2 if(age>18){
3   System.out.println("你可以喝酒了");
4 }
5 System.out.println("你还太小，不能喝酒");
  • 第二种：

if（条件表达式）{

执行表达式1

}else{

执行表达式2

}

1 int age=14;
2 if(age>18){
3   System.out.println("你可以看动作电影了");
4 }else{
5   System.out.println("你只能看动画片");
6 }
  • 第三种：

 

if（条件表达式）{

执行表达式1

}else{

执行表达式2

}else{

执行表达式3

}

.......

else{

执行表达式n

}

 1 if(age<0){
 2   System.out.println("你输入的数据非法");
 3 }else if(age<18){
 4   System.out.println("青少年时期");
 5 }else if(age<35){
 6   System.out.println("青壮年时期");
 7 }else if(age<60){
 8   System.out.println("中年时期");
 9 }else{
10   System.out.println("老年时期");
11 }

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

具体实现步骤：

1.导包：import java.util.Scanner；

2.Scanner的实例化：Scanner scan=new Scanner(System.in)；

3.调用Scanner类的相关方法，来获取指定类型的变量

1 Scanner scan=new Scanner(System.in);
2 int num=scan.nextInt();
3 System.out.println(num);
4 
5 Scanner scan=new Scanner(System.in);
6 String name=scan.next();
7 System.out.println(name);

练习1：

小黑打算买车： 如果他有500万就卖劳斯莱斯 如果他有200万就买马萨拉蒂；如果他有100万就买宝马；如果他有50万卡迪拉克；如果他有10万就买比亚迪； 如果他有5万就买五菱宏光；否则就扫个共享单车

  • 说明：else结构是可选的

  • 针对于条件表达式：

    • 如果多个条件表达式之间是“互斥”关系（或没有交集的关系），哪个判断和执行语句声明在上面还是下面，无所谓

    • 如果多个条件表达式之间有交集关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面

    • 如果多个条件表达式之间有包含关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了

 1 import java.util.Scanner;
 2 
 3 public class Text2 {
 4     public static void main(String[] args) {
 5         Scanner input=new Scanner(System.in);
 6         System.out.println("请输入你的钱数");
 7         int num=input.nextInt();
 8         if (num>=500){
 9             System.out.println("劳斯莱斯一辆");
10         }else if (num>=200){
11             System.out.println("玛莎拉蒂一辆");
12         }else if (num>=100){
13             System.out.println("宝马一辆");
14         }else if (num>=50){
15             System.out.println("凯迪拉克一辆");
16         }else if (num>=10){
17             System.out.println("比亚迪一辆");
18         }else if (num>=5){
19             System.out.println("五菱宏光一辆");
20         }else {
21             System.out.println("扫个共享单车");
22         }
23     }
24 }

练习2：

我家狗5岁了，5岁的狗相当于人类多大呢？其实，狗的前两年每一年相当于人类的10.5岁，之后每增加一年就增加四岁。那么5岁的狗相当于人类多少岁？10.5+10.5+4+4+4=33

1 int age=5;
2 if(age>=0&& age<=2){
3   System.out.println("相当于人的年龄"+age*10.5);
4 }else if(age>2){
5   System.out.println("相当于人的年龄"+(2*10.5+(age-2)*4));
6 }

练习3：如何获取一个随机数：10-99

  • 公式L[a,b] : ( int )( Math.random() * (b - a + 1 ) + a )

1 int value=(int)(Math.random()*90+10);

2.switch-case结构

格式：

switch(表达式){

case 常量1：

执行语句1；

//break；

case 常量2：

执行语句2；

//break；

.......

default;

执行语句n；

//break；

}

  • 说明

    • 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。当调用完执行语句后，仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。

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

    • switch结构中的表达式，只能是如下的6种数据类型之一：byte、short、int、char、枚举类型（JDK5.0新增）、String类型（JDK7.0新增）

    • case之后只声明常量，不能声明范围

    • break关键字是可选的

    • dafault：相当于if-else结构中的else，default结构之可选的，而且位置是灵活的。

  • 凡是可以使用switch-case的结构，都可以转换为if-else，反之，不成立。

  • 我们写分支结构时，当发现既可以使用switch-case，（同时switch中表达式的取值情况不太多），又可以使用if-else时，我们优先选择使用switch-case。原因：switch-case执行效率稍高。

 1 int num=2;
 2 switch(num){
 3   case 0:
 4     System.out.println("zero");
 5     break;
 6    case 1:
 7     System.out.println("one");
 8      break;
 9    case 2:
10     System.out.println("two");
11      break;
12   default:
13      System.out.println("other");
14 }

练习1：

使用switch实现输出学生的评分等级，A：100，B:99-90,C:89-80,D:79-70,E:69-60,F:60以下

 1 import java.util.Scanner;
 2 
 3 public class Text4 {
 4     public static void main(String[] args) {
 5         Scanner input=new Scanner(System.in);
 6         System.out.println("请输入你的成绩");
 7         int score=input.nextInt();
 8         switch (score/10){
 9             case 10:
10                 System.out.println("A");
11                 break;
12             case 9:
13                 System.out.println("B");
14                 break;
15             case 8:
16                 System.out.println("C");
17                 break;
18             case 7:
19                 System.out.println("D");
20                 break;
21             case 6:
22                 System.out.println("E");
23                 break;
24             default:
25                 System.out.println("F");
26                 break;
27         }
28     }
29 }

练习2：

从键盘输入2019年的“momth”和“day“，要求通过程序输出输入的日期为2019年的第几天

 1 Scanner input=new Scanner(System.in);
 2  System.out.println("请输入2019年的month");
 3 int month=input.nextInt();
 4  System.out.println("请输入2019年的day");
 5 int day=input.nextInt();
 6 int sumDays=0;
 7 switch(month){
 8   case 12:
 9      sumDays+=30;
10   case 11:
11      sumDays+=31;
12   case 10:
13      sumDays+=30;
14   case 9:
15      sumDays+=31;
16   case 8:
17      sumDays+=31;
18   case 7:
19      sumDays+=30;
20   case 6:
21      sumDays+=31;
22   case 5:
23      sumDays+=30;
24   case 4:
25      sumDays+=31;
26   case 3:
27      sumDays+=28;
28   case 2:
29      sumDays+=31;
30   case 1:
31     sumDays+=day;
32 }

练习3：

从键盘输入年、月、日，判断这一天是当年的第几天

注：判断一年是否是闰年的标准：

1）可以被4整除，但不可以被100整除

或

2）可以被400整除

 1 Scanner input=new Scanner(System.in);
 2 System.out.println("请输入year");
 3 int year=input.nextInt();
 4  System.out.println("请输入month");
 5 int month=input.nextInt();
 6  System.out.println("请输入day");
 7 int day=input.nextInt();
 8 int sumDays=0;
 9 switch(month){
10   case 12:
11      sumDays+=30;
12   case 11:
13      sumDays+=31;
14   case 10:
15      sumDays+=30;
16   case 9:
17      sumDays+=31;
18   case 8:
19      sumDays+=31;
20   case 7:
21      sumDays+=30;
22   case 6:
23      sumDays+=31;
24   case 5:
25      sumDays+=30;
26   case 4:
27      sumDays+=31;
28   case 3:
29  if((year%4==0 &&year %100!=0)||year%400==0){
30        sumDays+=29;
31     }else{
32        sumDays+=28;
33        }
34   case 2:
35      sumDays+=31;
36   case 1:
37     sumDays+=day;
38 }

二、循环结构

1.for循环

  • 循环结构的4个要素

①初始化条件

②循环条件 ------>是boolean类型

③循环体

④迭代条件

  • for循环的结构

for(①；②；④){

③

}

  • 执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ② - ③ - ④ - ...... -②

1 for(int i=1;i<=5;i++){
2    System.out.println("hello");
3 }

练习：

1 int num=1;
2 for(System.out.print('a');num<=3;System.out.print('c'),num++){
3   System.out.print('b');
4 }
5 //输出结果：abcbcbc

练习2：遍历100以内的偶数,输出所有偶数的和,输出偶数的个数

 1 int sum=0;
 2 int count=0;
 3 for(i=1;i<=100,i++){
 4   if(i%2==0){
 5     System.out.println(i);
 6     sum+=i;
 7     count++;
 8   }
 9 }
10 System.out.println(sum);//2550
11 System.out.println(count);//50

练习2：编写程序1-150，并在每一行打印一个值，另外在每个3的倍数行上打印”foo“，在每个5的倍数行上打印”biz”，在每个7的倍数行上打印“baz”

 1 for(i=1,i<=150;i++){
 2   System.out.print(i+" ");
 3   if(i%3==0){
 4     System.out.print("foo ");
 5   }
 6   if(i%5==0){
 7     System.out.print("biz ")
 8   }
 9   if(i%7==0){
10     System.out.print("baz ")
11   }
12    System.out.println();//换行
13 }

练习3：输入两个正整数m和n，求其最大公约数和最小公倍数。

 1 Scanner input=new Scanner(System.in);
 2  System.out.println("请输入第一个正整数：");
 3 int m=input.nextInt();
 4 System.out.println("请输入第二个正整数：");
 5 int n=input.nextInt();
 6 //获取最大公约数
 7 int min=(m<=n)?m:n;
 8 //遍历
 9 for(i=min;i>=1;i--){
10   if(m%i==0 && n%i==0){
11     System.out.println("最大公约数为："+i);
12     break;
13   }
14 }
15 //获取最小公倍数
16 int max=(m>n)?m:n;
17 for(int i=max;i<=m*n;i++){
18   if(i%m==0 && i%n==0){
19     System.out.println("最小公倍数为："+i);
20     break;
21   }
22 }

2.while循环

  • 循环结构的4个要素

①初始化条件

②循环条件 ------>是boolean类型

③循环体

④迭代条件

  • while循环的结构

    ①

    while（②）{

    ③；

    ④；

    }

  • 执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ..... -②

说明：

1.写while循环前往小心不要丢了迭代条件。一旦丢了，就可能导致死循环。

2.我们写程序要避免出现死循环。

3.for循环和while循环可以相互转换。

区别：for循环和while循环初始化条件作用范围不一样

1 //遍历100以内的所有偶数
2 int i=1;
3 while(i<=100){
4   if(i%2==0){
5      System.out.println(i);
6     }
7   i++;`
8 }

3.do-while循环

  • 循环结构的4个要素

①初始化条件

②循环条件 ------>是boolean类型

③循环体

④迭代条件

  • do-while循环结构：

①

do{

③；

④；

}while（②）；

  • 执行过程：① - ③ - ④ - ② - ③ - ④ - ② - .... -②

说明：

1.do-while循环至少会执行一次循环体

2.开发中，while和for使用较多，do-while循环使用较少

 1 //遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
 2 int i=1;
 3 int sum=0;
 4 int count=0;
 5 do{
 6   if(i%2==0){
 7     System.out.println(i);
 8     sum+=i;
 9     count++;
10   }
11   i++;
12 }while(i<=100);
13  System.out.println(sum);
14  System.out.println(count);

练习：从键盘输入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。

说明：

1.不在循环条件部分限制次数的结构：for( ; ; )或while(true)

2.结束循环有几种方式？

方式一：循环条件部分返回false

方式二：在循环体中，执行break

 1 Scanner input=new Scanner(System.in);
 2 int zs=0;
 3 int fs=0;
 4 for( ; ; )//while(true){
 5   int number=input.nextInt();
 6   if(number>0){
 7     zs++;
 8   }else if(number<0){
 9     fs++;
10   }else{
11     break;
12   }
13 }
14  System.out.println("输入的正数个数"+zs);
15 System.out.println("输入的负数个数"+fs);

4.嵌套循环

  • 嵌套循环：将一个循环结构声明在另一个循环结构的循环体中，就构成了嵌套循环

  • 外层循环：循环结构B

  • 内层循环：循环结构A

说明：

①内层循环遍历一遍，只相当于外层循环循环体执行了一次

②假设外层循环需要执行m次，内层循环需要执行n次，此时内层循环的循环体一共执行了m*n次

技巧：外层循环控制行数，内层循环控制列数

 1 //输出******
 2 for(int i=1;i<=6;i++){
 3   System.out.print("*");
 4 }
 5 
 6 /*
 7 ******
 8 ******
 9 ******
10 ******
11 */
12 for(int i=1;i<=4;i++){
13   for(j=1;j<=6;j++){
14     System.out.print("*");
15   }
16   System.out.println();
17 }
18 
19 /*     i(行数)   j(*的个数) 规律：i=j
20 *        1          1   
21 **       2          2
22 ***      3          3
23 ****     4          4
24 *****    5          5
25 */
26 for(int i=1;i<=5;i++){
27   for(int j=i;j<=i;j++){
28     System.out.print("*");
29   }
30    System.out.println();
31 }
32 
33 /*      i(行数)   j(*的个数) 规律：i+j=5  j=5-i;
34 ****       1        4
35 ***        2        3
36 **         3        2
37 *          4        1
38 */
39 for(int i=1;i<=4;i++){
40   for(int j=1;j<=5-i;j++){
41       System.out.print("*");
42   }
43   System.out.println();
44 }
45 
46 /*
47 *
48 **
49 ***
50 ****
51 *****
52 ****      
53 ***       
54 **         
55 *
56 */

练习1：九九乘法表

1 for(i=1;i<=9;i++){
2   for(j=1,j<=i,j++){
3      System.out.print(i+"*"+j+"="+i*j+"\t");
4   }
5   System.out.println();
6 }

练习2：100以内的所有质数

质数：素数，只能被1和他本身整除的自然数

从2开始，到这个数-1结束为止，都不能被这个数本身整除

 1 boolean isFlag=true;//表示i是否被j除尽过，一旦除尽，修改其值
 2 for(int i=2;i<=100,i++){//遍历100以内的自然数
 3   for(int j=2;j//j:被i去除
 4     if(i%j==0){
 5        isFlag=false;
 6     }
 7   }
 8  if(isFlag==true) {
 9    System.out.println(i);
10  }
11   //重置isFlag
12   isFlag=true;
13 }

优化代码

 1 boolean isFlag=true;//表示i是否被j除尽过，一旦除尽，修改其值
 2 //获取当前时间距离1970-01-01 00:00:00的毫秒数
 3 long start=System.currentTimeMillis();
 4 for(int i=2;i<=100,i++){//遍历100以内的自然数
 5   //优化二：对本身是质数的自然数是有效的
 6   for(int j=2;j<=Math.sqrt(i);j++){//j:被i去除
 7     if(i%j==0){
 8        isFlag=false;
 9       break;//优化一：只对本身非质数的自然数是有效的
10     }
11   }
12  if(isFlag==true) {
13    System.out.println(i);
14  }
15   //重置isFlag
16   isFlag=true;
17 }
18 //获取当前时间距离1970-01-01 00:00:00的毫秒数
19 long end =System.currentTimeMillis();
20  System.out.println("所花费的时间为"+(end-start));

练习3：一个数如果恰好等于它的因子之和，这个数就成为“完数”。例如6=1+2+3。

编程：找出1000以内的所有完数。（因子：除去这个数本身的其他约数）

 1 //int factor=0;
 2 for(int i=1;i<=1000;i++){
 3   int factor=0;
 4   for(int j=1;j){
 5     if(i%j==0){
 6       factor+=j;
 7     }
 8   }
 9   if(i==factor){
10     System.out.println(i);
11   }
12   //重置factor
13   //factor=0;
14 }

5.特殊关键字的使用

break和continue关键字的使用

1、适用范围

break：switch-case循环中使用，结束当前循环

continue：循环结构中使用，结束当次循环

相同点：关键字后不能声明执行语句

1 for(int i=1;i<=10;i++){
2   if(i%4==0){
3     //break;//123
4     continue;//123567910
5   }
6   System.out.print(i);
7 }

练习1：

 1 label:for(int i=1;i<=4;i++){
 2   for(int j=1;j<=10;j++){
 3     if(j%4==0){
 4    //break;//默认跳出包裹此关键字最近的一层循环123
 5      // continue;//123567910
 6      //break label;//结束指定标识的一层循环结构
 7 continue label;//结束指定标识的一层循环结构当次循环
 8     }
 9      System.out.print(i);
10   }
11    System.out.println();
12 }
Java系列

相关

Java系列之运算符

标签