uevpress

Appearance

Basic of Java ​

Java是一种面向对象的编程语言，由Sun Microsystems（现在是甲骨文公司Oracle Corporation的一部分）在1995年发布。Java语言的设计目标是实现跨平台的可移植性，即“一次编写，到处运行”（Write Once, Run Anywhere）。Java语言广泛应用于各种计算平台，从嵌入式设备和移动电话到企业服务器和超级计算机。

Java EE (Java Platform, Enterprise Edition)

Java EE是一套基于Java语言的企业级计算规范和API，它定义了构建大型、多层、可靠、安全的服务器端Java应用程序的标准。Java EE提供了一套完整的服务、API和协议，用于开发和部署可移植、健壮、可伸缩的服务器端Java应用程序。

Java EE包括了多种技术，如Servlets、JavaServer Pages (JSP)、Enterprise JavaBeans (EJB)、Java Persistence API (JPA)、Java Message Service (JMS)、Java Transaction API (JTA)等。

Java EE的版本包括Java EE 5、Java EE 6、Java EE 7和Java EE 8。

Jakarta EE

2017年，甲骨文公司将Java EE的技术规范和商标权移交给了Eclipse Foundation，以促进Java EE的进一步发展和创新。Eclipse Foundation是一个开放源代码的社区，致力于开发和维护开源软件项目。

2018年2月，Eclipse Foundation宣布将Java EE重新命名为Jakarta EE，以避免与甲骨文公司的Java商标冲突，并强调这是一个由社区驱动的项目。Jakarta EE是Java EE的后续版本，它继续为开发企业级Java应用程序提供一套完整的规范和API。

Jakarta EE的版本从Jakarta EE 8开始，继续发展，包括Jakarta EE 9等后续版本。

yco.vlogs
1991Sun Microsystemsoak1、Java最初被设计为一种用于嵌入式设备和消费电子产品的编程语言，名为“Oak”
1995Sun Microsystems1.01、Oak更名为Java，并发布了Java 1.0。
1996Sun Microsystems1.11、引入了JIT（即时编译器）和垃圾回收机制，提高了Java的性能。
2、引入了AWT（Abstract Window Toolkit）和Swing，为Java应用程序提供了图形用户界面（GUI）。
1998Sun Microsystems1.21、被称为“Java 2”，引入了集合框架、Swing组件库和JavaBean。
2、引入了J2EE（Java 2 Platform, Enterprise Edition），为构建企业级应用提供了框架。
2000Sun Microsystems1.31、引入了HotSpot虚拟机，提高了Java的性能。
2、引入了Java Sound API和Java 3D API。
2002Sun Microsystems1.41、引入了正则表达式、断言和日志记录。
2、引入了J2SE（Java 2 Platform, Standard Edition）和J2EE（Java 2 Platform, Enterprise Edition）。
2004Sun Microsystems1.51、引入了自动装箱/拆箱、泛型、枚举、可变参数和注解。
2、引入了Java编程语言的许多新特性，被认为是Java语言发展的一个重要里程碑。
2006Sun Microsystems1.61、引入了脚本引擎、编译器API和JDBC 4.0。
2、引入了对Unicode 4.0的支持和对64位平台的改进。
2011oracle71、引入了“钻石”语法、try-with-resources语句和多异常处理。
2、引入了JVM的新特性，如G1垃圾收集器。
2014oracle81、引入了Lambda表达式和Stream API，支持函数式编程。
2、引入了新的日期和时间API。
2017oracle91、引入了模块系统，允许更细粒度的控制Java应用程序的组件。
2、引入了JShell，一个交互式Java shell。
2018oracle101、引入了局部变量类型推断和新的垃圾收集器。
2018oracle111、引入了新的HTTP客户端和改进的垃圾收集器。
2019oracle121、引入了switch表达式和改进的垃圾收集器。
2020oracle141、引入了JFR事件流和模式匹配。
2021oracle161、引入了模式匹配、密封类和实例化接口方法的默认实现。
2022Eclipse Foundation171、引入了新的垃圾收集器、模式匹配增强和更高效的文件I/O。
2023Eclipse Foundation191、引入了JEP（JDK Enhancement Proposals）系统，用于跟踪Java平台的新特性。

API 架构

plain
JDK (Java Development Kit)
├── JRE (Java Runtime Environment)
│   └── JVM (Java Virtual Machine)
│   └── 核心类库
└── 开发工具 (javac, jar, javadoc 等)

安装

javax.net.ssl.SSLException

javax.net.ssl.SSLException: java.lang.RuntimeException: Unexpected error:java.security.InvalidAlgorithmParameterException: the trustAnchors parameter must be non-empty 注意./lib/security/cacerts 文件一般为100KB左右，若文件仅有几行或几KB会造成ssl认证异常。

类型 ​

基础类型

类型分类示例
byte整型1字节，-128~127
short整型2字节
int整型4字节（默认）
long整型8字节，需加 L
float浮点4字节，需加 F
double浮点8字节（默认）
char字符2字节，Unicode
boolean布尔true/false

引用类型

java
// 类
class Clz {
}

// 接口
interface Iface {
}

// 抽象类
abstract AbsClz {
}

// 枚举
enum Color {
	int i;
	public(int i) {
		this.i = i;
	}
	RED(0), GREEN(1), BLUE(2);
}

// 注解 annotation
// 元注解 
@ Retention(RetentionPolicy.RUNTIME) // 生命周期 SOURCE、CLASS、RUNTIME
@ Target({ElementType.TYPE, ElementType.METHOD}) // 可修饰的元素类型 CLASS、METHOD、FIELD
@ Documented // 是否生成到 javadoc
@ Inherited // 是否继承父类的注解
@ Repeatable // 是否可以重复使用
@interface Anno {
	String value() default "default";
}

变量 ​

  • 作用域：局部变量的作用域限于声明的方法、构造方法、代码块内。一旦代码执行流程离开这个作用域，局部变量就不再可访问。
  • 生命周期：局部变量的声明周期从声明时开始，到方法、构造方法、代码块内执行结束时终止。之后，局部变量将呗 gc 回收。
  • 初始化：局部变量再使用前必须被初始化、如果不进行初始化，编译器会报错，因为 Java 不会为局部变量提供默认值。
  • 声明：局部变量的声明必须在方法或代码块开始的处进行。
  • 赋值：局部变量在声明后必须被赋值，才能在方法内使用。赋值可以是直接赋值，也可以时通过方法调用或表达式。
  • 限制：局部变量不能被类的其他方法直接访问，它们只为声明它们的方法或代码块所私有。
  • 内存管理：局部变量存储在 JVM 的栈上，与存储在对上的实例变量或对象不同。
  • 垃圾回收：由于局部变量的声明周期严格限于方法或代码块的执行，它们在方法或代码块执行完毕后不在被引用，因此 JVM 的 gc 就会自动回收它们占用的内存。
  • 重用：局部变量的名称可以在不同的方法或代码块中重复使用，因此它们的作用域时局部的，不会引起命名冲突。
  • 参数和返回值：方法的参数可以视为一种特殊的局部变量，它们在方法被调用时初始化，并在方法返回后生命周期结束。
特性局部变量 (Local Variables)实例变量 (Instance Variables)
存储位置栈 (Stack)堆 (Heap)
生命周期随方法调用创建，方法结束销毁随对象创建而存在，对象被回收时销毁
作用域仅限于声明它的方法或代码块整个对象实例可访问
线程安全线程私有（每个线程有自己的栈）共享，需考虑同步问题
默认初始化不会自动初始化，必须显式赋值会自动初始化为默认值
java
class Var {
	// 实例变量（instance variables）
	int i0 = 1;
	
	// 类变量（class variables）
	static int I1 = 1;
	
	// 常量（constant）
	final int I = 10;
	
	// 参数变量（parameters）
	void meth(int i, final byte b) {
		// 局部变量 local variables，存储于栈上
		int i1 = 2;
		// 局部变量，引用存储于栈上，使用在堆
		Object obj = new Object();
	}
	// 可变参数
	void meth1(int ...args) {}
}

静态 ​

static关键字声明的变量、方法脱离对象仅属于类，JVM 中仅有一份。

  • Java 8 之前位于 JVM 中的永久代
  • Java 8 之后位于 JVM 中的元数据区（Metaspace）
java
# 静态导入
# 可以直接调用 java.lang.System.out 下的方法
import static java.lang.System.out;
class DemoStatic {
	# 静态变量
	static int VRA = 1;
	static final int VAR1 = 2;
	
	# 静态方法
	# 不能访问非静态变量
	# 不能调用非静态方法
	static void meth() {
		out.println("hello!");
	}
	
	# 静态内部类
	# 脱离外部类，可以直接实例。DemoStatic.StaticInner si = new DemoStatic.StaticInner();
	# 可以访问外部类声明的静态变量和静态方法。
	static StaticInner() {}

}

执行顺序

java
public class Test {
    static int a = 1;                    // 1、静态变量初始化
    static { a = 2; }                    // 2、静态代码块
    int b = 3;                           // 4、实例变量初始化（创建对象时）
    { b = 4; }                           // 5、构造代码块
    public Test() { b = 5; }             // 6、构造方法
    // 3、main 方法
    public static void main(String[] args) {
        new Test();
    }
}

访问控制 ​

修饰符当前类同包子类（同包）子类（不同包）其他包
privateoxxxx
defaultoooxx
protectedoooo/xx
publicooooo

运算符 ​

  • 算术运算：+、-、*、/、%（取余）、mod（取模）
  • 关系运算：==、!=、>、<、>=、<=
  • 逻辑逻辑：&&、 ||、 !
  • 位运算：&、|、^、~、<<、>>（右移）、>>>（无符号右移）
  • 三目运算：condition ? value1 : value2
java
Math.floorMod(+4, -3) == -2
Math.floorMod(-4, +3) == +2
Math.floorMod(-4, -3) == -1

(+4 % -3) == +1
(-4 % +3) == -1
(-4 % -3) == -1

流程控制 ​

java
// if 分支
if (condition) {
} else if (condition) {
} else {
}

// swith 分支
swith(variable) {
	case A:
	break;
	case B;
	break;
}

// for 循环
for(i=0; i <= 10; i++) {}

// for 增强
for(int i: arr) {}

// while
while(condition){}

// do-while
// 至少执行一次
do {} while(condition)

// 跳出循环
break;
// 跳出当前迭代
continue;
// 返回
return;

面对对象编程（OOP, Object Oriented Programming） ​

特性说明实现方式
封装隐藏内部细节private 字段 + public getter/setter
继承代码复用extends 关键字
多态同一接口不同实现重写(Override)、重载(Overload)、接口
抽象提取共同特征抽象类 abstract、接口 interface

类与实例

java
public class Student {
    // 成员变量（实例变量）
    private String name;
    private int age;
    
    // 类变量（静态变量）
    private static String school = "清华大学";
    
    // 构造方法
    public Student(String name, int age) {
        this.name = name;  // this 指代当前对象
        this.age = age;
    }
    
    // 实例方法
    public void study() {
        System.out.println(name + "在学习");
    }
    
    // 静态方法
    public static void showSchool() {
        System.out.println(school);
    }
    
    // getter/setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

// 创建对象
Student stu = new Student("张三", 20);
stu.study();
Student.showSchool();  // 静态方法通过类名调用

重载（Overload）/重写（Override)

java
// 重载（Overload）：同一类中，方法名相同，参数不同
class Calculator {
	@Overload
    int add(int a, int b) { return a + b; }
    @Overload
    double add(double a, double b) { return a + b; }
    @Overload
    int add(int a, int b, int c) { return a + b + c; }
}

// 重写（Override）：子类重新实现父类方法
class Animal {
    void makeSound() { System.out.println("动物叫声"); }
}

class Dog extends Animal {
    @Override
    void makeSound() { System.out.println("汪汪"); }  // 重写
}

抽象类与接口

java 8 接口（interface) 新特性：

  • default 方法：提供默认实现，实现类可覆盖
  • static 方法：接口级别的工具方法
  • 一个类可实现多个接口（弥补单继承局限）
java
// 抽象类：可有成员变量、构造方法、具体方法
abstract class Shape {
    protected String color;
    
    public Shape(String color) {
        this.color = color;
    }

	// 抽象方法（无实现）
    abstract double area();  
    
    void printColor() {
        System.out.println("颜色：" + color);
    }
}

// 接口：Java 8 前只能有抽象方法，8+ 可有默认/静态方法
interface Flyable {
	// 隐式 public abstract
    void fly();  
	// 默认方法
    default void land() {  
        System.out.println("降落");
    }
	// 静态方法
    static void checkEngine() {  
        System.out.println("检查引擎");
    }
}

// 实现
class Bird extends Animal implements Flyable {
    @Override
    public void fly() {
        System.out.println("鸟儿飞翔");
    }
}

包装类 ​

  • byte -> Byte
  • short -> Short
  • int -> Integer
  • long -> Long
  • float -> Float
  • double -> Double
  • boolean -> Boolean
  • char -> Character

自动拆装 ​

基本数据类型和其对应的包装类之间进行自动转换

java
// 自动装箱：int 转化为 Integer
Integer num = 100;

// 自动拆箱: Integer 转化为 int
int n = num;  

// 注意：-128~127 有缓存池
Integer a = 127, b = 127;
// true（同一对象）
System.out.println(a == b);  

Integer c = 128, d = 128;
// false（不同对象，用 equals）
System.out.println(c == d); 

// 每次循环都会发生装箱和拆箱
Integer sum = 0;
for (int i = 0; i < 1000000; i++) {
	sum += i; 
}

// 抛出NullPointerException
Integer nullInteger = null;
int num = nullInteger;

String ​

java
// 字符串常量池
String s1 = "hello";
// 堆内存
String s2 = new String("hello"); 

// 常用方法
s1.length();
s1.charAt(0);   
s1.substring(0, 3);
s1.equals(s2);
s1.contains("ell");
s1.split(",");
s1.trim();
s1.toUpperCase();

// 字符串拼接
// StringBuilder/StringBuffer（可变，用于频繁修改）
// StringBuilder 线程不安全但更快；StringBuffer 线程安全
StringBuilder sb = new StringBuilder();
sb.append("hello").append(" world");
String result = sb.toString();

// java 8 StringJoiner
StringJoiner join = new StringJoiner(",");
join.add("1");
join.add("2");
join.add("3");
join.add("4");
join.add("5");
join.toString(); // 1,2,3,4,5

日期时间 ​

Java 8 引入全新的日期时间 API 解决原有 Date Calender 设 计缺陷。

Date/Calendar新 API (java.time)
线程不安全不可变对象，线程安全
月份从 0 开始（易错）月份从 1 开始，清晰直观
设计混乱（Date 包含时间）职责分离（Date/Time/DateTime）
时区处理复杂ZoneId/ZoneOffset 明确区分
格式化类非线程安全DateTimeFormatter 线程安全

核心类概览

类名描述示例
LocalDate日期（年月日）2026-03-08
LocalTime时间（时分秒纳秒）14:30:00
LocalDateTime日期 + 时间2026-03-08T14:30:00
ZonedDateTime带时区的日期时间2026-03-08T14:30+08:00[Asia/Shanghai]
Instant时间戳（UTC 秒/纳秒）2026-03-08T06:30:00Z
Duration时间间隔（秒/纳秒）PT2H30M
Period日期间隔（年月日）P1Y2M3D
DateTimeFormatter格式化/解析yyyy-MM-dd

集合 ​

集合框架

plain
Collection（接口）
├── List（有序，可重复）
│   ├── ArrayList（数组实现，查询快）
│   ├── LinkedList（链表实现，增删快）
│   └── Vector（线程安全，已少用）
├── Set（无序，不重复）
│   ├── HashSet（哈希表，无序）
│   ├── LinkedHashSet（保持插入顺序）
│   └── TreeSet（红黑树，自动排序）
└── Queue（队列）
    ├── LinkedList（双端队列）
    └── PriorityQueue（优先队列）

Map（键值对）
├── HashMap（数组+链表/红黑树，无序，允许 null）
├── LinkedHashMap（保持插入顺序）
├── TreeMap（红黑树，按键排序）
└── Hashtable（线程安全，已少用）

例子

java
// List 示例
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.get(0);           // "Java"
list.remove(0);
list.size();

// 遍历（推荐方式）
for (String item : list) { }
list.forEach(item -> System.out.println(item));

// Set 示例
Set<Integer> set = new HashSet<>();
set.add(1);
set.add(1);  // 重复，不会添加

// Map 示例
Map<String, Integer> map = new HashMap<>();
map.put("Alice", 25);
map.get("Alice");      // 25
map.containsKey("Bob");

// 遍历 Map
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

异常 ​

plain
Throwable
├── Error（严重错误，不处理）
│   └── OutOfMemoryError, StackOverflowError...
└── Exception（可处理）
    ├── RuntimeException（运行时异常，非受检）
    │   ├── NullPointerException
    │   ├── ArrayIndexOutOfBoundsException
    │   └── IllegalArgumentException...
    └── 其他（受检异常，必须处理）
        ├── IOException
        ├── SQLException

try-catch-finally

java
// 异常处理
try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println(e.getMessage());
} catch (Exception e) {
    e.printStackTrace();
} finally {
    // 无论是否异常都执行（常用于释放资源）
    System.out.println("清理资源");
}

// try-with-resources（自动关闭资源，Java 7+）
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    String line = br.readLine();
} catch (IOException e) {
    e.printStackTrace();
}

// 抛出异常
public void validateAge(int age) throws IllegalArgumentException {
    if (age < 0) {
        throw new IllegalArgumentException("年龄不能为负数");
    }
}

// 自定义异常
class BusinessException extends RuntimeException {
    public BusinessException(String message) {
        super(message);
    }
}

NIO ​

Java NIO（New Input/Output），是从 Java 1.4 开始引入的一套新的IO API，用来替代标准Java IO API。NIO支持面向缓冲区的（IO是面向流的），非阻塞的IO操作。NIO提供了与标准IO不同的IO工作方式和更高的性能。

NIO 组件：

  • 通道（Channel）：类似于流，但可以进行双向数据传输，即可以读也可以写。
  • 缓冲区（Buffer）：NIO中数据的容器，所有数据的读写都是通过Buffer来进行的。
  • 选择器（Selector）：允许单线程处理多个Channel，如果你的应用打开了多个连接（Channel），但每个连接的流量都很低，使用Selector就会非常方便。
plain
// 字节流（二进制数据）
InputStream / OutputStream
├── FileInputStream / FileOutputStream
├── BufferedInputStream / BufferedOutputStream（带缓冲）
└── ObjectInputStream / ObjectOutputStream（对象序列化）

// 字符流（文本数据）
Reader / Writer
├── FileReader / FileWriter
├── BufferedReader / BufferedWriter
└── InputStreamReader / OutputStreamWriter（桥接流）
java
// 复制文件
try (InputStream in = new FileInputStream("source.jpg");
     OutputStream out = new FileOutputStream("target.jpg")
     ) {
    byte[] buffer = new byte[1024];
    int len;
    while ((len = in.read(buffer)) != -1) {
        out.write(buffer, 0, len);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// NIO（New IO，Java 1.4+，更高效）
Path path = Paths.get("data.txt");
Files.readAllLines(path);  // 读取所有行
Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
对比项区别
== vs equals()== 比较引用地址；equals() 比较内容（String 等已重写）
String vs StringBuilderString 不可变；StringBuilder 可变、高效
ArrayList vs LinkedListArrayList 数组实现，查询 O(1)；LinkedList 链表实现，增删 O(1)
HashMap vs TreeMapHashMap 无序 O(1)；TreeMap 有序 O(log n)
abstract class vs interface抽象类单继承，可有状态；接口多实现，Java 8+ 可有默认方法
Runnable vs CallableRunnable 无返回值；Callable 有返回值，可抛异常
checked vs unchecked 异常Checked 必须处理；Unchecked 如 RuntimeException 可选