备案号:蜀ICP备2026035467号-3 | 网址:www.xservx.com

java基础 教材

java基础 教材是通往Java技术世界的基石,它不仅是语法的堆砌,更是编程思维与工程化能力的启蒙。本教材以java基础为核心,构建从零到一的完整知识体系,涵盖开发环境配置、语法规范、面向对象思想、常用类库、异常处理、输入输出、多线程编程、JVM原理等核心模块,每部分均配备真实可运行的代码示例与典型应用场景解析。

与市面上零散的教程不同,本教材强调知识的系统性与逻辑递进性,通过“概念→原理→示例→实践→拓展”五步学习法,帮助读者建立扎实的java基础认知框架。无论您是计算机专业新生、转行开发者,还是希望夯实基础的资深工程师,本教材都能为您提供清晰、准确、可落地的学习路径。

在java基础 教材的学习过程中,需特别注意以下三个维度:

  1. 【语义理解】避免死记硬背,深入理解每条语法规则背后的设计意图,例如为何String是不可变类,为何==与equals()在不同场景下结果不同;
  2. 【实践驱动】每个核心概念必须通过编码验证,建议使用IntelliJ IDEA或Eclipse边学边练,构建“输入→执行→观察→反思”的闭环;
  3. 【体系关联】将新知识纳入已有认知网络,例如理解“多态”时,需关联“继承”“方法重写”“动态绑定”等概念,形成网状知识结构。

本教材不追求“速成”,但注重“扎实”。我们相信,只有对java基础有深刻理解的开发者,才能在面对Spring、MyBatis、微服务等高级技术时游刃有余,而非止步于API调用的表层。

开发者现状调研(2025年Q1)

据某技术社区统计,在参与调查的12,458名Java后端开发者中:

  • 78.3%自评java基础为“中等及以上”,但仅31.6%能完整手写单例模式(含线程安全变体);
  • 62.1%不了解HashMap在JDK1.8中红黑树阈值为何是8;
  • 44.8%在实际项目中未处理过ConcurrentModificationException,仅靠“try-catch”掩盖问题;
  • 仅19.2%能清晰解释final、finally、finalize()三者本质区别与适用边界。

这些数据揭示:java基础 教材并非“过时知识”,而是决定技术上限的“底层内功”。忽视基础者,终将为技术债买单。

语法基础:从Hello World到高级特性

java基础 教材的起点是public class HelloWorld,但终点远不止于此。本节系统梳理Java SE核心语法,覆盖变量、数据类型、运算符、流程控制、数组、方法、面向对象初步等模块,并延伸至泛型、注解、反射等进阶语法,强调每项特性的适用场景与陷阱。

1. 变量与数据类型

java基础中,变量是程序操作数据的入口。Java数据类型分为两大类:

典型误区解析

  1. 【自动装箱陷阱】
    Integer a = 128;
    Integer b = 128;
    System.out.println(a == b); // false(超出缓存范围[-128,127])
  2. 【精度丢失】
    double d = 0.1 + 0.2;
    System.out.println(d); // 0.30000000000000004
    解决方案:金融类计算使用BigDecimal,并用字符串构造:new BigDecimal("0.1")
  3. 【字符编码】
    char c = '中'; // 正确(UTF-16编码)
    char c = '中a'; // 编译错误(单引号仅允许一个字符)

2. 运算符优先级与表达式

Java运算符优先级(从高到低):()→!→++/--→* / %→+ -→< <= > >=→== !=→&→^→|→&&→||→? :→= += -= *= /= %=。

【关键点】逻辑运算符&&与||支持短路求值,而&与|(单个)不短路。例如:

int x = 5;
boolean result = (x > 10) && (x++ > 5); // x仍为5,因第一条件false,第二条件不执行

在java基础 教材中,此细节常被用于性能优化与避免空指针异常。

3. 数组与字符串

数组是java基础中重要的数据结构,具有固定长度、同质元素、连续内存三大特征。创建方式:

  • int[] arr = new int[5];
  • int[] arr = {1,2,3};
  • int[][] matrix = new int[3][4];(二维数组本质是一维数组的数组)

String是final类,其不可变性保障了线程安全与字符串池机制。常见误区:

  • "ab" + "cd"在编译期优化为"abcd",但String s1 = "ab"; String s2 = "cd"; String s3 = s1 + s2;会在堆中创建新对象;
  • 频繁拼接应使用StringBuilder(线程不安全)或StringBuffer(线程安全);
  • String.intern()可将字符串放入常量池,但JDK6与JDK7+行为不同(JDK7后常量池移至堆)。

字符串面试高频题

问题:以下代码输出什么?

String s1 = "hello";
String s2 = new String("hello");
String s3 = s2.intern();
System.out.println(s1 == s2); // false
System.out.println(s1 == s3); // true

解析:new String()强制在堆中创建对象,与字符串池中的s1地址不同;intern()返回池中已有对象的引用,故s3与s1相等。

面向对象:从封装到设计原则

java基础 教材的核心是面向对象编程(OOP)。它通过三大特性——封装、继承、多态,实现代码复用、降低耦合、提升可维护性。本节深入剖析OOP本质,并结合设计原则(SOLID)给出工程化实践建议。

1. 封装:隐藏实现细节

封装通过private修饰符与getter/setter方法实现。但需注意:

  • private字段应避免直接暴露setXXX(),尤其对可变对象(如Date、List),应返回防御性拷贝;
  • 构造器可重载,但需保证至少一个无参构造器(除非明确禁止实例化);
  • 使用final修饰类可禁止继承(如String、Integer),保障不可变性。

2. 继承与组合

继承通过extends实现,但“组合优于继承”是更优设计原则。原因:

  • 继承破坏封装性(子类依赖父类实现细节);
  • 继承层次过深导致脆弱基类问题(父类修改影响所有子类);
  • Java单继承限制了灵活性。

【示例对比】

继承 vs 组合

继承实现(问题):

class Engine { void start() {} }
class Car extends Engine {
    void drive() {
        start(); // 直接调用父类方法
    }
}

若Engine增加stop()方法,Car需重写drive()以适配新逻辑——耦合度高。

组合实现(推荐):

class Car {
    private Engine engine = new Engine();
    void drive() {
        engine.start();
    }
}

引擎可替换为ElectricEngine extends Engine,通过依赖注入(DI)实现松耦合。

3. 多态:动态绑定的魔法

多态的三大前提:父类引用指向子类对象、方法重写、动态绑定。关键点:

  • 编译期看引用类型,运行期看实际对象类型;
  • final、static、private方法不参与多态;
  • 构造器不能被重写(隐式调用父类构造器)。

多态典型场景

abstract class Animal {
    abstract void speak();
    void eat() { System.out.println("Animal eats"); }
}
class Dog extends Animal {
    void speak() { System.out.println("Woof!"); }
    void eat() { System.out.println("Dog eats meat"); }
}
public class Test {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.speak(); // Woof!(重写方法)
        a.eat();   // Dog eats meat(重写方法,非继承默认)
    }
}

注意:若eat()未被重写,则输出Animal eats。

4. 设计原则在java基础中的体现

  1. 开闭原则(OCP):对扩展开放,对修改关闭。例如Comparator接口通过匿名内部类扩展排序逻辑;
  2. 依赖倒置(DIP):高层模块不依赖低层模块,二者都依赖抽象。如Spring的ApplicationContext接口;
  3. 接口隔离(ISP):客户端不应依赖其不需要的接口。例如Serializable是标记接口,避免强制实现无用方法。

集合框架:从ArrayList到ConcurrentHashMap

java基础 教材中,集合是数据存储与操作的核心工具。Java集合体系以Collection与Map为根接口,涵盖List、Set、Queue、Map四大子体系,每种实现类均有其适用场景与性能特征。

1. List实现类对比

实现类底层结构线程安全适用场景时间复杂度
ArrayList动态数组否随机访问频繁get/set:O(1), add:O(1)均摊
LinkedList双向链表否频繁插入/删除add/remove:O(1),get:O(n)
Vector动态数组是(同步)旧版多线程场景与ArrayList相同,但性能低

【关键点】ArrayList扩容机制:默认增长50%(JDK8),即newCapacity = oldCapacity + (oldCapacity >> 1)。

2. Set实现类与哈希机制

HashSet基于HashMap实现,其元素唯一性依赖于equals()与hashCode()的正确重写。常见错误:

  • 重写equals()但未重写hashCode(),导致同一对象在不同位置存储;
  • 使用可变对象作为Set元素,修改字段后哈希值变化,破坏集合不变性。

【示例修复】

class Person {
    String name;
    int age;
    // 重写equals与hashCode
    @Override public boolean equals(Object o) {  }
    @Override public int hashCode() { return Objects.hash(name, age); }
}

3. Map深度解析

HashMap是java基础高频考点,其JDK1.8改进包括:

  • 链表转红黑树阈值:链表长度≥8且数组容量≥64时转换;
  • 扩容时元素重哈希:通过(e.hash & oldCap) == 0判断元素在新数组中的位置(高位不变则原索引,否则新索引=原索引+oldCap);
  • 并发问题:非线程安全,多线程环境应使用ConcurrentHashMap。

ConcurrentHashMap分段锁演进

JDK1.7:使用Segment数组(16个),每个Segment持有一个HashEntry数组;

JDK1.8:取消Segment,采用Node数组+链表/红黑树,锁粒度细化至桶(bucket),通过synchronized与CAS操作实现无锁化。

4. 集合遍历方式与性能

【foreach vs iterator vs for】

  • ArrayList:foreach性能≈for(索引访问),优于iterator(需维护cursor);
  • LinkedList:foreach性能≈iterator(基于cursor移动),远优于for(每次get需遍历);
  • HashMap:推荐entrySet()遍历(一次迭代获取键值),避免keySet() + get()二次查找。

多线程:从Thread到线程池

java基础 教材的多线程部分是区分初级与中级开发者的分水岭。本节从线程创建、同步机制、线程通信到线程池应用,构建完整的并发编程知识体系。

1. 线程创建方式

三种标准方式:

  1. 继承Thread类(受限于单继承);
  2. 实现Runnable接口(推荐,解耦任务与线程);
  3. 实现Callable接口(支持返回值与异常抛出)。

【Callable示例】

FutureTask task = new FutureTask<>(() -> {
    Thread.sleep(1000);
    return 42;
});
new Thread(task).start();
System.out.println(task.get()); // 阻塞等待结果

2. 同步机制深度解析

synchronized的三种用法:

  • 修饰实例方法:锁当前对象(this);
  • 修饰静态方法:锁Class对象;
  • 修饰代码块:锁指定对象(如new Object())。

【常见误区】

  • 不同对象实例的synchronized方法互不干扰;
  • static synchronized方法与非静态synchronized方法可并发执行(锁对象不同);
  • 锁对象被置空会导致NullPointerException。

死锁检测与预防

死锁四条件:互斥、占有且等待、不可剥夺、循环等待。

预防策略:

  1. 破坏“占有且等待”:一次性申请所有资源;
  2. 破坏“循环等待”:对资源排序,按序申请;
  3. 使用java.util.concurrent中的Lock配合tryLock(timeout)避免无限等待。

3. 线程池:线程复用的艺术

ThreadPoolExecutor构造参数:

new ThreadPoolExecutor(
    corePoolSize,      // 核心线程数
    maximumPoolSize,   // 最大线程数
    keepAliveTime,     // 空闲线程存活时间
    unit,
    workQueue,         // 阻塞队列
    threadFactory,     // 线程工厂
    handler            // 拒绝策略
)

【拒绝策略】

  • AbortPolicy:抛异常(默认);
  • CallerRunsPolicy:由调用线程执行任务;
  • DiscardPolicy:静默丢弃;
  • DiscardOldestPolicy:丢弃队列头任务。

【线程池类型对比】

类型核心线程数最大线程数队列适用场景
FixedThreadPoolnn无界队列任务量稳定、耗时短
CachedThreadPool0Integer.MAXSynchronousQueue大量短时任务
ScheduledThreadPoolnInteger.MAXDelayedWorkQueue定时/周期任务
WorkStealingPool并行度并行度无ForkJoin框架,CPU密集型

IO流:从字节流到NIO

java基础 教材的IO部分涵盖传统IO(Stream/Reader/Writer)与NIO(Buffer/Channel/Selector),理解其差异是构建高性能应用的基础。

1. 传统IO模型

传统IO以流(Stream)为核心,分为字节流(InputStream/OutputStream)与字符流(Reader/Writer)。关键点:

  • 字符流自动处理编码转换(默认UTF-8);
  • 缓冲流(BufferedInputStream等)提升性能,减少系统调用;
  • 转换流(InputStreamReader)连接字节流与字符流。

文件复制性能对比

【字节流+缓冲】

try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("in.txt"));
     BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("out.txt"))) {
    byte[] buffer = new byte[8192];
    int len;
    while ((len = bis.read(buffer)) != -1) {
        bos.write(buffer, 0, len);
    }
}

【NIO FileChannel】

try (FileChannel in = FileChannel.open(Paths.get("in.txt"), StandardOpenOption.READ);
     FileChannel out = FileChannel.open(Paths.get("out.txt"), StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
    in.transferTo(0, in.size(), out); // 零拷贝(底层依赖OS优化)
}

NIO在大文件场景下性能提升显著(减少内核态与用户态拷贝)。

2. NIO核心组件

Buffer:数据容器,支持flip()(切换读模式)、clear()(清空)、compact()(压缩剩余数据);

Channel:单向数据通道,支持读/写/读写(如FileChannel、SocketChannel);

Selector:多路复用器,单线程管理多个Channel,实现高并发(如Netty底层)。

阻塞IO vs 非阻塞IO vs 多路复用

  • 阻塞IO:线程等待数据就绪(传统Socket);
  • 非阻塞IO:轮询检查数据就绪(高CPU占用);
  • 多路复用:内核通知数据就绪(select/poll/epoll),高并发首选。

异常处理:从Throwable到最佳实践

java基础 教材的异常体系以Throwable为根,分为Error(严重错误,如OutOfMemoryError)与Exception(可处理异常),后者又分为Checked Exception(编译期强制处理)与Unchecked Exception(运行时异常)。

1. 异常分类与典型场景

类型示例处理方式设计意图
NullPointerException空对象调用方法前置校验(Objects.requireNonNull)编程错误
ArrayIndexOutOfBoundsException数组越界循环边界检查编程错误
IOException文件读写失败try-catch + 资源关闭可恢复异常
ClassNotFoundException反射类不存在try-catch + 备用方案可恢复异常

2. 自定义异常

自定义异常需继承Exception(Checked)或RuntimeException(Unchecked),并提供序列化ID与构造器链:

public class BizException extends RuntimeException {
    private int code;
    public BizException(int code, String msg) {
        super(msg);
        this.code = code;
    }
    public BizException(int code, String msg, Throwable cause) {
        super(msg, cause);
        this.code = code;
    }
    // getter/setter...
}

3. 异常处理最佳实践

  1. 【捕获粒度】避免catch (Exception e)泛化,应精确捕获具体异常;
  2. 【日志记录】使用logger.error("描述", e)记录完整堆栈;
  3. 【资源释放】优先使用try-with-resources(自动调用close());
  4. 【异常链】保留原始异常:throw new BizException(500, "业务失败", e)。

finally vs try-with-resources

【传统finally】

BufferedReader br = null;
try {
    br = new BufferedReader(new FileReader("file.txt"));
    return br.readLine();
} finally {
    if (br != null) br.close(); // 易遗漏异常处理
}

【try-with-resources】

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    return br.readLine();
} // 自动关闭,且不抛出关闭异常( suppressed exception)

JVM原理:从内存结构到垃圾回收

java基础 教材的JVM部分是高级开发者的必修课。掌握JVM内存模型、类加载机制、垃圾回收算法,能显著提升问题排查能力与性能调优水平。

1. 运行时数据区

JVM内存分为:

  • 程序计数器:线程私有,记录当前执行字节码指令地址;
  • 虚拟机栈:线程私有,存储栈帧(局部变量表、操作数栈等);
  • 本地方法栈:线程私有,服务Native方法;
  • 堆:线程共享,存储对象实例(新生代+老年代);
  • 方法区:线程共享,存储类信息、常量、静态变量(JDK8后为元空间Metaspace)。

栈溢出(StackOverflowError) vs 堆溢出(OutOfMemoryError)

栈溢出:递归深度过大(如无限递归),可通过-Xss调整栈大小;

堆溢出:对象过多且无法回收(如内存泄漏),可通过-Xmx调整堆大小,并用jmap分析堆转储。

2. 类加载机制

类加载过程:加载→验证→准备→解析→初始化。

  • 准备阶段:为静态变量分配内存并设置初始值(如static int a = 1;此时a=0);
  • 初始化阶段:执行<clinit>方法(静态变量赋值+静态代码块)。

【双亲委派模型】

  • 启动类加载器(Bootstrap)→扩展类加载器(Extension)→应用类加载器(Application);
  • 作用:避免类重复加载、保障核心库安全(如java.lang.String不会被替换)。

打破双亲委派

场景:OSGi模块化、SPI机制(如JDBC驱动加载)。

实现:自定义ClassLoader并重写loadClass()方法,跳过双亲委派逻辑。

3. 垃圾回收(GC)

判断对象存活:

  • 引用计数法(Java未采用,因循环引用问题);
  • 可达性分析:从GC Roots(线程栈、静态变量、JNI引用等)出发,不可达即为垃圾。

GC算法:

算法原理优缺点适用场景
标记-清除标记→清除产生碎片老年代(配合压缩)
复制算法复制到空闲区浪费空间新生代(Eden/Survivor)
标记-整理标记→整理→清除移动对象开销大老年代
分代收集新生代→老年代需对象年龄判断主流JVM(HotSpot)

GC日志解读

[GC (Allocation Failure) [PSYoungGen: 10240K->1024K(12288K)] 10240K->2048K(39936K), 0.0023456 secs]

  • PSYoungGen:Parallel Scavenge新生代收集器;
  • 10240K->1024K:GC前→GC后内存使用量;
  • (12288K):新生代总容量;
  • 0.0023456 secs:GC耗时(STW时间)。

网友常见问题与深度解答

Q1:为什么Java中没有指针?

A:Java采用“引用”(Reference)替代指针,本质是安全的指针实现。优点包括:

  • 【内存安全】JVM管理内存分配与回收,避免野指针、内存泄漏;
  • 【类型安全】引用需与对象类型匹配,禁止强制类型转换错误;
  • 【垃圾回收】通过引用链判断对象存活,实现自动GC。

但引用仍支持地址操作(如System.identityHashCode()获取对象哈希码),只是对开发者隐藏了底层细节。

Q2:final、finally、finalize()区别?

A:三者无关联,仅因拼写相似易混淆:

  • final:修饰符,表示不可变(类不可继承、方法不可重写、变量不可重新赋值);
  • finally:异常处理块,确保代码在try-catch后执行(即使发生异常);
  • finalize():Object方法,对象被GC前调用(已废弃,JDK9起标记为@Deprecated)。

【注意】finalize()存在性能问题、执行时间不确定,应使用try-with-resources或Cleaner(JDK9+)替代。

Q3:==与equals()区别?

A:==比较引用地址(基本类型比较值),equals()默认比较地址(等价于==),但常被重写为内容比较(如String、Integer)。

【关键点】重写equals()时必须重写hashCode(),否则违反“相等对象必须有相同哈希码”原则,导致集合(如HashSet)失效。

Q4:Java中如何实现高精度计算?

A:金融/科学计算需用BigDecimal,注意以下要点:

  1. 【构造方式】必须用字符串:new BigDecimal("0.1"),禁用double构造(保留二进制误差);
  2. 【运算方法】使用add()、subtract()、multiply()、divide()(divide需指定精度与舍入模式);
  3. 【舍入模式】常用RoundingMode.HALF_EVEN(银行家舍入法,减少累积误差)。

Q5:如何避免HashMap死循环(JDK1.7)?

A:JDK1.7中HashMap扩容时链表头插法可能导致环形链表,引发死循环。解决方案:

  • 【升级JDK】:JDK1.8采用尾插法,已修复此问题;
  • 【线程安全】:多线程场景使用ConcurrentHashMap;
  • 【替代方案】:使用Collections.synchronizedMap(new HashMap<>())(性能较低)。

Q6:什么是内存泄漏?Java如何检测?

A:内存泄漏指无用对象长期占用内存且无法回收。常见场景:

  • static集合未清理(如static List持续添加对象);
  • 监听器/回调未注销(如Observer模式);
  • ThreadLocal未remove(导致Entry值无法回收);
  • 数据库连接/文件流未关闭。

检测工具:

  • jmap -dump:format=b,file=heap.hprof <pid>生成堆转储;
  • 用Eclipse MAT分析histogram与dominator tree;
  • VisualVM监控内存曲线与GC频率。