首页手记 Java开发入门教程：从零开始学习Java编程

Java开发入门教程：从零开始学习Java编程

标签：

Java

本文详细介绍了Java开发环境的搭建，包括选择合适的开发工具、安装Java开发环境和配置IDE工具。文章还涵盖了Java基础语法入门，包括数据类型、变量、控制结构和数组操作。此外，文章进一步探讨了Java面向对象编程的概念和实践，以及常用类库的使用。最后，文章提供了Java开发进阶指南和学习资源推荐。

Java开发环境搭建

选择合适的开发工具（IDE）

选择合适的开发工具（Integrated Development Environment，IDE）对于提高编程效率至关重要。在Java编程中，常见的IDE有Eclipse、IntelliJ IDEA和NetBeans。其中，Eclipse是开源且功能强大的IDE，深受开发者喜爱；IntelliJ IDEA则以其智能代码辅助和高效的性能著称，适合专业的Java开发；NetBeans则是一个功能丰富的IDE，支持多种语言，适合初学者使用。

安装Java开发环境

安装Java开发环境需要完成两个主要步骤：安装Java开发工具包（JDK）和配置环境变量。

安装JDK

访问Oracle官方网站或OpenJDK官方网站下载适合您操作系统的JDK安装包。
运行下载的安装包，按照安装向导完成JDK的安装。
安装完成后，可以在“控制面板” > “程序” > “已安装的程序”中找到已安装的JDK。

配置环境变量

配置环境变量是为了让操作系统识别Java可执行文件（java.exe）的路径。以下是配置环境变量的具体步骤：

打开“此电脑”，在左上角点击“系统属性”，然后选择“高级系统设置”。
在“系统属性”窗口中点击“环境变量”按钮。
在“系统变量”区域中找到并选择Path变量，然后点击“编辑”按钮。
在“编辑环境变量”窗口中点击“新建”，然后输入JDK安装目录下的bin文件夹路径。例如：C:\Program Files\Java\jdk-11.0.1\bin。
点击“确定”按钮完成配置。

配置IDE工具

配置IDE工具需要根据您选择的IDE进行。以下以Eclipse为例，介绍如何完成配置。

下载并安装Eclipse。
打开Eclipse，选择“File” > “New” > “Java Project”，创建一个新的Java项目。
在项目目录下，右键点击“src”文件夹，选择“New” > “Class”，创建一个新的Java类。

编写并运行简单的Java程序。

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

Java基础语法入门

数据类型与变量

在Java中，数据类型决定了变量可以存储的数据类型。Java是一种强类型语言，变量的类型必须在声明时指定。Java的数据类型分为两类：基本类型和引用类型。

基本类型

基本类型包括整型、浮点型、字符型和布尔型。以下是各基本类型的说明：

整型（Integer）：byte, short, int, long
浮点型（Floating point）：float, double
字符型（Character）：char
布尔型（Boolean）：boolean

变量的声明与赋值

变量在使用前必须先声明，声明变量时需要指定数据类型和变量名。下面是一些基本变量的声明和赋值示例：

int age = 25;       // 整型变量
double weight = 65.5;  // 浮点型变量
char grade = 'A';   // 字符型变量
boolean isStudent = true;  // 布尔型变量

示例代码

public class DataTypesExample {
    public static void main(String[] args) {
        int age = 25;
        double weight = 65.5;
        char grade = 'A';
        boolean isStudent = true;

        System.out.println("Age: " + age);
        System.out.println("Weight: " + weight);
        System.out.println("Grade: " + grade);
        System.out.println("Is Student: " + isStudent);
    }
}

控制结构（条件语句和循环）

Java中的控制结构包括条件语句和循环。条件语句用于根据条件执行不同的代码块，而循环用于多次执行代码块。

条件语句

Java中的条件语句主要包括 if、else、else if 以及 switch。

if 语句

if 语句用于检查一个条件，如果条件为真，则执行相关代码块。

public class IfExample {
    public static void main(String[] args) {
        int num = 10;
        if (num > 5) {
            System.out.println("num is greater than 5");
        }
    }
}

if-else 语句

if-else 语句用于检查一个条件，如果条件为真，则执行一个代码块；如果条件为假，则执行另一个代码块。

public class IfElseExample {
    public static void main(String[] args) {
        int num = 3;
        if (num > 5) {
            System.out.println("num is greater than 5");
        } else {
            System.out.println("num is not greater than 5");
        }
    }
}

if-else if-else 语句

if-else if-else 语句用于检查多个条件，以找到第一个为真的条件，并执行相应的代码块。

public class IfElseIfElseExample {
    public static void main(String[] args) {
        int num = 2;
        if (num > 10) {
            System.out.println("num is greater than 10");
        } else if (num > 5) {
            System.out.println("num is greater than 5");
        } else {
            System.out.println("num is not greater than 5");
        }
    }
}

switch 语句

switch 语句用于根据不同的条件执行不同的代码块。

public class SwitchExample {
    public static void main(String[] args) {
        int day = 2;
        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            default:
                System.out.println("Other day");
        }
    }
}

循环

Java中的循环有 for、while 和 do-while。

for 循环

for 循环用于重复执行一段代码，直到某个条件不再满足为止。

public class ForLoopExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Iteration: " + i);
        }
    }
}

while 循环

while 循环用于在条件为真时重复执行一段代码。

public class WhileLoopExample {
    public static void main(String[] args) {
        int i = 1;
        while (i <= 5) {
            System.out.println("Iteration: " + i);
            i++;
        }
    }
}

do-while 循环

do-while 循环用于在条件为真时重复执行一段代码，但会在循环体执行后再检查条件。

public class DoWhileLoopExample {
    public static void main(String[] args) {
        int i = 1;
        do {
            System.out.println("Iteration: " + i);
            i++;
        } while (i <= 5);
    }
}

数组与字符串操作

数组

数组是一种数据结构，用于存储相同类型的多个值。数组在Java中可以通过 new 关键字创建。

数组的创建

public class ArrayExample {
    public static void main(String[] args) {
        int[] numbers = new int[5];
        numbers[0] = 1;
        numbers[1] = 2;
        numbers[2] = 3;
        numbers[3] = 4;
        numbers[4] = 5;

        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Element " + i + ": " + numbers[i]);
        }
    }
}

数组的初始化

Java也允许在创建数组的同时进行初始化。

public class ArrayInitializationExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};

        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Element " + i + ": " + numbers[i]);
        }
    }
}

字符串操作

字符串是Java中的一个基本数据类型，用于表示文本。字符串对象是由 String 类实现的。

创建字符串对象

public class StringExample {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "World";

        System.out.println("String 1: " + str1);
        System.out.println("String 2: " + str2);

        String str3 = str1 + " " + str2;
        System.out.println("Concatenated String: " + str3);
    }
}

字符串操作方法

String 类提供了许多有用的方法来操作字符串，如 length()、charAt()、substring()、indexOf() 等。

public class StringManipulationExample {
    public static void main(String[] args) {
        String str = "Hello, World";

        System.out.println("Length: " + str.length());
        System.out.println("Character at index 0: " + str.charAt(0));
        System.out.println("SubString from index 1 to 5: " + str.substring(1, 5));
        System.out.println("Index of 'W': " + str.indexOf('W'));
    }
}

Java面向对象编程

类与对象的概念

面向对象编程（Object-Oriented Programming，OOP）是Java编程的核心。它强调的是“类”和“对象”的概念。

类的定义

类是一种用户自定义的数据类型，它描述了一组具有相同属性和行为的对象。类中包含了属性（变量）和行为（方法）。

public class Person {
    // 属性
    String name;
    int age;

    // 方法
    void sayHello() {
        System.out.println("Hello, my name is " + name + " and I'm " + age + " years old.");
    }
}

对象的创建

对象是类的实例。通过 new 关键字可以创建对象。

public class ObjectExample {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.name = "Alice";
        person1.age = 25;

        person1.sayHello();
    }
}

封装、继承与多态

封装是面向对象编程中的一个重要概念，它是指隐藏对象内部的实现细节，只对外提供一些必要的方法。

封装

封装可以防止外部代码直接访问对象的内部状态，从而提高代码的安全性和可维护性。

public class EncapsulationExample {
    public static void main(String[] args) {
        Employee employee = new Employee("John Doe", 30);
        System.out.println(employee.getName());
        System.out.println(employee.getAge());
    }
}

class Employee {
    private String name;
    private int age;

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

继承

继承是面向对象编程的另一个重要特性，它允许一个类继承另一个类的属性和方法，从而实现代码的重用和层次结构的构建。

public class InheritanceExample {
    public static void main(String[] args) {
        Manager manager = new Manager("Alice", 30, 5000);
        manager.sayHello();
        manager.showSalary();
    }
}

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void sayHello() {
        System.out.println("Hello, my name is " + name + " and I'm " + age + " years old.");
    }
}

class Employee extends Person {
    int salary;

    Employee(String name, int age, int salary) {
        super(name, age);
        this.salary = salary;
    }

    void showSalary() {
        System.out.println("Salary: " + salary);
    }
}

class Manager extends Employee {
    Manager(String name, int age, int salary) {
        super(name, age, salary);
    }

    void sayHello() {
        System.out.println("Hello, my name is " + name + " and I'm " + age + " years old. I'm a manager.");
    }
}

多态

多态允许子类覆盖父类的方法，从而实现一种“相同的接口，不同的实现”的机制。

public class PolymorphismExample {
    public static void main(String[] args) {
        Person person = new Employee("Alice", 30, 5000);
        person.sayHello();

        person = new Manager("Bob", 35, 6000);
        person.sayHello();
    }
}

class Person {
    String name;
    int age;

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void sayHello() {
        System.out.println("Hello, my name is " + name + " and I'm " + age + " years old.");
    }
}

class Employee extends Person {
    int salary;

    Employee(String name, int age, int salary) {
        super(name, age);
        this.salary = salary;
    }

    void sayHello() {
        System.out.println("Hello, my name is " + name + " and I'm " + age + " years old. I'm an employee.");
    }
}

class Manager extends Employee {
    Manager(String name, int age, int salary) {
        super(name, age, salary);
    }

    void sayHello() {
        System.out.println("Hello, my name is " + name + " and I'm " + age + " years old. I'm a manager.");
    }
}

接口和抽象类

接口

接口是一种特殊的抽象类型，用于定义一组方法的规范。接口中的方法默认是抽象的，即没有实现。

public class InterfaceExample {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.makeSound();
        dog.eat();

        Animal cat = new Cat();
        cat.makeSound();
        cat.eat();
    }
}

interface Animal {
    void makeSound();
    void eat();
}

class Dog implements Animal {
    public void makeSound() {
        System.out.println("Woof!");
    }

    public void eat() {
        System.out.println("Dog eats food.");
    }
}

class Cat implements Animal {
    public void makeSound() {
        System.out.println("Meow!");
    }

    public void eat() {
        System.out.println("Cat eats food.");
    }
}

抽象类

抽象类是一种不能实例化的类，它可以包含抽象方法和非抽象方法。抽象方法没有实现，必须在子类中实现。

public class AbstractClassExample {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.makeSound();
        dog.eat();
    }
}

abstract class Animal {
    public void eat() {
        System.out.println("Animal eats food.");
    }

    abstract void makeSound();
}

class Dog extends Animal {
    public void makeSound() {
        System.out.println("Woof!");
    }
}

Java常用类库介绍

输入输出操作

Java提供了丰富的输入输出类库，用于处理文件操作、网络通信等。

文件操作

文件操作是最常见的输入输出操作之一。Java中的File类用于表示文件和目录，而FileInputStream、FileOutputStream等类用于读写文件。

读取文件

import java.io.*;

public class FileReaderExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

写入文件

import java.io.*;

public class FileWriterExample {
    public static void main(String[] args) {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
            bw.write("Hello, World!");
            bw.newLine();
            bw.write("This is a test.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

追加写入文件

import java.io.*;

public class AppendToFileExample {
    public static void main(String[] args) {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt", true))) {
            bw.newLine();
            bw.write("Appending this line.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件复制

import java.io.*;

public class FileCopyExample {
    public static void main(String[] args) {
        try (InputStream in = new FileInputStream("input.txt");
             OutputStream out = new FileOutputStream("output.txt")) {
            int c;
            while ((c = in.read()) != -1) {
                out.write(c);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

网络通信

Java中的Socket类和ServerSocket类用于实现简单的客户端-服务器通信。

服务器端

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

public class ServerExample {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(12345);
        Socket clientSocket = serverSocket.accept();
        BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        String input = in.readLine();
        System.out.println("Received: " + input);
        in.close();
        clientSocket.close();
        serverSocket.close();
    }
}

客户端

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

public class ClientExample {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 12345);
        PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
        out.println("Hello, Server!");
        socket.close();
    }
}

客户端发送多个消息

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

public class MultimessageClientExample {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 12345);
        PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
        out.println("Message 1");
        out.println("Message 2");
        out.println("Message 3");
        socket.close();
    }
}

服务器端处理多个消息

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

public class MultimessageServerExample {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(12345);
        Socket clientSocket = serverSocket.accept();
        BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        String input;
        while ((input = in.readLine()) != null) {
            System.out.println("Received: " + input);
        }
        in.close();
        clientSocket.close();
        serverSocket.close();
    }
}

异常处理

异常处理是Java编程中的重要部分，它可以捕获和处理程序运行时的错误。

异常的捕获

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Caught ArithmeticException: " + e.getMessage());
        }
    }

    static int divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("Divide by zero error");
        }
        return a / b;
    }
}

异常的抛出

public class ExceptionThrowExample {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Caught ArithmeticException: " + e.getMessage());
        }
    }

    static int divide(int a, int b) throws ArithmeticException {
        if (b == 0) {
            throw new ArithmeticException("Divide by zero error");
        }
        return a / b;
    }
}

处理`IOException`

public class IOExample {
    public static void main(String[] args) {
        try {
            BufferedReader br = new BufferedReader(new FileReader("input.txt"));
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

处理`NullPointerException`

public class NullPointerExample {
    public static void main(String[] args) {
        String s = null;
        try {
            System.out.println(s.length());
        } catch (NullPointerException e) {
            System.out.println("Caught NullPointerException: " + e.getMessage());
        }
    }
}

集合框架

Java集合框架提供了丰富的数据结构，用于存储和操作对象。常见的集合接口有List、Set和Map。

List

List接口用于存储有序的元素列表。

import java.util.*;

public class ListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("C++");

        System.out.println("List: " + list);

        for (String item : list) {
            System.out.println(item);
        }
    }
}

嵌套列表

import java.util.*;

public class NestedListExample {
    public static void main(String[] args) {
        List<List<String>> nestedList = new ArrayList<>();
        nestedList.add(Arrays.asList("red", "green", "blue"));
        nestedList.add(Arrays.asList("apple", "banana", "orange"));

        System.out.println("Nested List: " + nestedList);

        for (List<String> sublist : nestedList) {
            for (String item : sublist) {
                System.out.println(item);
            }
        }
    }
}

Set

Set接口用于存储不重复的元素。

import java.util.*;

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("Java");
        set.add("Python");
        set.add("C++");

        System.out.println("Set: " + set);

        for (String item : set) {
            System.out.println(item);
        }
    }
}

多级映射

import java.util.*;

public class MultiLevelMapExample {
    public static void main(String[] args) {
        Map<String, Map<String, Integer>> map = new HashMap<>();
        Map<String, Integer> map1 = new HashMap<>();
        map1.put("John", 25);
        map1.put("Alice", 30);
        map.put("Department1", map1);

        Map<String, Integer> map2 = new HashMap<>();
        map2.put("Bob", 35);
        map2.put("Charlie", 40);
        map.put("Department2", map2);

        System.out.println("Multi-Level Map: " + map);

        for (Map.Entry<String, Map<String, Integer>> entry : map.entrySet()) {
            System.out.println("Department: " + entry.getKey());
            for (Map.Entry<String, Integer> subEntry : entry.getValue().entrySet()) {
                System.out.println("Name: " + subEntry.getKey() + " Age: " + subEntry.getValue());
            }
        }
    }
}

Map

Map接口用于存储键值对。

import java.util.*;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Java", 1);
        map.put("Python", 2);
        map.put("C++", 3);

        System.out.println("Map: " + map);

        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

Java项目实践

小项目实战演练

进行实际项目练习是学习编程的重要方式。下面以一个简单的图书管理系统为例，介绍如何使用Java进行项目开发。

实现图书类

public class Book {
    private String title;
    private String author;
    private int year;

    public Book(String title, String author, int year) {
        this.title = title;
        this.author = author;
        this.year = year;
    }

    public String getTitle() {
        return title;
    }

    public String getAuthor() {
        return author;
    }

    public int getYear() {
        return year;
    }

    @Override
    public String toString() {
        return title + " by " + author + " (" + year + ")";
    }
}

实现图书管理类

import java.util.*;

public class BookManager {
    private List<Book> books = new ArrayList<>();

    public void addBook(Book book) {
        books.add(book);
    }

    public void removeBook(String title) {
        books.removeIf(book -> book.getTitle().equals(title));
    }

    public void displayBooks() {
        for (Book book : books) {
            System.out.println(book);
        }
    }

    public Book findBook(String title) {
        for (Book book : books) {
            if (book.getTitle().equals(title)) {
                return book;
            }
        }
        return null;
    }
}

实现主程序类

public class Main {
    public static void main(String[] args) {
        BookManager manager = new BookManager();

        manager.addBook(new Book("The Great Gatsby", "F. Scott Fitzgerald", 1925));
        manager.addBook(new Book("1984", "George Orwell", 1949));
        manager.addBook(new Book("Animal Farm", "George Orwell", 1945));

        manager.displayBooks();

        System.out.println("\nFinding '1984'");
        Book book = manager.findBook("1984");
        if (book != null) {
            System.out.println(book);
        } else {
            System.out.println("Book not found");
        }

        System.out.println("\nRemoving 'Animal Farm'");
        manager.removeBook("Animal Farm");
        manager.displayBooks();
    }
}

代码调试技巧

调试是确保代码正确运行的重要步骤。以下是一些常用的调试技巧：

使用打印语句：在关键位置插入System.out.println()语句，输出变量值或程序执行的痕迹。
使用调试工具：IDE通常提供了强大的调试工具，可以设置断点、查看变量值、单步执行等。
单元测试：编写单元测试用例，验证每个模块的功能。

代码规范与风格

编写规范和风格一致的代码是非常重要的，它有助于提高代码的可读性和可维护性。以下是一些常用的代码规范：

命名规范：变量名、函数名等应当有意义且易于理解。
代码格式：保持代码格式的一致性，如缩进、空格等。
注释：必要的地方添加注释，解释代码的功能和逻辑。

Java开发进阶指南

常见面试题解析

面试时常见的Java面试题包括面向对象的概念、集合框架的使用、基础语法等。

面试题示例

Java中的抽象类和接口有什么区别？
- 抽象类可以包含抽象方法也可以包含具体方法。
- 接口中只能包含抽象方法和常量。
- 子类只能继承一个抽象类，但可以实现多个接口。
Java中的final关键字有哪些用法？
- 可以修饰变量，表示该变量不能被修改。
- 可以修饰方法，表示该方法不能被重写。
- 可以修饰类，表示该类不能被继承。

学习资源推荐

推荐以下学习资源，有助于深入学习Java编程：

慕课网：提供大量的Java编程课程和实战项目。
Java官方文档：权威的Java编程指南，包括API文档和教程。
Stack Overflow：一个在线编程问答社区，可以找到许多Java编程问题的解答。

Java社区与论坛

加入Java编程的社区和论坛有助于与其他开发者交流学习心得，解决问题。

Java开发者论坛：Java开发者社区，提供技术交流和分享。
GitHub：开源项目托管平台，可以学习其他开发者的技术实现。
Reddit：技术讨论和分享社区，可以找到许多Java相关的资源和文章。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

宝慕林4294392

手记
篇

粉丝

36

获赞与收藏

149

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19187 313

Java 并发原理入门教程

26个小节 38860 566

Java 入门教程

50个小节 340924 3155

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空