Java 零基础入门教程 — 企业级开发首选语言

编程教程 管理员 2026年06月23日 203 次阅读 2909 字 约 10 分钟
适用人群：零基础、后端开发者、Android开发者、大厂求职者
学习时长：约5-7天（每天4小时）
Java版本：17+（LTS长期支持版）
适用场景：企业级应用、Android开发、大数据、微服务

一、Java 是什么？

Java 是全球使用最广泛的企业级编程语言，以"一次编写，到处运行"著称，是大厂后端开发的首选。

特点说明
上手难度★★★☆☆（语法严格，需要理解面向对象）
核心优势跨平台、生态完善、性能优秀、类型安全
主要用途企业级应用、Android、大数据(Hadoop)、微服务
薪资水平初级12-20K，中级20-35K，高级35K+
代表项目Spring、Hadoop、Elasticsearch、Minecraft

二、环境搭建

# 安装JDK 17（推荐用SDKMAN）
# macOS / Linux
curl -s "https://get.sdkman.io" | bash
sdk install java 17.0.10-tem

# 或用Homebrew (macOS)
brew install openjdk@17

# Windows
# 下载：https://adoptium.net/

# 验证安装
java -version
javac -version

# 安装Maven（构建工具）
brew install maven  # macOS
# 或下载：https://maven.apache.org/download.cgi

# 验证
mvn -version

三、Hello World

// HelloWorld.java
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

# 编译
javac HelloWorld.java

# 运行
java HelloWorld

四、Java 基础语法

4.1 变量与类型

public class Variables {
    public static void main(String[] args) {
        // ====================
        // 基本数据类型
        // ====================
        
        // 整数
        byte b = 127;           // 8位，-128 ~ 127
        short s = 32767;        // 16位
        int num = 2147483647;   // 32位（最常用）
        long big = 9999999999L; // 64位
        
        // 浮点数
        float f = 3.14f;        // 32位
        double d = 3.14159;     // 64位（最常用）
        
        // 布尔
        boolean isTrue = true;
        
        // 字符
        char c = 'A';
        
        // ====================
        // 引用数据类型
        // ====================
        String name = "张三";    // 字符串
        int[] arr = {1, 2, 3};  // 数组
        
        // ====================
        // 变量命名规范
        // ====================
        // 驼峰命名：userName, orderList
        // 常量全大写：MAX_SIZE, DEFAULT_VALUE
        // 类名首字母大写：UserService, OrderController
        
        System.out.println(name);
    }
}

4.2 字符串操作

public class StringDemo {
    public static void main(String[] args) {
        String name = "张三";
        
        // 字符串拼接
        String greeting = "你好，" + name + "！";
        String greeting2 = String.format("你好，%s！今年%d岁", name, 25);
        
        // 常用方法
        name.length();              // 长度
        name.charAt(0);            // 获取字符
        name.indexOf("三");         // 查找位置
        name.substring(0, 1);      // 截取
        name.contains("张");        // 是否包含
        name.startsWith("张");      // 是否以...开头
        name.equals("张三");        // 内容比较（推荐）
        name.equalsIgnoreCase("张三"); // 忽略大小写比较
        name.toUpperCase();        // 转大写
        name.toLowerCase();        // 转小写
        name.trim();               // 去除空格
        name.replace("张", "李");   // 替换
        name.split("");            // 分割
        name.isEmpty();            // 是否为空
        name.isBlank();            // 是否为空白
        
        // StringBuilder（高效拼接）
        StringBuilder sb = new StringBuilder();
        sb.append("Hello");
        sb.append(" ");
        sb.append("World");
        String result = sb.toString();  // "Hello World"
    }
}

4.3 数组

public class ArrayDemo {
    public static void main(String[] args) {
        // 声明数组
        int[] nums = {1, 2, 3, 4, 5};
        String[] names = new String[5];
        
        // 访问和修改
        nums[0] = 10;
        System.out.println(nums.length);  // 5
        
        // 遍历
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
        
        // 增强for循环
        for (int num : nums) {
            System.out.println(num);
        }
        
        // 二维数组
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        // 数组工具类
        java.util.Arrays.sort(nums);       // 排序
        String arrStr = java.util.Arrays.toString(nums);  // 转字符串
        int[] copied = java.util.Arrays.copyOf(nums, 10); // 复制
    }
}

4.4 条件与循环

public class ControlFlow {
    public static void main(String[] args) {
        // ====================
        // 条件判断
        // ====================
        int age = 25;
        
        if (age >= 18) {
            System.out.println("成年人");
        } else if (age >= 12) {
            System.out.println("青少年");
        } else {
            System.out.println("儿童");
        }
        
        // 三元运算符
        String status = age >= 18 ? "成年" : "未成年";
        
        // switch（Java 14+ 新语法）
        String day = "MONDAY";
        String type = switch (day) {
            case "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY" -> "工作日";
            case "SATURDAY", "SUNDAY" -> "周末";
            default -> "未知";
        };
        
        // ====================
        // 循环
        // ====================
        
        // for循环
        for (int i = 0; i < 5; i++) {
            System.out.println(i);
        }
        
        // while循环
        int count = 0;
        while (count < 5) {
            System.out.println(count);
            count++;
        }
        
        // do-while循环
        do {
            System.out.println("至少执行一次");
        } while (false);
        
        // break 和 continue
        for (int i = 0; i < 10; i++) {
            if (i == 3) continue;  // 跳过3
            if (i == 7) break;     // 到7停止
            System.out.println(i);
        }
    }
}

五、面向对象编程

5.1 类与对象

// User.java
public class User {
    // 属性（字段）
    private int id;
    private String name;
    private String email;
    private int age;
    
    // 构造方法
    public User() {}
    
    public User(String name, String email, int age) {
        this.name = name;
        this.email = email;
        this.age = age;
    }
    
    // Getter和Setter
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    
    public int getAge() { return age; }
    public void setAge(int age) {
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("年龄无效");
        }
        this.age = age;
    }
    
    // 方法
    public String greet() {
        return String.format("我是%s，今年%d岁", name, age);
    }
    
    // toString方法
    @Override
    public String toString() {
        return String.format("User{id=%d, name='%s', email='%s', age=%d}", 
                           id, name, email, age);
    }
}

// Main.java
public class Main {
    public static void main(String[] args) {
        User user = new User("张三", "zhangsan@example.com", 25);
        System.out.println(user.greet());
        System.out.println(user);
    }
}

5.2 继承与多态

// 父类
public class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void speak() {
        System.out.println(name + "发出声音");
    }
}

// 子类
public class Dog extends Animal {
    public Dog(String name) {
        super(name);  // 调用父类构造方法
    }
    
    @Override
    public void speak() {
        System.out.println(name + "汪汪叫");
    }
    
    public void fetch() {
        System.out.println(name + "去捡球");
    }
}

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
    
    @Override
    public void speak() {
        System.out.println(name + "喵喵叫");
    }
}

// 多态
public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog("旺财");
        Animal cat = new Cat("咪咪");
        
        dog.speak();  // 旺财汪汪叫
        cat.speak();  // 咪咪喵喵叫
        
        // 类型检查
        if (dog instanceof Dog) {
            ((Dog) dog).fetch();  // 向下转型
        }
    }
}

5.3 接口

// 接口定义
public interface Logger {
    void log(String message);           // 抽象方法
    default void logError(String msg) { // 默认方法
        log("[ERROR] " + msg);
    }
}

public interface Serializable {
    String toJson();
}

// 实现接口
public class UserLogger implements Logger, Serializable {
    @Override
    public void log(String message) {
        System.out.println("[UserLogger] " + message);
    }
    
    @Override
    public String toJson() {
        return "{\"type\": \"UserLogger\"}";
    }
}

// 接口作为参数
public class App {
    public static void process(Logger logger) {
        logger.log("处理中...");
        logger.logError("发生错误");
    }
    
    public static void main(String[] args) {
        process(new UserLogger());
    }
}

六、集合框架

import java.util.*;

public class CollectionDemo {
    public static void main(String[] args) {
        // ====================
        // List（有序，可重复）
        // ====================
        List<String> names = new ArrayList<>();
        names.add("张三");
        names.add("李四");
        names.add("王五");
        names.add(1, "赵六");  // 指定位置插入
        
        names.get(0);           // 获取元素
        names.set(0, "张三三");  // 修改元素
        names.remove(0);        // 删除元素
        names.size();           // 大小
        names.contains("李四");  // 是否包含
        names.indexOf("李四");   // 查找位置
        names.isEmpty();        // 是否为空
        
        // 遍历
        for (String name : names) {
            System.out.println(name);
        }
        
        // Lambda遍历（Java 8+）
        names.forEach(name -> System.out.println(name));
        
        // ====================
        // Map（键值对）
        // ====================
        Map<String, Object> user = new HashMap<>();
        user.put("name", "张三");
        user.put("age", 25);
        user.put("city", "北京");
        
        user.get("name");                  // 获取值
        user.getOrDefault("email", "无");  // 获取值或默认值
        user.containsKey("name");          // 是否包含键
        user.remove("city");               // 删除
        user.size();                       // 大小
        
        // 遍历
        for (Map.Entry<String, Object> entry : user.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
        
        // Lambda遍历
        user.forEach((key, value) -> System.out.println(key + ": " + value));
        
        // ====================
        // Set（无序，不重复）
        // ====================
        Set<String> skills = new HashSet<>();
        skills.add("Java");
        skills.add("Python");
        skills.add("Go");
        skills.add("Java");  // 重复，不会添加
        
        System.out.println(skills.size());  // 3
        
        // ====================
        // 常用操作
        // ====================
        // 排序
        List<Integer> numbers = Arrays.asList(5, 3, 1, 4, 2);
        Collections.sort(numbers);  // [1, 2, 3, 4, 5]
        
        // 不可变集合
        List<String> immutable = List.of("a", "b", "c");
        Map<String, Integer> immutableMap = Map.of("a", 1, "b", 2);
    }
}

七、Lambda 与 Stream API

import java.util.*;
import java.util.stream.*;

public class StreamDemo {
    public static void main(String[] args) {
        List<User> users = List.of(
            new User("张三", "zhangsan@example.com", 25),
            new User("李四", "lisi@example.com", 30),
            new User("王五", "wangwu@example.com", 22),
            new User("赵六", "zhaoliu@example.com", 28)
        );
        
        // ====================
        // Stream 操作
        // ====================
        
        // filter - 过滤
        List<User> adults = users.stream()
            .filter(u -> u.getAge() >= 25)
            .collect(Collectors.toList());
        
        // map - 转换
        List<String> names = users.stream()
            .map(User::getName)
            .collect(Collectors.toList());
        
        // sorted - 排序
        List<User> sorted = users.stream()
            .sorted(Comparator.comparing(User::getAge))
            .collect(Collectors.toList());
        
        // 聚合操作
        int totalAge = users.stream()
            .mapToInt(User::getAge)
            .sum();
        
        double avgAge = users.stream()
            .mapToInt(User::getAge)
            .average()
            .orElse(0);
        
        Optional<User> oldest = users.stream()
            .max(Comparator.comparing(User::getAge));
        
        // 分组
        Map<String, List<User>> grouped = users.stream()
            .collect(Collectors.groupingBy(u -> u.getAge() >= 25 ? "成年" : "未成年"));
        
        // 统计
        IntSummaryStatistics stats = users.stream()
            .mapToInt(User::getAge)
            .summaryStatistics();
        System.out.println("最大: " + stats.getMax());
        System.out.println("最小: " + stats.getMin());
        System.out.println("平均: " + stats.getAverage());
        System.out.println("总和: " + stats.getSum());
        System.out.println("数量: " + stats.getCount());
        
        // 链式操作
        String result = users.stream()
            .filter(u -> u.getAge() > 25)
            .map(User::getName)
            .collect(Collectors.joining("、"));
        System.out.println(result);  // 李四、赵六
    }
}

八、异常处理

public class ExceptionDemo {
    
    // 自定义异常
    public static class NotFoundException extends Exception {
        public NotFoundException(String message) {
            super(message);
        }
    }
    
    // 抛出异常
    public static User findUser(int id) throws NotFoundException {
        if (id <= 0) {
            throw new NotFoundException("用户不存在: " + id);
        }
        return new User("张三", "test@example.com", 25);
    }
    
    // 异常处理
    public static void main(String[] args) {
        try {
            User user = findUser(0);
        } catch (NotFoundException e) {
            System.out.println("捕获异常: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("其他异常: " + e.getMessage());
        } finally {
            System.out.println("无论如何执行");
        }
        
        // try-with-resources（自动关闭资源）
        try (var scanner = new java.util.Scanner(System.in)) {
            // 使用scanner
        }
    }
}

九、Spring Boot 入门

9.1 创建项目

# 使用Spring Initializr创建项目
# https://start.spring.io/
# 选择：Java 17, Maven, Spring Web, Spring Data JPA, MySQL Driver

# 或用命令行
curl https://start.spring.io/starter.zip \
  -d type=maven-project \
  -d language=java \
  -d bootVersion=3.2.0 \
  -d dependencies=web,jpa,mysql \
  -o myproject.zip

unzip myproject.zip
cd myproject
mvn spring-boot:run

9.2 项目结构

src/main/java/com/example/demo/
├── DemoApplication.java     # 启动类
├── controller/              # 控制器
│   └── UserController.java
├── service/                 # 业务逻辑
│   └── UserService.java
├── repository/              # 数据访问
│   └── UserRepository.java
├── model/                   # 实体类
│   └── User.java
└── dto/                     # 数据传输对象
    └── UserDTO.java

src/main/resources/
├── application.yml          # 配置文件
└── static/                  # 静态资源

9.3 核心代码

// application.yml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: your_password
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

// User.java - 实体类
package com.example.demo.model;

import jakarta.persistence.*;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, unique = true, length = 50)
    private String username;
    
    @Column(nullable = false)
    private String email;
    
    @Column(nullable = false)
    private Integer age;
    
    // Getter和Setter省略（或用Lombok @Data）
}

// UserRepository.java - 数据访问
package com.example.demo.repository;

import com.example.demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;

public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByUsernameContaining(String keyword);
    List<User> findByAgeGreaterThan(Integer age);
}

// UserService.java - 业务逻辑
package com.example.demo.service;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public List<User> findAll() {
        return userRepository.findAll();
    }
    
    public Optional<User> findById(Long id) {
        return userRepository.findById(id);
    }
    
    public User save(User user) {
        return userRepository.save(user);
    }
    
    public void delete(Long id) {
        userRepository.deleteById(id);
    }
    
    public List<User> search(String keyword) {
        return userRepository.findByUsernameContaining(keyword);
    }
}

// UserController.java - 控制器
package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
@RequestMapping("/api/users")
@CrossOrigin
public class UserController {
    @Autowired
    private UserService userService;
    
    @GetMapping
    public List<User> getAll() {
        return userService.findAll();
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<User> getById(@PathVariable Long id) {
        return userService.findById(id)
            .map(ResponseEntity::ok)
            .orElse(ResponseEntity.notFound().build());
    }
    
    @PostMapping
    public ResponseEntity<User> create(@RequestBody User user) {
        User saved = userService.save(user);
        return ResponseEntity.status(HttpStatus.CREATED).body(saved);
    }
    
    @PutMapping("/{id}")
    public ResponseEntity<User> update(@PathVariable Long id, @RequestBody User user) {
        if (!userService.findById(id).isPresent()) {
            return ResponseEntity.notFound().build();
        }
        user.setId(id);
        return ResponseEntity.ok(userService.save(user));
    }
    
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> delete(@PathVariable Long id) {
        if (!userService.findById(id).isPresent()) {
            return ResponseEntity.notFound().build();
        }
        userService.delete(id);
        return ResponseEntity.noContent().build();
    }
    
    @GetMapping("/search")
    public List<User> search(@RequestParam String keyword) {
        return userService.search(keyword);
    }
}

十、Lombok（简化代码）

// 添加依赖后，用注解替代getter/setter等样板代码
import lombok.*;

@Data               // 生成getter/setter/toString/equals/hashCode
@AllArgsConstructor // 全参构造方法
@NoArgsConstructor  // 无参构造方法
@Builder            // 建造者模式
public class User {
    private Long id;
    private String username;
    private String email;
    private Integer age;
}

// 使用Builder
User user = User.builder()
    .username("张三")
    .email("zhangsan@example.com")
    .age(25)
    .build();

学习建议

  1. 先理解面向对象编程，这是Java的核心思想
  2. 重点掌握集合框架，List/Map/Set是日常开发的基础
  3. 学习Lambda和Stream，现代Java的必备技能
  4. 尽早学Spring Boot，企业开发几乎都用它
  5. 理解Maven/Gradle，学会依赖管理和项目构建

下一步学习

返回首页