From 9f1c839adee9bff22c921f7fceed184a56b2ab50 Mon Sep 17 00:00:00 2001
From: YinShunyu <1648067239@qq.com>
Date: Fri, 31 Oct 2025 18:11:02 +0800
Subject: [PATCH] =?UTF-8?q?=E5=B0=B9=E9=A1=BA=E5=AE=8710.31=E7=AC=AC?=
 =?UTF-8?q?=E4=B8=80=E6=AC=A1=E6=8F=90=E4=BA=A4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../尹顺宇10.31学习总结.docx                | Bin 0 -> 10546 bytes
 尹顺宇10.31作业/尹顺宇10.31学习笔记.md | 560 +++++++++++++++++++++
 2 files changed, 560 insertions(+)
 create mode 100644 尹顺宇10.31作业/尹顺宇10.31学习总结.docx
 create mode 100644 尹顺宇10.31作业/尹顺宇10.31学习笔记.md

diff --git a/尹顺宇10.31作业/尹顺宇10.31学习总结.docx b/尹顺宇10.31作业/尹顺宇10.31学习总结.docx
new file mode 100644
index 0000000000000000000000000000000000000000..7ec72f48e83fb561f768ed5d1759e3641b348c46
GIT binary patch
literal 10546
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
TAKy9*Fv)QW{5;9iJcIrp#Fl=D

literal 0
HcmV?d00001

diff --git a/尹顺宇10.31作业/尹顺宇10.31学习笔记.md b/尹顺宇10.31作业/尹顺宇10.31学习笔记.md
new file mode 100644
index 0000000..73834de
--- /dev/null
+++ b/尹顺宇10.31作业/尹顺宇10.31学习笔记.md
@@ -0,0 +1,560 @@
+# Javase回顾
+## 1.环境
+jdk8及之前：jdk+jre
+jdk：java development kit
+jre:  java runtime environment
+jdk8以后：只有jdk
+环境变量配置只需要配置JAVAHOME和path里面指向JAVAHOME的bin
+## 2.开发工具
+idea(目前最流行)
+eclipse(已经不常用)
+## 3.基础语法
+### 3.1 java语言特点
+简单，严谨，易读
+编译+解释
+### 3.2  8种基本数据类型
+
+|数据类型    |  精度 | 范围|
+|--|--|--|
+| byte  |     1   |-2^7^ ~ 2^7^-1（-128～127）
+| short  |   2|-2^15^ ~ 2^15^-1（-32768 ~ 32767）
+| int |   4|-2^31^ ~ 2^31^-1（约21亿多）
+|long|   8  |-2^63^~ 2^63^-1（-9223372036854775808 ～ 9223372036854775807）
+| float    |    4    |约±3.4e38（± 3.4 × 10^38^  ）
+| double  |   8      |	约±1.7e308（± 1.7 × 10^308^ ）
+| char    |      2   |0 ~ 65535（Unicode）
+| boolean  |     1(不一定，不同虚拟机不一样 )    |																																																					
+### 3.3 运算符
+> 算数运算符   ：+   -    *    /    %  双目运算符
+> 比较运算符   ： > ,  <,   >= ,   <=,   == ,  !=   计算结果是boolean值
+> 逻辑运算符:&& , ||,  !    运算结果是boolean值，存在短路运算
+> 赋值运算符： =  ,+=,   -=,    *=  ,  /=   
+> 条件运算符 a?b:c  唯一的三目运算符
+> 位运算符：基本用不到    
+> 其他运算符：instanceof   (例：a instanceof   b  )
+> 表达式（有值）
+> ### 3.4语句   
+> java代码执行的基本单位
+
+>流程控制语句：
+>1.顺序结构：
+>2.分支结构：
+>3.循环结构：
+
+### 3.5 数组
+>int[] a = new int[](1,2,3}
+>获取数组长度。.length属性，只读。
+>如果访问数组元素。索引（下标），整数，包括0，不能是负数，不能是小数，不能超
+>出边界。
+
+```java
+public class Test1 {
+    public static void main(String[] args) {
+        int[] a = new int[5];
+        int[] b = new int[]{1, 2, 3, 4, 5};
+        int[] c = {1, 2, 3, 4, 5};
+        System.out.println(c.length);
+        a[0] = 1;
+        a[1] = 2;
+        a[40] = 4;
+    }
+}
+
+```
+
+```java
+import java.util.Arrays;
+
+public class Test2 {
+    public static void main(String[] args) {
+        int[] arr = new int[20];
+        //存入随机数
+        for (int i = 0; i < arr.length; i++) {
+            arr[i] = (int) (Math.random() * 100);
+        }
+        //输出随机数数组
+        System.out.println(Arrays.toString(arr));
+
+        boolean found = false;
+        //判断生成的随机数数组中包不包含50并给出下标
+        for (int i = 0; i < arr.length; i++) {
+            if (arr[i] == 50) {
+                found = true;
+                System.out.println(i);
+                break;
+            }
+        }
+        if (!found) {
+            System.out.println("无此值");
+        }
+
+    }
+}
+
+
+```
+
+数组应用：   
+排序:冒泡，选择，快排
+
+```java
+import java.util.Arrays;
+
+public class Test3 {
+    public static void main(String[] args) {
+        int[] arr = {44, 64, 35, 66, 10, 67, 86, 32, 2, 44};
+        quickSort2(arr);//调用函数
+        System.out.println(Arrays.toString(arr));
+    }
+
+    //冒泡
+    static void bubbleSort(int[] arr) {
+        for (int i = 0; i < arr.length - 1; i++) {
+            for (int j = 0; j < arr.length - 1 - i; j++) {
+                if (arr[j] < arr[j + 1]) {
+                    int temp = arr[j];
+                    arr[j] = arr[j + 1];
+                    arr[j + 1] = temp;
+                }
+            }
+        }
+    }
+
+    static void bubbleSort2(int[] arr) {
+        for (int i = 0; i < arr.length - 1; i++) {
+            for (int j = 0; j < arr.length - 1 - i; j++) {
+                if (arr[j] > arr[j + 1]) {
+                    int temp = arr[j];
+                    arr[j] = arr[j + 1];
+                    arr[j + 1] = temp;
+                }
+            }
+        }
+    }
+
+    //选择
+    static void selectSort(int[] arr) {
+        for (int i = 0; i < arr.length - 1; i++) {
+            for (int j = i + 1; j < arr.length; j++) {
+                if (arr[j] < arr[i]) {
+                    int temp = arr[j];
+                    arr[j] = arr[i];
+                    arr[i] = temp;
+                }
+            }
+        }
+    }
+
+    static void selectSort2(int[] arr) {
+        for (int i = 0; i < arr.length - 1; i++) {
+            for (int j = i + 1; j < arr.length; j++) {
+                if (arr[j] < arr[i]) {
+                    int temp = arr[i];
+                    arr[i] = arr[j];
+                    arr[j] = temp;
+                }
+            }
+        }
+    }
+
+    //快排
+    static void quickSort(int[] arr) {
+        quickSort(arr, 0, arr.length - 1);
+    }
+
+    static void quickSort2(int[] arr) {
+        quickSort2(arr, 0, arr.length - 1);
+    }
+
+
+    //快排实现
+    static void quickSort(int[] arr, int low, int high) {
+        if (low >= high) {
+            return;
+        }
+        int pivot = arr[low];//基准值
+        int left = low;//左指针
+        int right = high;//右指针
+
+        while (left < right) {
+            //右指针不断左移
+            while (left < right && arr[right] >= pivot) {
+                right--;
+            }
+            //左指针不断右移
+            while (left < right && arr[left] <= pivot) {
+                left++;
+            }
+
+            if (left < right) {
+                int temp = arr[left];
+                arr[left] = arr[right];
+                arr[right] = temp;
+            }
+        }
+
+        //二者相遇
+        if (left != low) {
+            arr[low] = arr[left];
+            arr[left] = pivot;
+        }
+
+        //递归
+        quickSort(arr, low, left - 1);//对左区递归
+        quickSort(arr, left + 1, high);//对右区递归
+    }
+
+    static void quickSort2(int[] arr, int low, int high) {
+        if (low > high) {
+            return;
+        }
+        int target = arr[low];
+        int left = low;
+        int right = high;
+
+        while (left < right) {
+            while (left < right && arr[right] >= arr[low]) {
+                right--;
+            }
+            while (left<right &&arr[left]<=arr[low]){
+                left++;
+            }
+            if(left<right){
+                int temp = arr[left];
+                arr[left]=arr[right];
+                arr[right]=temp;
+            }
+
+        }
+        //left和right相遇
+        if(left!=low){
+            arr[low]=arr[left];
+            arr[left]=target;
+        }
+        quickSort2(arr,low,left-1);
+        quickSort2(arr,left+1,high);
+
+    }
+}
+
+```
+
+查找：二分查找
+
+```java
+public class Test4 {
+    public static void main(String[] args) {
+        int[] arr = {2, 10, 32, 35, 44, 44, 64, 66, 67, 86};
+        int idx = find2(arr, 0, arr.length - 1, 67);
+        System.out.println(idx);
+    }
+
+    static int find(int[] arr, int low, int high, int target) {
+        if (low >= high) {
+            return -1;
+        }
+        int mid = (low + high) / 2;
+        if (target == arr[mid]) {
+            return mid;
+        } else if (target < arr[mid]) {
+            return find(arr, low, mid - 1, target);
+        } else {
+            return find(arr, mid + 1, high, target);
+        }
+    }
+
+    static int find2(int[] arr, int low, int high, int target) {
+        if (low >= high) {
+            return -1;
+        }
+        int mid = (low + high) / 2;
+        if (target == arr[mid]) {
+            return mid;
+        } else if (target < arr[mid]) {
+            return find2(arr, low, mid - 1, target);
+
+        } else {
+            return find2(arr, mid + 1, high, target);
+        }
+    }
+}
+
+```
+
+### 3.6 函数（方法）
+
+### 3.7 面向对象
+类：类型，将很多实例抽取共性，总结归纳
+对象：独一无二的实例，在java中，对象通过类创建
+
+创建对象：new 构造方法（）
+
+### 3.8封装
+将成员属性和成员方法包含到一个类中，选择性的对外开放成员。
+
+成员访问修饰符：对外开放程度
+public：公开，公有的，任何位置都可访问。
+protected：受保护的，包内及后代可以访问。
+<空>：包内访问。
+private：当前类内部访问。
+### 3.9 继承
+单继承，默认继承自object,顶级根类
+1.非私有成员可以被继承
+2.构造函数不能被继承
+
+protect:
+super:父对象
+this:当前对象
+
+```java
+package com.situ.chapter1;
+
+public class Person {
+    public int age;//年龄
+    private String name;//姓名
+//无参构造方法
+    public Person() {
+
+    }
+//有参构造
+    public Person(String name) {
+        this.name = name;
+        System.out.println("创建Person对象");
+    }
+
+    //行为
+    protected void sayHello() {
+        System.out.println("父亲sayHello");
+    }
+
+    void wang() {
+        System.out.println("aaa");
+        sayHello();
+    }
+}
+
+```
+
+```java
+package com.situ.chapter1;
+
+public class Teacher extends Person {
+
+    public Teacher() {
+        super();
+    }
+
+    @Override
+    protected void sayHello() {
+        System.out.println("儿子sayHello");
+    }
+
+    public void sayBye() {
+        this.sayHello();
+        super.sayHello();
+
+        //System.out.println(super.name);
+    }
+}
+```
+
+```java
+package com.situ.chapter1;
+
+public class Test1 {
+    public static void main(String[] args) {
+       Person person = new Person();
+        person.sayHello();
+        person.wang();
+        System.out.println("---------------");
+        Teacher teacher = new Teacher();
+        teacher.sayHello();
+        teacher.sayBye();
+
+    }
+}
+```
+
+访问构造函数：
+this（xxx）：调用当前类的构造函数	
+super(xxx)：调用父类的构造函数
+
+构造函数：对对象的成员属性进行初始化
+1.与类同名
+2.无返回值
+3.如果一个类没有显式定义构造函数，会自动创建一个公有的无参的构造函数,如果显式指定了构造函数，就不会再自动创建无参构造函数
+4.构造函数是类成员，可以指定修饰符
+5.创建对象时，使用new<构造函数>（xxx）
+6.创建子类对象时，必须先调用父类的构造函数
+7.一个构造函数的第一句代码必须是this(xxx)或者super（xxx）,有且只有一次调用
+8.如果没有显式调用this(xxx)或super(xxx),默认调用super()
+### 3.10 多态（非常重要）
+
+在程序运行期间，同一行为，表现出多种形态
+1.继承或接口
+2。重写
+3.使用一个父类型（祖先类型）的引用指向一个子类（后代类）的实例
+
+```java
+package com.situ.chapter2;
+
+public class Animal {
+    public void run() {
+        System.out.println("动物在跑");
+    }
+}
+
+```
+
+```java
+package com.situ.chapter2;
+
+public class Cat extends Animal {
+    private static String name;
+
+    @Override
+    public void run() {
+        System.out.println("猫在跑");
+    }
+}
+
+```
+
+```java
+package com.situ.chapter2;
+
+public class Fish extends Animal {
+    @Override
+    public void run() {
+        System.out.println("鱼在跑");
+    }
+}
+
+```
+
+```java
+package com.situ.chapter2;
+
+public class Test1 {
+    static int a = 10;
+    public static void main(String[] args) {
+        Animal animal = new Cat();
+        run(animal);
+    }
+
+    static void run(Animal animal) {
+        animal.run();
+    }
+}
+```
+### 3.11 static和final
+static成员即类成员，属于类的，不属于某个对象，通过类名称直接访问
+
+final：表示最终的，不变的
+1.修饰类，表示类不能被继承
+2.修饰方法：表示方法不可被重写
+3.修饰变量：表示变量为不可变的变量（常量）
+
+### 3.12 抽象类和接口
+抽象方法：只有方法定义，没有实现的方法，叫抽象方法
+抽象类：使用abstract关键字
+1.使用abstract关键字
+2.不能创建实例（对象）
+3.除此之外，和普通类没有区别。
+4.可以有构造函数。
+5.抽象类中允许有抽象方法(也可以没有)，普通类中一定没有抽象方法。
+6.一个类中只要有抽象方法，则必须是抽象类
+
+接口：
+1.接口不是类。
+2.接口中只能有抽象方法()，jdk1.8之后新增：静态方法（static）和默认方法(default)
+3.接口中的方法默认是public  abstract修饰，不写也行
+4.接口中的静态方法和类中的静态方法类似
+可直接接口名调用
+5.接口中的默认方法可被继承到实现类中，在默认方法中可以使用this关键字，由实现类来调用
+
+接口提供一定的规范和约束，不提供实现
+实现类去实现接口  implements实现接口
+实现类必须对接口中的方法提供实现，如果不能，则只能为抽象类
+
+
+### 3.13 常用类
+1.Object：所有类的终极父类。没有父类
+hashCode:用于生成对象的唯一(尽量唯一)标识码
+默认返回对象的内存地址。
+equals:用于判定两个对象是否逻辑上相等，逻辑是由程序员决定的，重写。默认比较是否同一个内存地址
+toString:将一个对象以字符串的形式展示
+clone():克隆一个对象
+getClass:获取对象的类型实例（Class）
+
+2.String:表达式字符串，不可继承。内容不可变
+3.Math：数学相关方法
+4.Date：日期相关。LocalDate,LocalTime,LocalDateTime
+
+### 3.14 集合相关类：
+1.List:ArrayList，LinkedList.列表：有序，可重复。
+2.set:HashSet 集合,无序，不重复
+3.Map:HashMap  映射：存储键-值对，键无序，不重复
+
+### 3.15 泛型
+<T> 类型变量
+
+### 3.16异常
+程序出错时的处理方式.挽救或补回措施
+try...catch...finally
+caatch可以已有多个分支，第一个分支，捕获某一个类型的异常
+finally分支中的代码一定会执行，无论是否出现异常
+
+异常是有类型的
+
+异常分两种：
+异常分成两种：
+1.编译时异常，检查异常  ，checkedException。在编译期就要求处理异常。
+2.运行时异常。RuntimeException。
+
+
+
+### 3.17 IO
+Input & Output   流对象完成输入输出的
+
+流动的方向分为输入流和输出流
+
+流动的单位：字节流和字符流
+
+介质类型：文件流，网络流，数组流
+
+以Stream结尾的是字节流
+以InputStream结尾的是输入流
+流在使用完之后必须关闭，如果忘记，容易内存泄漏
+
+
+throws：写在方法后面，表示此方法向上抛出异常
+throw:原地抛出（触发，引发）异常
+
+### 3.18 多线程
+进程：Process,操作系统管理的独立的分配资源的单位，依靠端口进行通信
+一个程序至少有一个进程。
+如：QQ此时6个进程
+![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/f000c716e26b4ac385455546ca2556bb.png)
+
+
+线程：Thread。一个进程中可以包含至少一个线程。所有线程共享进程的资源。线程是cpu可调度的最小单位
+
+cpu:单核。一个核心。
+多核。真正的并行。
+web开发程序都是并行的，多线程。
+![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/ac0c637b29364252bc4fef75de588a71.png)
+
+### 3.18 反射
+反射：java的灵魂,在程序运行期间，在无法直接使用目标类的情况下，以一种间接的方式，去操作对象。
+Reflect: 镜像。
+
+常用类：
+Class: 描述其他类，描述类的类
+Field:  描述字段的类。描述成员属性
+Method:描述成员方法的。
+Constructor:描述构造函数的。
+Parameter:描述方法的参数的。
+Annotation:描述注解的。
+
+获取Class类型实例三种方式：
\ No newline at end of file