【运算符+逻辑控制】

---

1.类型转换

隐式类型转换
范围小的赋值给范围大的，编译器会自动把范围小的类型转换成范围大的那个类型

int a = 10;
long b = 10L;
b = a;//int-->long,数据由小到大，类型提升
1
2
3

强制类型转换
范围大的赋值给范围小的，编译器不能自动完成，需要强转，否则精度丢失。

float f = 3.14F;
double d = 5.12;
f = (float)d; // double-->float, 数据范围由大到小，需要强转，否则编译失败
1
2
3

2.类型提升

1. 不同类型的数据混合运算, 范围小的会提升成范围大的.

 int a = 10;
 long b = 20;
long d = a + b; // 编译成功：int + long--->long + long 赋值给long
1
2
3

2. 对于 short, byte 这种比 4 个字节小的类型, 都会先提升成 4 个字节的 int , 结果也用int接收

byte a = 10;
byte b = 20;
int c = a + b;
1
2
3

============================================================

3.如何求字符串长度

String e="hello world";
System.out.println(e.length());
1
2

4.字符串类型

注意：String是引用类型不是包装类型

String的神奇用法

1. 字符串与字符串拼接

        String s1 = "hello";
        String s2 = " world";
        System.out.println(s1+s2);//hello world
1
2
3

2. 字符串与整数之间的转换

        String str2="234";
        System.out.println(str2+1);//234+1=2341

        //使用String的库方法，把字符串转换成整数
        String str3="234";
        int val=Integer.valueOf(str3);
        System.out.println(val+1);//234+1=235
1
2
3
4
5
6
7

3. 字符串 拼 其他（有点难理解）

        int a=10;
        int b=20;
        
        System.out.println("a = "+a+" b = "+b);//a = 10 b = 20
        //字符串在前，整体还是字符串
        System.out.println("a + b = "+a+b);//a + b = 1020
       // 加完才拼
        System.out.println(a+b + "a + b");//30a + b
1
2
3
4
5
6
7
8

4.运算符

算术运算符

1. 基本四则运算符：加减乘除模(+ - * / %

练习

        System.out.println(5/2); //2
        System.out.println((float)5/2);//2.5
        System.out.println(5/(float)2);//2.5
        System.out.println((float)(5/2));//2.0
1
2
3
4

        System.out.println(10 % 3);// 10/3=3...1
        System.out.println(-10 % 3);// -10/3=-3...-1
        System.out.println(10 % -3);// 10/-3=-3...1
        System.out.println(-10 % -3);// -10/-3=3...-1
        System.out.println("11.5 % 2");//11.5/2=5...1.5
1
2
3
4
5

注意：做除法和取模时，右操作数不能为0

2. 增量运算符 += -= *= %=
   该种类型运算符操作完成后，会将操纵的结果赋值给左操作数

增量操作符有一个特点就是不用强转就能自动进行整型提升

int a = 4;
double b = 5.0;
a += b;//a = a+b
System.out.println(a);//9
1
2
3
4

3. 自增/自减运算符 ++ –
   ++是给变量的值+1，–是给变量的值-1。

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

        int c = 10;
        int d =++c;//c++,d=c
        System.out.println(d);
        System.out.println(c);
1
2
3
4
5
6
7
8
9

关系运算符

关系运算符主要有六个: == != < > <= >= ，其计算结果是 true 或者 false 。

int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a < b);
1
2
3
4
5
6
7

逻辑运算符

1. 逻辑与 &&
   表达式1 && 表达式2，
   只有两个表达式结果为真，才算真，

2. 逻辑或 ||
   语法规则：表达式1 || 表达式2
   只要有一个表达式为真，结果就为真

3. 逻辑非 !
   语法规则：! 表达式
   真变假，假变真。

5.位运算符

按位与 &
如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.

按位或 |
如果两个二进制位都是 0, 则结果为 0, 否则结果为 1

按位取反 ~
如果该位为 0 则转为 1, 如果该位为 1 则转为 0

按位异或 ^
如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.

移位运算符

移位运算符有三个: << >> >>>

左移 <<: 最左侧位不要了, 最右侧补 0.
右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1
无符号右移 >>>: 最右侧位不要了, 最左侧补 0.

条件运算符

表达式1 ? 表达式2 : 表达式3

当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;
当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值

        boolean flg = true == true ? false ? true : false :true;
        System.out.println(flg);//false
1
2

============================================================

6.java的输入

要输入需要导一个包：import java.util.Scanner;

import java.util.Scanner;

public class Test{
    Scanner scanner=new Scanner(System.in);
    int year=scanner.nextInt();
}
1
2
3
4
5
6

7. 判断是否为闰年

public class Test{
    public static void main(String[] args) {
        int year = 1000;
        if(year % 100 == 0){
            if(year % 400 == 0){
                System.out.println("是世纪闰年");
            }else{
                System.out.println("不是闰年");
            }
        }else{
            if(year % 4 == 0){
                System.out.println("是普通闰年");
            }else{
                System.out.println("不是闰年");
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

8.switch 语句

注意：不建议使用switch嵌套，不美观。

        int day = 1;
        switch(day) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

注意：不能做switch参数类型有：boolean/ double/ long/float

switch的括号内只能是以下类型的表达式：
基本类型：byte、char、short、int，注意不能是long类型
引用类型：String常量串、枚举类型

9.while循环

计算1~100之间的和

public class Test{
    public static void main(String[] args) {
        int sum=0;
        int i=1;
        while(i<=100){
           sum+=i;
           i++;
        }
        System.out.println(sum);
    }
}
1
2
3
4
5
6
7
8
9
10
11

计算1~100之间的奇数的和

public class Test{
    public static void main(String[] args) {
        int sum=0;
        int i=1;
        while(i<=100){
           sum+=i;
           i+=2;
        }
        System.out.println(sum);
    }
}
1
2
3
4
5
6
7
8
9
10
11

计算1~100之间偶数的和

public class Test{
    public static void main(String[] args) {
        int sum=0;
        int i=2;
        while(i<=100){
           sum+=i;
           i+=2;
        }
        System.out.println(sum);
    }
}
1
2
3
4
5
6
7
8
9
10
11

求5的阶层

    public static void main(String[] args) {
        int b = 1;
        int ret = 1;
        while(b <= 5){
          ret *= b;
          b++;
        }
        System.out.println(ret);
    }
1
2
3
4
5
6
7
8
9

求1！+2！+3！+4！+5！

    public static void main(String[] args) {
        int b = 1;
        int ret = 1;
        int sum=0;
        while(b <= 5){
          ret *= b;
            b++;
          sum += ret;
        }
        System.out.println(sum);
    }
1
2
3
4
5
6
7
8
9
10
11

求100~200之间第一个能被3整除的数

    public static void main(String[] args) {
        int i=100;
        while(i >= 100 && i <= 200){
            if(i%3==0){
                System.out.println(i);
                break;
            }
            i++;
        }
    }
1
2
3
4
5
6
7
8
9
10

找到1~100之间能被3并且被5整除的数据

要求使用break或者continue

    public static void main(String[] args) {
        int i = 1;
        while(i <= 100){
            if(i % 3 == 0 && i % 5 ==0){
                System.out.println(i);
                i++;
                continue;
            }
            i++;
        }
    }
1
2
3
4
5
6
7
8
9
10
11

10.for循环

用for循环嵌套求1~5的阶层

    public static void main(String[] args) {
        int sum = 0;
        for (int k = 1; k <=5; k++) {
            int ret = 1;
            for (int i = 1; i <= k; i++) {
                ret *= i;
            }
            sum += ret;
        }
        System.out.println(sum);
    
1
2
3
4
5
6
7
8
9
10
11

11.输入输出

使用 Scanner 读取字符串/整数/浮点数（不常用）

import java.util.Scanner;//导包
public class Test {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入你的姓名：");
        String name = scanner.nextLine();输出名字
        System.out.println(name);
        
        scanner.nextInt();
        
        System.out.println("请输入你的年龄：");
        int age = scanner.nextInt();
        System.out.println(age);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

12.如何生成随机数

import java.util.Random;
public class Test {
    public static void main(String[] args) {
        Random random = new Random();
        int randNum=random.nextInt(100);//随机生成0~100之间的随机数
    }
}
1
2
3
4
5
6
7

13.猜数字游戏

import java.util.Random;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Random random = new Random();
        int randNum = random.nextInt(100);//随机生成0~100之间的随机数
        Scanner scanner=new Scanner(System.in);
        
        while(true){
            System.out.println("请输入你要猜的数字");
            int num =scanner.nextInt();//输出数字
            if(num < randNum) {
                System.out.println("猜小了");
            }else if(num > randNum){
                System.out.println("猜大了");
            }else {
                System.out.println("猜对了");
            }
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

总结

以上便是今日的复习内容，每个练习都自己动手敲代码，自我感觉对于今天写得几道while循环练习题掌握得差不多了。