java基础 教材是通往Java技术世界的基石,它不仅是语法的堆砌,更是编程思维与工程化能力的启蒙。本教材以java基础为核心,构建从零到一的完整知识体系,涵盖开发环境配置、语法规范、面向对象思想、常用类库、异常处理、输入输出、多线程编程、JVM原理等核心模块,每部分均配备真实可运行的代码示例与典型应用场景解析。
与市面上零散的教程不同,本教材强调知识的系统性与逻辑递进性,通过“概念→原理→示例→实践→拓展”五步学习法,帮助读者建立扎实的java基础认知框架。无论您是计算机专业新生、转行开发者,还是希望夯实基础的资深工程师,本教材都能为您提供清晰、准确、可落地的学习路径。
在java基础 教材的学习过程中,需特别注意以下三个维度:
String是不可变类,为何==与equals()在不同场景下结果不同;IntelliJ IDEA或Eclipse边学边练,构建“输入→执行→观察→反思”的闭环;本教材不追求“速成”,但注重“扎实”。我们相信,只有对java基础有深刻理解的开发者,才能在面对Spring、MyBatis、微服务等高级技术时游刃有余,而非止步于API调用的表层。
据某技术社区统计,在参与调查的12,458名Java后端开发者中:
HashMap在JDK1.8中红黑树阈值为何是8;ConcurrentModificationException,仅靠“try-catch”掩盖问题;final、finally、finalize()三者本质区别与适用边界。这些数据揭示:java基础 教材并非“过时知识”,而是决定技术上限的“底层内功”。忽视基础者,终将为技术债买单。
java基础 教材的起点是public class HelloWorld,但终点远不止于此。本节系统梳理Java SE核心语法,覆盖变量、数据类型、运算符、流程控制、数组、方法、面向对象初步等模块,并延伸至泛型、注解、反射等进阶语法,强调每项特性的适用场景与陷阱。
java基础中,变量是程序操作数据的入口。Java数据类型分为两大类:
int默认为整型,long需加后缀;float需加,double可省略。 Integer a = 128; Integer b = 128; System.out.println(a == b); // false(超出缓存范围[-128,127])
double d = 0.1 + 0.2; System.out.println(d); // 0.30000000000000004解决方案:金融类计算使用
BigDecimal,并用字符串构造:new BigDecimal("0.1")char c = '中'; // 正确(UTF-16编码) char c = '中a'; // 编译错误(单引号仅允许一个字符)
Java运算符优先级(从高到低):()→!→++/--→* / %→+ -→< <= > >=→== !=→&→^→|→&&→||→? :→= += -= *= /= %=。
【关键点】逻辑运算符&&与||支持短路求值,而&与|(单个)不短路。例如:
int x = 5; boolean result = (x > 10) && (x++ > 5); // x仍为5,因第一条件false,第二条件不执行
在java基础 教材中,此细节常被用于性能优化与避免空指针异常。
数组是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)给出工程化实践建议。
封装通过private修饰符与getter/setter方法实现。但需注意:
private字段应避免直接暴露setXXX(),尤其对可变对象(如Date、List),应返回防御性拷贝;final修饰类可禁止继承(如String、Integer),保障不可变性。继承通过extends实现,但“组合优于继承”是更优设计原则。原因:
【示例对比】
继承实现(问题):
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)实现松耦合。
多态的三大前提:父类引用指向子类对象、方法重写、动态绑定。关键点:
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。
Comparator接口通过匿名内部类扩展排序逻辑;ApplicationContext接口;Serializable是标记接口,避免强制实现无用方法。java基础 教材中,集合是数据存储与操作的核心工具。Java集合体系以Collection与Map为根接口,涵盖List、Set、Queue、Map四大子体系,每种实现类均有其适用场景与性能特征。
| 实现类 | 底层结构 | 线程安全 | 适用场景 | 时间复杂度 |
|---|---|---|---|---|
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)。
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); }
}
HashMap是java基础高频考点,其JDK1.8改进包括:
(e.hash & oldCap) == 0判断元素在新数组中的位置(高位不变则原索引,否则新索引=原索引+oldCap);ConcurrentHashMap。JDK1.7:使用Segment数组(16个),每个Segment持有一个HashEntry数组;
JDK1.8:取消Segment,采用Node数组+链表/红黑树,锁粒度细化至桶(bucket),通过synchronized与CAS操作实现无锁化。
【foreach vs iterator vs for】
ArrayList:foreach性能≈for(索引访问),优于iterator(需维护cursor);LinkedList:foreach性能≈iterator(基于cursor移动),远优于for(每次get需遍历);HashMap:推荐entrySet()遍历(一次迭代获取键值),避免keySet() + get()二次查找。java基础 教材的多线程部分是区分初级与中级开发者的分水岭。本节从线程创建、同步机制、线程通信到线程池应用,构建完整的并发编程知识体系。
三种标准方式:
Thread类(受限于单继承);Runnable接口(推荐,解耦任务与线程);Callable接口(支持返回值与异常抛出)。【Callable示例】
FutureTasktask = new FutureTask<>(() -> { Thread.sleep(1000); return 42; }); new Thread(task).start(); System.out.println(task.get()); // 阻塞等待结果
synchronized的三种用法:
new Object())。【常见误区】
synchronized方法互不干扰;static synchronized方法与非静态synchronized方法可并发执行(锁对象不同);NullPointerException。死锁四条件:互斥、占有且等待、不可剥夺、循环等待。
预防策略:
java.util.concurrent中的Lock配合tryLock(timeout)避免无限等待。ThreadPoolExecutor构造参数:
new ThreadPoolExecutor(
corePoolSize, // 核心线程数
maximumPoolSize, // 最大线程数
keepAliveTime, // 空闲线程存活时间
unit,
workQueue, // 阻塞队列
threadFactory, // 线程工厂
handler // 拒绝策略
)
【拒绝策略】
AbortPolicy:抛异常(默认);CallerRunsPolicy:由调用线程执行任务;DiscardPolicy:静默丢弃;DiscardOldestPolicy:丢弃队列头任务。【线程池类型对比】
| 类型 | 核心线程数 | 最大线程数 | 队列 | 适用场景 |
|---|---|---|---|---|
FixedThreadPool | n | n | 无界队列 | 任务量稳定、耗时短 |
CachedThreadPool | 0 | Integer.MAX | SynchronousQueue | 大量短时任务 |
ScheduledThreadPool | n | Integer.MAX | DelayedWorkQueue | 定时/周期任务 |
WorkStealingPool | 并行度 | 并行度 | 无 | ForkJoin框架,CPU密集型 |
java基础 教材的IO部分涵盖传统IO(Stream/Reader/Writer)与NIO(Buffer/Channel/Selector),理解其差异是构建高性能应用的基础。
传统IO以流(Stream)为核心,分为字节流(InputStream/OutputStream)与字符流(Reader/Writer)。关键点:
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在大文件场景下性能提升显著(减少内核态与用户态拷贝)。
Buffer:数据容器,支持flip()(切换读模式)、clear()(清空)、compact()(压缩剩余数据);
Channel:单向数据通道,支持读/写/读写(如FileChannel、SocketChannel);
Selector:多路复用器,单线程管理多个Channel,实现高并发(如Netty底层)。
java基础 教材的异常体系以Throwable为根,分为Error(严重错误,如OutOfMemoryError)与Exception(可处理异常),后者又分为Checked Exception(编译期强制处理)与Unchecked Exception(运行时异常)。
| 类型 | 示例 | 处理方式 | 设计意图 |
|---|---|---|---|
NullPointerException | 空对象调用方法 | 前置校验(Objects.requireNonNull) | 编程错误 |
ArrayIndexOutOfBoundsException | 数组越界 | 循环边界检查 | 编程错误 |
IOException | 文件读写失败 | try-catch + 资源关闭 | 可恢复异常 |
ClassNotFoundException | 反射类不存在 | try-catch + 备用方案 | 可恢复异常 |
自定义异常需继承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...
}
catch (Exception e)泛化,应精确捕获具体异常;logger.error("描述", e)记录完整堆栈;try-with-resources(自动调用close());throw new BizException(500, "业务失败", e)。【传统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)
java基础 教材的JVM部分是高级开发者的必修课。掌握JVM内存模型、类加载机制、垃圾回收算法,能显著提升问题排查能力与性能调优水平。
JVM内存分为:
栈溢出:递归深度过大(如无限递归),可通过-Xss调整栈大小;
堆溢出:对象过多且无法回收(如内存泄漏),可通过-Xmx调整堆大小,并用jmap分析堆转储。
类加载过程:加载→验证→准备→解析→初始化。
static int a = 1;此时a=0);<clinit>方法(静态变量赋值+静态代码块)。【双亲委派模型】
java.lang.String不会被替换)。场景:OSGi模块化、SPI机制(如JDBC驱动加载)。
实现:自定义ClassLoader并重写loadClass()方法,跳过双亲委派逻辑。
判断对象存活:
GC算法:
| 算法 | 原理 | 优缺点 | 适用场景 |
|---|---|---|---|
| 标记-清除 | 标记→清除 | 产生碎片 | 老年代(配合压缩) |
| 复制算法 | 复制到空闲区 | 浪费空间 | 新生代(Eden/Survivor) |
| 标记-整理 | 标记→整理→清除 | 移动对象开销大 | 老年代 |
| 分代收集 | 新生代→老年代 | 需对象年龄判断 | 主流JVM(HotSpot) |
[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时间)。A:Java采用“引用”(Reference)替代指针,本质是安全的指针实现。优点包括:
但引用仍支持地址操作(如System.identityHashCode()获取对象哈希码),只是对开发者隐藏了底层细节。
A:三者无关联,仅因拼写相似易混淆:
final:修饰符,表示不可变(类不可继承、方法不可重写、变量不可重新赋值);finally:异常处理块,确保代码在try-catch后执行(即使发生异常);finalize():Object方法,对象被GC前调用(已废弃,JDK9起标记为@Deprecated)。【注意】finalize()存在性能问题、执行时间不确定,应使用try-with-resources或Cleaner(JDK9+)替代。
A:==比较引用地址(基本类型比较值),equals()默认比较地址(等价于==),但常被重写为内容比较(如String、Integer)。
【关键点】重写equals()时必须重写hashCode(),否则违反“相等对象必须有相同哈希码”原则,导致集合(如HashSet)失效。
A:金融/科学计算需用BigDecimal,注意以下要点:
new BigDecimal("0.1"),禁用double构造(保留二进制误差);add()、subtract()、multiply()、divide()(divide需指定精度与舍入模式);RoundingMode.HALF_EVEN(银行家舍入法,减少累积误差)。A:JDK1.7中HashMap扩容时链表头插法可能导致环形链表,引发死循环。解决方案:
ConcurrentHashMap;Collections.synchronizedMap(new HashMap<>())(性能较低)。A:内存泄漏指无用对象长期占用内存且无法回收。常见场景:
static集合未清理(如static List持续添加对象);Observer模式);检测工具:
jmap -dump:format=b,file=heap.hprof <pid>生成堆转储;Eclipse MAT分析histogram与dominator tree;