【JavaSE 第三天】

Jade_Heng_Star

已于 2022-10-02 16:06:30 修改

阅读量425

点赞数 1

分类专栏： JavaSE 基础文章标签： java 开发语言后端

于 2022-01-28 21:34:48 首次发布

本文链接：https://blog.csdn.net/Jade_Heng_Star/article/details/122714728

版权

JavaSE 基础专栏收录该内容

25 篇文章 1 订阅

订阅专栏

【JavaSE 第三天】

一、运算符

1. 算术运算符

++ 自增（前）先运算后取值 a=2； b=a++ a是3，b是3
++ 自增（后）先取值后运算 a=2；b=++a a是3，b是2
除法：两个整数做除法，如果不能整除，会自动舍弃小数部分
- 除以零的过程中会报错，数学错误
取模也叫取余被取模的数值为负时，取模的结果也为负
- 取模结果是正数还是负数看被取模的数值是正数还是负数
- 小数取模结果可能是小数

// 字符串的连接
boolean operatorJoin01 = true;
float operatorJoin02 = 3.55f
System.out.println("" + operatorJoin01 + operatorJoin02);
// 自增一 
// 先取值后加
int operatorIncrease01 = 10;
int increaseResult = operatorIncrease01++;
System.out.println("10 increaseResult = "+increaseResult);
System.out.println("11 operatorIncrease = "+operatorIncrease01);
// 先加后取值
operatorIncrease01 = 10;
increaseResult = ++operatorIncrease01;
System.out.println("11 increaseResult = "+increaseResult);
System.out.println("11 operatorIncrease = "+operatorIncrease01);
//自减一
//先取值后减
int operatorDecrease = 10;
int decreaseResult = operatorDecrease--;
System.out.println("10 decreaseResult="+decreaseResult);
System.out.println("9 operatorDecrease="+operatorDecrease);
//先减后取值
operatorDecrease = 10;
decreaseResult = --operatorDecrease;
System.out.println("9 decreaseResult="+decreaseResult);
System.out.println("9 operatorDecrease="+operatorDecrease);

2. 赋值运算符

运算的方向：从右往左运算
连续赋值运算

        int x;
        int y;
        int z;
        x=y=z=10;
        // 第一步：z=10； 整个赋值表达式的值是10
        // 第二部：把z=10赋值表达式的值10赋给y
        // 第三步：把y=10赋值表达式的值赋给x

运算实例1：

short s=3;
// s=s+2;  //byte short char进行算数运算时要变为int类型相当于将short类型放入int类型中可能放不进去 不兼容的类型需要
s=(short)(s+2);
s+=2; // 编译可以通过，说明 += 的操作底层会有自动的类型转换

运算实例2：

int i=1;
i*=0.1;
// 第一步：1*0.1 结果应该是0.1
// 第二步：因为i是int类型所以舍弃小数部分，变为了0；
System.out.println(i);

运算实例3：

int m=2;
int n=3;
n*=m++;
// 第一步：m++ 先取值，得到2
// 第二步：用2和n执行"*="的操作，就是n=n*2

运算实例4：

int n=10;
n+=(n++)+(++n)
// 第一步：取n的值用来做加法
// 第二步：++n先加再取值，n变为11
// 第三步：执行加法，得到21
// 第四步：计算 += 的操作 n=n+21
// 第五步：计算n++里面的自增1，得到33
// 但结果是32
// 运用 java -c 文件名操作
// 根据反编译字节码文件，看到实际的执行过程
// 不符合常见的逻辑原则
// 不建议的写法 不要写这样有歧义的

运用 java -c 文件名操作

3. 比较运算符

instanceof

运算：检查是否是类的对象
规范："Hello"instanceof String
结果：true

// 检查左边的对象是否是右边指定类型的对象
System.out.println("Hello" instanceof String);

4. 逻辑运算符

符号	含义
&	逻辑与（且）
&&	逻辑且（有短路效果）
或（竖）	逻辑或
或或（竖竖）	逻辑或
!	逻辑取反
^	逻辑异或（不同返回true）

boolean a=true;
boolean b=true;
// 逻辑与：不带短路效果
System.out.println(a&b);
// 逻辑与：带有短路效果 前面是false后面就不必执行
System.out.println(a&&b);

        boolean a=false;
        boolean b=true;
        int i=10;
        // 逻辑与，不带短路效果
        System.out.println(a&(i++>5));
        System.out.println("i="+i);//11
        // 逻辑与，带短路效果
        System.out.println(a&&(i++>5));
        System.out.println("i="+i);//11
        // 逻辑或，不带短路效果
        System.out.println(b|(i++>5));
        System.out.println("i="+i);//12
        // 逻辑或，带短路效果
        System.out.println(b||(i++>5));
        System.out.println("i="+i);//12

通常写程序用带短路效果的

5. 位运算符

运算符	运算	范例	运算结果
<<	左移	3<<2	12
>>	右移	4>>1	2
>>>	无符号右移	3>>>1	1
&	按位与	6&3	2
或	按位或	6 或 3	7
^	按位异或	6^3	5
-	按位取反	-6	-7

“或” 是： “|” 符号

运算符	运算方式
<<	空位补0，被移除的高位丢弃，空缺位补0。
>>	当最高位是0，右移后，空缺位补0，当最高位是1，空缺位补1。
>>>	被移位二进制最高位无论是0或者是1，空缺位都用0补。
&	二进制位进行&运算，只有1&1时结果是1，否则是0;
“或”	二进制位进行"或"运算，只有0"或"0时结果是0，否则是1;
^	二进制位相同是0，二进制位不同是1
~	按补码取反

在二进制中进行移动

        // 左移操作
        // 正数左移
        int i=0b00101100;
        System.out.println("i="+Integer.toBinaryString(i));//用二进制来表示
        int j=i<<2;
        // 00101100
        // 01011000
        // 10110000
        System.out.println("j="+Integer.toBinaryString(j));//用二进制来表示
        System.out.println("j="+j);
        // 负数的左移
        int x=-0b00101100;
        int y=x<<1;
        System.out.println("x="+x);
        System.out.println("x="+Integer.toBinaryString(x));//用二进制来表示
        System.out.println("y="+Integer.toBinaryString(y));//用二进制来表示
        System.out.println("y="+y);
        // 最大值的基础上左移一位
        int maxValue=Integer.MAX_VALUE;
        System.out.println("maxValue=0"+Integer.toBinaryString(maxValue));
        maxValue=maxValue<<1;
        System.out.println("maxValue="+Integer.toBinaryString(maxValue));
        System.out.println("maxValue="+maxValue);

移动一位：
1. 左移乘2
2. 右移除以2

6. 三元运算符

        int i=10;
        int j=20;
        String result=(i>j)?"i比j大":"i比j小";
        System.out.println(result);

二、流程控制

1. 顺序结构

使用 Scanner 对象从控制台输入数据是暂时的

// 导入 Scanner 类
import  java.util.Scanner;
public class Demo1 {
    public static void main(String[] args){
       // 1.创建 Scanner 对象
        Scanner scanner=new Scanner(System.in);
        // 2.读取 int 类型的数据
        System.out.println("请输入一个整数：");
        // 调用 scanner 对象的 nextInt() 方法
        int age=scanner.nextInt();
        System.out.println("age="+age);
        // 3.读取 Boolean 类型的数据
        System.out.println("请输入一个布尔值：");
        boolean flag=scanner.nextBoolean();
        System.out.println("flag="+flag);
        // 4.读取字符串
        System.out.println("请输入一个字符串：");
        String stringValue=scanner.next(); // next() 会因为空格终止读取
        System.out.println("stringValue="+stringValue);
        // nextLine() 方法不会因为空格而终止读取
        stringValue=scanner.nextLine();
        System.out.println("stringValue="+stringValue);
    }
}

2. 分支结构

import java.util.Scanner;
public class Demo1 {
    public static void main(String[] args){
       // 创建 Scanner 对象
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入i:");
        int i=scanner.nextInt();
        System.out.println("请输入j：");
        int j=scanner.nextInt();
        if(i>j){
            System.out.println("i比j大");
        }
        if(i<j){
            System.out.println("i比j小");
        }
        System.out.println("后续");
    }
}

if()...else...
if()...else if()......else...
switch...case...

import java.util.Scanner;
public class Demo1 {
    public static void main(String[] args){
       // 创建 Scanner 对象
       Scanner scanner=new Scanner(System.in);
       System.out.println("请输入一个季节:");
       String season=scanner.nextLine();
       switch (season){
           case "spring":
               System.out.println("春天");
               break;
           case "summer":
               System.out.println("夏天");
               break;
           case "autumn":
               System.out.println("秋天");
               break;
           case "winter":
               System.out.println("冬天");
               break;
           default:
           // 当前面每一个都不匹配就执行它
               System.out.println("全部都");
       }
    }
}

switch（表达式）中表达式的可选值类型
(都是非常确定的值) byte，short，int，char，枚举，String
case 子句中指定的值必须是常量，不能是变量或不确定的表达式的值
同一个 switch 语句中所有 case 子句中的常量值必须互不相同
default 子句是可选的
default 子句的位置是灵活的

冒泡排序

import java.util.Scanner;
public class Demo1 {
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入：num1");
        int num1=scanner.nextInt();
        System.out.println("请输入：num2");
        int num2=scanner.nextInt();
        System.out.println("请输入：num3");
        int num3=scanner.nextInt();
        // 定义空变量
        int swap=0;
        if(num1>num2){
            // 交换变量
            swap=num1;
            num1=num2;
            num2=swap;
        }
        if(num2>num3){
            swap=num3;
            num3=num2;
            num2=swap;
            if(num1>num2){
                swap=num2;
                num2=num1;
                num1=swap;
            }
        }
        System.out.println("num1="+num1);
        System.out.println("num2="+num2);
        System.out.println("num3="+num3);
    }
}

3. 循环结构

for 循环 for(循环入口;判断条件;循环变量迭代){ 循环体 }
1. 循环结构中的判断条件部分必须是布尔类型。
2. 初始化部分可以声明多个变量，但必须是同一个类型，同逗号分隔。
3. 可以有多个变量迭代更新。
while 循环 while(){ 循环体 }
do…while… 循环
先进入循环体一次，后判断条件，再次执行（运用稀少）。