JavaSE总结---ing

JavaSE总结

1.数据类型

基本数据类型和引用数据类型。

2.基本数据类型：4类8种

类型

名称

范围

位数

 

 

 

整型

byte

-128~127

8位

short

-2^15~2^15-1

16位

int（最常用）

-2^31~2^31-1

32位

long

-2^63~2^64-1

64位

 

浮点型

float

 

32位

double

 

64位

字符型

char

0~2^16

16位

布尔型

boolean

 

8位

3.变量的声明：后期程序的可维护性

   数据类型 变量名 = 值;

   变量名不能重复，变量是可以重复赋值。

   int a = 10; a = 20;

   变量要先定义，再使用。

4.引用数据类型

除了基本数据类型，都是引用数据类型。String和数组（常用的引用数据类型）

5.运算符

算术运算符

+、-、*、/、%

 

赋值运算符

+=，-=，*=，/=，%=，=，++，—

i++和++i

i++：先赋值，后运算

++i：先运算，后赋值

比较运算符

>，<，>=，<=，==，!=

运算结果为boolean

逻辑运算符

&,|,!,&&,||，^

运算结果为boolean。

&和&&的区别：&&短路的意思，遇见false就停止判断。

位运算符

>>，<<，>>>，&，|，^

做一个了解即可！

三元运算符

条件 ? 表达式1:表达式2

1.表达式1和表达式2的返回值要统一。

2.三元运算符只能写这三个结构。

3.三元运算符都可以转换成if...else...

连接符

+

任意数据类型和字符串做加法，得到的都是字符串类型。这里的+就是连接符

括号运算符

()

可以把需要先执行的代码放入小括号

6. 条件判断语句

   if...else...：

     （1）if后面的小括号放的是一个条件表达式，得到一个boolean类型的结果。

     （2）明确if...else if...和多重if的区别。

     （3）else是对其上面所有的if的互补。

   switch...case...：

     （1）写在switch括号中的必须是一个能够得到具体值的表达式。

     （2）switch支持的数据类型：char,byte,short,int;枚举（JDK5以后），String（JDK7以后）

     （3）break;跳出当前的case。

     （4）default语句可以放在任意位置。

7.循环语句

循环的四个条件：初始化条件，循环判断条件，循环条件，循环体。

循环的执行顺序：初始化条件->循环判断条件->循环体->循环条件->循环判断条件->....->循环               

判断条件为false

  • for循环：i++和++i是一样的。for(;;){}
  • while循环：各种条件是分开的，不知道要循环到什么时候停，选择使用while循环。

               如果条件不满足，则一次都不执行。

  • do...while循环：无论条件是否满足，循环至少执行一次。
  • foreach语句（JDK5以后）：增强for循环，主要是用来做遍历操作的。

两个关键字： 

     continue：终止当前次循环，并开启下一次循环。

     break：终止全部循环。

goto语法：a:for，a:while。

8.数组（引用数据类型）

   开辟一个连续的内存空间存储多个数据。

   int [] arr = new int[10]; int arr[] = new int[10];

   数组一旦声明，就必须指定长度。

   数组的下标（索引）：从0开始，到数组.length-1结束

   数组的长度：数组.length。

   接触到一个异常：ArrayIndexOutOfBoundsException。

   二维数组、多维数组（了解即可）。

   数组的遍历。

9.String

   使用 = 直接赋值。

   字符串之间的比较不能用 == 。

   字符串实际上是一个类，是一个引用数据类型。

10.面向对象

（1）三大特征：封装，继承，多态（抽象）

（2）方法：

   public void show(参数列表){方法体}

   访问权限 【修饰符】 返回值类型 方法名(【参数列表】)。

（3）构造器：

   public Dog(String name){}

   访问权限 构造器名(【参数列表】){}

   构造器是在创建对象的时候调用执行。

   每个类会提供一个默认的无参构造器，不需要我们显式的声明出来。

   如果说显式的声明了构造器，则类中默认存在的无参构造器就失效。

（4）属性，字段，成员变量。

     private String name;

   访问权限 数据类型 属性名;

（5）方法重载Overload：

　 发生在同一个类中，方法名相同，参数个数或参数顺序或参数类型不同。构造器也是可以重载。

（6）this关键字：

　 代表本类的对象，代表方法的调用者，也可以调用构造器，this(name,age,gender)，当this调用构造器时，必须是构造器的第一条语句。

（7）封装：

　 思想上：我们把可以重复利用的代码块封装成为方法，把可以重复利用的方法封装成为一个工具类。

　 代码上：类中的属性私有化，提供公有的set，get方法。

（8）继承：extends关键字，父类（超类），子类（基类）。在继承时，子类可以继承父类的属性和方法。

（9）访问权限修饰符：

   public：公有的，在当前工程的任意位置都可以访问。（类，属性，构造器，方法）

   默认的：在同一包下可以访问（类，属性，构造器，方法）

   protected：受保护的，在不同包下的子类可以访问（属性，方法，构造器）

   private：私有的，只有在当前类才能访问（属性，方法，构造器）

（10）super关键字：调用父类的结构。super调用构造器时必须放在构造器语句中的第一条。

（11）方法重写Override：子类重写父类的方法。

    重写的方法访问权限不能低于被重写的方法，返回值，方法名，参数列表必须相同，重写的方法不能抛出比被重写方法更大的异常。

 （12）多态：一个对象的多种形态。

　　父类 对象 = new 子类;父类引用指向子类对象，向上转型，自动转。

    子类 对象 = (子类)new 父类;向下转型，发生向下转型时，必须先发生向上转型。

 （13）instance of运算符：判断一个对象是否是某个类的实例。

 （14）抽象：abstract（类，方法）。

     抽象类：不能创建对象。可以放抽象方法。就是让子类去继承。

     抽象方法：没有方法体。就是让子类去重写抽象方法。

 （15）接口：可以理解为是特殊的抽象类interface。

     JDK7以前：常量和抽象方法。

     JDK8以后：常量，抽象方法，默认方法，静态方法。

 （16）接口是可以多实现的，继承只能单继承。

 （17）static静态：属性，方法。这个属性或方法是属于这个类的，不属于任何一个对象。

 （18）final：最终的。类，属性，方法。

     final类不能被继承。

     final方法不能被重写。

     final属性为常量。

 （19）代码块：

     静态块：在类加载的时候执行。

   实例块：在类被实例化的时候执行。

 （20）内部类：

     普通内部类：

     静态内部类：在静态内部类中操作的都是静态的属性和方法。

 （21）Object类：所有Java类的最顶级父类。

 （22）String类：各种字符串的操作方法。

11.异常

最顶级的异常类Throwable

错误

（Error）无法处理的错误，只能去修改源代码。

错误一般情况下我们是遇不见的。

 

StackOverFlowError
// 栈溢出错误

 

异常

最顶级的异常的父类 -- Exception

运行期异常：在运行时抛出的异常

 

编译期异常：写代码的时候出现的异常

 

处理异常

1.try...catch...finally
复制代码
try {
    // 有可能出现异常的代码
}catch(Exception e){
    // 出现异常时要执行的代码
    // 获取异常信息
    String message = e.getMessage();
    // 打印值栈信息
    e.printStackTrance();
} finally {
    // 无论是否出现异常一定会执行的代码
}
复制代码

catch的说明：

  1. catch是可以有多个的

  2. catch中捕获的异常是有顺序的，先要捕获小的，后捕获大的

  3. catch括号中写的是一个异常对象，这个异常对象在出现相应的异常时被实例化

finally的说明：

  1. 无论是否出现异常，finally中的代码块都会执行

  2. 一般情况下，我们写在finally中的代码都是类似释放资源的操作

2.throws

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

public void show() throws RuntimeException{
    
}

throws的说明：

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

进一步处理的方式：

 

  • 继续throws
  • try...catch

 

3.throw

人为的抛出一个异常

 

复制代码
public void show() {
    int i = 10;
    if(i < 10) {
        throw new RuntimeException("i的值不合法");
    }
}

public void show() throws Exception {
    int i = 0;
    if(i < 10){
        throw new Exception();
    }
}
复制代码

 

  1. 人为的抛出一个运行期异常，通常情况下，我们在调用方法时是不需要做进一步处理的。
  2. 如果抛出的是一个编译期异常，在方法声明处，需要进行异常的throws，在调用方法处也需要进一步处理。

自定义异常

我们只需要创建一个类，继承Exception或者继承RuntimeException即可。

 

  1. 如果继承的是Exception，我们自定义的异常就是编译期异常。

  2. 如果继承的是RuntimeException，我们自定义的异常就是运行期异常。

public class MyException extends RuntimeException {

    public MyException(String message) {
        super(message);
        // 还要做好多事
    }
}

面试题

  1. throw和throws的区别？

    throw手动抛出一个异常

    throws被动抛出一个异常

  2. finally和finalize的区别？

    finally异常处理的一个结构，放在finally中的代码无论是否出现异常都会执行。

    finalize()是Object类的一个方法，垃圾回收的方法，JDK9已过时。

  3. 编译期异常和运行期异常的区别？

    编译期异常在写代码时期抛出的异常，如果不处理，编译不通过。

    运行期异常只要不运行，就不报错。

 

12.枚举

用来存储有限个数对象的类，枚举。

枚举中的对象都是静态final，枚举类中的构造器都是private。

复制代码
public enum Season {
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","大雪纷飞"),
    ;


    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以后。

13.泛型

类型参数化

泛型只能是引用数据类型

泛型类

public class Father<T> {
    
}

泛型类的泛型在实例化时确定。

继承泛型类时：

  1. 子类不是泛型类
  2. 子类有自己的泛型，父类也有自己的泛型，他们之间毫无瓜葛。
  3. 子类在继承父类时，直接继承了父类的泛型，在声明子类时，直接指定父类的泛型类型。

泛型方法

public <E> E show(E e) {
    
}

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

14.常用API

Date日期类

Date

SimpleDateFormat

Instant

LocalDate

LocalTime

LocalDateTime

DateTimeFormat

Math类

比较重要的方法：

  1. ceil向上取整，返回值是double类型

  2. floor向下取整，返回值是double类型

  3. roune四舍五入，返回值是int、long类型

  4. random随机数，生成一个0~1的随机小数

Random类

随机类，生成一个伪随机数

Random random = new Random();
random.nextInt(5);

BigDecimal

大统计类型，一般情况下在开发中，涉及金额的计算，都用这个。

比较：推荐使用compareTo方法。

@Test
public void show(){
    BigDecimal bigDecimal1 = new BigDecimal("120");
    BigDecimal bigDecimal2 = new BigDecimal("120.0");
    System.out.println(bigDecimal1.equals(bigDecimal2));
    System.out.println(bigDecimal1.compareTo(bigDecimal2));
}

注意：构建BigDecimal时，尽量使用new BigDecimal(String str)。

BigInteger

大整型。范围很大。

 

StringBuffer和StringBuilder

 

可变的字符串。

 

比较重要的方法：append：追加。  reverse：反转。

三个字符串的区别：

 

  1. String是一旦声明不可改变，StringBuffer和StringBuilder是可以改变的。
  2. StringBuffer是JDK1.0就存在了，线程安全。
  3. StringBuilder是JDK1.5推出，线程不安全。

 

 

System

系统类。

比较重要的方法：

  • currentTimeMills：获取当前系统的毫秒数。

  • getProperty(String name)：获取系统对应的属性值。

System.getProperty("user.dir");
// 获取当前所在的目录

15.多线程

线程的生命周期

1.新建 → 2.就绪 → 3.运行 → 4.阻塞 → 5.死亡

线程创建的方式

  1. 继承Thread类：重写run方法，调用start方法启动线程。
  2. 实现Runnable接口：重写run方法，把当前的实现类包装成Thread类对象，调用start方法。 
    new Thread(()-> {
    // run方法
}).start();
  3. 实现Callable接口：重写call方法，把当前的实现类先包装成Runnable，再包装成Thread，再调用start方法。 
    call() throws Exception;

线程池

开发中，基本上涉及到多线程，一定会用线程池。

但是我们不会用JDK提供的线程池（阿里规约的约定）。

我们一般会自定义线程池。

synchronized同步锁

 

 

 ReentrantLock锁

Lock锁。

Lock和synchronized的区别？

Lock是手动上锁，手动解锁。

synchronized全自动

常用方法

sleep：线程休眠。

interrupt：线程中断。

join：线程加入。

yield：释放CPU执行权。

线程的优先级

整型。1-10的整数。

复制代码
public static final int MIN_PRIORITY = 1;

/**
     * The default priority that is assigned to a thread.
     */
public static final int NORM_PRIORITY = 5;

/**
     * The maximum priority that a thread can have.
     */
public static final int MAX_PRIORITY = 10;
复制代码

线程通信

wait()：线程等待

notify()：唤醒下一个正在等待的线程

notifyAll()：唤醒所有等待的线程。

死锁：互相拿着对方需要的资源不释放。

16.集合框架

Collection

存放单值的最大父接口

List

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

ArrayList

内部结构是数组。有下标，而且比较适合于查询，不适合做频繁的增删。

Vector：早期的集合类。

和ArrayList的区别：

  • Vector是线程安全，效率低。

  • ArrayList是线程异步，效率高。

LinkedList

内部结构是双向链表。查询遍历效率较低，增删的效率较高。

Set

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

Set集合如何来保证数据的唯一性？

通过重写hashCode和equals方法。

HashSet：哈希表。内部结构是HashMap。

HashSet没有取出一个值的方法。

TreeSet：可以排序的set集合。

排序方式：

  1. 自然排序：

    • 实现Comparable接口，重写compareTo方法。

  2. 定制排序（临时排序）

    • 实现Comparator接口，重写compare方法。

Map

存放对值的最大父接口。（K-V）

key是不能重复的。value是可以重复的。

Map集合也是无序，不是按照添加的先后顺序来排序的。

HashMap

内部结构：

  1. JDK1.7之前：数组 + 链表

  2. JDK1.8以后：数组 + 链表 + 红黑树

面试题：

HashMap和Hashtable区别：

  1. HashMap线程不安全，效率高，key值可以为null。

  2. Hashtable线程安全，效率低，key值不可以为null。

17.循环遍历

List

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

Set

复制代码
// 1.增强for循环
for (String s : set) {
    // TODO
}

// 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（推荐）
for (Map.Entry<String, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + entry.getValue());
}
复制代码

18.Collection

操作集合的工具类

19.IO流

File

各种方法。

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

输入输出流

输入（读）：把磁盘上的数据读取到内存中。

输出（写）：把内存中的数据写出到磁盘上。

组织架构：

注意：

字节流可以操作二进制文件->所有文件。

字符流只能操作纯文本文件。

  • .java

  • .py

  • .txt

  • .....

关闭流：把关闭流的操作放在finally中。

序列化与反序列化

  • 序列化：把一个对象按照某种规则以及某个版本号保存到硬盘上的某个文件。一个对象对应一个文件。

  • 反序列化：把一个文件根据某种规则以及当时序列化时使用的版本号来读取对象，读到内存中。

如何实现序列化操作：

  1. 序列化的类要实现Serializable接口

  2. 添加一个序列号

    private static final long serialVersionUID = -6849794470754667710L;

20.Socket通信

TCP和UDP的区别：

  1. TCP是可靠的传输，在传输数据之前必须建立可靠的连接。效率低。

  2. UDP是不可靠的传输，在传输数据时无需建立可靠的连接。效率高。

ip，端口号，通信协议，请求，响应，请求体，请求头，响应体，响应头，URL...

21.注解和反射

22.正则表达式

从一个文章中找到所有的邮箱  看看输入的手机号是否合法  身份证号

又叫规则表达式  Regular Expression Regex

判断字符串，核心功能处理文本。

正则表达式不局限于某一种语言。

元字符

.：匹配除了换行符之外的任意字符

\w：匹配字符或数字或下划线或汉字

\s：空格

\d：匹配数字

\b：匹配单词的开始或结束

^：匹配字符串的开始

$：匹配字符串的结束

如：匹配8位数字的QQ号：^\d\d\d\d\d\d\d\d$

匹配1开头的11位数：^1\d\d\d\d\d\d\d\d\d\d$

重复限定符：

*：重复零次或更多次

+：重复一次或更多次

？：重复零次或一次

{n}：重复n次

{n,}：重复n次或更多次

{n.m}：重复n到m次

如：匹配8位数字的QQ号：^\d{8}$

匹配1开头的11位数：^1\d{10}$

银行卡号14-18位：^\d{14,18}$

匹配以a开头，0个或多个b结尾的字符串^ab*$

分组

限定符的作用与它相邻的最左边的一个字符起作用

那么问题：如果我想要ab同时被限定怎么办？

正则表达式中可以用小括号来分组，括号内的内容会作为一个整体

^(ab)*$

转义

匹配字符串中包含0到多个（ab）开头：^((\ab\))*

条件

手机号：

联通：130 131 132 134 155 156 185 186

匹配一个联通的手机号。或

|单或

^(130|131|132|134|155|156|185|186)\d{8}$

区间

正则表达式提供了一个[]来表示区间

0~~9：[0-9]

A~~Z：[A-Z]

限定某些数字：[130]

^((13[0-2]))|((15[5-6]))|((18[5-6]))\d{8}$

反义

\W：不是字母、数字、下划线、中文

\S：不是空格

\D：不是数字

\B：不是单词的开始或结束

[^X]：除了X以外的任意字符

常见的正则表达式

匹配中文的字符：[ ]，匹配的是ASCII码

邮箱：^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$（不一定对）

Pattern类

Matcher类

PatternSyntaxException类

23.JDK

JDK5

  1. 增强for循环

  2. 枚举

  3. 泛型

  4. 包装器

  5. 自动装箱和自动拆箱

  6. Callable接口

  7. switch...case可以使用枚举

  8. StringBuilder

JDK7

  1. 类型推断

  2. try中可以创建对象

  3. switch...case支持String

  4. Objects类

JDK8

  1. 函数式接口

  2. 箭头函数（lambda表达式）

  3. 断言

  4. 接口的改变

    • 默认方法

    • 静态方法

  5. HashMap内部结构（数组 + 链表 + 红黑树）

  6. Stream式编程

JDK10

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

JDK13

1. 文档字符串

posted @   Myy蒋  阅读(26)  评论(0)  编辑  收藏  举报
相关博文：
· 2022-08-01 第六组 Myy 学习笔记_Java_泛型和枚举
· 2022-07-13 第十组 Myy 学习笔记_初识Java
· 2022-8-10 第一组 (≧∇≦) 学习笔记
· 2022-8-12 第一组 (≥▽≤) JavaSE总结
· JavaSE笔记
阅读排行：
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· C#/.NET/.NET Core优秀项目和框架2025年2月简报
· DeepSeek在M芯片Mac上本地化部署
· 葡萄城 AI 搜索升级：DeepSeek 加持，客户体验更智能
点击右上角即可分享
微信分享提示