模块三 IDEA 运算符

概述：开发工具idea 是 java 写的，所以本地上必须有正确的 jdk 环境（JAVA_HOME）idea 自动保存不用我们打开 dos 命令窗口执行 javac 和 java 命令idea 有强大的快捷键，生成代码，纠错等idea会自动管理我们写的代码相关开发工具：eclipse、myeclipse作用：加速我们的开发。

枫林残忆168

860人浏览 · 2024-03-12 05:28:36

枫林残忆168 · 2024-03-12 05:28:36 发布

模块二回顾

常量：在代码运行过程中，之不会发生改变的数据

a.整数常量：所有整数

b.小数常量：所有带小数点的如：2.0

c.字符常量：带单引号，单引号中必须有，且只能有一个内容

d.字符串常量：带双引号的

e.布尔常量：true false → 可以当条件判断使用

f.空常量：null 代表数据不存在，所以不能直接使用
变量：在代码运行过程中，会根据不同的情况而随时改变的数据

a.定义：数据类型变量名 = 值 → 将等号右边的值赋值给等号左边的变量

b.数据类型：

基本数据类型：byte，short， int， long，float，double，boolean，char

引用数据类型：类，数组，接口，枚举，注解
数据类型转换：当等号左右两边类型不一致时，或者不同的类型做运算

a.自动类型转换：小转大

将取值范围小的类型赋值给取值范围大的类型

取值范围小的类型和取值范围大的类型之间做运算

b.强转：大转小

取值范围小的类型变量名 = （取值范围小的数据类型）取值范围大的数据类型

模块三的重点

all（都是重点）

第一章 IDEA的使用

1.1 idea的介绍以及安装

1.1.1 idea的介绍

概述：开发工具
特点：
1. idea 是 java 写的，所以本地上必须有正确的 jdk 环境（JAVA_HOME）
2. idea 自动保存
3. 不用我们打开 dos 命令窗口执行 javac 和 java 命令
4. idea 有强大的快捷键，生成代码，纠错等
5. idea会自动管理我们写的代码
相关开发工具：eclipse、myeclipse
作用：加速我们的开发

1.1.2 idea的安装

1.2 idea的目录结构

先创建 project，在 project 下创建 module，在 module下创建 package，必须记住。

1.3 Project的操作

1.3.1 如何创建一个 Project

1.3.2 再次创建一个新的Project

在这里插入图片描述

1.3.3 关闭Project

file → close project

1.3.4 打开Project

1.4 module 的操作

1.4.1 创建 module

1.4.2 关闭 module

a. 对着要关闭的 module 右键 → remove module → 此时是关闭，不是真正的删除 module

b. 再对对着关闭的module右键 → delete → 从本地真正的删除

1.4.3 导入已有的module

1.5 创建以及删除package

1.5.1 创建

1.5.2 package的删除

右键 → Delete

1.5.3 package取名规范

公司域名倒着写

比如：尚硅谷域名为：www.atguigu.com

我们写代码创建包：com.atguigu.b

1.6 创建类以及基本语句生成快捷键

1.6.1 创建类

生成 main 方法：输入 main → 回车

生成输出语句：sout → 回车

将变量名放到输出语句中：

a.变量名.sout

b.变量名.soutv → 带字符串拼接格式的输出方式 → 输出格式好看

1.7 基本设置

1.7.1 设置字体

1.7.2 设置提示的快捷键

file → Settings

1.7.3 设置注释字体

file → Settings

1.8 快捷键

快捷键	功能
Alt + Enter	导入包，自动修正代码（重中之重）
Ctrl + Y	删除光标所在行
Ctrl + D	复制光标所在行的内容，插入光标位置下面
Ctrl + Alt + L	格式化代码
Ctrl + /	单行注释
Ctrl + Alt + /	选中代码注释，多行注释，再按取消注释
Alt + Shift + 上下箭头	移动当前代码行

先写等号左边的，可以自动生成等号右边的变量，通过 Alt + Enter 激活

或者

1.9 出现的问题

在运行代码时会出现 “ 找不到对应的发行源 ” 或者 “ 不支持版本 ” 或者 “ 无效的发行源版本 ”，证明本地 jdk 版本和 idea 中的 language level 不匹配

所以要匹配版本 file → project Structure → 点击project → 引入本地 jdk → project level 选择对应的版本
没有 out 路径的问题

out 路径是专门存放 idea 自动编译生成的 .class 文件的，所以需要指明 out 路径，操作：file → project Structure → 点击project → 设置compiler output。
src 是灰色的，对着 src，右键，选项中没有 java class 或者 package
刚使用，jdk 没有配置

第二章运算符

2.1 算术运算符

符号	说明
+	加法
-	减法
*	乘法
/	除法如果符号前后都是整数，结果取整数部分如果符号前后有一个为小数，结果就是正常小数
%	模，取余数部分

public class Demo01Arithmetic {
    public static void main(String[] args) {
        int i = 10;
        int j = 3;
        int add = i+j; // 推荐使用
        System.out.println(add); // 13

        int sub = i - j;
        System.out.println(sub); // 7

        int mul = i*j;
        System.out.println(mul); // 30

        int div = i / j;
        System.out.println(div); // 3

        int mo = i % j;
        System.out.println(mo); // 1
    }
}

+ :

运算
字符串拼接：任何字类型的数据遇到字符串都会变成字符串，此时 + 就不再是运算了，而是字符串拼接，将内容直接往后拼接

public class Demo02Arithmetic {
    public static void main(String[] args) {
        int i = 10;
        int j = 3;
        System.out.println(i+j+""); // 13
        System.out.println(i+j+""+1); // 131
        System.out.println(i+""+j); // 103
        System.out.println("i和j相加之和为："+(i+j)); // i和j相加之和为：13
    }
}

2.2 自增自减运算符（也算算术运算符的一种）

格式：

变量名++ → 后自加

++变量名 → 前自加

变量名-- → 后自减

–变量名 → 前自减

自增和自减只变化 1

使用：

a. 单独使用：++ – 单独为一句，没有和其他的语句掺和使用

i++;

符号在前在后都先运算。

b.混合使用：++ – 和其他的语句掺和使用了（比如：输出语句，赋值语句）

符号在前：先运算，在使用运算后的值；

符号在后：先使用原值，使用完毕之后，自身在运算。

public class Demo03Arithmetic {
    public static void main(String[] args) {
        int i = 10;
        // i++;
        ++i;
        System.out.println("i = "+i); // 11
        System.out.println("====================");
        int j = 100;
        int result01 = ++j;
        System.out.println("result01 = "+result01); // result01 = 101
        System.out.println(j); // 101
        System.out.println("====================");
        int k = 10;
        int result02 = k++;
        System.out.println("result02 = "+result02); // result02 = 10
        System.out.println("k = "+k); // k = 11

        int z = 100;
        System.out.println(z++); // 100
        System.out.println(z); // 101

        System.out.println("====================");
        int x = 10;
        int y = 20;
        /**
         * 10 + 19 = 29
         * 29+12 = 41
         * */
        int result03 = x++ + --y + ++x;
        System.out.println("result03 = "+result03); // result03 = 41

        System.out.println("====================");
        int c = 10;
        c=c++;
        System.out.println(c); // 10

    }
}

2.2 赋值运算符

基本的赋值运算符： = → 先看等号右边的，再将右边的数据赋值给等号左边的变量

复合赋值运算符：

+=：

int i = 10;

i += 2 → i = i+2

public class Demo01Assignment {
    public static void main(String[] args) {
        int i = 10;
        i += 2; // i = i +2;
        System.out.println("i = " + i);
    }
}

public class Demo02Assignment {
    public static void main(String[] args) {
        byte b = 10;
        // b = (byte)(b + 1);
        b+=1;  // b = b+1;
        System.out.println("b = " + b);
    }
}

-=：

*=：

/=：取整数部分

%=：取余数部分

注意：byte short 遇到复合运算符，jvm 会自动转型

2.3 比较运算符（关系运算符）

结果： boolean型 → 要么是true，要么是false
作用：做条件判断使用

符号	说明
==	如果符号前后相等为true，否则为false
>	如果符号前的数据大于符号后的数据为true，否则为false
<	如果符号前的数据小于符号后的数据为true，否则为false
>=	如果符号前的数据大于或者等于符号后的数据为true，否则为false
<=	如果符号前的数据小于或者等于符号后的数据为true，否则为false
!=	如果符号前后不相等为true，否则为false

public class Demo01Compare {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;

        boolean result01 = i==j;
        System.out.println("result01 = " + result01); // result01 = false
        boolean result02 = i>j;
        System.out.println("result02 = " + result02); // result02 = false
        boolean result03 = i<j;
        System.out.println("result03 = " + result03); // result03 = true
        boolean result04 = i>=j;
        System.out.println("result04 = " + result04); // result04 = false
        boolean result05 = i<=j;
        System.out.println("result05 = " + result05); // result05 = true
        boolean result06 = i!=j;
        System.out.println("result06 = " + result06); // result06 = true
    }
}

2.4 逻辑运算符

作用：连接多个boolean结果的
结果：boolean型结果

符号	说明
&&（与，并且）	有假则假，符号前后有一个结果为false，整体就是false
\|\|（或者）	有真则真，符号前后有一个结果为true，整体就是true
！（非，取反）	不是true，就是false；不是false，就是true
^（异或）	符号前后结果一样为false，不一样为true true^true → false true^false → true false^true→ true false ^false → false

public class Demo01Logic {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;
        int k = 10;

        boolean result01 = (i>j) && i == k;
        System.out.println("result01 = " + result01); // result01 = false

        boolean result02 = (i>j) || i == k;
        System.out.println("result02 = " + result02); // result02 = true

        boolean result03 = (i>j) ^ i == k;
        System.out.println("result03 = " + result03); // result03 = true

        boolean result04 = !(i>j);
        System.out.println("result04 = " + result04); // result04 = true
    }
}

符号说明
& 1.单与，如果前后都是布尔型，有假则假；但是如果符号前为false，符号后的判断会继续执行
2.如果该符号前后都是数字，看做是为运算符
&& 1.双与，有假则假，但是有短路效果；如果符号前为false；符号后的判断就不会执行
| 1.单或，如果前后都是布尔型，有真则真；但是如果符号前为true，符号后面的判断会继续执行
2.如果该符号前后都是数字，看作为运算符
|| 1.双或，有真则真，但是有短路效果；如果符号前为true；符号后的判断就不会执行

符号	说明
&	1.单与，如果前后都是布尔型，有假则假；但是如果符号前为false，符号后的判断会继续执行 2.如果该符号前后都是数字，看做是为运算符
&&	1.双与，有假则假，但是有短路效果；如果符号前为false；符号后的判断就不会执行
\|	1.单或，如果前后都是布尔型，有真则真；但是如果符号前为true，符号后面的判断会继续执行 2.如果该符号前后都是数字，看作为运算符
\|\|	1.双或，有真则真，但是有短路效果；如果符号前为true；符号后的判断就不会执行

public class Demo02Logic {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        // boolean result01 = (++a > 100) & (++b > 10);
        // boolean result01 = (++a > 100) && (++b > 10); // 有短路效果
        // boolean result01 = (++a < 100) | (++b > 10);
        boolean result01 = (++a < 100) || (++b > 10); // 有短路效果
        System.out.println("result01 = " + result01);
        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
}

问题：定义一个变量（a），随意给一个值，判断这个变量接收的值是否在1-100之间

1<= a <=100 → 错误，这是数学的写法

i>=1 && i<=100 →正确，java的写法，用逻辑运算符拼接多个判断

2.5 三元运算符

格式

boolean 表达式 ? 表达式1 : 表达式2;
执行流程

先判断，如果是true，就走 ? 后面的表达式1；否则就走 : 后面的表达式2.

6.1 练习1

需求：小明考完试了，判断小明的分数是否及格，返回结果

public class Demo01Ternary {
    public static void main(String[] args) {
        // 定义一个变量，表示小明的分数
        int score = 90;
        String result = score >= 60 ? "及格" : "不及格";
        System.out.println("result = " + result);
    }
}

6.2 练习2

需求：有两个老人，年龄分别为70 80，求出两个老人的最高年龄

public class Demo02Ternary {
    public static void main(String[] args) {
        int old1 = 70;
        int old2 = 80;

        int max = old1 > old2 ? old1 : old2;
        System.out.println("max = " + max);
    }
}

6.3 练习3

需求：有三个老人，年龄分别为70 80 60，求出三个老人的最高年龄

public class Demo03Ternary {
    public static void main(String[] args) {
        int old1 = 70;
        int old2 = 80;
        int old3 = 60;

        int temp = old1 > old2 ? old1 : old2;

        int max = temp > old3 ? temp : old3;
        System.out.println("max = " + max);
    }
}