欢迎访问 java基础练习嗖嗖移动 |每日一练 · 高效提升

Java基础练习嗖嗖移动|零基础入门 · 实战进阶 · 高频考点全覆盖

系统化构建Java编程能力体系,从变量类型到多线程并发,从集合框架到异常处理,配套真实代码案例与解题思路,助你高效掌握Java核心语法与编程思维,为进阶开发打下坚实根基。

一、新手入门:从零搭建Java学习路径

⑴ 学习前必知:Java语言定位与发展现状

Java是一门面向对象、跨平台、强类型的通用编程语言,由Sun Microsystems于1995年发布,现为Oracle旗下核心技术。其核心特性包括:

  • ● Write Once, Run Anywhere:通过JVM实现字节码跨平台运行
  • ● 自动垃圾回收(GC):减轻开发者内存管理负担
  • ● 丰富标准库:涵盖IO、网络、并发、安全、XML等模块
  • ● 生态成熟稳定:支撑企业级应用(如电商、银行、政务系统)

据TIOBE 2025年3月统计,Java仍稳居全球前三编程语言,尤其在后端开发、Android原生开发、大数据框架(Hadoop/Spark)中占据绝对主导地位。

⑵ 环境搭建三步走:JDK、IDE、HelloWorld

初学者常卡在环境配置环节。正确流程如下:

  1. 安装JDK:推荐JDK 17 LTS(长期支持版),下载地址:https://www.oracle.com/java/technologies/downloads/#jdk17-windows
  2. 配置环境变量:
    • WIN:系统变量→新建JAVA_HOME→值为JDK安装路径(如C:\Program Files\Java\jdk-17)
    • PATH中追加:%JAVA_HOME%\bin
    • 验证:终端输入 java -version 与 javac -version 应显示一致版本号
  3. 选择IDE:推荐IntelliJ IDEA Community(免费)或Eclipse

经典首例代码:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("欢迎来到java基础练习嗖嗖移动!");
    }
}

关键点解析:

  • ● public:访问修饰符,表示公开可见
  • ● class:类声明,文件名必须与类名完全一致(区分大小写)
  • ● main方法:JVM入口点,签名固定为 public static void main(String[] args)
  • ● System.out.println():标准输出方法,ln表示换行

常见错误排查:

  • ● 编译报错“找不到符号”:检查类名、文件名是否大小写一致
  • ● 运行报错“找不到或无法加载主类”:确认classpath设置正确,或在源码目录执行 java -cp . HelloWorld
  • ● 中文乱码:IDE中设置文件编码为UTF-8(非ANSI)

⑶ 开发习惯养成:代码规范与调试技巧

优秀Java代码应遵循《阿里巴巴Java开发手册》核心原则:

  • ● 命名规范:类名大驼峰(UserService),方法/变量小驼峰(getUserName),常量全大写加下划线(MAX_SIZE)
  • ● 注释原则:关键逻辑写注释,避免“注释即代码”式重复
  • ● 异常处理:禁止空catch,应记录日志或抛出明确异常
  • ● 资源管理:IO流、数据库连接等必须使用try-with-resources

调试技巧:

  • ● 设置断点:在关键逻辑行点击行号左侧添加红色断点
  • ● 单步执行:F7进入方法,F8跳过,F9运行至下一断点
  • ● 变量监视:右键变量→Watch,实时观察值变化
  • ● 日志输出:用System.out.println()临时调试后务必移除,改用log.info()

二、语法核心:面向对象与基础语法精讲

面向对象编程(OOP)核心思想

OOP通过封装、继承、多态三大特性,实现高内聚低耦合的软件设计:

  • ● 封装:隐藏实现细节,暴露必要接口(如手机APP仅暴露操作按钮,不暴露内部电路)
  • ● 继承:子类复用父类属性/方法,实现代码复用(如Student继承Person)
  • ● 多态:同一操作作用于不同对象,产生不同效果(如“叫声”在猫是“喵”,狗是“汪”)

示例:定义Person类并创建对象

class Person {
    private String name; // 封装:私有属性
    private int age;
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 公开方法(get/set)
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    // 行为方法
    public void introduce() {
        System.out.println("我是" + name + ",今年" + age + "岁");
    }
}
public class Main {
    public static void main(String[] args) {
        Person p = new Person("张三", 20);
        p.introduce(); // 输出:我是张三,今年20岁
    }
}

OOP三大特性深度解析

⑴ 封装(Encapsulation)

通过private修饰符隐藏内部状态,强制通过public方法访问:

  • ● 防止外部非法修改(如年龄设为负数)
  • ● 可添加校验逻辑(如年龄必须在0~150之间)
  • ● 提升代码可维护性(修改内部实现不影响调用方)

⑵ 继承(Inheritance)

使用extends实现类间关系:

class Student extends Person {
    private String school;
    public Student(String name, int age, String school) {
        super(name, age); // 调用父类构造器
        this.school = school;
    }
    @Override
    public void introduce() { // 方法重写
        super.introduce();
        System.out.println("就读于" + school);
    }
}

⚠️注意:Java只支持单继承,避免“菱形继承”问题

⑶ 多态(Polymorphism)

父类引用指向子类对象:

Person p = new Student("李四", 18, "清华");
p.introduce(); // 输出:我是李四...就读于清华

运行时动态绑定,实现“一个接口,多种实现”

类与对象详解

类是对象的模板,对象是类的实例。关键点:

  • ● 构造方法:
    • 无参构造:必须显式声明(否则默认提供),否则子类无法调用
    • 有参构造:支持灵活初始化
    • 构造器重载:多个构造方法参数列表不同
  • ● static关键字:
    • 修饰属性:类级别共享(如计数器static int count)
    • 修饰方法:无需创建对象即可调用(如Math.max())
    • 静态代码块:类加载时执行一次(初始化静态资源)
  • ● final关键字:
    • 修饰类:不可被继承(如String)
    • 修饰方法:不可被重写
    • 修饰变量:常量(必须显式初始化)

示例:单例模式(饿汉式)

class Singleton {
    private static final Singleton INSTANCE = new Singleton();
    private Singleton() {} // 私有构造器
    public static Singleton getInstance() {
        return INSTANCE;
    }
}
异常处理机制(try-catch-finally)

Java异常体系分三大类:

  • ● Error:JVM严重错误(如栈溢出),无法处理
  • ● Exception:可处理异常,分运行时异常(RuntimeException)与编译时异常
  • ● RuntimeException:如空指针NullPointerException、数组越界ArrayIndexOutOfBoundsException

标准处理结构:

try {
    // 可能抛出异常的代码
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("除零错误:" + e.getMessage());
} finally {
    System.out.println("资源清理操作");
}

最佳实践:

  • ● 精确捕获:避免catch (Exception e)泛泛捕获
  • ● finally必执行:关闭资源(流、连接等)
  • ● 自定义异常:业务场景需继承Exception或RuntimeException
常用API:String、包装类、日期处理

⑴ String字符串

不可变类(final),常用方法:

方法说明示例
equals()内容比较"abc".equals("abc") → true
substring()截取子串"hello".substring(1,3) → "el"
split()按分隔符拆分"a,b".split(",") → ["a","b"]
replace()替换字符/字符串"abc".replace('b','x') → "axc"

注意:==比较引用地址,equals()比较内容!

⑵ 包装类

基本类型对应包装类(int→Integer),支持自动装箱/拆箱:

Integer a = 100; // 装箱
int b = a;         // 拆箱

缓存机制:-128 ≤ n ≤ 127时使用缓存对象,避免重复创建

⑶ 日期处理(Java 8+)

推荐使用java.time包:

LocalDate today = LocalDate.now();
LocalDateTime now = LocalDateTime.now();
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String str = now.format(fmt); // "2025-03-15 14:30:00"
集合框架:List/Map/Set核心用法

⑴ List(有序可重复)

  • ArrayList:基于动态数组,查询快(O(1)),增删慢(O(n))
  • LinkedList:基于双向链表,增删快(O(1)),查询慢(O(n))
  • Vector:线程安全(已过时,改用Collections.synchronizedList)

⑵ Set(无序不重复)

  • HashSet:基于HashMap实现,元素必须重写hashCode()和equals()
  • TreeSet:排序Set,元素需实现Comparable或传入Comparator

⑶ Map(键值对)

实现类特点适用场景
HashMap线程不安全,允许null键值单线程高频读写
HashTable线程安全,不允许null旧系统兼容
ConcurrentHashMap分段锁,高性能并发多线程环境
TreeMap红黑树,按键排序需排序的键值对

遍历方式:

Map map = new HashMap<>();
map.put("Java", 100);
for (Map.Entry entry : map.entrySet()) {
    System.out.println(entry.getKey() + " → " + entry.getValue());
}

三、数据处理:IO流、正则表达式与泛型

⑴ IO流体系详解

Java IO分四大流基类:

  • InputStream / OutputStream:字节流(处理二进制数据)
  • Reader / Writer:字符流(处理文本数据,自动处理编码)

常用场景示例:

// 读取文本文件(Java 7+)
try (BufferedReader br = new BufferedReader(
        new FileReader("data.txt", StandardCharsets.UTF_8))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

关键点:

  • ● 使用try-with-resources自动关闭资源
  • ● 文本文件必须指定编码(避免乱码)
  • ● 大文件处理用Buffered包装提升性能

⑵ 正则表达式实战

Java正则通过java.util.regex.Pattern和Matcher实现:

// 验证手机号(11位,1开头)
String regex = "^1[3-9]\\d{9}$";
boolean valid = Pattern.matches(regex, "13812345678");
// 分组提取
String text = "姓名:张三,年龄:25";
Pattern p = Pattern.compile("姓名:(.+?),年龄:(\\d+)");
Matcher m = p.matcher(text);
if (m.find()) {
    String name = m.group(1); // "张三"
    int age = Integer.parseInt(m.group(2)); // 25
}

常用元字符:

  • .:任意字符(需转义\.匹配点)
  • \d:数字(等价[0-9])
  • \w:单词字符(字母/数字/下划线)
  • +:1次或多次
  • *:0次或多次
  • ?:0次或1次

⑶ 泛型(Generic):类型安全的容器

避免运行时ClassCastException,提升代码复用性:

// 自定义泛型类
class Box {
    private T content;
    public void set(T content) { this.content = content; }
    public T get() { return content; }
}
Box stringBox = new Box<>();
stringBox.set("Hello");
String s = stringBox.get(); // 无需强转

通配符使用:

  • ?:未知类型(如List list)
  • ?:上限(只读,如List)
  • ?:下限(只写,如Consumer)

四、并发编程:多线程基础与线程安全

创建线程的三种方式

① 继承Thread

class MyThread extends Thread {
    public void run() {
        System.out.println("线程执行中...");
    }
}
new MyThread().start();

② 实现Runnable

class MyTask implements Runnable {
    public void run() {
        System.out.println("任务执行中...");
    }
}
new Thread(new MyTask()).start();

③ Lambda表达式

new Thread(() -> {
    System.out.println("Lambda线程");
}).start();

推荐使用Runnable或Lambda,避免单继承局限

线程同步与锁机制

共享资源竞争导致数据不一致,需同步控制:

⑴ synchronized关键字

// 同步代码块
synchronized (lockObj) {
    // 临界区代码
}
// 同步方法
public synchronized void deposit(int amount) {
    balance += amount;
}

⑵ Lock接口

Lock lock = new ReentrantLock();
lock.lock();
try {
    // 临界区
} finally {
    lock.unlock(); // 必须在finally释放
}

对比:

  • synchronized:JVM层面实现,自动释放锁,但功能较弱
  • Lock:API层面实现,支持尝试获取锁、可中断锁、公平锁

线程池管理

避免频繁创建销毁线程,使用ExecutorService:

ExecutorService pool = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
    pool.execute(() -> {
        System.out.println(Thread.currentThread().getName() + "执行任务");
    });
}
pool.shutdown(); // 关闭线程池

线程池类型:

方法特点适用场景
newFixedThreadPool固定大小线程池负载较重的服务器
newCachedThreadPool可缓存线程池大量短期异步任务
newSingleThreadExecutor单线程池需保证顺序执行
newScheduledThreadPool定时任务线程池周期性任务

⑴ 线程生命周期

新线程→就绪(start())→运行(CPU调度)→阻塞(wait/sleep)→死亡(run结束)

⑵ 线程通信

wait() / notify()必须在同步块中调用,用于线程间协作

⑶ volatile关键字

保证可见性(内存立即刷新),但不保证原子性(需配合CAS)

五、JVM基础:内存模型与调优入门

JVM运行时数据区

Java程序运行时内存划分为:

① 程序计数器

线程私有,记录当前执行字节码指令地址

② 虚拟机栈

线程私有,存储栈帧(局部变量表/操作数栈等)

③ 本地方法栈

为Native方法服务

④ 堆

线程共享,存储对象实例(GC主要区域)

⑤ 方法区

存储类信息/常量/静态变量(JDK8后为元空间)

垃圾回收机制(GC)

常用GC算法:

  • ● 标记-清除:标记存活对象,清除未标记区域(产生碎片)
  • ● 复制:将内存分为两块,存活对象复制到另一块(高效但浪费空间)
  • ● 标记-整理:标记后将存活对象向一端移动(避免碎片)

分代收集理论:

  • 新生代:Eden + 2个Survivor区, Minor GC频繁
  • 老年代:长期存活对象, Major GC(Full GC)较少

常用JVM参数:

参数说明
-Xms512m初始堆大小
-Xmx1024m最大堆大小
-XX:+UseG1GC使用G1垃圾回收器
-XX:MaxMetaspaceSize=256m限制元空间大小

六、高频面试题:Java基础核心考点

⑴ String、StringBuffer与StringBuilder区别

String

  • ● 不可变字符序列
  • ● 线程安全(但效率低)
  • ● 适合少量字符串操作

StringBuffer

  • ● 可变字符序列
  • ● 线程安全(方法加synchronized)
  • ● 多线程环境适用

StringBuilder

  • ● 可变字符序列
  • ● 线程不安全(效率高)
  • ● 单线程环境首选

⑵ ArrayList与LinkedList区别

特性ArrayListLinkedList
底层结构动态数组双向链表
随机访问快(O(1))慢(O(n))
插入/删除慢(需移动元素)快(仅修改指针)
内存占用小(仅存储元素)大(存储前后指针)
适用场景频繁查询频繁增删

⑶ HashMap工作原理

核心机制:

  • ● 存储结构:数组+链表/红黑树(JDK8+)
  • ● 哈希计算:key.hashCode() → 扰动函数 → 索引计算
  • ● 冲突解决:链地址法(同一桶位用链表/树存储)
  • ● 扩容机制:负载因子0.75,达到阈值时2倍扩容

JDK8优化:

  • ● 链表长度≥8且数组长度≥64时转为红黑树
  • ● 链表长度≤6时退化为链表

⑷ ==与equals区别

String s1 = new String("hello");
String s2 = new String("hello");
String s3 = s1.intern();
System.out.println(s1 == s2);     // false(不同对象)
System.out.println(s1.equals(s2)); // true(内容相同)
System.out.println(s1 == s3);     // true(s3指向常量池)

equals默认行为(Object类):

public boolean equals(Object obj) {
    return (this == obj);
}

重写规则:

  1. 自反性:x.equals(x)返回true
  2. 对称性:x.equals(y)与y.equals(x)一致
  3. 传递性:x.equals(y)且y.equals(z)→x.equals(z)
  4. 一致性:多次调用结果不变
  5. 非空性:x.equals(null)返回false

七、开发工具:IDEA/Eclipse与调试技巧

⑴ IntelliJ IDEA快捷键

快捷键功能
Ctrl + Shift + N快速打开文件
Ctrl + Shift + A查找所有操作
Alt + Insert生成代码(构造器/getter/setter)
Ctrl + D复制当前行
Ctrl + Y删除当前行
Shift + F6重命名
Ctrl + Alt + L格式化代码

⑵ 调试技巧实战

高效调试四步法:

  1. 定位问题:通过异常堆栈确定错误位置
  2. 设置断点:在关键逻辑行添加断点(点击行号左侧)
  3. 单步执行:
    • F7:进入方法
    • F8:跳过方法
    • F9:运行至下一断点
  4. 观察变量:
    • 右键变量→Add to Watches
    • 使用Evaluate Expression(Alt+F8)执行表达式

示例:调试集合遍历错误

for (String s : list) {
    if (s.equals("stop")) {
        break; // 断点设在此处,检查list内容
    }
}

八、学习资源:推荐书籍与在线平台

⑴ 必读经典书籍

《Java编程思想》

全面讲解OOP思想,适合初学者建立正确编程思维

《Effective Java》

Joshua Bloch著,2.5k+条最佳实践,进阶必读

《Java核心技术 卷I》

Cay Horstmann著,知识点系统全面

⑵ 实战学习平台

平台特点适合人群
LeetCode算法题库,支持Java解题准备面试
牛客网企业真题+在线编程国内求职者
慕课网视频课程,实战项目初学者
极客时间深度专栏,架构师视角进阶开发者

⑶ 每日练习建议

「java基础练习嗖嗖移动」推荐三步学习法:

  1. 10分钟理论:每日学习1个知识点(如集合框架)
  2. 20分钟编码:在IDE中实现该知识点示例
  3. 10分钟复盘:总结易错点,整理到个人笔记

示例任务:

  • Day1:实现String反转(3种方法)
  • Day2:模拟HashMapput/get过程
  • Day3:多线程卖票系统(线程安全版)

九、常见问题:新手高频疑问解答

Q:Java是值传递还是引用传递?

A:Java只有值传递!但对象引用的值是地址值,因此修改对象内容会影响原对象。

void swap(Point p1, Point p2) {
    Point temp = p1;
    p1 = p2;
    p2 = temp; // 仅交换形参,实参不变
}
Point a = new Point(1,2);
Point b = new Point(3,4);
swap(a, b);
// a和b的引用未变,但若在swap中修改p1.x=100,则a.x会变
Q:final修饰的集合可修改内容吗?

A:可以!final只保证引用不变,不保证对象内容不变。

final List list = new ArrayList<>();
list.add("Java"); // 合法
list = new ArrayList<>(); // 编译错误!
Q:为什么重写equals要重写hashCode?

A:保证哈希表(如HashMap)正确性!若两个对象equals()为true,则hashCode()必须相同。

违反后果:

Map map = new HashMap<>();
Person p1 = new Person("张三");
Person p2 = new Person("张三");
map.put(p1, "北京");
System.out.println(map.get(p2)); // 可能返回null(hashCode不同)