diff --git "a/29 \347\216\213\351\233\257\351\235\231/2022.11.24\345\246\202\344\275\225\344\270\213\350\275\275jdk\345\222\214\344\275\277\347\224\250git.md" "b/29 \347\216\213\351\233\257\351\235\231/20221124 \345\246\202\344\275\225\344\270\213\350\275\275jdk\345\222\214\344\275\277\347\224\250git.md.md"
similarity index 100%
rename from "29 \347\216\213\351\233\257\351\235\231/2022.11.24\345\246\202\344\275\225\344\270\213\350\275\275jdk\345\222\214\344\275\277\347\224\250git.md"
rename to "29 \347\216\213\351\233\257\351\235\231/20221124 \345\246\202\344\275\225\344\270\213\350\275\275jdk\345\222\214\344\275\277\347\224\250git.md.md"
diff --git "a/29 \347\216\213\351\233\257\351\235\231/20221125 idea\345\246\202\344\275\225\345\256\211\350\243\205 \351\205\215\347\275\256 \345\270\270\347\224\250\347\232\204\345\277\253\346\215\267\351\224\256\345\222\214\345\237\272\346\234\254\350\257\255\346\263\225.md.md" "b/29 \347\216\213\351\233\257\351\235\231/20221125 idea\345\246\202\344\275\225\345\256\211\350\243\205 \351\205\215\347\275\256 \345\270\270\347\224\250\347\232\204\345\277\253\346\215\267\351\224\256\345\222\214\345\237\272\346\234\254\350\257\255\346\263\225.md.md"
new file mode 100644
index 0000000000000000000000000000000000000000..feff730e9279e20615832eb40e7e2891f948e96a
--- /dev/null
+++ "b/29 \347\216\213\351\233\257\351\235\231/20221125 idea\345\246\202\344\275\225\345\256\211\350\243\205 \351\205\215\347\275\256 \345\270\270\347\224\250\347\232\204\345\277\253\346\215\267\351\224\256\345\222\214\345\237\272\346\234\254\350\257\255\346\263\225.md.md"	
@@ -0,0 +1,178 @@
+**IDEA**
+
+idea:用于JAVA语言的开发的集成环境
+
+集成环境：把代码编写，编译，运行调试多种功能综合到一起的开发工具
+
+下载：**：**https://www.jetbrains.com/idea 或国内镜像下载
+
+安装：建议修改安装路径
+
+**IDEA****中代码结构**
+
+1. 项目(project): 学生成绩管理 系统
+
+2. 模块(module) 老师录入模块,辅导员查询模块,学生查询模块
+
+3. 包(package) 文件夹
+
+4. 类(class) java源码的实际文件
+   
+   **IDEA中字体大小和背景主题的修改**
+
+打开文件选择设置选择外观胡总编辑器里面的主题或字体
+
+**注释的几种表达方式**
+
+1//单行注释
+
+2/*(星号）内容（星号）/多行注释*
+
+3/(星号*2)内容(星号)/文档注释
+
+**常用的快捷键**
+
+快速生成main方法和输出语句
+
+lmain方法：main或者psvm，回车
+
+l输出语句：sout，回车
+
+
+
+**常用快捷键******
+
+lCtrl+D：复制数据到下一行
+
+lCtrl+X：剪切数据，可以用来删除所在行
+
+lCtrl+Alt+L：格式化代码，建议自己写代码的时候就注意格式
+
+lCtrl+/：对选中的代码添加单行注释，如果想取消注释，再来一次即可
+
+lCtrl+Shift+/：对选中的代码添加多行注释，如果想取消注释，再来一次即可
+
+***基本语法***
+
+第一字面量
+
+第二数据类型
+
+第三变量
+
+第四关键字
+
+第五标识符
+
+1.字面量：直接写出来的人可以理解的数据
+
+| 字面量类型  | 说明         | 举例                     |
+| ------ | ---------- | ---------------------- |
+| 字符串字面量 | 用双引号括起来的内容 | “HelloWorld”,“java程序员” |
+| 整数字面量  | 不带小数的数字    | 666，-88                |
+| 小数字面量  | 带小数的数字     | 13.14，-5.21            |
+| 字符字面量  | 用单引号括起来的内容 | ‘A’，‘0’，‘我’            |
+| 布尔字面量  | 布尔值，表示真假   | 只有两个值：true，false       |
+
+小数自变量也叫做浮点
+
+2.数据类型
+
+| 数据           | 数据类型        |
+| ------------ | ----------- |
+| “HelloWorld” | 字符串类型（两个以上） |
+| 666          | 整数类型        |
+| 13.14        | 小数类型（浮点）    |
+| ‘A’          | 字符类型（一个）    |
+| true         | 布尔类型（只有两个值） |
+
+注意：
+
+Java语言是强类型语言，对于每一种数据都给出了明确的类型
+
+不同的数据类型分配了不同的内存空间
+不同的内存空间，所存储的数据大小是不一样的
+
+
+
+| 数据类型       | 关键字     | 占用内存                                                             | 取值范围                                                              |
+| ---------- | ------- | ---------------------------------------------------------------- | ----------------------------------------------------------------- |
+| 整数         | byte    | 1                                                                | -128~127                                                          |
+| short      | 2       | -32768~32767                                                     | -32768~32767                                                      |
+| int(默认)    | 4       | -2的31次方到2的31次方-1                                                 | -2的31次方到2的31次方-1                                                  |
+| long       | 8       | -2的63次方到2的63次方-1                                                 | -2的63次方到2的63次方-1                                                  |
+| 浮点数        | float   | 4                                                                | 负数：-3.402823E+38到-1.401298E-45正数：1.401298E-45到3.402823E+38        |
+| double(默认) | 8       | 负数：-1.797693E+308到-4.9000000E-324正数：4.9000000E-324到1.797693E+308 | 负数：-1.797693E+308到-4.9000000E-324
正数：4.9000000E-324到1.797693E+308 |
+| 字符         | char    | 2                                                                | 0~65535                                                           |
+| 布尔         | boolean | 1                                                                | true，false                                                        |
+
+3.变量：
+
+变量就是内存中的存储空间空间中存储的数据是可以发生改变。
+
+变量的定义格式：格式：数据类型 变量名 = 变量值;
+
+注意：根据变量名进行使用，可以输出，也可以修改值
+
+***变量名不能重复定义
+变量未赋值，不能使用
+定义long类型变量，数据后面加L
+定义float类型变量，数据后面加F***
+
+**
+
+4.关键字
+
+关键字：就是被Java语言赋予了特定含义的单词
+
+特点：
+
+关键字的字母全部小写
+常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观
+
+5.标识符
+
+标识符：就是给类，方法，变量等起名字的符号
+
+组成规则
+由数字、字母、下划线(_)和美元符($)组成
+
+***注意：***
+
+***不能以数字开头
+不能是关键字
+区分大小写***
+
+******
+
+****
+
+命名约定
+
+小驼峰命名法
+约定1：标识符一个单词的时候，首字母小写
+范1：name
+约定2：标识符是多个单词的时候，第一个单词首字母小写，其他单词首字母大
+
+例2：firstName
+
+大驼峰命名法
+约定1：标识符一个单词的时候，首字母大写
+范1：Hello
+约定2：标识符是多个单词的时候，每个单词首字母大写
+
+例2：Helloworld
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/29 \347\216\213\351\233\257\351\235\231/20221129  \351\224\256\347\233\230\347\232\204\345\275\225\345\205\245 \351\232\220\345\274\217\350\275\254\346\215\242 \345\274\272\345\210\266\350\275\254\346\215\242 \347\256\227\346\234\257\350\277\220\347\256\227\347\254\246 \345\255\227\347\254\246\357\274\210\345\255\227\347\254\246\344\270\262\357\274\211\347\232\204\342\200\234+\342\200\235\346\223\215\344\275\234 \346\225\260\345\200\274\347\232\204\346\213\206\345\210\206.md.md" "b/29 \347\216\213\351\233\257\351\235\231/20221129  \351\224\256\347\233\230\347\232\204\345\275\225\345\205\245 \351\232\220\345\274\217\350\275\254\346\215\242 \345\274\272\345\210\266\350\275\254\346\215\242 \347\256\227\346\234\257\350\277\220\347\256\227\347\254\246 \345\255\227\347\254\246\357\274\210\345\255\227\347\254\246\344\270\262\357\274\211\347\232\204\342\200\234+\342\200\235\346\223\215\344\275\234 \346\225\260\345\200\274\347\232\204\346\213\206\345\210\206.md.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6466457ae815b9132b22ad2f89f870568230ffcc
--- /dev/null
+++ "b/29 \347\216\213\351\233\257\351\235\231/20221129  \351\224\256\347\233\230\347\232\204\345\275\225\345\205\245 \351\232\220\345\274\217\350\275\254\346\215\242 \345\274\272\345\210\266\350\275\254\346\215\242 \347\256\227\346\234\257\350\277\220\347\256\227\347\254\246 \345\255\227\347\254\246\357\274\210\345\255\227\347\254\246\344\270\262\357\274\211\347\232\204\342\200\234+\342\200\235\346\223\215\344\275\234 \346\225\260\345\200\274\347\232\204\346\213\206\345\210\206.md.md"	
@@ -0,0 +1,276 @@
+# **键盘录入**
+
+操作：第一步 创建扫描器   
+
+​                                              {Scanner （变量名） = new Scanner(System.in);
+
+​           第二步 打印提示信息 提示用户输入
+
+​                                             System.our.println    (请输入您的姓名)
+
+​           第三步 创建对应的变量接受用户输入
+
+​                                              name = 变量名.next（）；
+
+例如：
+
+```java
+import java.util.Scanner;
+
+public class D2 {
+    public static void main(String[] args) {
+        String name;
+        int age;
+        String bj;
+        long xh;
+        double sg;
+        Scanner sc = new Scanner(System.in);//创建//
+        System.out.println("请输入您的姓名");//打印提示信息，提示用户输入//
+        name = sc.next();//输入//
+        System.out.println("年龄");
+        age = sc.nextInt();
+        System.out.println("班级");
+        bj = sc.next();
+        System.out.println("学号");
+        xh = sc .nextLong();
+        System.out.println("身高");
+        sg = sc.nextLong();
+    }
+}
+
+```
+
+#### **类型转换**：隐式转换（自动转换）
+
+####                    强制转换
+
+## *隐式转换：*
+
+把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，直接书写即可。
+
+```java
+double num = 10; // 将int类型的10直接赋值给double类型
+System.out.println(num); // 输出10.0
+```
+
+ 1.整数默认是int类型其他的还有byte short char类型运算都会自动转换为int类型
+
+  2.boolean（布尔）类型不可以和其他基本类型相互转换（因为布尔只有两个值 ture  false）
+
+## 强制转换：
+
+​	把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。
+
+强制类型转换格式：
+
+目标数据类型 变量名 = （目标数据类型）值或变量值
+
+例如：
+
+```java
+double num1 = 5.5;
+int num2 = (int) num1; // 将double类型的num1强制转换为int类型
+System.out.println(num2); // 输出5（小数位直接舍弃）
+```
+
+##### 案例代码：
+
+```java
+byte a = 3;
+byte b = 4;
+byte c = a + b; //错误。因为两个byte变量相加，会先提升为int类型
+byte d = 3 + 4; //正确。常量优化机制
+```
+
+**常量优化机制**：
+
+​	在编译时，整数常量的计算会直接算出结果，并且会自动判断该结果是否在byte取值范围内，
+
+- 在：编译通过
+- 不在：编译失败
+
+**运算符**
+
+运算符：对常量或者变量进行操作的符号
+
+表达式：用运算符把常量或者变量连接起来符合Java语法的式子就可以称为表达式。
+
+​                    不同运算符连接的表达式体现的是不同类型的表达式。
+
+举例说明：
+
+```java
+int a = 10;
+int b = 20;
+int c = a + b;
+```
+
+  +：是运算符，并且是算术运算符。
+
+  a + b：是表达式，由于+是算术运算符，所以这个表达式叫算术表达式。 a和b称为操作数
+
+| 符号 | 作用 | 说明                         |
+| :--: | :--: | ---------------------------- |
+|  +   |  加  | 参看小学一年级               |
+|  -   |  减  | 参看小学一年级               |
+|  *   |  乘  | 参看小学二年级，与“×”相同    |
+|  /   |  除  | 参看小学二年级，与“÷”相同    |
+|  %   | 取余 | 获取的是两个数据做除法的余数 |
+
+**注意：**
+
+1. /和%的区别：两者都做除法，
+   - / 取结果的商，
+   - % 取结果的余数。
+   - 整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。
+
+
+~~~java
+int a = 10;
+int b = 3;
+System.out.println(a / b); // 输出结果
+System.out.println(a % b); // 输出结果
+~~~
+
+
+
+#### 字符的“+”操作
+
+char类型参与算术运算，使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值：
+
+'a'  --  97		a-z是连续的，所以'b'对应的数值是98，'c'是99，依次递加
+
+'A'  --  65		A-Z是连续的，所以'B'对应的数值是66，'C'是67，依次递加
+
+'0'  --  48		0-9是连续的，所以'1'对应的数值是49，'2'是50，依次递加
+
+~~~java
+// 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少
+char ch1 = 'a';
+System.out.println(ch1 + 1); // 输出98，97 + 1 = 98
+
+char ch2 = 'A';
+System.out.println(ch2 + 1); // 输出66，65 + 1 = 66
+
+char ch3 = '0';
+System.out.println(ch3 + 1); // 输出49，48 + 1 = 49
+~~~
+
+算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。
+
+**提升规则：**
+
+```java
+1. byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。
+2. 整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型    
+3.  等级顺序：byte,short,char --> int --> long --> float --> double
+```
+
+例如：
+
+~~~java
+byte b1 = 10;
+byte b2 = 20;
+// byte b3 = b1 + b2; // 该行报错，因为byte类型参与算术运算会自动提示为int，int赋值给byte可能损失精度
+int i3 = b1 + b2; // 应该使用int接收
+byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型
+-------------------------------
+int num1 = 10;
+double num2 = 20.0;
+double num3 = num1 + num2; // 使用double接收，因为num1会自动提升为double类型
+~~~
+
+####  字符串的“+”操作
+
+当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。【+号的左右两边任意一边出现字符串，那这个就个拼接符】
+
+当+号是拼接符的时候。得到的结果，也是字符串
+
+~~~java
+System.out.println("qiuqiu"+ 666); // 输出：qiuqiu666
+~~~
+
+在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。
+
+~~~java
+System.out.println(1 + 99 + "年白酒");            // 输出：100年白酒
+System.out.println(1 + 2 + "兔子" + 3 + 4);   // 输出：3兔子34  // 只要前面有字符串，后面都被污染成字符串
+// 可以使用小括号改变运算的优先级 
+System.out.println(1 + 2 + "兔子" + (3 + 4)); // 输出：3兔子7
+~~~
+
+#### 数值拆分
+
+需求：
+
+​	键盘录入一个三位数，将其拆分为个位，十位，百位，打印在控制台
+
+示例代码：
+
+```java
+import java.util.Scanner;
+public class Test {
+	public static void main(String[] args) {
+		// 1：使用Scanner键盘录入一个三位数
+		Scanner sc = new Scanner(System.in);
+		System.out.println("请输入一个三位数");
+		int num = sc.nextInt();
+		// 2：个位的计算：数值 % 10
+		int ge = num % 10;		
+		// 3：十位的计算：数值 / 10 % 10
+		int shi = num / 10 % 10;	
+		// 4：百位的计算：数值 / 100
+		int bai = num / 100;
+		// 5：将个位, 十位, 百位拼接上正确的字符串, 打印即可
+		System.out.println("整数"+num+"个位为:" + ge);
+		System.out.println("整数"+num+"十位为:" + shi);
+		System.out.println("整数"+num+"百位为:" + bai);
+		
+	}
+}
+```
+
+
+
+# 作业1：
+
+```java
+import java.util.Scanner;
+
+public class a1 {
+    public static void main(String[] args) {
+        int num;
+        Scanner sc = new Scanner(System.in);
+        System.out.println("请输入四位数字：");
+        num = sc.nextInt();
+        System.out.println("个位："+num%10);
+        System.out.println("十位："+num/10%10);
+        System.out.println("百位："+num/100%10);
+        System.out.println("千位："+num/1000);
+
+    }
+}
+
+```
+
+# 作业2：
+
+```java
+import java.util.Scanner;
+
+public class a2 {
+    public static void main(String[] args) {
+        double num1;
+        double num2;
+        Scanner sc = new Scanner(System.in);
+        System.out.println("华氏温度:");
+        num1 = sc.nextDouble();
+        System.out.println("摄氏温度:"+((num1-32)*5/9));
+        System.out.println("摄氏温度:");
+        num2 = sc.nextDouble();
+        System.out.println("华氏温度:"+(num2*9/5+32));
+    }
+}
+
+```
+
diff --git "a/29 \347\216\213\351\233\257\351\235\231/20221201 \350\207\252\345\242\236\350\207\252\345\207\217  \350\265\213\345\200\274\350\277\220\347\256\227 \345\205\263\347\263\273\357\274\210\347\237\255\350\267\257\351\200\273\350\276\221 \344\270\211\345\205\203\357\274\211\350\277\220\347\256\227\347\254\246.md" "b/29 \347\216\213\351\233\257\351\235\231/20221201 \350\207\252\345\242\236\350\207\252\345\207\217  \350\265\213\345\200\274\350\277\220\347\256\227 \345\205\263\347\263\273\357\274\210\347\237\255\350\267\257\351\200\273\350\276\221 \344\270\211\345\205\203\357\274\211\350\277\220\347\256\227\347\254\246.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2758b9448f563adcc7e4699ddcadc828b54557d9
--- /dev/null
+++ "b/29 \347\216\213\351\233\257\351\235\231/20221201 \350\207\252\345\242\236\350\207\252\345\207\217  \350\265\213\345\200\274\350\277\220\347\256\227 \345\205\263\347\263\273\357\274\210\347\237\255\350\267\257\351\200\273\350\276\221 \344\270\211\345\205\203\357\274\211\350\277\220\347\256\227\347\254\246.md"	
@@ -0,0 +1,395 @@
+## 自增自减运算符
+
+自增：变量值加1
+
+符号：++
+
+自减：变量值减1
+
+符号：--
+
+例如：
+
+```java
+public class D1 {
+    public static void main(String[] args) {
+        int i = 1;
+        i++; // 单独使用
+        System.out.println("i:" + i); // i:2
+
+
+
+        int j = 1;
+        ++j; // 单独使用
+        System.out.println("j:" + j); // j:2
+
+
+        int x = 10;
+        int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
+        System.out.println("x:" + x + ", y:" + y); // x:11，y:10
+
+        int m = 10;
+        int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
+        System.out.println("m:" + m + ", n:" + n); // m:11，n:11
+
+
+    }
+}
+
+```
+
+注意事项：
+
+​    ++和-- 既可以放在变量的后边，也可以放在变量的前边。
+
+​    单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的。
+
+​    参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者--。
+
+​    参与操作的时候，如果放在变量的前边，先拿变量做++或者--，后拿变量参与操作。
+
+​    最常见的用法：单独使用。
+
+## 赋值运算符
+
+#### 赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。
+
+##### 1符号：=
+
+##### 作用：赋值
+
+##### 说明：a=10，将10赋值给变量a
+
+##### 2符号：+=
+
+##### 作用：先加后赋值
+
+##### 说明：a+=b，将a+b值给变量a
+
+##### 3符号：-=
+
+##### 作用：先减后赋值
+
+##### 说明：a-=b，将a-b值给变量a
+
+##### 4符号：*=
+
+##### 作用：先乘后赋值
+
+##### 说明：a=b，将ab值给变量a
+
+##### 5符号：/=
+
+##### 作用：除后赋值赋值
+
+##### 说明：a/=b，将a/b商给变量a
+
+##### 6符号：%=
+
+##### 作用：取余后赋值
+
+##### 说明：a%=b，将a%b余数给变量a
+
+注意：
+
+扩展的赋值运算符隐含了强制类型转换。
+
+例如：
+
+```java
+public class D1 {
+    public static void main(String[] args) {
+        short s = 10;
+        s =s + 10;//因为运算中s会自动提升为int类型，运算结果int赋值给short可能不准确
+
+        s += 10;  //隐含了强制类型转换，相当于s = （short） （s + 10）；20
+
+        s -= 10;    // 相当于 x= （short） （s + 20）；0
+
+
+
+    }
+}
+
+```
+
+## 关系运算符
+
+##### 1符号 ：==
+
+##### 说明：a==b，判断a和b的值是否相等，成立为true，不成立为false
+
+##### 2符号 ：！=
+
+##### 说明：a!=b，判断a和b的值是否不相等，成立为true，不成立为false
+
+##### 3符号 ：>
+
+##### 说明：a>b，判断a是否大于b，成立为true，不成立为false
+
+##### 4符号 ：>=
+
+##### 说明：a>=b，判断a是否大于等于b，成立为true，不成立为false
+
+##### 5符号 ：<
+
+##### 说明：a<b，判断a是否小于b，成立为true，不成立为false
+
+##### 6符号 ：<=
+
+##### 说明：a<=b，判断a是否小于等于b，成立为true，不成立为false
+
+注意事项：
+
+​    关系运算符的结果都是boolean类型，要么是true，要么是false。
+
+​    千万不要把“==”误写成“=”，"=="是判断是否相等的关系，"="是赋值。
+
+```java
+public class D1 {
+    public static void main(String[] args) {
+        int a = 10;
+        int b = 20;
+        System.out.println(a == b); // false
+        System.out.println(a != b); // true
+        System.out.println(a > b); // false
+        System.out.println(a >= b); // false
+        System.out.println(a < b); // true
+        System.out.println(a <= b); // true
+
+        // 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
+        boolean flag = a > b;
+        System.out.println(flag); // 输出false
+        }
+}
+
+
+```
+
+## 逻辑运算符
+
+逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。（Boolean）
+
+##### 1符号：&
+
+##### 作用：逻辑与
+
+##### 说明：a&b，a和b都是true，结果为true，否则为false（两真）
+
+##### 2符号：|
+
+##### 作用：逻辑或
+
+##### 说明：a\|b，a和b都是false，结果为false，否则为true（有真就真）
+
+##### 3符号：^
+
+##### 作用：逻辑异或
+
+##### 说明：a^b，a和b结果不同为true，相同为false（一真一假则为真）
+
+##### 4符号：!
+
+##### 作用：逻辑非
+
+##### 说明：!a，结果和a的结果正好相反（取反）
+
+```java
+public class D1 {
+    public static void main(String[] args) {
+        //定义变量
+       int i = 10;
+       int j = 20;
+       int k = 30;
+       //& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
+       System.out.println((i > j) & (i > k)); //false & false,输出false
+       System.out.println((i < j) & (i > k)); //true & false,输出false
+       System.out.println((i > j) & (i < k)); //false & true,输出false
+       System.out.println((i < j) & (i < k)); //true & true,输出true
+       System.out.println("--------");
+
+       //| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
+       System.out.println((i > j) | (i > k)); //false | false,输出false
+       System.out.println((i < j) | (i > k)); //true | false,输出true
+       System.out.println((i > j) | (i < k)); //false | true,输出true
+       System.out.println((i < j) | (i < k)); //true | true,输出true
+       System.out.println("--------");
+
+       //^ “异或”，相同为false，不同为true
+       System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
+       System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
+       System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
+       System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
+       System.out.println("--------");
+
+       //! “非”，取反
+       System.out.println((i > j)); //false
+       System.out.println(!(i > j)); //!false，,输出true
+
+
+    }
+}
+```
+
+## 短路逻辑运算符
+
+##### 短路：前面一个条件判断条件已经可以决定最终结果就没有必要执行下一步。
+
+**1符号：&&**
+
+  **作用：短路与**
+
+  **说明：作用和&相同，但是有短路效果**
+
+**2符号：**||
+
+**作用：短路或**
+
+**说明：作用和\|相同，但是有短路效果**
+
+在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。
+
+* 逻辑与&，无论左边真假，右边都要执行。
+
+* 短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
+
+* 逻辑或|，无论左边真假，右边都要执行。
+
+* 短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。
+
+```java
+int x = 3;
+int y = 4;
+System.out.println((x++ > 4) & (y++ > 5)); // 两个表达都会运算
+System.out.println(x); // 4
+System.out.println(y); // 5
+
+System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false，右边不参与运算
+System.out.println(x); // 4
+System.out.println(y); // 4
+```
+
+## 三元运算符
+
+语法格式：
+
+关系表达式？表达式1：表达式2
+
+解释：问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1，为false时调用表达式2。
+
+其逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。
+
+例如:
+
+```ja
+
+作业3:
+
+利用三元运算符求任意三个数中最大者 【三元】
+
+```java
+import java.util.Scanner;
+
+public class D1 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        System.out.println("请输入第一个数：");
+            int height  = sc .nextInt();
+        System.out.println("请输入第二个数：");
+            int num1   = sc .nextInt();
+        System.out.println("请输入第三个数：");
+            int num2  = sc .nextInt();
+         int height1 = num1>num2? num1:num2;
+         int maxnum = height1>height? height1:height;
+        System.out.println("最大值：" +maxnum);
+
+    }
+}
+
+```
+
+作业4:
+
+若任意两数和是3的倍数或其中一个为3，则输出true，否者输出false 【断路或】
+
+```java
+import java.util.Scanner;
+
+public class D2 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+         System.out.println("请输入第一个数：");
+           int num1 = sc .nextInt();
+         System.out.println("请输入第二个数：");
+           int num2 = sc.nextInt();
+           int num8 = num1+num2;
+           boolean num3 = num8%3==0;
+           boolean num5 = num1==3;
+           boolean num6 = num2==3;
+           boolean num7 = (num5 || num6);
+           boolean num4 =num3 || num7;
+           System.out.println(num4);
+    }
+}
+    
+
+
+```
+
+作业5:
+
+身高是具有遗传性的，子女的身高和父母的身高有一定的关系。假定，父母和子女的身高遗传关系如下：
+
+> 儿子身高（厘米）＝(父亲身高＋母亲身高) ×1.08÷2
+> 
+> 女儿身高（厘米）＝(父亲身高×0.923＋母亲身高) ÷2
+> 
+> 现有父亲身高177CM,母亲身高165CM。求子女身高分别预计为多少？【使用变量的定义和算术运算符完成本题】
+
+```java
+public class D3 {
+    public static void main(String[] args) {
+        double dad = 177;
+        double mon = 165;
+        System.out.println("儿子身高：" + (dad + mon ) *1.08 /2);
+        System.out.println("女儿身高：" + (dad*0.923 + mon ) /2);
+    }
+}
+
+```
+
+作业6:
+
+红茶妹妹有21元钱，她攒了几天钱之后自己的钱比原来的两倍还多三块。绿茶妹妹有24元钱，她攒了几天钱之后自己的钱正好是原来的两倍。那么红茶和绿茶现在的钱一样多，请问对么？【使用赋值运算符和算术运算符计算各自的钱，使用比较运算符对比大小】
+
+```java
+public class D4 {
+    public static void main(String[] args) {
+        int redtea = 21;
+        int greentea = 24;
+        System.out.println("那么红茶和绿茶现在的钱一样多，请问对么？" + ((redtea*2+3)== greentea*2));
+    }
+}
+
+```
+
+作业7:
+
+小明想在食堂打包一份午饭，商家的优惠方式如下：鱼香肉丝单点24元，油炸花生米单点8元，米饭单点3元。订单满30元8折优惠。鱼香肉丝优惠价16元，但是优惠价和折扣不能同时使用。那么这个小伙要点这三样东西，最少要花多少钱？【使用算术运算符、赋值运算符和三元运算符联合完成本题】
+
+```java
+public class D5 {
+    public static void main(String[] args) {
+ public static void main(String[] args) {
+        double num1 = 24;
+        double num2 = 8;
+        double num3 = 3;
+        double num4 = (num1+num2+num3)*0.8;
+        double num5 = 16+num2+num3;
+        double num6 = num4 < num5 ? num4:num5;
+        System.out.println("最少要花多少钱？"+num6);
+    }
+}
+
+
+```