2022-8-12 第一组 (≥▽≤) JavaSE总结

1.异常

最顶级的异常类：Throwable
- 错误（Error）：无法处理的错误，只能去修改源代码。
  - 错误一般情况下不会遇见
- 异常最顶级的父类（Exception）

1.1运行器异常

在运行时抛出的异常

英文	中文
NullPointerException	空指针异常
ArithmeticException	除数为0异常
IndexOutOfBoundsException	下标越界异常

1.2编译器异常

写代码的时候出现的异常

英文	中文
IOException	IO异常
FileNotFoundException	文件未找到异常

1.3处理异常

try...catch

try{
    // 有可能出现异常的代码
}catch{
    // 出现异常时要执行的代码
                // 打印值栈信息
            e.printStackTrace();
            // 获取异常信息
            System.out.println(e.getMessage());
}finally{
	// 一定会执行的代码——无论是否出现异常
}

catch用法：
- catch可以有多个
- catch中捕获异常要有顺序，先捕获小的，后捕获大的
- catch括号中写的是一个异常对象，这个异常对象在出现相应的异常时被实例化
finally的说明：
- 无论是否出现异常，finally里的代码块都会执行
- 一般情况下，我们写在finally中的代码都是类似释放资源的操作

throws

抛异常通常是使用在方法的声明处。

    public static   void a1 () throws  Exception{}

如果在方法的声明处抛出了异常，在方法的调用处需要进一步处理
- throws
- try...catch

throw

人为的抛出一个异常

    public static   void a1 () {
        int i=10;
        if (i<10){
            throw new RuntimeException("i的值不合法");
        }
    }

如果人为的抛出一个运行器异常——在调用方法时不需要做进一步处理

如果抛出的是一个编译器异常——在方法声明处也需要进行异常的throws，在调用方法处也需要进一步处理

    public static void main(String[] args) throws Exception {
        a1();
    }

    public static   void a1 () throws Exception {
        int i=10;
        if (i<10){
            throw new Exception("i的值不合法");
        }
    }

1.4自定义异常

创建一个类继承Exception或者继承RuntimeException即可
- 如果继承的是Exception，我们自定义的异常就是编译器异常
- 如果继承的是RuntimeException，我们自定义的异常就是运行器异常

2.枚举

用来存储有限个数对象的类——枚举
枚举中的对象都是静态final，枚举类中的构造器都是私有的（private）。

public enum  Season {
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINNER("冬天","凛冬将至");
    private  String name;
    private  String desc;

    Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
}

枚举在switch...case中的应用，在JDK5以后

3.泛型

类型参数化
泛型只能是引用数据类型

3.1泛型类

public class Season<T>{
    
}

泛型类的泛型在实例化时确定
继承泛型类时
- 子类可以不是泛型类
- 子类有自己的泛型时，父类也有自己的泛型时，他们之间毫无瓜葛
- 子类在继承父类时，之间继承了父类的泛型，在声明子类时，直接指定父类的泛型

3.2泛型方法

public <E>E show(E t){
    return t;
}

泛型方法的泛型在传参时确定

4.常用API

Date日期类

Date
SimpleDateFormat
Instant
LocalDateTime
LocalDate
LocalTime
DateTimeFormat
Calendar

Math数学类

ceil——向上取整，返回值是double类型
floor——向下取值，返回值是double类型
round——四舍五入，返回值是整型（int，long）
random——生成一个0~1的随机小数
所有方法都是静态

Random随机类

生成一个伪随机数

BigDecimal

大统计类型，一般情况下在开发中，涉及金额的计算，都用这个
- 比较推荐使用compareTo方法
- ```
    BigDecimal bigDecimal = new BigDecimal("123");
    BigDecimal bigDecimal1 = new BigDecimal("123");
    System.out.println(bigDecimal.compareTo(bigDecimal1));
```
- 注意——在构建BigDecimal时，尽量使用new BigDecamal（String str）

BigInteger

范围：很大——比double还大

StringBuffer与StringBuilder

比较重要的方法
- append——追加
- reverse——反转
三个字符串的区别
- String一旦声明不可改变，其他两个是可以改变的
- StringBuffer是JDK1.0存在，线程安全
- StringBuilder是JDK5推出，线程不安全

System系统类

比较重要的方法
- currenttTimeMills：获取当前系统的毫秒数
- getProperty（String name）：获取系统对应的属性值

5.多线程

5.1线程的生命周期

新建
就绪
运行
阻塞
死亡

5.2线程的创建方式

继承Thread类

重写run方法，调用start方法来启动线程

实现Runnable接口

重写run方法，把当前的实现类包装成Thread类对象，调用start方法

实现Callable接口

重写call方法，把当前的实现类先包装成Runnable，在包装成Thread类，再调用start方法

线程池

开发中，基本上涉及到线程池，一定会用线程池。
但是不会用JDK提供的线程池（阿里规约的约定）。——一般会自定义线程池

5.3锁

synchronized同步锁

	同步监视器
同步代码块	类对象，第三方的对象
同步方法	实例对象

ReentrantLock锁

Lock锁
Lock与synchronized的区别：
- Lock是手动上锁，手动解锁
- synchronized是全自动【不能控制的很好】

5.4线程的常用方法

sleep：线程休眠
interrupr：线程中断
join：线程加入
yield：释放CPU执行权

5.5线程的优先级

整型【1~10】

5.6线程通信

wait线程等待
notify：唤醒下一个正在等待的线程
notifyAll：唤醒所有等待的线程
死锁：互相拿着对方的资源不放手

6.集合框架

6.1Collection接口

存放单值的最大父接口

List

特点：数据是按照添加的先后顺序来排序，数据是可以重复的

ArrayList

内部结构是数组——有下标，而且比较适合于查询，不适合做频繁的增删
Vector：早期的集合类——和ArrayList的区别
- Vector是线程安全，效率低
- ArrayList是线程异步，效率高

LinkedList

内部结构是双向链表——没有下标，不适合用来查询，增删的效率较高

Set

存储数据的特点——数据没有按照添加的先后顺序来排序，数据不可以重复。
Set集合如何保证数据的唯一性——通过重写hashCode与equals方法

HashSet

哈希表。

内部结构是HashMap。

TreeSet

可以排序的Set集合
排序方式
- 自然排序——实现Comparable接口，重写compareTo方法。
- 定制排序（临时排序）——实现Comparator接口，重写compare方法。

6.2Map接口

存放对值的最大父接口。（K,V）
key是不能重复的
value是可以重复的
map集合也是无序的，不按照添加的先后顺序来排序的

HashMap

内部结构：
- JDK7之前是数组+链表
- JDK8以后是数组+链表+红黑树
常用方法
- put：赋值
- get：取值

6.3集合的遍历

List集合遍历

        // 1.for循环
        for (int i = 0; i < list.size(); i++) {
            
        }
        // 2.增强for循环
        for (String s : list) {
        }
        // 3.迭代器
        Iterator<String> iterator = list.iterator();
        while (!iterator.hasNext()){
            System.out.println(iterator.next());
        }

Set集合遍历

        // 1.增强for循环
        for (String s : set) {
        }
        // 2.迭代器
        Iterator<String> iterator = set.iterator();
        while (!iterator.hasNext()){
            System.out.println(iterator.next());
        }

Map集合遍历

        // 1.使用keySet先拿到所有的key,再根据key去拿value
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key+"->"+map.get(key));
        }
        // 2.使用内部类Entry--------推荐使用
        Set<Map.Entry<String, String>> entries = map.entrySet();
        entries.forEach(System.out::println);

7.IO流

组织架构

InputStream	OutputStream	Reader	Writer
File~	File~	File~	File~
Buffered~	Buffered~	Buffered~	Buffered~

7.1File类

File类只能操作文件，不能操作文件的内容

7.2输入输出流

输入（读）：把磁盘上的内容读取到内存中
输出（写）：把内存中的数据写出到硬盘上
注意
- 字节流可以操作二进制文件（所有文件）
- 字符流只能存在纯文本文件（.java .py .txt【只能写字的文件】）
关闭流：把关闭流的操作放在finally中。

序列化与反序列化

序列化：把一个对象按照某种规则以及某个版本号保存到硬盘上的某个文件，一个对象对应一个文件
反序列化：把一个文件根据某种规则以及当时序列化的版本号来读取对象，读取到内存中
如何实现序列化的操作
- 实现序列化的Serializable接口
- 添加一个序列号
- ```
    private static final long serialVersionUID = 7523967970034938905L;
```

8.Socket通信

TCP与UDP的区别
- TCP是可靠的传输，再传输数据之前必须建立可靠的连接，效率低
- UDP是不可靠的传输，在传输数据时无需建立可靠的连接，效率高
IP,端口号，请求，响应，请求体，响应体，响应头，URL

9.JDK

9.1JDK5

增强for循环
枚举
泛型
包装器
自动装箱和自动拆箱
Callable接口
switch...case可以使用枚举
StringBuilder

9.2JDK7

类型推断——实例化泛型类时泛型类的构造器的泛型不用写
try中可以创建对象
switch...case支持String

9.3JDK8

函数式接口
箭头函数【lambda表达式】
断言(Junit)
接口的改变
- 放默认方法
- 放静态方法
HashMap内部结构（数组+链表+红黑树）
Stream流式编程

9.4JDK10

类型推断（定义变量可以用var）

9.5JDK13

文档字符串

注解和反射

反射获取
- 类的方法
- 类的属性
- 类的构造器

正则表达式

面试题

throw和throws的区别
1. throw——人为抛出一个异常
2. throws——被动（让JVM去处理）抛出一个异常
finally和finalize的区别
1. finally——是异常处理的一个结构，放在finally中的代码无论是否出现异常都会执行
2. finalize——是Object类的一个方法，用来垃圾回收的方法，JDK9已过时
编译器异常和运行器异常的区别
1. 编译器异常在写代码时期抛出的异常，如果不处理，编译不通过
2. 运行器异常只要不运行，就不会报错
HashMap与Hashtable的区别
1. HashMap是线程不安全，效率高，key值可以为null
2. Hashtable是线程安全，效率低，key值不可以为null

上一篇2022-8-10 第一组 (≧∇≦) 学习笔记

下一篇2022-8-15 第一组（≥▽≤）学习笔记

本文作者：(≧∇≦)(≧∇≦)(≧∇≦)

本文链接：https://www.cnblogs.com/gycddd/p/16580392.html

posted @ 2022-08-12 16:15 (≧∇≦)(≧∇≦)(≧∇≦) 阅读(9) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 2022-8-10 第一组 (≧∇≦) 学习笔记

· 2022-7-29 第一小组甘源册学习笔记

· JavaSE总结---ing

· JavaSE基础day13异常处理

· javaSE基础

阅读排行：
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
· 上周热点回顾（2.24-3.2）

Java小白