Java 基础入门

Java 是一种广泛使用的编程语言，它具有跨平台、面向对象、安全性高等特点。本文将介绍 Java 的核心概念和基本语法。

1. 基本概念

什么是 Java

Java 是一种面向对象的编程语言，由 Sun Microsystems 于 1995 年推出。它的设计目标是"一次编写，到处运行"（Write Once, Run Anywhere），这意味着 Java 程序可以在任何支持 Java 虚拟机 (JVM) 的平台上运行，而不需要重新编译。

Java 的特点

• 跨平台：Java 程序可以在任何支持 JVM 的平台上运行
• 面向对象：Java 是一种纯面向对象的编程语言
• 安全性：Java 具有内置的安全机制，如沙箱模型
• 健壮性：Java 具有强类型检查、自动内存管理等特性
• 多线程：Java 内置支持多线程编程
• 分布式：Java 支持网络编程，便于开发分布式应用

2. 环境搭建

安装 JDK

JDK (Java Development Kit) 是 Java 开发工具包，它包含了编译 Java 程序所需的工具和 JVM。

1. 访问 Oracle JDK 下载页面 或 OpenJDK 下载页面
2. 下载适合您操作系统的 JDK 版本
3. 安装 JDK 并设置环境变量

验证安装

打开命令提示符或终端，输入以下命令验证 JDK 是否安装成功：

java -version

如果显示 Java 版本信息，则说明安装成功。

IDE 选择

推荐使用以下 IDE 进行 Java 开发：

• IntelliJ IDEA：功能强大的 Java IDE
• Eclipse：开源的 Java IDE
• NetBeans：另一个开源的 Java IDE

3. 基本语法

第一个 Java 程序

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

编译和运行

1. 保存文件为 HelloWorld.java
2. 编译程序：javac HelloWorld.java
3. 运行程序：java HelloWorld

注释

// 单行注释

/*
 * 多行注释
 */

/**
 * 文档注释
 */

数据类型

基本数据类型

类型	大小	范围
byte	1 字节	-128 到 127
short	2 字节	-32768 到 32767
int	4 字节	-2^31 到 2^31-1
long	8 字节	-2^63 到 2^63-1
float	4 字节	约 ±3.40282347E+38F
double	8 字节	约 ±1.79769313486231570E+308
char	2 字节	0 到 65535
boolean	1 位	true 或 false

引用数据类型

• 类：如 String、Integer 等
• 接口：如 List、Map 等
• 数组：如 int[]、String[] 等

变量

// 声明变量
int age;
String name;

// 初始化变量
age = 25;
name = "John";

// 声明并初始化变量
int score = 95;
String city = "New York";

运算符

算术运算符

• +：加法
• -：减法
• *：乘法
• /：除法
• %：取模
• ++：自增
• --：自减

关系运算符

• ==：等于
• !=：不等于
• >：大于
• <：小于
• >=：大于等于
• <=：小于等于

逻辑运算符

• &&：逻辑与
• ||：逻辑或
• !：逻辑非

赋值运算符

• =：赋值
• +=：加等于
• -=：减等于
• *=：乘等于
• /=：除等于
• %=：取模等于

控制流

if-else

if (condition) {
    // 条件为真时执行
} else if (anotherCondition) {
    // 另一个条件为真时执行
} else {
    // 所有条件都为假时执行
}

switch

switch (value) {
    case 1:
        // 处理值为 1 的情况
        break;
    case 2:
        // 处理值为 2 的情况
        break;
    default:
        // 处理其他情况
        break;
}

for 循环

for (int i = 0; i < 10; i++) {
    // 循环体
}

// 增强 for 循环
for (String item : array) {
    // 循环体
}

while 循环

while (condition) {
    // 循环体
}

do-while 循环

do {
    // 循环体
} while (condition);

4. 面向对象编程

类和对象

定义类

public class Person {
    // 成员变量
    private String name;
    private int age;
    
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 成员方法
    public void sayHello() {
        System.out.println("Hello, my name is " + name);
    }
    
    // getter 和 setter 方法
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
}

创建对象

// 创建对象
Person person = new Person("John", 25);

// 调用方法
person.sayHello();

// 访问属性（通过 getter 和 setter）
System.out.println(person.getName());
person.setAge(26);

继承

// 父类
public class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + " is eating");
    }
}

// 子类
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    @Override
    public void eat() {
        System.out.println(name + " is eating bones");
    }
    
    public void bark() {
        System.out.println(name + " is barking");
    }
}

多态

Animal animal = new Dog("Buddy");
animal.eat(); // 调用 Dog 类的 eat 方法

封装

封装是指将类的成员变量私有化，通过公共的 getter 和 setter 方法来访问和修改。

抽象

// 抽象类
public abstract class Shape {
    public abstract double calculateArea();
}

// 具体类
public class Circle extends Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

接口

// 接口
public interface Drawable {
    void draw();
}

// 实现接口
public class Rectangle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

5. 异常处理

异常类型

• 检查型异常：编译时必须处理的异常，如 IOException
• 非检查型异常：运行时异常，如 NullPointerException、ArithmeticException

try-catch-finally

try {
    // 可能抛出异常的代码
} catch (Exception e) {
    // 处理异常
    e.printStackTrace();
} finally {
    // 无论是否发生异常都会执行的代码
}

throws 和 throw

// throws 声明方法可能抛出的异常
public void readFile() throws IOException {
    // 代码
}

// throw 手动抛出异常
if (age < 0) {
    throw new IllegalArgumentException("Age cannot be negative");
}

6. 集合框架

集合类型

• List：有序集合，允许重复元素
  • ArrayList：基于数组实现，随机访问效率高
  • LinkedList：基于链表实现，插入和删除效率高
• Set：无序集合，不允许重复元素
  • HashSet：基于哈希表实现
  • TreeSet：基于红黑树实现，有序
• Map：键值对集合
  • HashMap：基于哈希表实现
  • TreeMap：基于红黑树实现，键有序

集合操作

// List 操作
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");
System.out.println(list.get(0)); // 输出 Java

// Set 操作
Set<String> set = new HashSet<>();
set.add("Java");
set.add("Python");
set.add("Java"); // 重复元素不会被添加
System.out.println(set.size()); // 输出 2

// Map 操作
Map<String, Integer> map = new HashMap<>();
map.put("Java", 1);
map.put("Python", 2);
map.put("C++", 3);
System.out.println(map.get("Java")); // 输出 1

7. 输入输出

控制台输入

Scanner scanner = new Scanner(System.in);
System.out.print("Enter your name: ");
String name = scanner.nextLine();
System.out.println("Hello, " + name);
scanner.close();

文件操作

// 写入文件
try (FileWriter writer = new FileWriter("file.txt")) {
    writer.write("Hello, World!");
} catch (IOException e) {
    e.printStackTrace();
}

// 读取文件
try (FileReader reader = new FileReader("file.txt")) {
    int character;
    while ((character = reader.read()) != -1) {
        System.out.print((char) character);
    }
} catch (IOException e) {
    e.printStackTrace();
}

8. 多线程

创建线程

继承 Thread 类

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }
}

// 使用
MyThread thread = new MyThread();
thread.start();

实现 Runnable 接口

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }
}

// 使用
Thread thread = new Thread(new MyRunnable());
thread.start();

使用 Lambda 表达式

Thread thread = new Thread(() -> {
    System.out.println("Thread is running");
});
thread.start();

线程同步

class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public int getCount() {
        return count;
    }
}

9. 泛型

泛型类

public class Box<T> {
    private T value;
    
    public void setValue(T value) {
        this.value = value;
    }
    
    public T getValue() {
        return value;
    }
}

// 使用
Box<String> stringBox = new Box<>();
stringBox.setValue("Hello");
String value = stringBox.getValue();

泛型方法

public <T> void printArray(T[] array) {
    for (T item : array) {
        System.out.println(item);
    }
}

// 使用
Integer[] intArray = {1, 2, 3};
printArray(intArray);

String[] stringArray = {"Java", "Python", "C++"};
printArray(stringArray);

10. 反射

反射是指在运行时动态获取类的信息并操作类的方法和属性。

// 获取类的 Class 对象
Class<?> clazz = Class.forName("com.example.Person");

// 创建对象
Object obj = clazz.newInstance();

// 获取方法
Method method = clazz.getMethod("sayHello");

// 调用方法
method.invoke(obj);

// 获取字段
Field field = clazz.getDeclaredField("name");
field.setAccessible(true);

// 设置字段值
field.set(obj, "John");

11. 注解

注解是一种标记，可以添加到类、方法、字段等元素上，用于提供元数据。

内置注解

• @Override：标记方法重写
• @Deprecated：标记已过时的元素
• @SuppressWarnings：抑制编译器警告

自定义注解

// 定义注解
@interface MyAnnotation {
    String value();
    int number() default 1;
}

// 使用注解
@MyAnnotation(value = "Hello", number = 2)
public class MyClass {
    // 代码
}

12. 模块系统

Java 9 引入了模块系统，它允许将代码组织成模块，提高代码的可维护性和安全性。

模块定义

在 module-info.java 文件中定义模块：

module com.example.app {
    requires java.base;
    requires java.sql;
    exports com.example.app.model;
    exports com.example.app.service;
}

13. 实践示例

学生管理系统

public class Student {
    private String id;
    private String name;
    private int age;
    private double score;
    
    public Student(String id, String name, int age, double score) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.score = score;
    }
    
    // getter 和 setter 方法
    // ...
    
    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}

public class StudentManager {
    private List<Student> students;
    
    public StudentManager() {
        students = new ArrayList<>();
    }
    
    public void addStudent(Student student) {
        students.add(student);
    }
    
    public void removeStudent(String id) {
        students.removeIf(student -> student.getId().equals(id));
    }
    
    public Student findStudent(String id) {
        return students.stream()
                .filter(student -> student.getId().equals(id))
                .findFirst()
                .orElse(null);
    }
    
    public List<Student> getAllStudents() {
        return students;
    }
    
    public List<Student> getStudentsByScore(double minScore) {
        return students.stream()
                .filter(student -> student.getScore() >= minScore)
                .collect(Collectors.toList());
    }
}

public class Main {
    public static void main(String[] args) {
        StudentManager manager = new StudentManager();
        
        // 添加学生
        manager.addStudent(new Student("1001", "John", 18, 95.5));
        manager.addStudent(new Student("1002", "Jane", 17, 92.0));
        manager.addStudent(new Student("1003", "Bob", 19, 88.5));
        
        // 查找学生
        Student student = manager.findStudent("1001");
        System.out.println("Found student: " + student);
        
        // 获取所有学生
        System.out.println("All students:");
        for (Student s : manager.getAllStudents()) {
            System.out.println(s);
        }
        
        // 获取分数大于 90 的学生
        System.out.println("Students with score >= 90:");
        for (Student s : manager.getStudentsByScore(90)) {
            System.out.println(s);
        }
        
        // 删除学生
        manager.removeStudent("1003");
        System.out.println("After removing student 1003:");
        for (Student s : manager.getAllStudents()) {
            System.out.println(s);
        }
    }
}

14. 常见问题与解决方案

编译错误

问题：javac: command not found解决方案：检查 JDK 是否安装成功，环境变量是否正确设置。

运行时错误

问题：Exception in thread "main" java.lang.NullPointerException解决方案：检查是否有未初始化的变量或对象。

内存泄漏

问题：程序运行一段时间后内存使用过高 解决方案：确保所有资源都被正确释放，如关闭文件流、数据库连接等。

性能问题

问题：程序运行速度慢 解决方案：

• 优化算法
• 使用合适的数据结构
• 避免频繁的对象创建
• 考虑使用缓存

15. 总结

Java 是一种功能强大、跨平台的编程语言，它具有面向对象、安全性高、健壮性好等特点。通过学习 Java 的基本概念和语法，我们可以开始编写 Java 程序。

Java 的核心概念包括：

• 数据类型和变量
• 控制流
• 面向对象编程
• 异常处理
• 集合框架
• 输入输出
• 多线程
• 泛型
• 反射
• 注解
• 模块系统

通过不断学习和实践，我们可以掌握 Java 的技能，并将其应用到实际的开发中。