编程入门|Java入门教学|www.xservx.com

编程入门:Java入门教学|零基础掌握

从变量声明到Spring Boot开发,本教学系统讲解Java语言核心语法、面向对象思想、集合框架、异常处理、I/O流、多线程编程、JDBC数据库连接及Web开发基础,结合真实代码示例与学习路径规划,助你高效入门程序员职业道路。

开始学习

为什么选择Java?

Java语言的市场地位与学习价值分析

Java语言的三大核心优势

Java作为全球最流行的编程语言之一,长期稳居TIOBE指数前列,其“一次编译,到处运行”的跨平台特性源于Java虚拟机(JVM)的抽象层设计。对于新手而言,Java入门教学不仅教会语法,更培养严谨的工程思维与模块化开发习惯。

  • 企业级应用开发首选:银行、电信、电商等大型系统广泛采用Java技术栈,如Spring、Dubbo、RocketMQ等开源生态成熟稳定。
  • 语法规范性强:强制面向对象设计、自动垃圾回收(GC)机制大幅降低内存管理门槛,适合编程初学者建立正确抽象思维。
  • 学习资源丰富:官方API文档详尽、社区活跃、教学体系完善,国内高校计算机专业普遍以Java作为第一门编程语言。

Java语言的发展历程

Java由Sun Microsystems于1995年正式发布,最初定位为嵌入式设备语言,后因互联网兴起转向Web开发。2006年Sun开源JDK,2009年Oracle收购Sun后持续推动语言演进。截至2024年,Java SE 21已支持虚拟线程(Virtual Threads)、结构化并发(Structured Concurrency)等现代特性。

从Java 8引入Lambda表达式与Stream API,到Java 14的switch表达式与记录类(Record),再到Java 17的密封类(Sealed Classes)与模式匹配增强,Java持续融合函数式编程与现代语言特性,在保持向后兼容的同时提升开发效率。

据Stack Overflow 2023年开发者调查,Java在“最常用编程语言”中排名第4(占比21.2%),在“希望继续使用”榜单中排名第3(71.5%),印证其在企业级开发中的长期生命力。

Java技术栈全景图

层级 技术代表 用途说明
基础语法 变量、数据类型、运算符 构建程序逻辑的原子单元
面向对象 类、继承、多态、接口 模拟现实世界的建模能力
集合框架 ArrayList、HashMap、TreeSet 高效组织与操作数据集合
异常处理 try-catch-finally、自定义异常 保障程序健壮性与可恢复性
输入输出 FileInputStream、BufferedReader 实现文件与网络数据交互
多线程 Thread、Runnable、ExecutorService 提升程序并发性能的关键技术
数据库连接 JDBC、MyBatis、Spring Data JPA 操作关系型数据库的标准接口
Web开发 Servlet、JSP、Spring MVC 构建动态网站与RESTful服务

掌握上述模块后,可进一步学习微服务架构(Spring Cloud)、分布式中间件(Kafka、ZooKeeper)、容器化部署(Docker、Kubernetes)等进阶内容,形成完整技术能力闭环。

开发环境搭建

从零配置Java开发所需工具链

必备工具清单

  • JDK(Java Development Kit):包含编译器(javac)、解释器(java)及核心类库,推荐使用LTS版本(如JDK 8/11/17/21)。
  • IDE(集成开发环境):推荐IntelliJ IDEA(社区版免费,Ultimate版功能完整)或Eclipse(开源免费)。
  • 构建工具:Maven或Gradle,用于项目依赖管理与自动化构建。
  • 版本控制:Git,配合GitHub/Gitee实现代码托管与协作开发。

JDK安装步骤(以Windows为例)

  1. 访问Oracle官网或OpenJDK镜像站点(如Adoptium、Azul)下载JDK安装包。
  2. 运行安装程序,选择安装路径(建议避免含空格或中文的目录)。
  3. 配置系统环境变量:
    JAVA_HOME = C:\Program Files\Java\jdk-17
    PATH += %JAVA_HOME%\bin
  4. 验证安装:打开命令提示符,执行 java -version 与 javac -version,确认输出版本号一致。

IntelliJ IDEA快速配置

  • 新建项目:File → New → Project → Java,选择JDK路径。
  • 启用Maven支持:在项目根目录创建 pom.xml,添加依赖如 <artifactId>spring-boot-starter-web</artifactId>。
  • 设置代码风格:File → Settings → Editor → Code Style → Java,导入Google Style或自定义规则。
  • 安装插件:Lombok(简化getter/setter)、MyBatisX(SQL映射)、Alibaba Java Coding Guidelines(规范检查)。

Java核心语法

变量、数据类型与基础控制结构详解

数据类型分类

类型 字节数 默认值 示例
byte 1 0 byte b = 10;
short 2 0 short s = 100;
int 4 0 int age = 25;
long 8 0L long distance = 123456789L;
float 4 0.0f float price = 9.9f;
double 8 0.0d double pi = 3.1415926;
char 2 '\u0000' char grade = 'A';
boolean 1位 false boolean isVip = true;
String 对象 null String name = "Java";

注意:基本类型(如int)与包装类型(如Integer)在自动装箱/拆箱时存在性能差异,高并发场景需谨慎使用。

控制结构示例

if-else用于条件判断,支持嵌套与多分支:

int score = 85;
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

从Java 14起,switch支持表达式形式:

int day = 3;
String dayName = switch (day) {
    case 1 -> "Monday";
    case 2 -> "Tuesday";
    case 3 -> "Wednesday";
    default -> "Unknown";
};

switch语句支持int、char、String及枚举类型,注意避免fall-through(需显式break):

String fruit = "apple";
switch (fruit) {
    case "apple":
        System.out.println("苹果");
        break;
    case "banana":
        System.out.println("香蕉");
        break;
    default:
        System.out.println("未知水果");
}

for循环适用于已知次数的遍历:

for (int i = 1; i <= 5; i++) {
    System.out.println("第" + i + "次循环");
}

while循环适用于未知次数的循环:

int count = 0;
while (count < 3) {
    System.out.println("尝试第" + (++count) + "次");
}

增强for循环(for-each)简化集合遍历:

String[] names = {"张三", "李四", "王五"};
for (String name : names) {
    System.out.println(name);
}

方法定义与重载

方法是完成特定功能的代码块,定义格式为:修饰符 返回类型 方法名(参数列表) { ... }

public static int add(int a, int b) {
    return a + b;
}

方法重载要求方法名相同、参数列表不同(个数、类型或顺序),与返回类型无关:

public static int add(int a, int b) { ... }
public static double add(double a, double b) { ... }
public static int add(int a, int b, int c) { ... }

重载机制提升了API的灵活性,如System.out.println()支持多种参数类型。

面向对象编程

封装、继承、多态的核心思想与实践

三大特性详解

封装将数据(属性)与操作(方法)绑定为类,并隐藏内部实现细节,通过访问修饰符控制可见性:

public class Person {
    private String name; // 私有属性
    private int age;
    public String getName() { // 公有方法访问
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

封装优势:增强数据安全性、提高模块独立性、便于维护与扩展。

继承实现代码复用,子类继承父类的非私有成员,使用extends关键字:

public class Student extends Person {
    private String studentId;
    public void study() {
        System.out.println(name + "正在学习");
    }
}

Java仅支持单继承,但可通过接口实现多实现(implements)。

多态指同一操作作用于不同对象时可产生不同效果,需满足:继承关系、方法重写、父类引用指向子类对象。

public class Animal {
    public void makeSound() {
        System.out.println("动物叫声");
    }
}
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪");
    }
}
// 多态调用
Animal animal = new Dog();
animal.makeSound(); // 输出:汪汪

多态是实现“开闭原则”(对扩展开放,对修改关闭)的关键机制。

抽象类与接口对比

对比项 抽象类 接口
关键字 abstract class interface
构造方法 可以有 不能有
成员变量 可有各种类型 默认public static final
方法实现 可有抽象与具体方法 Java 8前仅抽象;之后支持default/static
继承限制 单继承 多实现
使用场景 模板方法设计模式 行为规范定义

示例:定义Runnable接口实现线程任务:

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

常用设计模式示例

单例模式确保一个类仅有一个实例,提供全局访问点:

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

饿汉式实现线程安全,适用于实例创建开销小的场景。

工厂模式将对象创建与使用分离,降低耦合度:

public interface Fruit {
    void eat();
}
public class Apple implements Fruit {
    public void eat() { System.out.println("吃苹果"); }
}
public class Banana implements Fruit {
    public void eat() { System.out.println("吃香蕉"); }
}
public class FruitFactory {
    public static Fruit getFruit(String type) {
        if ("apple".equals(type)) return new Apple();
        if ("banana".equals(type)) return new Banana();
        return null;
    }
}

客户端仅需调用FruitFactory.getFruit("apple"),无需关心具体实现类。

集合框架

List、Set、Map体系结构与使用场景

集合体系概览

顶层接口 常用实现类 特性 适用场景
Collection ArrayList, LinkedList, HashSet 单列集合 存储单一对象序列
Map HashMap, TreeMap, LinkedHashMap 键值对映射 通过键快速查找值
List ArrayList(数组), LinkedList(链表) 有序可重复 频繁随机访问用ArrayList;频繁插入删除用LinkedList
Set HashSet(哈希), TreeSet(红黑树) 无序不可重复 去重操作;TreeSet支持排序

List接口典型用法

ArrayList底层为动态数组,查询快(O(1))、增删慢(O(n)):

List names = new ArrayList<>();
names.add("张三");
names.add("李四");
System.out.println(names.get(0)); // 输出:张三
names.remove(1); // 删除李四

初始容量为10,扩容为1.5倍;线程不安全,高并发需用Collections.synchronizedList()或CopyOnWriteArrayList。

LinkedList底层为双向链表,增删快(O(1))、查询慢(O(n)):

List queue = new LinkedList<>();
queue.addFirst("任务1");
queue.addLast("任务2");
System.out.println(queue.removeFirst()); // 输出:任务1

可作为栈(push/pop)、队列(offer/poll)使用,适合频繁插入删除的场景。

Map接口典型用法

HashMap基于哈希表,键值对无序,允许null键(仅一个)与null值:

Map scores = new HashMap<>();
scores.put("语文", 95);
scores.put("数学", 92);
System.out.println(scores.get("语文")); // 输出:95

默认负载因子0.75,容量为2的幂;Java 8后链表长度≥8且容量≥64时转为红黑树。

TreeMap基于红黑树,键有序(自然排序或自定义比较器):

Map map = new TreeMap<>();
map.put("banana", "香蕉");
map.put("apple", "苹果");
for (String key : map.keySet()) {
    System.out.println(key + " → " + map.get(key));
}
// 输出顺序:apple → 苹果, banana → 香蕉

适用于需要排序遍历的场景,如字典、排行榜。

LinkedHashMap在HashMap基础上维护插入顺序或访问顺序:

Map cache = new LinkedHashMap<>(16, 0.75f, true) {
    protected boolean removeEldestEntry(Map.Entry eldest) {
        return size() > 3; // LRU缓存:仅保留最近3项
    }
};

常用于实现LRU缓存,通过构造参数控制顺序模式。

集合遍历与Stream API

传统遍历方式:

List list = Arrays.asList("A", "B", "C");
for (String s : list) {
    System.out.println(s);
}

Java 8引入Stream API实现函数式操作:

List filtered = list.stream()
    .filter(s -> s.startsWith("A"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());

支持并行流(.parallelStream())提升大数据集处理效率,但需注意线程安全问题。

异常处理机制

try-catch-finally与自定义异常设计

异常体系结构

层级 说明 示例
Throwable 所有异常的父类
├─ Error JVM内部错误(不可处理) StackOverflowError, OutOfMemoryError
└─ Exception 程序可处理异常
  ├─ RuntimeException 运行时异常(非受检) NullPointerException, IllegalArgumentException
  └─ 其他Exception 受检异常(编译器强制处理) IOException, SQLException

try-catch-finally执行逻辑

public static int divide(int a, int b) {
    try {
        return a / b; // 可能抛出ArithmeticException
    } catch (ArithmeticException e) {
        System.out.println("除数为0");
        return 0;
    } finally {
        System.out.println("finally块总是执行");
    }
}
System.out.println(divide(10, 0));
// 输出:
// 除数为0
// finally块总是执行
// 0

注意:finally中若含return语句会覆盖try/catch的返回值,应避免此类写法。

自定义异常示例

public class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}
public class PersonValidator {
    public static void validateAge(int age) throws InvalidAgeException {
        if (age < 0 || age > 150) {
            throw new InvalidAgeException("年龄无效:" + age);
        }
    }
}

使用场景:业务规则校验、数据校验等需明确错误类型的场景。

异常处理最佳实践

  • 避免空catch块:至少记录日志(如logger.error("错误", e))。
  • 优先使用具体异常类型:避免笼统捕获Exception。
  • 合理使用finally释放资源(或采用try-with-resources):
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    String line = br.readLine();
} catch (IOException e) {
    e.printStackTrace();
} // 自动关闭资源

try-with-resources要求资源实现AutoCloseable接口,Java 7+支持。

输入输出流

字节流、字符流与NIO文件操作

流分类体系

分类维度 类型 代表类
方向 输入流 InputStream, Reader
  输出流 OutputStream, Writer
处理单元 字节流 FileInputStream, BufferedOutputStream
  字符流 FileReader, BufferedWriter

字节流处理二进制数据(如图片、视频),字符流处理文本数据(自动处理编码转换)。

文件读写示例

try (FileInputStream fis = new FileInputStream("input.bin");
     FileOutputStream fos = new FileOutputStream("output.bin")) {
    byte[] buffer = new byte[1024];
    int len;
    while ((len = fis.read(buffer)) != -1) {
        fos.write(buffer, 0, len);
    }
} catch (IOException e) {
    e.printStackTrace();
}
try (BufferedReader br = new BufferedReader(new FileReader("input.txt"));
     BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        bw.write(line);
        bw.newLine();
    }
} catch (IOException e) {
    e.printStackTrace();
}

注意:字符流需指定编码(如new InputStreamReader(fis, StandardCharsets.UTF_8))避免中文乱码。

NIO.2文件操作(Java 7+)

Path source = Paths.get("input.txt");
Path target = Paths.get("output.txt");
// 复制文件
Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
// 读取全部文本
List lines = Files.readAllLines(source, StandardCharsets.UTF_8);
// 写入文本
Files.write(target, "Hello Java NIO".getBytes(StandardCharsets.UTF_8));

NIO.2提供更简洁的API,支持异步文件通道(AsynchronousFileChannel)。

对象序列化

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    // 构造器、getter/setter省略
}
// 序列化
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser"))) {
    oos.writeObject(new User("张三", 25));
}
// 反序列化
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"))) {
    User user = (User) ois.readObject();
    System.out.println(user.getName()); // 输出:张三
}

注意:静态字段不参与序列化;transient修饰的字段跳过序列化。

多线程编程

线程创建、同步机制与并发工具类

线程创建方式

public class MyThread extends Thread {
    public void run() {
        System.out.println("线程执行中:" + Thread.currentThread().getName());
    }
}
// 启动线程
new MyThread().start();

缺点:单继承限制;无法返回结果。

public class MyTask implements Runnable {
    public void run() {
        System.out.println("任务执行:" + Thread.currentThread().getName());
    }
}
// 启动线程
new Thread(new MyTask()).start();

推荐方式:避免单继承限制,支持多线程共享资源。

public class MyCallable implements Callable {
    public String call() throws Exception {
        return "任务完成";
    }
}
// 启动线程
FutureTask future = new FutureTask<>(new MyCallable());
new Thread(future).start();
System.out.println(future.get()); // 阻塞等待结果

支持返回值与异常抛出,配合Future使用。

线程同步机制

public class Counter {
    private int count = 0;
    public synchronized void increment() { // 同步方法
        count++;
    }
    public void safeIncrement() {
        synchronized (this) { // 同步代码块
            count++;
        }
    }
}

隐式锁:自动获取与释放;适用于简单同步场景。

public class Counter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock(); // 必须在finally中释放
        }
    }
}

显式锁:支持公平锁、可中断锁、超时锁;性能更优但需手动管理。

并发工具类(java.util.concurrent)

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

线程池避免频繁创建销毁线程开销,推荐使用ThreadPoolExecutor自定义参数。

public class AtomicCounter {
    private final AtomicInteger count = new AtomicInteger(0);
    public void increment() {
        count.incrementAndGet(); // 原子操作
    }
    public int getCount() {
        return count.get();
    }
}

基于CAS(Compare-And-Swap)实现,无锁竞争,适用于高并发计数场景。

线程间通信

public class ProducerConsumer {
    private final Queue queue = new LinkedList<>();
    private final Object lock = new Object();
    public void produce() throws InterruptedException {
        synchronized (lock) {
            while (queue.size() == 10) { // 队列满时等待
                lock.wait();
            }
            queue.offer(1);
            lock.notifyAll(); // 通知消费者
        }
    }
    public void consume() throws InterruptedException {
        synchronized (lock) {
            while (queue.isEmpty()) { // 队列空时等待
                lock.wait();
            }
            queue.poll();
            lock.notifyAll(); // 通知生产者
        }
    }
}

注意:wait/notify必须在同步块中调用;推荐使用BlockingQueue简化生产者-消费者模式。

数据库连接技术

JDBC核心API与连接池配置

JDBC操作五步法

  1. 加载驱动:Class.forName("com.mysql.cj.jdbc.Driver");
  2. 获取连接:Connection conn = DriverManager.getConnection(url, user, pwd);
  3. 创建语句:PreparedStatement pstmt = conn.prepareStatement(sql);
  4. 执行查询:ResultSet rs = pstmt.executeQuery();
  5. 处理结果:while (rs.next()) { ... }

完整示例代码

public class JdbcDemo {
    private static final String URL = "jdbc:mysql://localhost:3306/test";
    private static final String USER = "root";
    private static final String PASSWORD = "123456";
    public static void main(String[] args) {
        String sql = "SELECT * FROM users WHERE age > ?";
        try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);
             PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setInt(1, 18);
            try (ResultSet rs = pstmt.executeQuery()) {
                while (rs.next()) {
                    System.out.println(rs.getInt("id") + " " + rs.getString("name"));
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

使用try-with-resources自动关闭资源;PreparedStatement防止SQL注入。

数据库连接池配置

// Maven依赖
<dependency>
    <groupId>com.mchange</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.5.5</version>
</dependency>
// 配置示例
ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setJdbcUrl("jdbc:mysql://localhost:3306/test");
ds.setUser("root");
ds.setPassword("123456");
ds.setMinPoolSize(5);
ds.setMaxPoolSize(20);
// Maven依赖
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.21</version>
</dependency>
// 配置示例
DruidDataSource ds = new DruidDataSource();
ds.setUrl("jdbc:mysql://localhost:3306/test");
ds.setUsername("root");
ds.setPassword("123456");
ds.setInitialSize(5);
ds.setMaxActive(20);
ds.setMinIdle(5);

Druid提供监控页面(/druid),支持SQL防火墙、慢SQL统计等企业级功能。

Web开发基础

Servlet、JSP与MVC模式实践

Servlet核心概念

  • 生命周期:init() → service() → destroy(),单例多线程。
  • 请求处理:doGet()处理GET请求,doPost()处理POST请求。
  • 作用域对象:request(请求范围)、session(会话范围)、application(应用范围)。

Servlet示例代码

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        resp.setContentType("text/html;charset=UTF-8");
        PrintWriter out = resp.getWriter();
        out.println("

Hello Java Web!

"); } }

web.xml配置:<servlet> <servlet-name>hello</servlet-name> <servlet-class>HelloServlet</servlet-class> </servlet>

JSP内置对象

对象名 类型 作用域
request HttpServletRequest request
response HttpServletResponse page
session HttpSession session
application ServletContext application
out JspWriter page

JSP中可直接使用:<%= request.getParameter("name") %>

MVC模式实现

Model:数据与业务逻辑,如User实体类、UserService业务类。

View:展示层,JSP页面负责渲染HTML,使用JSTL/EL表达式显示数据。

Controller:请求分发,如UserServlet处理用户相关请求:

public class UserServlet extends HttpServlet {
    private UserService userService = new UserService();
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        String action = req.getParameter("action");
        if ("list".equals(action)) {
            List users = userService.getAllUsers();
            req.setAttribute("users", users);
            req.getRequestDispatcher("/WEB-INF/userList.jsp").forward(req, resp);
        }
    }
}

系统化学习路径

从零基础到企业级开发的进阶路线图

第1阶段:Java基础语法(1-2个月)

掌握变量、数据类型、控制结构、数组、方法、面向对象基础、常用API(String、Math、Date)。

配套练习:控制台版学生管理系统、简易计算器。

第2阶段:核心进阶(1-2个月)

深入集合框架、异常处理、I/O流、多线程、泛型、反射、注解。

配套练习:文件加密工具、多线程下载器、注解模拟Spring IOC。

第3阶段:数据库与Web(2-3个月)

学习JDBC、MySQL、JSP/Servlet、HTML/CSS/JavaScript基础。

配套练习:图书管理系统(JDBC版)、简易论坛(Servlet版)。

第4阶段:框架与工程化(3-4个月)

掌握Spring Core/AOP/Transaction、MyBatis、Spring MVC、Maven、Git。

配套练习:基于MVC模式的电商后台系统。

第5阶段:微服务与分布式(持续学习)

学习Spring Boot、Spring Cloud、Redis、RabbitMQ、Docker、K8s。

配套练习:基于Spring Boot的RESTful API服务。

高频问题解答

新手最常问的10个问题

Q1:Java和JavaScript有什么关系?

A:两者无实质关系!Java是静态强类型语言,由Sun Microsystems开发;JavaScript是动态弱类型脚本语言,由Netscape开发。名称相似是因1995年JavaScript发布时借用了Java的热度,但两者语法、用途、运行环境均不同。

Q2:Windows和Mac/Linux开发环境有差异吗?

A:核心语法完全一致,差异仅在于路径分隔符(Windows用\,Unix用/)、环境变量配置。建议使用跨平台IDE(如IntelliJ IDEA),避免环境问题。

Q3:需要先学C语言再学Java吗?

A:非必需!Java设计初衷就是降低编程门槛,无需前置C语言基础。但C语言有助于理解内存与指针概念,对深入理解Java的底层机制有帮助。

Q4:如何解决“编译通过但运行报错”?

A:检查以下三点:

  1. 类名与文件名是否一致(大小写敏感);
  2. 包声明(package)与目录结构是否匹配;
  3. main方法签名是否正确:public static void main(String[] args)。

Q5:IDEA中如何快速生成getter/setter?

A:在类中按Alt+Insert(Windows/Linux)或Cmd+N(Mac),选择“Getter and Setter”即可自动生成。推荐安装Lombok插件,用注解省略样板代码。

Q6:什么是JVM、JRE、JDK?

A:JVM(Java Virtual Machine)是Java程序运行的虚拟机;JRE(Java Runtime Environment)包含JVM和核心类库,用于运行Java程序;JDK(Java Development Kit)包含JRE及编译器、调试器等开发工具。

Q7:如何理解“面向对象”与“面向过程”?

A:面向过程关注执行步骤(如:1.买菜 2.洗菜 3.炒菜);面向对象关注对象与行为(如:厨师对象有“炒菜”方法)。面向对象更易维护、复用,适合大型项目。

Q8:ArrayList和LinkedList怎么选?

A:ArrayList:随机访问快(O(1)),适合查询频繁的场景;LinkedList:插入删除快(O(1)),适合频繁修改的场景。默认优先选ArrayList。

Q9:什么是单例模式?有哪些实现方式?

A:单例模式确保一个类仅有一个实例。常见实现:

  • 饿汉式(线程安全,但可能浪费内存);
  • 懒汉式(延迟加载,需加synchronized);
  • 静态内部类(推荐,兼顾性能与安全);
  • 枚举(最简洁,防反射攻击)。

Q10:如何高效学习Java?

A:三遍学习法:

  1. 第一遍:快速通读,建立知识框架;
  2. 第二遍:精读+敲代码,理解每个细节;
  3. 第三遍:项目实战,整合知识点解决实际问题。

坚持“学-练-复盘”循环,加入技术社区(如CSDN、GitHub)参与开源项目。