JavaSE（入门）

Java SE 学习资料：从入门到精通

Java 是一种广泛使用的编程语言，具有简洁、面向对象、跨平台等特点。本文将详细介绍 Java SE（Standard Edition）的学习路线，从入门到精通，并提供相应的代码示例。

一、Java 基础

1. Java 简介

Java 是由 Sun Microsystems（现为 Oracle）推出的一种面向对象的编程语言。Java 的主要特点包括：

• 跨平台性：通过 Java 虚拟机（JVM），Java 程序可以在不同操作系统上运行。
• 面向对象：Java 支持封装、继承、多态等面向对象的特性。
• 安全性：Java 提供了丰富的安全机制，保护程序免受恶意代码的侵害。
• 多线程：Java 内置了多线程支持，可以充分利用多核处理器的性能。

2. 开发环境搭建

要进行 Java 开发，首先需要搭建开发环境。主要步骤如下：

1. 安装 JDK（Java Development Kit）：从 Oracle 官方网站下载并安装最新版本的 JDK。
2. 配置环境变量：将 JDK 的 bin 目录添加到系统环境变量 PATH 中。
3. 安装 IDE（集成开发环境）：推荐使用 IntelliJ IDEA 或 Eclipse。

3. 第一个 Java 程序

下面是一个简单的 Java 程序，用于打印 "Hello, World!"。

public class HelloWorld {
    public static void main(String[] args) {
        // 打印 "Hello, World!" 到控制台
        System.out.println("Hello, World!");
    }
}

编译并运行上述程序：

javac HelloWorld.java  // 编译
java HelloWorld        // 运行

4. 基本语法

数据类型

Java 支持多种数据类型，包括：

• 基本数据类型：int, float, double, char, boolean 等。
• 引用数据类型：String, 数组, 类等。

public class DataTypes {
    public static void main(String[] args) {
        int num = 10;           // 整数
        float price = 19.99f;   // 浮点数
        double amount = 45.67;  // 双精度浮点数
        char grade = 'A';       // 字符
        boolean isJavaFun = true; // 布尔值
        String message = "Hello, Java!"; // 字符串
    }
}

操作符

Java 提供了丰富的操作符，包括：

• 算术操作符：+, -, *, /, %
• 关系操作符：==, !=, >, <, >=, <=
• 逻辑操作符：&&, ||, !
• 赋值操作符：=, +=, -=, *=, /=, %=

public class Operators {
    public static void main(String[] args) {
        int a = 10;  // 定义整数 a 并赋值为 10
        int b = 20;  // 定义整数 b 并赋值为 20
        int sum = a + b; // 加法操作，将 a 和 b 相加并赋值给 sum
        boolean isEqual = (a == b); // 等于操作，判断 a 是否等于 b
        boolean isGreater = (a > b); // 大于操作，判断 a 是否大于 b
        boolean isAnd = (a > 5 && b < 30); // 逻辑与操作，判断 a 是否大于 5 且 b 是否小于 30
    }
}

控制结构

Java 支持多种控制结构，包括条件语句和循环语句。

条件语句：

public class Conditional {
    public static void main(String[] args) {
        int age = 20;  // 定义整数 age 并赋值为 20
        if (age >= 18) {  // 如果 age 大于等于 18
            System.out.println("You are an adult.");  // 打印 "You are an adult."
        } else {  // 否则
            System.out.println("You are not an adult.");  // 打印 "You are not an adult."
        }
    }
}

循环语句：

public class Loops {
    public static void main(String[] args) {
        // for 循环
        for (int i = 0; i < 5; i++) {  // 循环变量 i 从 0 到 4，每次增加 1
            System.out.println("i = " + i);  // 打印 i 的值
        }

        // while 循环
        int j = 0;  // 定义整数 j 并赋值为 0
        while (j < 5) {  // 当 j 小于 5 时循环
            System.out.println("j = " + j);  // 打印 j 的值
            j++;  // j 增加 1
        }

        // do-while 循环
        int k = 0;  // 定义整数 k 并赋值为 0
        do {
            System.out.println("k = " + k);  // 打印 k 的值
            k++;  // k 增加 1
        } while (k < 5);  // 当 k 小于 5 时继续循环
    }
}

二、面向对象编程

1. 类与对象

Java 是一种面向对象的编程语言，类和对象是其核心概念。

类 是一种模板，定义了对象的属性和行为。

对象 是类的实例，通过类创建。

// 定义一个类
public class Person {
    // 属性
    String name;  // 定义字符串类型的 name 属性
    int age;  // 定义整数类型的 age 属性

    // 方法
    void introduce() {
        // 打印介绍信息
        System.out.println("My name is " + name + " and I am " + age + " years old.");
    }
}

// 创建对象
public class Main {
    public static void main(String[] args) {
        Person person = new Person();  // 创建 Person 类的对象
        person.name = "John";  // 设置对象的 name 属性
        person.age = 25;  // 设置对象的 age 属性
        person.introduce();  // 调用对象的 introduce 方法
    }
}

2. 继承

继承是面向对象编程的一个重要特性，它允许一个类继承另一个类的属性和方法。

// 父类
class Animal {
    void eat() {
        // 打印 "This animal eats food."
        System.out.println("This animal eats food.");
    }
}

// 子类
class Dog extends Animal {
    void bark() {
        // 打印 "The dog barks."
        System.out.println("The dog barks.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();  // 创建 Dog 类的对象
        dog.eat();  // 调用继承自父类的方法
        dog.bark();  // 调用子类的方法
    }
}

3. 多态

多态是面向对象编程的另一个重要特性，它允许方法在不同的对象中有不同的实现。

// 父类
class Animal {
    void sound() {
        // 打印 "This animal makes a sound."
        System.out.println("This animal makes a sound.");
    }
}

// 子类
class Dog extends Animal {
    @Override
    void sound() {
        // 打印 "The dog barks."
        System.out.println("The dog barks.");
    }
}

// 另一个子类
class Cat extends Animal {
    @Override
    void sound() {
        // 打印 "The cat meows."
        System.out.println("The cat meows.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();  // 创建 Dog 类的对象，类型为 Animal
        Animal myCat = new Cat();  // 创建 Cat 类的对象，类型为 Animal
        myDog.sound();  // 调用 Dog 类的 sound 方法，输出 "The dog barks."
        myCat.sound();  // 调用 Cat 类的 sound 方法，输出 "The cat meows."
    }
}

4. 封装

封装是将对象的状态（属性）隐藏在类的内部，只能通过类的方法访问和修改，提供了一种保护数据的机制。

public class Person {
    // 私有属性
    private String name;  // 定义私有字符串类型的 name 属性
    private int age;  // 定义私有整数类型的 age 属性

    // 公共方法访问私有属性
    public String getName() {
        // 返回 name 属性的值
        return name;
    }

    public void setName(String name) {
        // 设置 name

 属性的值
        this.name = name;
    }

    public int getAge() {
        // 返回 age 属性的值
        return age;
    }

    public void setAge(int age) {
        // 如果 age 大于 0，则设置 age 属性的值
        if (age > 0) {
            this.age = age;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();  // 创建 Person 类的对象
        person.setName("Alice");  // 设置对象的 name 属性
        person.setAge(30);  // 设置对象的 age 属性
        System.out.println("Name: " + person.getName());  // 打印对象的 name 属性
        System.out.println("Age: " + person.getAge());  // 打印对象的 age 属性
    }
}

5. 抽象类和接口

抽象类 是不能被实例化的类，可以包含抽象方法和具体方法。

// 定义抽象类
abstract class Animal {
    // 抽象方法
    abstract void sound(); 

    // 具体方法
    void sleep() {
        // 打印 "This animal sleeps."
        System.out.println("This animal sleeps.");
    }
}

// 子类继承抽象类
class Dog extends Animal {
    @Override
    void sound() {
        // 打印 "The dog barks."
        System.out.println("The dog barks.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();  // 创建 Dog 类的对象，类型为 Animal
        myDog.sound();  // 调用 Dog 类的 sound 方法
        myDog.sleep();  // 调用 Animal 类的 sleep 方法
    }
}

接口 是一种完全抽象的类，只包含抽象方法。类通过实现接口来提供具体的实现。

// 定义接口
interface Animal {
    void sound(); // 抽象方法
}

// 类实现接口
class Dog implements Animal {
    @Override
    public void sound() {
        // 打印 "The dog barks."
        System.out.println("The dog barks.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();  // 创建 Dog 类的对象，类型为 Animal
        myDog.sound();  // 调用 Dog 类的 sound 方法
    }
}

三、常用类库

1. 字符串处理

Java 提供了丰富的字符串处理类，如 String, StringBuilder, StringBuffer。

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";  // 创建字符串
        System.out.println("Length: " + str.length());  // 打印字符串长度
        System.out.println("Substring: " + str.substring(7, 12));  // 打印子字符串
        System.out.println("Uppercase: " + str.toUpperCase());  // 打印大写字符串

        StringBuilder sb = new StringBuilder("Hello");  // 创建 StringBuilder 对象
        sb.append(", World!");  // 追加字符串
        System.out.println("StringBuilder: " + sb.toString());  // 打印 StringBuilder 内容
    }
}

2. 集合框架

Java 的集合框架提供了一组类和接口，用于存储和操作数据集合，如 ArrayList, HashMap, HashSet 等。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;

public class CollectionExample {
    public static void main(String[] args) {
        // ArrayList 示例
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");  // 添加元素到 ArrayList
        list.add("Banana");
        list.add("Orange");
        System.out.println("ArrayList: " + list);  // 打印 ArrayList 内容

        // HashMap 示例
        HashMap<String, Integer> map = new HashMap<>();
        map.put("Apple", 1);  // 添加键值对到 HashMap
        map.put("Banana", 2);
        map.put("Orange", 3);
        System.out.println("HashMap: " + map);  // 打印 HashMap 内容

        // HashSet 示例
        HashSet<String> set = new HashSet<>();
        set.add("Apple");  // 添加元素到 HashSet
        set.add("Banana");
        set.add("Orange");
        System.out.println("HashSet: " + set);  // 打印 HashSet 内容
    }
}

3. 文件操作

Java 提供了丰富的文件操作类，如 File, FileReader, FileWriter, BufferedReader, BufferedWriter 等。

import java.io.*;

public class FileExample {
    public static void main(String[] args) {
        // 写入文件
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("example.txt"))) {
            writer.write("Hello, World!");  // 写入内容到文件
        } catch (IOException e) {
            e.printStackTrace();  // 捕获并打印异常
        }

        // 读取文件
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {  // 逐行读取文件内容
                System.out.println(line);  // 打印每行内容
            }
        } catch (IOException e) {
            e.printStackTrace();  // 捕获并打印异常
        }
    }
}

四、高级特性

1. 多线程

Java 提供了丰富的多线程支持，通过继承 Thread 类或实现 Runnable 接口来创建线程。

// 通过继承 Thread 类创建线程
class MyThread extends Thread {
    public void run() {
        // 打印 "Thread is running..."
        System.out.println("Thread is running...");
    }
}

// 通过实现 Runnable 接口创建线程
class MyRunnable implements Runnable {
    public void run() {
        // 打印 "Runnable is running..."
        System.out.println("Runnable is running...");
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        MyThread thread = new MyThread();  // 创建 MyThread 对象
        thread.start();  // 启动线程

        Thread runnableThread = new Thread(new MyRunnable());  // 创建 Thread 对象，传入 MyRunnable 对象
        runnableThread.start();  // 启动线程
    }
}

2. 异常处理

Java 提供了强大的异常处理机制，通过 try, catch, finally 和 throw 语句来处理异常。

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);  // 调用 divide 方法，尝试除以 0
            System.out.println("Result: " + result);  // 打印结果
        } catch (ArithmeticException e) {
            System.out.println("Error: " + e.getMessage());  // 捕获并打印异常信息
        } finally {
            System.out.println("Finally block executed.");  // 无论是否发生异常，都会执行 finally 块
        }
    }

    public static int divide(int a, int b) throws ArithmeticException {
        // 如果 b 为 0，将会抛出 ArithmeticException 异常
        return a / b;
    }
}

3. 网络编程

Java 提供了丰富的网络编程类，如 Socket, ServerSocket, URL 等。

import java.io.*;
import java.net.*;

public class NetworkExample {
    public static void main(String[] args) {
        try {
            // 创建一个服务器端 socket，监听端口 6666
            ServerSocket serverSocket = new ServerSocket(6666);
            System.out.println("Server started...");

            // 等待客户端连接
            Socket socket = serverSocket.accept();
            System.out.println("Client connected...");

            // 创建输入输出流
            DataInputStream input = new DataInputStream(socket.getInputStream());
            DataOutputStream output = new DataOutputStream(socket.getOutputStream());

            // 接收客户端消息
            String message = input.readUTF();
            System.out.println("Client says: " + message);

            // 发送回复
            output.writeUTF("Hello, Client!");

            // 关闭连接
            input.close();
            output.close();
            socket.close();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();  // 捕获并打印异常
        }
    }
}

4. 注解与反射

Java 提供了注解与反射机制，用于在运行时获取类的信息和动态调用方法。

import java.lang.reflect.Method;

// 定义一个注解
@interface MyAnnotation {
    String value(); // 注解的属性
}

// 使用注解
class AnnotatedClass {
    @MyAnnotation("Hello, World!") // 给方法加上 MyAnnotation 注解
    public void annotatedMethod() {
        // 打印 "This is an annotated method."
        System.out.println("This is an annotated method.");
    }
}

public class AnnotationExample {
    public static void main(String

[] args) {
        try {
            // 获取类的 Class 对象
            Class<?> cls = AnnotatedClass.class;
            // 获取方法
            Method method = cls.getMethod("annotatedMethod");
            // 检查方法是否有 MyAnnotation 注解
            if (method.isAnnotationPresent(MyAnnotation.class)) {
                // 获取注解
                MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
                // 输出注解的值
                System.out.println("Annotation value: " + annotation.value());
            }
            // 调用方法
            method.invoke(cls.newInstance());
        } catch (Exception e) {
            e.printStackTrace();  // 捕获并打印异常
        }
    }
}

从 Java 基础到高级特性，对 Java SE 有了全面的了解，并能够在实际开发中应用这些知识。