基础语法
面向对象
集合体系
IO与NIO
并发编程
Java基础语法体系全景
Java语言语法严谨、生态完善,是构建企业级应用的首选语言之一。掌握其核心语法是进入java编程平台技术体系的第一步。
数据类型与变量声明需注意:基本类型(如int、double)与包装类型(Integer、Double)的自动装箱/拆箱机制虽简化代码,但可能导致性能损耗与空指针风险。例如:
Integer a = 127;
Integer b = 127;
System.out.println(a == b); // true(缓存池机制)
Integer c = 128;
Integer d = 128;
System.out.println(c == d); // false(超出缓存范围)
循环结构中,for-each循环(增强for)适用于遍历集合与数组,但无法获取索引;传统for循环则更适合需要精确控制迭代过程的场景。异常处理方面,try-with-resources(JDK 7+)自动关闭资源,避免手动close()导致的资源泄露:
try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
return br.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
面向对象编程核心原则
面向对象编程(OOP)是Java的基石,其三大特性——封装、继承、多态,结合设计模式,构成高质量代码的保障体系。
封装通过private字段与public getter/setter实现,隐藏内部实现细节。但过度封装(如无意义的getter/setter)会增加代码冗余,应结合业务语义优化。例如:
public class User {
private String name;
private int age;
public User(String name, int age) {
if (name == null || name.trim().isEmpty()) {
throw new IllegalArgumentException("姓名不能为空");
}
if (age < 0 || age > 150) {
throw new IllegalArgumentException("年龄不合法");
}
this.name = name;
this.age = age;
}
}
继承应遵循“is-a”关系,避免滥用(如仅为复用代码而继承)。推荐优先使用组合(has-a)而非继承。例如:
// 推荐:组合
public class Car {
private Engine engine;
public Car() {
this.engine = new Engine();
}
}
// 不推荐:仅为复用而继承
class Engine {
public void start() { }
}
class Car extends Engine {} // 违反LSP原则
多态依赖于接口与继承,是框架扩展性的核心。Spring的依赖注入(DI)即基于多态实现,例如:
public interface PaymentService {
void pay(double amount);
}
public class WechatPayment implements PaymentService { }
public class AlipayPayment implements PaymentService { }
// Spring自动注入具体实现
@Service
public class OrderService {
@Autowired
private PaymentService paymentService; // 运行时决定具体类型
}
Java集合体系深度解析
Java集合框架(JCF)是开发中高频使用的工具库,掌握其底层原理与适用场景至关重要。
List实现类对比:
- ArrayList:基于动态数组,随机访问快(O(1)),插入/删除慢(O(n)),线程不安全。适合读多写少场景。
- LinkedList:基于双向链表,插入/删除快(O(1)),随机访问慢(O(n)),内存开销大。适合频繁增删的场景。
- Vector:线程安全的ArrayList,性能较差,已基本被Collections.synchronizedList替代。
Map实现类对比:
- HashMap:JDK 8后采用数组+链表+红黑树结构,链表长度≥8且数组长度≥64时转为红黑树,提升查询效率。非线程安全。
- ConcurrentHashMap:JDK 8采用CAS+synchronized分段锁,避免HashMap的线程不安全问题,性能优于HashTable。
- LinkedHashMap:维护插入/访问顺序,支持LRU缓存淘汰策略(通过accessOrder参数控制)。
Set实现类:HashSet底层为HashMap的key,TreeSet基于红黑树实现有序集合,LinkedHashSet维护插入顺序。
IO与NIO体系实战对比
Java IO模型经历了同步阻塞(BIO)、同步非阻塞(NIO)、异步非阻塞(AIO)的演进,直接影响高并发系统性能。
BIO(Blocking IO):每个连接需独立线程处理,线程资源消耗大。适用于连接数少、IO操作频繁的场景:
ServerSocket server = new ServerSocket(8080);
while (true) {
Socket socket = server.accept(); // 阻塞等待连接
new Thread(() -> handle(socket)).start();
}
NIO(Non-blocking IO):基于Channel、Buffer、Selector实现,单线程可管理多连接。核心是Selector轮询注册的Channel事件:
Selector selector = Selector.open();
ServerSocketChannel server = ServerSocketChannel.open();
server.configureBlocking(false);
server.register(selector, SelectionKey.OP_ACCEPT);
while (selector.select() > 0) {
Iterator it = selector.selectedKeys().iterator();
while (it.hasNext()) {
SelectionKey key = it.next();
it.remove();
if (key.isAcceptable()) { }
if (key.isReadable()) { }
}
}
AIO(Asynchronous IO):JDK 7引入,基于事件驱动,无需轮询。适用于高并发、长连接场景(如IM系统)。
并发编程核心机制
Java并发编程是java编程平台的重点内容,涉及线程模型、同步工具、线程池及无锁编程。
线程状态转换:NEW→RUNNABLE→BLOCKED/WAITING/TIMED_WAITING→TERMINATED。常见死锁场景包括:资源竞争+循环等待。
synchronized原理:对象头中的Mark Word存储锁标志位,偏向锁→轻量级锁→重量级锁升级机制。适用于细粒度同步。
显式锁(ReentrantLock):支持公平锁、可中断锁、条件变量(Condition)。示例:
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
lock.lock();
try {
while (!conditionReady) {
condition.await(); // 释放锁并等待
}
// 执行业务逻辑
condition.signal(); // 唤醒等待线程
} finally {
lock.unlock();
}
线程池(ExecutorService):推荐使用ThreadPoolExecutor手动配置,避免Executors的隐式限制。例如:
ExecutorService pool = new ThreadPoolExecutor(
10, 20, 60L, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(1000),
new ThreadFactoryBuilder().setNameFormat("biz-pool-%d").build(),
new ThreadPoolExecutor.CallerRunsPolicy()
);
原子类(AtomicXXX):基于CAS(Compare-And-Swap)实现,无锁高并发。适用于计数器、状态标记等场景。