本页面系统讲解java编程语言基础核心内容,涵盖语法结构、面向对象、集合框架、异常处理、多线程、IO流、网络编程、JVM原理、常用工具类及企业级开发实践。内容基于最新Java 17 LTS版本编写,结合实战案例与高频面试题,助您构建完整知识体系。
作为全球使用最广泛的编程语言之一,java编程语言基础具备以下优势:
据TIOBE 2025年3月统计,java编程语言基础仍稳居全球前三,企业级后端开发岗位需求常年位居榜首。掌握java编程语言基础不仅是学习一门语言,更是进入现代软件工程体系的钥匙。
java编程语言基础诞生于1995年,由Sun Microsystems(后被Oracle收购)正式发布。其核心理念“Write Once, Run Anywhere”(一次编写,到处运行)颠覆了当时软件开发模式。
詹姆斯·高斯林(James Gosling)领导团队开发Oak语言,目标是用于嵌入式设备控制。
改名Java,首次提出“Java Applet”概念,掀起Web交互式编程浪潮。
引入泛型、注解、枚举、自动装箱、增强for循环等现代语法,java编程语言基础真正步入成熟期。
Lambda表达式与Stream API彻底改变开发范式,函数式编程成为主流。
当前长期支持版本,新增Pattern Matching、Sealed Classes、Vector API等特性,java编程语言基础持续进化。
从嵌入式设备到超大规模分布式系统,java编程语言基础已覆盖云计算(AWS SDK)、大数据(Hadoop/Spark)、移动开发(Android)、金融交易系统等全场景。
Spring生态(Spring Boot/Spring Cloud)已成为Java后端开发事实标准。微服务架构下,java编程语言基础凭借高并发处理能力、稳定GC机制、丰富中间件支持,成为金融、电商、政务系统首选。
典型场景:
Hadoop、Spark、Flink等大数据框架核心组件均采用java编程语言基础开发。其强类型系统与JIT编译优化,使Java在处理TB/PB级数据时性能卓越。
示例:Spark任务提交脚本本质是Java进程启动;HDFS NameNode内存管理依赖JVM调优。
尽管Kotlin已成为官方首选语言,但Android SDK底层及大量现有项目仍基于java编程语言基础。掌握Java是深入Android系统级开发的必经之路。
Java ME(Micro Edition)支持低功耗设备开发;Eclipse OSGi框架用于智能网关;Java在智能家居、工业控制领域广泛应用。
Java 11起引入G1垃圾回收器默认化;Java 14新增Record类简化数据载体;Java 17优化容器内内存识别。Spring Native支持GraalVM原生镜像,启动时间从秒级降至毫秒级。
java编程语言基础数据类型分为两类:
| 类型 | 字节数 | 取值范围 | 默认值 |
|---|---|---|---|
| byte | 1 | -128 ~ 127 | 0 |
| short | 2 | -32,768 ~ 32,767 | 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 | 0 ~ 65,535 | '\u0000' |
| boolean | 1位 | true / false | false |
示例:
int age = 25; // 基本类型
String name = "Java"; // 引用类型(字符串常量)
double price = 99.99; // 自动装箱:double → Double
java编程语言基础运算符优先级(从高到低):
注意:短路求值(&&与||)可避免无效计算,提高性能。
隐藏实现细节,暴露受控接口。通过private修饰符+getter/setter实现。
public class User {
private String name; // 私有属性
private int age;
// 公共方法访问
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;
}
}
通过extends实现代码复用。Java仅支持单继承,但可通过接口实现多重继承效果。
public class Animal {
public void eat() { System.out.println("动物进食"); }
}
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗啃骨头");
}
}
同一操作作用于不同对象,产生不同执行结果。依赖方法重写与动态绑定。
Animal dog = new Dog(); // 父类引用指向子类对象
dog.eat(); // 输出"狗啃骨头",运行时决定具体方法
一个类只负责一个功能领域。违反示例:
public class OrderService {
public void createOrder() { }
public void saveToFile() { }
public void log() { }
}
应拆分为OrderService、FileWriter、Logger三个类。
对扩展开放,对修改关闭。通过接口编程实现。
public interface Payment {
void pay(double amount);
}
public class Alipay implements Payment {
public void pay(double amount) { }
}
public class WeChatPay implements Payment {
public void pay(double amount) { }
}
确保一个类只有一个实例。双重检查锁实现:
public class Singleton {
private static volatile Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
屏蔽对象创建细节,解耦客户端与具体实现。
public class PaymentFactory {
public static Payment createPayment(String type) {
switch (type) {
case "alipay": return new Alipay();
case "wechat": return new WeChatPay();
default: throw new IllegalArgumentException("未知支付方式");
}
}
}
Collection
├── List(有序可重复)
│ ├── ArrayList(数组实现,查询快)
│ ├── LinkedList(链表实现,增删快)
│ └── Vector(线程安全)
└── Set(无序不重复)
├── HashSet(哈希表)
├── LinkedHashSet(有序HashSet)
└── TreeSet(红黑树,排序)
Map(键值对)
├── HashMap(非线程安全)
├── Hashtable(线程安全)
├── LinkedHashMap(有序HashMap)
└── TreeMap(排序Map)
| 特性 | ArrayList | LinkedList |
|---|---|---|
| 底层结构 | 动态数组 | 双向链表 |
| 随机访问 | O(1) | O(n) |
| 插入/删除 | O(n) | O(1) |
| 内存占用 | 低 | 高(需存储前后指针) |
| 线程安全 | 否 | 否 |
选择建议:
java编程语言基础的HashMap在JDK 8中引入红黑树优化:
public class User {
private String id;
private String name;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return Objects.equals(id, user.id);
}
@Override
public int hashCode() {
return Objects.hash(id);
}
}
java编程语言基础线程有6种状态:
public class MyThread extends Thread {
public void run() {
System.out.println("线程执行中:" + Thread.currentThread().getName());
}
}
// 启动
new MyThread().start();
public class MyRunnable implements Runnable {
public void run() {
System.out.println("Runnable执行中");
}
}
// 启动
new Thread(new MyRunnable()).start();
public class MyCallable implements Callable {
public Integer call() {
return 123;
}
}
// 启动
FutureTask future = new FutureTask<>(new MyCallable());
new Thread(future).start();
System.out.println("结果:" + future.get());
缺点:无法中断、无法超时、公平性不可控
Lock lock = new ReentrantLock();
lock.lock();
try {
// 临界区代码
} finally {
lock.unlock(); // 必须在finally中释放
}
try (InputStream in = new FileInputStream("src.txt");
OutputStream out = new FileOutputStream("dest.txt")) {
byte[] buffer = new byte[8192];
int len;
while ((len = in.read(buffer)) != -1) {
out.write(buffer, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
}
try (BufferedReader br = new BufferedReader(
new FileReader("test.txt", StandardCharsets.UTF_8))) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
java编程语言基础 NIO 2.0引入三大核心组件:
优势:非阻塞IO、零拷贝、内存映射文件,适合高并发网络应用。
| 特性 | TCP | UDP |
|---|---|---|
| 连接 | 面向连接(三次握手) | 无连接 |
| 可靠性 | 可靠(重传机制) | 不可靠 |
| 流量控制 | 有(滑动窗口) | 无 |
| 应用场景 | HTTP/FTP/SMTP | DNS/视频直播 |
ServerSocket server = new ServerSocket(8080);
while (true) {
Socket client = server.accept();
new Thread(() -> {
try (BufferedReader in = new BufferedReader(
new InputStreamReader(client.getInputStream()));
PrintWriter out = new PrintWriter(client.getOutputStream(), true)) {
String msg = in.readLine();
out.println("Echo: " + msg);
} catch (IOException e) {
e.printStackTrace();
}
}).start();
}
try (Socket socket = new Socket("localhost", 8080);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in = new BufferedReader(
new InputStreamReader(socket.getInputStream()))) {
out.println("Hello");
System.out.println("服务器响应:" + in.readLine());
}
| 回收器 | 适用区域 | 特点 |
|---|---|---|
| Serial | 新生代 | 单线程,Client模式默认 |
| Parallel Scavenge | 新生代 | 吞吐量优先 |
| Parallel Old | 老年代 | Parallel Scavenge老年代版本 |
| CMS | 老年代 | 低停顿,并发标记清除 |
| G1 | 全堆 | 分区回收,可预测停顿(JDK 9默认) |
典型场景:通过jstack分析死锁、jmap分析内存泄漏。
String对象不可变,每次拼接生成新对象:
String s = "";
for (int i = 0; i < 10000; i++) {
s += "a"; // 每次新建StringBuilder,效率低
}
应改用StringBuilder:
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
sb.append("a");
}
String result = sb.toString();
JDK 8引入的java.time包解决旧版Date的线程安全问题:
LocalDate today = LocalDate.now(); // 2025-03-28
LocalTime now = LocalTime.now(); // 14:30:15
LocalDateTime dt = LocalDateTime.now();
// 格式化
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String text = dt.format(fmt);
// 解析
LocalDateTime parsed = LocalDateTime.parse("2025-03-28 14:30:15", fmt);
// 计算
LocalDate nextWeek = today.plusDays(7);
long days = ChronoUnit.DAYS.between(today, nextWeek);
避免NullPointerException:
// 传统写法
if (user != null) {
String name = user.getName();
if (name != null) {
System.out.println(name.toUpperCase());
}
}
// Optional写法
Optional.ofNullable(user)
.map(User::getName)
.map(String::toUpperCase)
.ifPresent(System.out::println);
变量、数据类型、运算符、流程控制、数组、方法、OOP基础
集合、异常、IO、多线程、Lambda、Stream
Spring Boot + MySQL + MyBatis/Redis
电商系统、权限管理、博客平台
==比较引用地址,equals()默认比较地址(可重写为值比较)
HashMap非线程安全;ConcurrentHashMap通过分段锁(JDK 7)或CAS+synchronized(JDK 8)保证线程安全
前者是关键字,后者是类;后者支持公平锁、可中断、超时等高级特性
选择建议:
技术趋势:两者互补性强,企业常采用“Java后端+Python工具链”混合架构。
java编程语言基础开发必备数据库技能:
现代Java工程师需掌握:
| 区别 | ClassNotFoundException | NoClassDefFoundError |
|---|---|---|
| 类型 | Exception | Error |
| 触发时机 | 运行时Class.forName()加载失败 | 编译时存在,运行时缺失 |
| 常见原因 | 类路径问题、依赖缺失 | 静态初始化失败、类依赖缺失 |
JDK 8中:
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
| 关键字 | 用途 | 示例 |
|---|---|---|
| abstract | 抽象类/方法 | abstract class Animal { ... } |
| break | 跳出循环 | break; |
| case | switch分支 | case 1: ... |
| catch | 异常捕获 | catch (Exception e) { ... } |
| class | 类定义 | class MyClass { ... } |
| const* | 未使用(保留) | - |
| continue | 跳过本次循环 | continue; |
| default | switch默认/接口默认方法 | default void method() { ... } |
| do | do-while循环 | do { ... } while(...) |
| double | 双精度浮点 | double price = 9.9; |
| else | 条件分支 | if(...) {} else {} |
| enum | 枚举类型 | enum Color { RED, GREEN } |
| extends | 继承 | class Dog extends Animal |
| final | 常量/不可继承 | final int MAX = 100; |
| finally | 异常处理 | try { ... } catch { ... } finally { ... } |
| float | 单精度浮点 | float rate = 0.05f; |
| for | 循环 | for (int i=0; i<10; i++) { ... } |
| goto* | 未使用(保留) | - |
| if | 条件判断 | if (score > 60) { ... } |
| implements | 实现接口 | class Dog implements Animal |
| import | 包导入 | import java.util.*; |
| instanceof | 类型检查 | obj instanceof String |
| int | 整型 | int age = 25; |
| interface | 接口定义 | interface Runnable { ... } |
| long | 长整型 | long id = 123456L; |
| native | 本地方法 | public native void sleep(); |
| new | 对象创建 | new ArrayList(); |
| package | 包声明 | package com.example; |
| private | 私有访问 | private String name; |
| protected | 受保护访问 | protected void method(); |
| public | 公共访问 | public class Main { ... } |
| return | 方法返回 | return result; |
| short | 短整型 | short count = 100; |
| static | 静态成员 | static int count; |
| strictfp | 严格浮点运算 | strictfp class MathUtil { ... } |
| super | 父类引用 | super.method(); |
| switch | 分支结构 | switch (day) { ... } |
| synchronized | 同步块 | synchronized(this) { ... } |
| this | 当前对象 | this.name = name; |
| throw | 抛出异常 | throw new Exception(); |
| throws | 声明异常 | void method() throws IOException |
| transient* | 序列化忽略 | transient int temp; |
| try | 异常处理 | try { ... } catch { ... } |
| void | 无返回值 | void print() { ... } |
| volatile | 可见性保证 | volatile boolean flag; |
| while | 循环 | while (condition) { ... } |
本页面内容基于Java 17 LTS版本整理,部分特性(如record、pattern matching)在低版本JDK中不可用。企业开发中请根据实际JDK版本调整语法。
本页面持续更新,最后修订时间:2025年3月28日
© 2025 java编程语言基础 | www.xservx.com