第02章–Java基本语法

第02章--Java基本语法

2.1 关键字和保留字


关键字

​ 定义:被Java语言赋予了特殊含义,用作专门用途的字符串

​ 特点:关键字的所有字母都为小写

保留字

​ 定义:现有Java版本尚未使用,但是之后版本可能会作为关键字。

​ goto、const


2.2 标识符


标识符

​ Java对各种变量方法等要素命名时使用的字符序列成为标识符

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

合法命名:

  • 有26个英文字母大小写、0-9、 _ 和 $ 组成
  • 数字不可以开头
  • 不可以使用关键字和保留字,但是可以包含关键字和保留字
  • Java严格区分大小写,长度无限制
  • 标识符不能含有空格

规范命名

  • 包名:所有单词均为小写 xxxyyyzzz
  • 类名、接口名:所有单词首字母大写 XxxYyyZzz
  • 变量名、方法名:第一个单词首字母小写,剩下单词首字母大写 xxxYyyZzz
  • 常量名:所有字母大写,多个单词时用下划线连接 XXX_YYY_ZZZ注意:见名知意、不用汉字

2.3 变量


变量

​ 内存中的一个存储区域

​ 该区域的数据可以在同一类型范围内不断变化

​ 变量时程序中最基本的存储单元:变量类型、变量名、变量值

说明:

  • Java中的变量必须先声明,后使用
  • 使用变量名来访问这块区域的数据
  • 变量的作用域:其定义所在的一对 { }内
  • 变量只有在其作用域内才有效
  • 同一个作用域内,不能定义重名的变量

Java定义变量的格式: 数据类型 变量名 = 变量值;

int myAge;  //变量声明
myAge = 12; //变量赋值

int myAge = 12; //声明+赋值

2.3.1 基本数据类型

基本数据类型

  • 数值型
    • 整数类型(byte、short、int、long)
    • 浮点类型(float、double)
  • 字符型(char)
  • 布尔型(double)

引用数据类型

  • 类(class)
  • 接口(interface)
  • 数组([])
2.3.1.1 整型

通常使用int类型

类型 缺省值 长度 数的范围
byte 0 8 -128 ~ 127
short 0 16 -32768 ~ 32767
int 0 32 -2147483648 ~ 2147483647
long 0 64 -9223373036854775808 ~ 9223373036854775807
public class HelloWorld{

    public static void main(Stirng[] args){
        byte b = 1;
        short s = 200;
        int i = 300;
        long l = 400;
        //如果试图给byte类型的变量赋超出范围的值,会产生编译错误
        byte b2 = 200;
    }
}
2.3.1.2 浮点型

通常使用double类型

类型 缺省值 长度 数的范围
float 0.0 32 3.4E-38 ~ 3.4E38
double 0.0 64 1.7E-308 ~ 1.7E308
public class HelloWorld{

    public static void main(String[] args){
        double d = 123.45;
        // 下面的编译会出错,因为默认是double类型
        float f = 123.45;
        // 下面这种才是正确的
        float f = 123.45f;
    }
}
2.3.1.3 字符型

char类型用于存放一个字符,用单引号表示(双引号用于表示字符串)4

长度和short一样,16位

public class HelloWorld{

    public static void main(String[] args){
        char c = '中';
        // char只能存一个字符,超过一个就会报错
        char c2 = '中国';
        char c3 = 'ab';
        //下面这种也行,通过ASCII码,开发中基本不用。
        char c4 = 97;
    }
}
2.3.1.4 布尔类型

布尔值用来表示真假,长度为1

虽然布尔值真正存放的是0和1,但是不能使用0和1来进行赋值。必须使用true和false赋值

类型 缺失值 长度 数的范围
boolean false 1 false、true
public class HelloWorld{

    public static void main(String[] args){

        boolean b1 = true;
        boolean b2 = false;
        //不能直接用0和1进行赋值
        boolean b3 = 1;
    }
}
2.3.1.4 String类型
/*
String类型变量的使用
1.String属于引用数据类型
2.声明String类型时,使用双引号 " "
3.String类型是可以和8种数据类型做运算的,且运算只能是连接运算 +
4.如果跟8种类型做运算,结果仍然为String类型
*/

class StringTest{
    public static void main(String[] args){
        String s1 = "Hello World";
        System.out.println(s1);

        String s2 = "a";
        String s2 = "";
        //char c = '';   char中不能为空,有且仅有一个字符

       // String的链接
        int number = 100;
        String numStr = '学号:';
        String info = numStr + number;  // + 表示连接
        System.out.println(info);  
    }
}

2.3.2 基本数据类型变量间转换

2.3.2.1 自动类型提升(7种类型,不包括boolean型)
/*
byte、char、short --> int --> long --> float --> double
当byte、char、short三种类型的变量做运算的时候,结果至少需要用int接收
即使是byte + byte等相同类型做运算,也需要至少用int接收
*/

class VariableTest2{
    public static void main(String[] args){
        /*
        当容量小的数据类型的变量与容量大的数据类型的变量做运算时
        结果自动提升为容量大的类型
        此时的容量大小,是指表示的数字的范围,而不是占用的字节数
        */
        byte b1 = 2;
        int i1 = 1225;
        //下面的不行
        byte b2 = b1 + i1;
        //至少要用一个int来接收
        int I2 = b1 + i1;
        float f = b1 + i1;

        //关于char的情况
        char c1 = 'a';
        int i3 = 10;
        //最小需要用int接收结果
        int i4 = c1 + i3;

    }
}
2.3.2.2 强制类型转换

强制类型转换:是自动类型提升的逆运算

/*
强制类型转换:是自动类型提升的逆运算
1.需要使用强转符()
2.强制类型转换,可能导致精度损失
*/

class VariableTest3{
    public static void main(String[] args){
        double d1 = 12.4;
        //使用强转符
        int i1 = (int)d1;   //只剩下整数部分,损失精度
        System.out.println(i1);

        int i2 = 128;
        byte b = (byte)i2;
        System.out.println(b);  //结果:-128
    }
}
2.3.2.3 小问题
class VariableTest4{
    public static void main(String[] args){
        // 编码情况1
        long l = 123123; //按理说应该加l,但是没有报错,为什么?
        //因为整数123123不大,会以int存入,int -> long(自动类型提升)

        long l2 = 1232344523424523423;
        //这么玩,就不行了
        System.out.println(l);

        // 编码情况2
        //整型常量,默认是int类型
        //浮点型常量,默认是double类型
        float f1 = 12.3;
        //这个是编译失败,因为12.3是double,不能往低了转。

        byte b =12;
        byte b1 = b + 1;
        //这个也是编译失败,因为1是int,不能往低了转。
    }
}

2.3.3 基本数据类型与String间转换

/*
String类型变量的使用
1.String属于引用数据类型
2.声明String类型时,使用双引号 " "
3.String类型是可以和8种数据类型做运算的,且运算只能是连接运算 +
4.如果跟8种类型做运算,结果仍然为String类型
*/

class StringTest{
    public static void main(String[] args){
        String s1 = "Hello World";
        System.out.println(s1);

        String s2 = "a";
        String s2 = "";
        //char c = '';   char中不能为空,有且仅有一个字符

       // String的链接
        int number = 100;
        String numStr = '学号:';
        String info = numStr + number;  // + 表示连接
        System.out.println(info);  
    }
}

2.3.4 总结

对于7种数据类型:

  • 在自动类型提升中
    • 小于int,统一用int接收
    • 大于int,自由选择更大的
  • 在强制类型转换中
    • 需要使用强转符
    • 即使损失精度,也得保证有足够的空间去接收

对于String,可以跟8种类型运算,只能是拼接

2.3.4 进制与进制间转换

知道原码、反码、补码


2.4 运算符

2.4.1 算术运算符

运算符 运算 范例 结果
+ 正号 +3 3
- 负号 b=4;-b -4
+ 5+5 10
- 6-4 2
* 3*3 9
/ 5/5
% 取模(取余) 7%5 2
++ 自增(前):先运算后取值 a=2;b=++a; a=3;b=3;
++ 自增(后):先取值后运算 a=2;b=a++; a=
-- 自减(前):先运算后取值 a=2;b=--a;
-- 自减(前):先取值后运算 a=2;b=a--;
+ 字符串连接 "He"+"llo" "Hello"
class AirTest{
    public static void main(String[] args){
        int num1 = 12;
        int num2 = 5;
        int result1 = num1/num2;
        System.out.println(result1); // 2

        int result2 = num1/num2 * num2;
        System.out.println(result2); // 10

        double result3 = num1/num2;
        System.out.println(result3); // 2.0

        double result4 = num1 / num2 + 0.0; //2.0
        double result5 = num1/(num2 + 0.0); //2.4

        //强转
        double result6 = (double) num1/num2;
        System.out.println(result6);

        //取模结果的正负号怎么判断
        //结果与被模数的符号相同
        int m1 = 12;
        int n1 = 5;
        System.out.println("m1 % n1 = "+ m1%n1); //2

        int m2 = -12;
        int n2 = 5;
        System.out.println("m2 % n2 = "+ m2%n2); // -2

        int m3 = 12;
        int n3 = -5;
        System.out.println("m3 % n3 = "+ m3%n3); // 2

        int m4 = -12;
        int n4 = -5;
        System.out.println("m4 % n4 = "+ m4%n4); // -2

        //前加加,后加加
        int a1 = 10;
        int b1 = ++a1;
        System.out.println("a1 = "+a1+"b1 = "+ b1);

        int a2 = 10;
        int b2 = ++a2;
        System.out.println("a2 = "+a2+"b2 = "+ b2);

        //注意点:
        short s1 = 10;
        //s1 = s1 + 1;//编译不通过
        //s1 = (short)(s1 + 1);//正确的

        //自加1,不会改变变量类型
        byte bb1 = 127;
        bb1 ++;
        System.out.println("bb1 = " + bb1);

    }
}

2.4.2 赋值运算符

符号:=

支持连续赋值

/*

*/

class SetValueTest{
    public static void main(String[] args){
        // 赋值 = 
        int i1 = 10;
        int j1 = 10;
        //连续赋值
        int i2,j2;
        i2 = j2 = 10;
        int i3 = 10,j3 = 10; //用逗号分割

        // += -+ *= /=
        int num1 = 10;
        num1 += 2;
        System.out.println(num1);

        //
        short s1 = 10;
        // s1 = s1 +2;  //编译不通过
        s1 += 2; //自加不改变数据类型

        //如果开发中想要实现 +2的操作,有几种方法?前提是int num = 10;
        //方法1:
        num = num + 2;
        //方法2:
        num += 2;

    }

}

/*
练习1:
int i = 1;
i *= 0.1;
System.out.println(i); //0
i++;
System.out.println(i); //1

练习2:
int m = 2;
int n = 3;
n *= m++;
System.out.println(m); //3
System.out.println(n); //6

练习3:
int n = 10;
n += (n++) + (++n);
System.out.println(n); //32

*/

2.4.3 比较运算符(关系运算符)

返回结果都为boolean类型

运算符 运算 范例 结果
== 等于 4==3 false
!= 不等于 4!=2 true
< 小于 4<3 false
> 大于 4>3 true
<= 小于等于 4<=3 false
>= 大于等于 4>=3 true
instanceof 检查是否是类的对象 "Hello" instanceof String true
/*
比较运算符的返回结果都为boolean类型

*/

class CompareTest{
    public static void main(String[] args){
        int i = 10;
        int j = 20;
        System.out.println(i == j); //false
        System.out.println(i = j); //20
    }
}

2.4.4 逻辑运算符

一共有6种

符号 含义
& 逻辑与
&& 短路与
| 逻辑或
|| 单路或
! 逻辑非
^ 逻辑异或(相同为false)
a b a&b a&&b ab a||b !a a^b
true true true true true true false false
true false false false true true false true
false true false false true true true true
false false false false false false true false
/*
都是针对boolean类型

*/

class LogicTest{
    public static void main(String[] args){
        //区分逻辑与、短路与
        boolean b1 = true;
        int num1 = 10;
        if(b1 & (num1 ++ >0)){
            System.out.println("我现在在北京");
        }else{
            System.out.println("我现在在南京");
        }
        System.out.println(num1);
    }
}

2.4.5 位运算符(用的比较少)

运算符 运算 范例
<< 左移 3<<2 = 12
>> 右移 3>>1 = 1
>>> 无符号右移 3>>>1 = 1
& 与运算 6&3 = 2
| 或运算 6 | 3 = 7
^ 异或运算 6 ^ 3 = 5
~ 取反运算 ~6 = -7
/*
操作的都是整型的数据
<<在一定范围内,每左移一位相当于乘2
>>在一定范围内,每右移以为相当于除以2
了解就可以了

*/
class BitTest{
    public static void main(String[] args){
        int i = 21;
        System.out.println("i << 2 :"+ (i <<2));
    }
}
/*
交换两个数据
*/

int num1 = 10;
int num2 = 20;
//方法1:最常用
int temp = num1;
num1 = num2;
num2 = temp;
//方法2:    不太好,只能适用于数值类型
num1  += num2;
num2 = num1 - num2;
num1 = num1 - num2;

//方法3:很少用
//两次异或
num1 = num1 ^ num2;
num2 = num1 ^ num2;
num1 = num1 ^ num2;

2.4.6 三元运算符

格式 (条件表达式)?表达式1:表达式2

/*
条件表达式为boolean类型
三元运算符是可以嵌套使用的
三元运算符都可以改写为if-else语句
if-else的不一定能改成三元运算符
如果都可以用,优先选择三元运算符
*/
class SanYuanTest{
    public static void main(String[] args){
        //获取两个整数的较大值
        int m = 12;
        int n = 5;
        int max = (m > n)? m:n;
        System.out.println(max);

        //嵌套
        String maxStr = (m > n)? "m大":((m == n)?"相等":"n大");
    }
}

小练习:获取三个数的最大值

int n1 = 12;
int n2 = 30;
int n3 = -43;

int max1 = (n1>n2)? n1:n2;
int max2 = (max1 > n3)?max1 :n3;
System.out.println("最大值为:"+max2);

2.4.7 运算优先级

不用管,想优先就加括号


2.5 程序流程控制

  • 顺序结构
  • 分支结构
    • if-else
    • switch-case
  • 循环结构
    • while
    • do-while
    • for

2.5.1 if-else结构(条件判断结构)

//样式1:
if(条件语句){
    执行的代码块;
}
//样式2:
if(条件语句){
    执行的代码块1;
}else{
    执行的代码块2;
}

//样式3:
if(条件表达式1){
    执行代码块1;
}else if(条件表达式2){
    执行代码块2;
}
......
else{
    执行代码块n;
}
class IfTest{
    public static void main(String[] args){
        //举例1
        int heartBeats = 80;
        if (heartBeats<60 || heartBeats > 100){
            System.out.println("需要做进一步检查");
        }
        System.out.println("检查结束");

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

        //举例3
        if(age < 0){
            System.out.println("您输入的数据非法");
        }else if(age < 18){
            System.out.println("青少年时期");
        }else if(age <35){
            System.out.println("青壮年时期");
        }else if(age < 60){
            System.out.println("老年");
        }else{
            System.out.println("你终于可以好好休息了")
        }
    }
}

2.5.2 如何从键盘获取值

/*
如何从键盘获取不同类型的变量,需要使用Scanner类
1.导包:import java.util.Scanner;
2.实例化:Scanner scan = new Scanner(System.in);

*/
class ScannerTest{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int num  = scan.nextInt();
        System.out.println(num);

    }
}

class ScannerTest{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);

        System.out.println("请输入你的名字: ");
        String name = scan.next();
        System.out.println(name);

        System.out.println("请输入你的年龄: ");
        int age = scan.nextInt();
        System.out.println(age);

        System.out.println("请输入你的体重: ");
        double weight = scan.nextDouble();
        System.out.println(weight);

        System.out.println("你是否相中我了呢?(true/false) ");
        boolean isLove = scan.nextBoolean();
        System.out.println(isLove);

        //对于char类型,Scanner没有提供相应的方法,只能使用next方法

    }
}

小练习 1

/*
岳小鹏参加java考试,他和父亲达成承诺:
如果:
100分,奖励BMW
(80,99],iphone
[60,80],ipad
其他情况,没有奖励
请从键盘输入岳小鹏的成绩,并进行判断

说明:

*/

import java.util.Scanner;

class IfTest{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);

        System.out.println("请输入岳小鹏的成绩: ");
        float grade = scan.nextFloat();
        if(grade == 100){
            System.out.println("奖励你一辆BMW");
        }else if(grade >80){
            System.out.println("奖励你一个iphone");
        }else if(grade >= 60){
            System.out.println("奖励你一个ipad");
        }else{
            System.out.println("考不及格,还想要奖励!!");
        }
    }
}

小练习 2

/*
从键盘输入三个整数,分别存入num1、num2、num3
对他们排序,并按照从小到大输出

说明:
if-else结构是可以嵌套的
但是实际开发中,嵌套层数不是很多
代码块只有一行的时候是可以省略 { } ,但是不建议

*/
import java.util.Scanner;

class IfTest{   
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        System.out.println("请输入第一个整数");
        int num1 = scan.nextInt();
        System.out.println("请输入第二个整数");
        int num2 = scan.nextInt();
        System.out.println("请输入第三个整数");
        int num3 = scan.nextInt();

        if(num1 <= num2 && num1 <=num3){
            if(num2 <= num3){
                System.out.println(num1 + " " + num2 + " " + num3);
            }else{
                System.out.println(num1 + " " + num3 + " " + num2);
            }
        }else if(num2 <= num1 && num2 <=num3){
            if(num1 <= num3){
                System.out.println(num2 + " " + num1 + " " + num3);
            }else{
                System.out.println(num2 + " " + num3 + " " + num1);
            }
        }else {
            if(num1 <= num2){
                System.out.println(num3 + " " + num1 + " " + num2);
            }else{
                System.out.println(num3 + " " + num2 + " " + num1);
            }
        }   
    }

}

小练习 3

import java.util.Scanner;

class IfExer1{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);

        System.out.println("请输入你的身高(cm)");
        int height = scan.nextInt();

        System.out.println("请输入你的财富(千万)");
        double wealth = scan.nextdouble();

        System.out.println("请输入你是否帅 (true/false)");
        boolean isHandsome = scan.nextBoolean();

        /*
        输入 是 或者 否 就可以进行判断

        System.out.println("请输入你是否帅 (是/否)");
        boolean isHandsome = scan.nextBoolean();
        if(height >= 180 && wealth >= 1 && isHandsome.equal("是")){
            System.out.println("我愿意嫁给你");
        }else if(height >= 180 || wealth >= 1 || isHandsome.equal("是")){
            System.out.println("你还需要加把劲啊");
        }else{
            System.out.println("你这啥都没有,我怎么嫁给你啊");
        }
        */

        if(height >= 180 && wealth >= 1 && isHandsome){
            System.out.println("我愿意嫁给你");
        }else if(height >= 180 || wealth >= 1 || isHandsome){
            System.out.println("你还需要加把劲啊");
        }else{
            System.out.println("你这啥都没有,我怎么嫁给你啊");
        }
    }
}

2.5.3 switch-case语句

//格式:
switch(表达式){
        case
}
/*
switch-case 结构
格式:
switch(表达式){
        case 常量1:
        执行语句1;
        //break;

        case 常量2:
        执行语句2;
        //break;

        case 常量3:
        执行语句3;
        //break;

        default:
        执行语句n;
        //break;
}

说明: 
1. 根据switch表达式中的值,依次匹配case中的常量,一旦匹配成功,会进入相应case中,调用其执行语句
    执行完了之后,还会继续向下执行别的case中的语句,直到遇到break,或者运行完该switch-case语句
2. break关键字,表示一旦遇到break,就跳出switch-case结构
3. switch结构中的表达式,只能是如下六种类型之一(byte、short、char、int、枚举类型、String )
4. case后面跟的是常量!!
5. 根据实际情况选择加不加break
6. default(可选的),相当于if-else中的else
7. default的位置是灵活的!

*/

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

        int number = 2;

        switch(number){

        case 0:
            System.out.println("zero");
            break;
        case 1:
            System.out.println("one");
            break;
        case 2:
            System.out.println("two");
            break;
        case 3:
            System.out.println("three");
            break;
        default:
            System.out.println("Other");

        }
    }
}

小练习 1

//对于学生的成绩,大于等于60分的,合格,低于60分的,输出不合格
//如果多个语句的执行内容是相同的, 那可以考虑合并。
class SwitchCaseTest{
    public static void main(String[] args){
        int score = 78;

        switch(score / 10){
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("不及格");
                break;
            case 6:
            case 7:
            case 8:
            case 9:
            case 10:
                System.out.println("及格");
                break;

        }
    }
}

小练习 2

//编写程序,从键盘输入2019年的月和日,输出这是2019年的第几天。
//不用break,有时候更舒服
import java.util.Scanner;
class switchCaseTest{
    public static void main(String[] args){

        Scanner scan = new Scanner(System.in);
        System.out.println("请输入2019年的month:");
        int month = scan.nextInt();
        System.out.println("请输入2019年的day:");
        int day = scan.nextInt();

        int sunDays = 0;

        switch(month){
            case 12:
                sunDays += 30;
            case 11:
                sunDays += 31;    
            case 10:
                sunDays += 30;
            case 9:
                sunDays += 31;
            case 8:
                sunDays += 31;    
            case 7:
                sunDays += 30;
            case 6:
                sunDays += 31;
            case 5:
                sunDays += 30;    
            case 4:
                sunDays += 31;
            case 3:
                sunDays += 28;    
            case 2:
                sunDays += 31;
            case 1:
                sunDays += day;
        }
        System.out.println(sunDays);
    }
}

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

当switch-case、if-else都可以使用时,且case的情况不是太多,优先选择switch-case

原因:switch-case效率稍微高一点


2.5.4 for循环结构

/*
一、循环结构的4个要素
1. 初始化条件
2. 循环条件(boolean类型)
3. 循环体
4. 迭代条件

对于for循环来说:
for(1;2;4){
    3;
}

*/

class ForTest{ 
    public static void main(String[] args){
        for(int i = 1; i<=5; i++){
            System.out.println("HelloWorld");
        }
    }  
}

小练习 1

int num = 1;
for(System.out.print("a");num <= 3;System.out.print("c"),num ++){
    System.out.print("b");
}

//请问输出的结果是什么?
abcbcbc

小练习 2

//遍历100以内的偶数,并且求和

class EvenNum{
    public static void main(String[] args){
        int sum = 0;
        for(int i = 1; i<=100 ; i++){
            if(i % 2 ==0) {
                System.out.println(i);
                sum += i;
            } 
        }
        System.out.println(sum);
    }
}

小练习 3

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

        for(int i = 1; i <= 150; i++){
            System.out.print(i + "  ");

            if(i % 3 == 0){
                System.out.print("foo ");
            }
            if(i % 5 == 0){
                System.out.print("biz ");
            }
            if(i % 7 == 0){
                System.out.print("baz ");
            }
           //换行
            System.out.println(); 
        } 
    }
}

2.5.5 while循环结构

/*
While循环的使用
一、循环结构的四个要素
1、初始化条件
2、循环条件---》boolean类型
3、循环体
4、迭代条件

while的结构:
    1
    while (2) {
        3;
        4; //非常重要,不能丢了这部分,不然很可能就是死循环

}
1->2->3->4->2->3->4->2->3->4......

for循环和while循环是可以相互转换的。
非要说什么区别的话,那就是这俩的初始化条件的作用域不同。

*/   

//遍历100以内的所有偶数
class WhileTest{
    public static void main(String[] args){
        //遍历100以内的所有偶数
        int i = 1;
        while(i <= 100){
            if(i % 2 == 0){
                System.out.println(i);
            }
            i++;
        }
    }
}

2.5.6 do-while循环结构

/*
do-while循环的结构:
1
do{
    3;
    4;
}while(2);

1->3->4->2->3->4->2->3->4->2.......

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

实际开发中,使用for和while比较多一些
do-while使用较少
*/

//遍历100以内的偶数
class DoWhileTest{
    public static void main(String[] args){
        //遍历100以内的偶数
        int i = 1;
        do{
            if(i % 2 == 0 ){
                System.out.println(i);
            }
            i++;
        }while(i<=100);
    }
}

//遍历100以内的偶数,并计算所有偶数的和与偶数的个数
class DoWhileTest{
    public static void main(String[] args){
        //遍历100以内的偶数
        int i = 1;
        int sum = 0;
        int count = 0;
        do{
            if(i % 2 == 0 ){
                System.out.println(i);
                count ++;
                sum += i;
            }
            i++;
        }while(i<=100);
        System.out.println("所有偶数的和为: " + sum);
        System.out.println("所有偶数的个数为: " + count);
    }
}
循环的小例题
//从键盘输入个数不确定的整数,并且判断输入数字的正负的个数
//当用户输入 0 时,程序结束

/*
结束循环有几种方式:
1、循环条件部分返回false
2、在循环体中遇到break
*/

import java.util.Scanner;

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

        Scanner scan = new Scanner(System.in);
        int posNum = 0;
        int negNum = 0;

        while(true){

            int number  = scan.nextInt();
            //判断number的正负
            if(number > 0){
                posNum++;
            }else if(number < 0){
                negNum ++;
            }else{
                //跳出循环
                break;
            }
        }
        System.out.println("输入的正数的个数为:" + posNum);
        System.out.println("输入的负数的个数为:" + negNum);
    }
}

2.5.7 嵌套循环

/*
将一个循环结构,声明在另一个循环结构的循环体中,这就构成了嵌套循环
1、外层循环
2、内层循环
*/

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

        //在控制台输出******
        for(int i = 1; i<=6;i++){
            System.out.print("*");
        }

    }
}
/*
输出结果:
******
******
******
******
******
******
*/

class ForForTest{
    public static void main(String[] args){
        for(int wai = 1;wai<=6;wai++){
            for(int nei = 1; nei <= 6;nei ++){
                System.out.print("*");
            }
            System.out.println();
        }

    }
}
/*
输出结果:
*
**
***
****
*****
******
*/
小练习-九九乘法表
//通过嵌套循环输出九九乘法表

class NineNineTable{
    public static void main(String[] args){
       for(int zuo = 1; zuo <= 9; zuo ++){
           for(int you = 1; you <= zuo; you ++){
               System.out.print(zuo+ " * " + you+ " = " +(zuo * you)+"\t");
           }
           System.out.println();
       }

    }
}

/*
1 * 1 = 1   
2 * 1 = 2   2 * 2 = 4   
3 * 1 = 3   3 * 2 = 6   3 * 3 = 9   
4 * 1 = 4   4 * 2 = 8   4 * 3 = 12  4 * 4 = 16  
5 * 1 = 5   5 * 2 = 10  5 * 3 = 15  5 * 4 = 20  5 * 5 = 25  
6 * 1 = 6   6 * 2 = 12  6 * 3 = 18  6 * 4 = 24  6 * 5 = 30  6 * 6 = 36  
7 * 1 = 7   7 * 2 = 14  7 * 3 = 21  7 * 4 = 28  7 * 5 = 35  7 * 6 = 42  7 * 7 = 49  
......
*/
小练习-100以内所有的质数
/*
找出100以内所有的质数
从2到n-1都不能被这个数整除
*/

class PrimeNumTest{
    public static void main(String[] args) {
        for(int i = 2; i <= 100; i++) {
            boolean isFlag = true; //在测试的每一个数的时候,重置flag
            for(int j = 2; j <= (int)(Math.sqrt(i)+1);j++) {
                if(i % j == 0) {
                    isFlag = false;
                    break;
                }
            }
            if(isFlag == true) {
                System.out.println(i);
            }
        }
    }
}

//break优化
class PrimeNumTest{
    public static void main(String[] args) {

        long start = System.currentTimeMillis(); //起始时间

        for(int i = 2; i <= 1000000; i++) {
            boolean isFlag = true;
            for(int j = 2; j <= Math.sqrt(i);j++) {
                if(i % j == 0) {
                    isFlag = false;
                    break; //能整除了,立马退出当前循环。
                }
            }
            if(isFlag == true) {
                System.out.println(i);
            }
        }
        long end = System.currentTimeMillis(); //结束时间
        System.out.println(end-start);
    }
}

2.5.8 break、continue关键字的使用

/*
break的使用范围
    1.switch-case
    2.循环结构
continue的使用范围
    1.循环结构

break:结束当前循环
continue:结束当次循环

*/

class BreakContinueTest{
    public static void main(String[] args){
        for(int i = 1 ; i <= 10; i++){
            if(i % 4 == 0){
                break;
            }
            System.out.println(i);
        }
    }
}
/*
输出结果:
1
2
3
*/

class BreakContinueTest{
    public static void main(String[] args){
        for(int i = 1 ; i <= 10; i++){
            if(i % 4 == 0){
                continue;
            }
            System.out.println(i);
        }
    }
}

/*
输出结果:
1
2
3
5
6
7
9
10
*/

//默认break是就近结束循环
//也可以通过加一个标签,结束执行层的循环
lable:for(int i = 1; i<= 10; i++){
    for(int j = 1; j <= 10; j++){
        //......
        break lable;
    }
}

//有了这个功能之后,就可以重写找质数的代码了
class primeNumTest{
    public static void main(String[] args){
        long start = System.currentTimeMillis();
        int count = 0;
        lable:for(int i = 2; i <= 100000; i++){
            for(int j = 2; j <= Math.sqrt(i); j++){
                if(i % j ==0){
                    continue lable;
                }
            }
            count++;
        }
        long end = System.currentTimeMillis();
        System.out.println((end-start) +"   "+ count);
    }
}
暂无评论

发送评论 编辑评论


				
上一篇
下一篇