java基础知识讲座|系统·深入·实用

java基础知识讲座

本页面为java基础知识讲座的首页,旨在为所有希望系统掌握Java编程语言的开发者提供一份权威、全面、结构清晰的学习指南。无论您是初学者,还是已有一定经验但希望夯实基础的开发者,本页面都将为您提供扎实的知识体系与丰富的实战示例。

在当今软件开发领域,Java语言凭借其跨平台性、健壮性、丰富的生态系统以及强大的社区支持,长期稳居主流编程语言前列。从企业级后端应用、Android移动开发,到大数据处理、微服务架构,Java的身影无处不在。掌握Java基础知识,不仅是进入大型企业开发团队的敲门砖,更是构建高可用、可维护系统架构的基石。

本页面内容严格遵循知识递进逻辑,从最基础的语法结构出发,逐步深入到面向对象核心思想、集合与泛型机制、并发编程模型、JVM运行机制及主流设计模式,每个模块均辅以真实代码示例、常见误区解析与最佳实践建议。我们特别注重java基础知识讲座的系统性与实用性,避免碎片化学习带来的知识断层。

此外,页面还设置了「网友们还关心」板块,精选开发者高频搜索问题,如“Java与Python在企业级开发中的对比”、“JVM垃圾回收机制如何影响应用性能”、“Spring框架与原生Java开发的关系”等,帮助您拓展技术视野,理解Java在真实技术栈中的定位与价值。

通过本页面的学习,您将能够:

我们坚信,扎实的java基础知识讲座是成为高级工程师的必经之路。本页面所有内容均经过多次教学实践验证,确保知识准确、示例可运行、讲解透彻。请随时通过导航栏跳转至各核心模块,开启您的Java进阶之旅。

语法基础:构建程序的砖石

Java语法是所有Java程序的基石,其设计强调清晰性、安全性与可读性。掌握语法不仅是记住关键字与规则,更要理解其背后的设计哲学。以下从数据类型、运算符、控制流、数组与字符串五大核心维度展开讲解。

1. 数据类型与变量

Java为强类型语言,所有变量必须先声明后使用。数据类型分为基本类型(primitive types)与引用类型(reference types):

类型字节数默认值示例
byte10byte b = 127;
short20short s = 32767;
int40int i = 2_147_483_647;
long80Llong l = 9_223_372_036_854_775_807L;
float40.0ffloat f = 3.14159f;
double80.0ddouble d = 3.141592653589793;
char2'\u0000'char c = '中'; // Unicode字符
boolean1 bitfalseboolean flag = true;

⚠️ 注意:整数字面量默认为int类型,浮点字面量默认为double类型。声明long或float变量时必须加后缀L或f,否则编译报错。

从Java 7起支持数字分隔符(下划线),提升可读性,如:int billion = 1_000_000_000;。但分隔符不能出现在首尾、小数点附近或类型前缀后(如0x_123非法)。

2. 运算符与表达式

Java支持算术、关系、逻辑、位、三元、赋值等运算符。特别注意:

3. 控制流语句

包括if-else、switch、for、while、do-while及跳转语句break/continue。Java 7起switch支持字符串,Java 12起支持表达式形式(yield关键字):

String fruit = "apple";
String result = switch (fruit) {
  case "apple"  -> "red";
  case "banana" -> "yellow";
  default       -> "unknown";
};

⚠️ 注意:传统switch需显式使用break防止fall-through;表达式形式自动断开,无需break。

4. 数组与字符串

数组是固定长度的同类型元素序列,声明方式:int[] arr = new int[5];或int[] arr = {1,2,3};。字符串是String类的实例,具有不可变性(immutable),每次修改均生成新对象:

String s = "Hello";
s += " World"; // 实际创建两个String对象

高频陷阱:循环中拼接字符串应使用StringBuilder,避免性能劣化。正确做法:StringBuilder sb = new StringBuilder(); sb.append("Hello").append(" World");

5. 方法与重载

方法定义格式:访问修饰符 静态/实例 修饰符 返回类型 方法名(参数列表) { ... }。方法重载要求:方法名相同、参数列表不同(类型/个数/顺序)、返回类型可同可异。注意:仅返回类型不同不构成重载!

int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }
int add(int a, int b, int c) { return a + b + c; }

调用时根据实参类型与个数自动匹配,若存在模糊匹配(如add(1, 2L)可能匹配add(int,int)或add(double,double)),编译报错。

面向对象编程:Java的灵魂

Java是纯面向对象语言(除基本类型外),其核心思想——封装、继承、多态——构成了软件工程中高内聚、低耦合设计的基础。本节深入解析三大特性及抽象类与接口的区别,破除常见误解。

1. 封装:隐藏实现,保护数据

通过private字段与public方法(getter/setter)实现数据隐藏。示例:Person类:

public class Person {
  private String name;
  private int age;
  public String getName() { return name; }
  public void setName(String name) { this.name = name; }
  public int getAge() { return age; }
  public void setAge(int age) {
    if (age >= 0 && age <= 150) this.age = age;
    else throw new IllegalArgumentException("年龄无效");
  }
}

封装的价值在于:① 防止非法状态;② 允许内部实现变更而不影响外部调用;③ 控制访问粒度(如只读字段可不提供setter)。

2. 继承:复用与扩展

使用extends关键字实现单继承,子类继承父类非private成员。注意:final类不可被继承(如String),private方法不可被重写(仅可见性提升可被子类定义同名方法,但非重写)。

构造器调用链:子类构造器首行隐式或显式调用super(),确保父类初始化。若父类无无参构造器,子类必须显式调用super(...),否则编译失败。

3. 多态:运行时绑定

多态的三个前提:① 继承/实现;② 方法重写;③ 父类引用指向子类对象。示例:

class Animal { void sound() { System.out.println("Animal sound"); } }
class Dog extends Animal { @Override void sound() { System.out.println("Woof"); } }
Animal a = new Dog(); // 向上转型
a.sound(); // 输出"Woof"——动态绑定

⚠️ 重要:多态仅作用于实例方法!字段、静态方法、构造器均不体现多态,编译时已确定绑定对象。

4. 抽象类 vs 接口

特性抽象类接口(Java 8+)
关键字abstract classinterface
构造器可有(供子类调用)不可有
成员变量可有任意修饰符默认public static final
方法实现可有抽象/具体方法可有默认方法(default)、静态方法
继承/实现单继承多实现
设计定位is-a关系,模板式复用行为契约,能力声明

Java 8起接口支持默认方法与静态方法,极大增强了其表达能力,但抽象类仍不可替代——它能持有状态(实例字段),而接口仅能定义行为规范。

5. 关键字辨析

常见误区:认为static方法可被重写(实际为隐藏),或认为final方法不能被子类定义同名方法(实际可定义,但非重写)。

集合框架:高效处理数据的核心

Java集合框架(Java Collections Framework)是开发中使用最频繁的API之一,提供统一的接口与高效实现。掌握其体系结构与关键实现类,是编写高性能Java程序的必备技能。

1. 集合体系概览

Iterable

所有集合的根接口,提供迭代器支持

Collection

单值集合:List(有序可重复)、Set(无序不重复)

Map

键值对集合:HashMap、TreeMap、LinkedHashMap

2. List详解

实现类底层结构线程安全适用场景
ArrayList动态数组否频繁查询、尾部插入
LinkedList双向链表否频繁插入/删除(非随机访问)
Vector动态数组是(方法同步)旧版线程安全需求

⚠️ 注意:ArrayList扩容策略为1.5倍(原容量+原容量>>1),LinkedList插入时需更新前后节点引用。

3. Set详解

Set通过equals()与hashCode()保证元素唯一性:

重写hashCode()时必须同时重写equals(),否则Set无法正确去重!示例:

class Person {
  String name; int age;
  @Override public int hashCode() {
    return Objects.hash(name, age);
  }
  @Override public boolean equals(Object o) {
    return o instanceof Person p && name.equals(p.name) && age == p.age;
  }
}

4. Map核心技巧

Map的常用操作包括:put/get/containsKey/containsValue/remove。Java 8新增实用方法:

示例:统计词频

Map freq = new HashMap<>();
for (String word : words) {
  freq.merge(word, 1, Integer::sum); // 等价于computeIfAbsent+put
}

5. 泛型:类型安全的基石

泛型仅存在于编译期(类型擦除),运行时无泛型信息。关键规则:

示例:安全合并集合

void copyAll(Collection src, Collection dest) {
  for (Number n : src) dest.add(n); // 安全添加

多线程编程:并发的挑战与艺术

Java的多线程支持是其企业级应用的核心优势之一。从早期的Thread与synchronized,到现代的java.util.concurrent(JUC)包,并发编程工具日益成熟。本节聚焦实战中的关键概念与避坑指南。

1. 线程状态与创建

线程六种状态:NEW→RUNNABLE→BLOCKED→WAITING/TIMED_WAITING→TERMINATED。创建方式:

线程池创建示例(Java 19+推荐方式):

ExecutorService pool = Executors.newFixedThreadPool(4);
Future future = pool.submit(() -> {
  return calculate();
});
Integer result = future.get(); // 阻塞等待结果

2. synchronized机制

synchronized可修饰方法或代码块,确保同一时刻仅一个线程执行临界区。三种锁粒度:

⚠️ 注意:锁对象必须是共享的!若每个线程用不同对象锁,同步失效:

// 错误示例:每个线程创建新锁对象
synchronized(new Object()) { ... }
// 正确示例:共享锁对象
private final Object lock = new Object();

3. JUC核心工具

工具用途关键方法
CountDownLatch等待多个线程完成await(), countDown()
CyclicBarrier线程间同步点await(), reset()
Semaphore控制并发访问数acquire(), release()
ConcurrentHashMap线程安全MapputIfAbsent(), compute()
AtomicInteger原子整数getAndIncrement(), compareAndSet()

示例:用Semaphore实现连接池

Semaphore sem = new Semaphore(3); // 3个连接
sem.acquire(); // 获取连接
try {
  useConnection();
} finally {
  sem.release(); // 归还连接
}

4. 死锁排查与避免

死锁四条件:互斥、占有且等待、不可抢占、循环等待。避免策略:

排查工具:jstack可输出线程栈,定位死锁线程(显示"Found one Java-level deadlock")。

5. volatile关键字

volatile保证可见性与有序性(禁止指令重排),但不保证原子性。适用场景:

⚠️ 注意:volatile不能替代synchronized处理复合操作(如i++仍需同步)!

JVM原理:理解程序的运行环境

深入理解JVM是Java工程师进阶的必经之路。掌握内存模型、类加载机制与垃圾回收策略,能显著提升问题排查与性能调优能力。

1. 内存区域划分

区域作用溢出异常
程序计数器当前线程执行字节码行号指示器无
Java虚拟机栈方法调用栈帧(局部变量表、操作数栈)StackOverflowError
本地方法栈Native方法调用StackOverflowError
Java堆对象实例存储区(GC主战场)OutOfMemoryError
方法区/元空间类信息、常量、静态变量(JDK8后移至Metaspace)OutOfMemoryError

关键点:堆是线程共享区,栈是线程私有区;元空间使用本地内存,不再受JVM内存限制。

2. 类加载机制

类加载过程五阶段:

  1. 加载:通过类名获取二进制字节流,转为方法区运行时数据结构
  2. 验证:确保字节流符合JVM规范(文件格式、元数据、字节码、符号引用)
  3. 准备:分配内存并设置默认初始值(static字段→0/null)
  4. 解析:将常量池符号引用转为直接引用
  5. 初始化:执行类构造器<clinit>()(静态变量赋值+静态代码块)

双亲委派模型:类加载器优先委托父加载器,避免重复加载。自定义类加载器需重写loadClass(),但应保持委派逻辑。

3. 垃圾回收机制

判断对象存活:可达性分析(从GC Roots出发的引用链)。GC Roots包括:

常见GC算法:

算法原理优缺点
标记-清除标记存活对象,清除未标记效率低,产生碎片
复制算法内存分两区,存活对象拷贝至另一区高效,内存浪费
标记-整理标记后移动存活对象,清除边界外无碎片,移动成本高

现代JVM(如HotSpot)采用分代收集:新生代(复制算法)+老年代(标记-整理/标记-清除)。

4. 常见调优参数

-Xms2g -Xmx2g      # 堆初始/最大值2GB
-Xss1m             # 线程栈大小1MB
-XX:MetaspaceSize=256m
-XX:+UseG1GC       # 使用G1垃圾回收器(推荐)

G1回收器将堆划分为Region,实现停顿时间可控(-XX:MaxGCPauseMillis=200),适合大内存应用。

设计模式:可复用的解决方案

设计模式是前人经验的结晶,帮助开发者解决常见问题。本节精选3种高频模式,结合java基础知识讲座场景说明其应用。

1. 单例模式(Singleton)

确保一个类仅有一个实例,并提供全局访问点。线程安全实现:

public class Singleton {
  private Singleton() {}
  private static class Holder {
    private static final Singleton INSTANCE = new Singleton();
  }
  public static Singleton getInstance() {
    return Holder.INSTANCE;
  }
}

利用类加载机制保证线程安全,无同步开销,推荐用于配置管理、日志器等。

2. 工厂模式(Factory)

定义创建对象的接口,但由子类决定实例化哪个类。示例:数据库连接工厂

interface DBConnection { void connect(); }
class MySQLConnection implements DBConnection { ... }
class OracleConnection implements DBConnection { ... }
class ConnectionFactory {
  public static DBConnection createConnection(String type) {
    return switch (type) {
      case "mysql" -> new MySQLConnection();
      case "oracle" -> new OracleConnection();
      default -> throw new IllegalArgumentException("未知DB类型");
    };
  }
}

解耦对象创建与使用,便于扩展新类型(新增类即可)。Spring的BeanFactory即基于此模式。

3. 代理模式(Proxy)

为其他对象提供代理以控制访问。JDK动态代理实现:

interface Service { void execute(); }
class RealService implements Service { ... }
class LoggingProxy implements InvocationHandler {
  private final Service target;
  LoggingProxy(Service target) { this.target = target; }
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("调用" + method.getName());
    return method.invoke(target, args);
  }
}
Service proxy = (Service) Proxy.newProxyInstance(
  Service.class.getClassLoader(),
  new Class[]{Service.class},
  new LoggingProxy(new RealService())
);

Spring AOP底层即基于动态代理,实现日志、事务、权限校验等横切关注点。

4. 设计原则速查