java基础常识

全面解析Java核心技术体系 · 从零入门到深度掌握

一、Java语言基础体系

1.1 Java语言特点与平台特性

Java作为一种跨平台的面向对象编程语言,其核心特性可归纳为以下五点:

以“Hello World”为例说明Java程序基本结构:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

其中: • public class HelloWorld:声明公共类,类名与文件名必须严格一致 • public static void main(String[] args):程序入口点,JVM固定调用签名 • System.out.println():标准输出流,用于向控制台打印信息

1.2 数据类型与变量系统

Java数据类型分为基本类型与引用类型两大类,共八种基本类型:

类型分类 关键字 字节数 取值范围 默认值
整数型 byte 1 -128 ~ 127 0
整数型 short 2 -32768 ~ 32767 0
整数型 int 4 -2³¹ ~ 2³¹-1 0
整数型 long 8 -2⁶³ ~ 2⁶³-1 0L
浮点型 float 4 ±3.402823e+38 0.0f
浮点型 double 8 ±1.797693e+308 0.0d
字符型 char 2 Unicode字符集 \u0000
布尔型 boolean 1 true / false false

特别注意以下易混淆点:

1.3 流程控制与运算符体系

Java流程控制语句可分为三类:

  1. 顺序结构:代码按书写顺序依次执行
  2. 选择结构:基于条件分支执行不同代码块
    • if-else语句:处理二选一或多选一场景
    • switch语句:处理等值匹配场景,支持int/byte/short/char/enum/String
  3. 循环结构:重复执行特定代码块
    • for循环:适合已知循环次数的场景
    • while循环:先判断后执行,可能一次不执行
    • do-while循环:先执行后判断,至少执行一次

运算符优先级关键点:

经典案例:判断闰年条件(能被4整除但不能被100整除,或能被400整除)

boolean isLeapYear = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);

1.4 常见新手误区解析

命名规范

  • 采用驼峰命名法:studentScore、MAX_VALUE
  • 首字母小写,后续单词首字母大写
  • 常量全大写,单词间用下划线分隔
  • 避免使用拼音、拼音缩写或无意义缩写
  • 禁止使用Java关键字(如int、class)作为标识符

反例:int 123abc(数字开头)、String class(关键字)均为非法命名

运算符陷阱

  • ==与equals()区别:
    • ==比较基本类型值,比较引用类型时比较内存地址
    • equals()比较对象内容(需重写实现)
  • i = i++陷阱:后置++先返回原值再自增,导致i值不变
  • 浮点精度问题:0.1 + 0.2 == 0.3结果为false

正确比较字符串:if("Java".equals(lang))可避免空指针异常

数据溢出

  • Integer.MAX_VALUE + 1结果为负数(-2147483648),发生整数溢出
  • 解决方案:
    • 使用long类型存储中间结果
    • 使用Math.addExact()等安全方法(JDK8+)
    • 循环中添加边界检查
  • 经典案例:计算阶乘时int仅能正确表示到12!
// 安全计算阶乘(示例)
long factorial(int n) {
    if (n < 0) throw new IllegalArgumentException();
    long result = 1;
    for (int i = 2; i <= n; i++) {
        result *= i;
        if (result < 0) throw new ArithmeticException("Overflow!");
    }
    return result;
}

二、面向对象核心机制

2.1 类与对象的构建逻辑

Java面向对象三大特征实现原理:

封装示例:

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        setAge(age); // 使用setter验证
    }
    public String getName() { return name; }
    public void setName(String name) {
        if (name != null && !name.isEmpty()) {
            this.name = name;
        }
    }
    public int getAge() { return age; }
    public void setAge(int age) {
        if (age >= 0 && age <= 150) {
            this.age = age;
        }
    }
}

2.2 接口与抽象类深度对比

对比维度 接口(interface) 抽象类(abstract class)
声明关键字 interface abstract class
成员变量 public static final 可有各种修饰符
方法类型 public abstract(JDK8+默认/静态方法) 可含具体实现方法
继承/实现 类可实现多个接口 类只能继承一个抽象类
构造方法 无 有(供子类调用)
设计目的 行为规范 代码复用与模板

典型应用场景:

设计原则:

  • 优先使用接口而非抽象类(符合里氏替换原则)
  • 接口方法命名体现行为特征(如run()、compareTo())
  • 抽象类方法命名体现通用逻辑(如calculateSalary())
  • 2.3 多态性实现机制

    向上转型原理

    子类对象赋值给父类引用变量:

    Animal animal = new Dog(); // Dog是Animal子类

    此时animal只能访问Animal类定义的方法,但实际调用的是Dog类重写的方法

    动态绑定过程

    1. 编译期:检查引用类型是否有该方法签名
    2. 运行期:根据对象实际类型查找方法表
    3. 调用:执行实际对象类型的方法实现

    方法表(vtable)机制确保多态正确性

    多态局限

    解决方案:向下转型(需instanceof检查)

    if (animal instanceof Dog) {
        Dog dog = (Dog) animal;
        dog.bark(); // 调用子类特有方法
    }

    三、集合框架体系

    3.1 集合层次结构概览

    Java集合框架分为两大体系:

    核心接口关系图:

    Collection
    ├── List
    │   ├── ArrayList(数组实现,随机访问快)
    │   ├── LinkedList(链表实现,增删快)
    │   └── Vector(线程安全)
    └── Set
        ├── HashSet(哈希表实现)
        ├── LinkedHashSet(LinkedHashMap实现)
        └── TreeSet(红黑树实现)
    Map
    ├── HashMap(数组+链表+红黑树)
    ├── LinkedHashMap(双向链表维护顺序)
    ├── Hashtable(线程安全)
    └── TreeMap(红黑树实现)

    3.2 常用集合实现对比

    集合类型 底层结构 线程安全 允许null 典型场景
    ArrayList 动态数组 否 允许 频繁随机访问
    LinkedList 双向链表 否 允许 频繁插入删除
    HashSet HashMap键 否 一个null 快速查找去重
    TreeSet TreeMap键 否 不允许 有序集合
    HashMap 数组+链表+红黑树 否 允许 通用映射存储
    ConcurrentHashMap CAS+synchronized 是 不允许 高并发映射

    ArrayList与LinkedList性能对比:

    3.3 集合遍历与修改陷阱

    增强for循环原理

    编译器转换为迭代器遍历:

    for (String s : list) {
        System.out.println(s);
    }
    // 等价于:
    Iterator it = list.iterator();
    while (it.hasNext()) {
        String s = it.next();
        System.out.println(s);
    }

    不能用于修改集合(删除/添加元素)

    安全删除方式

    使用迭代器的remove方法:

    Iterator it = list.iterator();
    while (it.hasNext()) {
        if (it.next().equals("Java")) {
            it.remove(); // 安全删除
        }
    }

    Java 8+可使用removeIf:

    list.removeIf("Java"::equals);

    并发修改异常

    在遍历中直接调用集合remove方法会抛出ConcurrentModificationException:

    for (String s : list) {
        if (s.equals("Java")) {
            list.remove(s); // 抛出异常!
        }
    }

    解决方案:

    四、异常处理机制

    4.1 异常层次结构

    Java异常体系以Throwable为根:

    典型异常继承树:

    Throwable
    ├── Error
    │   ├── OutOfMemoryError
    │   └── StackOverflowError
    └── Exception
        ├── RuntimeException
        │   ├── NullPointerException
        │   ├── ArrayIndexOutOfBoundsException
        │   └── IllegalArgumentException
        └── IOException
            ├── FileNotFoundException
            └── EOFException

    4.2 异常处理最佳实践

    try-catch-finally使用规范:

    资源自动关闭(try-with-resources):

    try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
        return br.readLine();
    } catch (IOException e) {
        logger.error("读取文件失败", e);
    }

    4.3 异常处理常见误区

    过度捕获

    错误示例:

    try {
        riskyOperation();
    } catch (Exception e) {
        // 空实现!
    }

    危害:掩盖问题,难以定位故障

    正确做法:

    异常链

    保留原始异常信息:

    try {
        // 低层操作
    } catch (SQLException e) {
        throw new DataAccessException("数据库操作失败", e);
    }

    堆栈信息包含完整异常链,便于调试

    异常丢失

    finally中异常覆盖try异常:

    try {
        throw new RuntimeException("原始异常");
    } finally {
        throw new RuntimeException("finally异常"); // 覆盖原异常!
    }

    解决方案:使用Suppressed异常(Java7+)

    try (Resource r = new Resource()) {
        throw new RuntimeException("主异常");
    } catch (Exception e) {
        e.addSuppressed(new RuntimeException("附加异常"));
    }

    五、IO流处理体系

    5.1 流分类与抽象模型

    Java IO流按方向分为:

    按处理单位分为:

    典型流继承体系:

    InputStream
    ├── FileInputStream
    ├── BufferedInputStream
    └── ByteArrayInputStream
    Reader
    ├── FileReader
    ├── BufferedReader
    └── StringReader

    5.2 缓冲流与转换流

    缓冲流提升IO性能:

    try (BufferedReader br = new BufferedReader(
            new FileReader("input.txt"))) {
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
    }

    转换流实现字节-字符转换:

    new InputStreamReader(inputStream, StandardCharsets.UTF_8)

    5.3 NIO与传统IO对比

    阻塞IO模型

    非阻塞IO模型

    示例:非阻塞服务器核心逻辑

    Selector selector = Selector.open();
    ServerSocketChannel ssc = ServerSocketChannel.open();
    ssc.configureBlocking(false);
    ssc.register(selector, SelectionKey.OP_ACCEPT);

    内存映射文件

    try (RandomAccessFile file = new RandomAccessFile("data.bin", "rw")) {
        FileChannel channel = file.getChannel();
        MappedByteBuffer buffer = channel.map(
            FileChannel.MapMode.READ_WRITE, 0, 1024);
        buffer.put((byte) 'A');
    }

    六、多线程编程

    6.1 线程创建与状态

    创建线程方式:

    1. 继承Thread类,重写run()方法
    2. 实现Runnable接口,传入Thread构造器
    3. 实现Callable接口,配合FutureTask(可返回结果)
    4. 线程池(Executors工厂创建)

    线程状态转换:

    典型线程创建示例:

    Thread thread = new Thread(() -> {
        System.out.println("执行中...");
    }, "Worker-1");
    thread.start();

    6.2 线程同步机制

    synchronized关键字:

    可见性保证:

    死锁必要条件:

    1. 互斥条件
    2. 请求与保持
    3. 不可剥夺
    4. 循环等待

    预防策略:

    6.3 线程池与任务调度

    核心参数

    常见拒绝策略:

    便捷工厂

    示例:定时任务

    ScheduledExecutorService scheduler =
        Executors.newScheduledThreadPool(2);
    scheduler.scheduleAtFixedRate(
        () -> System.out.println("执行中..."),
        0, 5, TimeUnit.SECONDS);

    工作窃取

    ForkJoinPool pool = new ForkJoinPool();
    int result = pool.invoke(new SumTask(array, 0, array.length));

    七、JVM运行机制

    7.1 内存区域划分

    JVM运行时数据区:

    内存溢出常见场景:

    7.2 垃圾回收机制

    对象存活判定:

    垃圾回收算法:

    常见垃圾收集器:

    收集器 适用区域 特点
    Serial 新生代 单线程,简单高效
    ParNew 新生代 Serial多线程版本
    Parallel Scavenge 新生代 关注吞吐量
    Serial Old 老年代 Serial单线程老年代版本
    Parallel Old 老年代 Parallel Scavenge老年代版本
    CMS 老年代 低停顿,并发收集
    G1 整堆 面向服务端,可预测停顿

    7.3 内存调优关键指标

    GC日志分析

    启用GC日志:

    -Xlog:gc*:file=gc.log:time,uptime:filecount=5,filesize=10m

    关键指标:

    堆参数设置

    典型配置(8GB内存服务器):

    -Xms4g -Xmx4g -XX:MetaspaceSize=256m -XX:MaxMetaspaceSize=512m

    监控工具

    生成堆快照:

    jmap -dump:format=b,file=heap.hprof <pid>

    8.1 开发环境配置

    JDK安装与版本选择:

    验证安装:

    java -version
    javac -version

    8.2 构建工具对比

    工具 依赖管理 构建速度 配置复杂度 适用场景
    Maven 中央仓库 中 低 传统企业项目
    Gradle 灵活仓库 高 中 大型多模块项目
    Ant 手动管理 高 高 简单项目/脚本

    Gradle优势:

    典型build.gradle配置:

    plugins {
        id 'java'
        id 'application'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        implementation 'org.springframework.boot:spring-boot-starter:3.0.0'
        testImplementation 'org.junit.jupiter:junit-jupiter:5.9.0'
    }

    8.3 常见面试题解析

    Q1:equals与==的区别?

    ==比较基本类型时比较值,比较引用类型时比较内存地址;equals()默认行为与==相同,但String等类已重写该方法用于比较内容。

    经典陷阱:Integer缓存范围[-128,127]

    Integer a = 127;
    Integer b = 127;
    System.out.println(a == b); // true(缓存对象)
    System.out.println(a.equals(b)); // true
    Integer c = 128;
    Integer d = 128;
    System.out.println(c == d); // false(新对象)
    System.out.println(c.equals(d)); // true

    Q2:HashMap与HashTable的区别?

    • 线程安全:HashMap非线程安全,Hashtable线程安全(synchronized方法)
    • 性能:HashMap更快(无同步开销)
    • null值:HashMap允许null键值,Hashtable不允许
    • 默认容量:HashMap 16,Hashtable 11
    • 扩容机制:HashMap 2倍,Hashtable 2n+1

    现代开发推荐:

    • 单线程环境:HashMap
    • 高并发环境:ConcurrentHashMap(替代Hashtable)

    Q3:String、StringBuilder、StringBuffer?

    • String:不可变字符串,每次修改生成新对象
    • StringBuilder:可变字符串,线程不安全,单线程首选
    • StringBuffer:可变字符串,线程安全(方法synchronized),多线程环境

    性能对比(10000次拼接):

    • String:约3000ms
    • StringBuffer:约5ms
    • StringBuilder:约3ms

    最佳实践:频繁字符串操作使用StringBuilder

    8.4 学习路径建议

    1. 基础阶段(1-2个月)
      • 掌握语法基础(变量、流程控制、方法)
      • 理解面向对象核心(类、对象、继承、多态)
      • 熟悉常用API(String、集合、日期)
    2. 进阶阶段(2-3个月)
      • 深入异常处理与IO操作
      • 掌握多线程编程与同步机制
      • 学习JVM基础与性能调优
    3. 实战阶段(持续)
      • 参与开源项目
      • 阅读优秀源码(JDK、Spring)
      • 构建个人项目库

    推荐学习资源:

    网友们还关心