亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

為了賬號安全，請及時綁定郵箱和手機立即綁定

Java后端入門：簡潔教程助你快速上手

標簽：
Java
概述

本文详细介绍了Java后端入门所需的开发环境搭建、基础语法学习以及框架使用，帮助初学者快速上手。从安装JDK和配置环境变量开始，到使用集成开发环境（IDE）如IntelliJ IDEA或Eclipse，再到掌握Java基础语法和面向对象编程，逐步引导读者入门。此外，文章还介绍了Spring和Hibernate等常用框架的使用方法，并通过实战项目演示如何构建简单的后端应用。

Java开发环境搭建

安装Java开发工具包（JDK）

JDK（Java Development Kit）是开发Java应用程序的基础工具包。安装JDK包括Java编译器、Java运行时环境和其他开发工具。以下是安装JDK的步骤：

  1. 访问Oracle官方网站，下载最新版本的JDK。
  2. 打开下载的安装文件，按照提示完成安装。
  3. 安装完成后，确保安装路径正确，通常为C:\Program Files\Java\jdk-<version>。

配置环境变量

配置环境变量是为了让操作系统能够识别和使用JDK中的工具。以下是配置环境变量的步骤：

  1. 打开“控制面板” > “系统和安全” > “系统” > “高级系统设置”。
  2. 点击“环境变量”按钮。
  3. 在“系统变量”部分，选择“新建”，添加以下变量：
    • 变量名：JAVA_HOME
    • 变量值：C:\Program Files\Java\jdk-<version>
  4. 在“系统变量”部分，选择“编辑”，找到Path变量，点击“编辑”。
  5. 在“编辑环境变量”窗口中，点击“新建”，添加%JAVA_HOME%\bin。
  6. 确保%JAVA_HOME%\bin在Path变量的前面，以确保优先使用JDK中的工具。
  7. 点击“确定”保存所有设置。

使用集成开发环境（IDE）：如IntelliJ IDEA或Eclipse

IDE（Integrated Development Environment）是开发Java应用程序的重要工具，提供了代码编辑、调试、测试等功能。以下是安装和配置IDE的步骤：

IntelliJ IDEA

  1. 访问IntelliJ IDEA官方网站，下载最新版本的IntelliJ IDEA。
  2. 打开安装文件，按照提示完成安装。
  3. 打开IntelliJ IDEA，创建新的Java项目。
  4. 在项目创建向导中，选择Java项目模板，输入项目名称和位置。
  5. 配置项目SDK，选择之前安装的JDK。
  6. 完成项目创建，开始编写Java代码。

Eclipse

  1. 访问Eclipse官方网站，下载最新版本的Eclipse。
  2. 打开安装文件，按照提示完成安装。
  3. 打开Eclipse，创建新的Java项目。
  4. 在项目创建向导中，选择Java项目模板，输入项目名称和位置。
  5. 配置项目JRE（Java Runtime Environment），选择之前安装的JDK。
  6. 完成项目创建，开始编写Java代码。
Java基础语法入门

数据类型与变量声明

Java中的数据类型分为基本数据类型（Primitive Types）和引用数据类型（Reference Types）。

基本数据类型

  • 整型：
    • byte：8位
    • short：16位
    • int：32位
    • long：64位
  • 浮点型：
    • float：32位
    • double：64位
  • 布尔型：
    • boolean：用于表示true或false
  • 字符型：
    • char：16位

变量声明

下面分别展示每种类型变量的声明方式：

// 整型变量声明
int age = 25;

// 浮点型变量声明
float pi = 3.14f;

// 布尔型变量声明
boolean isActive = true;

// 字符型变量声明
char gender = 'M';

流程控制语句

Java中的流程控制语句主要包括条件语句（if-else）、循环语句（for、while、do-while）和跳转语句（break、continue）。

if-else语句

int score = 85;

if (score >= 60) {
    System.out.println("及格了");
} else {
    System.out.println("不及格");
}

for循环

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

while循环

int num = 0;
while (num < 10) {
    System.out.println("循环第 " + num + " 次");
    num++;
}

do-while循环

int num = 0;
do {
    System.out.println("循环第 " + num + " 次");
    num++;
} while (num < 10);

循环嵌套和复杂条件语句

for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 3; j++) {
        System.out.println("i = " + i + ", j = " + j);
    }
}

int a = 10, b = 20, c = 30;
if (a > b && b > c) {
    System.out.println("a > b > c");
} else if (a < b && b < c) {
    System.out.println("a < b < c");
} else {
    System.out.println("其他情况");
}

函数与方法

Java中的方法主要用于封装代码逻辑，实现代码的复用。方法定义的基本格式如下：

[访问修饰符] 返回类型 方法名(参数列表) {
    // 方法体
    [return 返回值;]
}

示例方法

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

public void printMessage(String message) {
    System.out.println(message);
}

更复杂的函数示例

public int addNumbers(int a, int b, int c) {
    return a + b + c;
}

public int addNumbers(int a, int b, int c, int d) {
    return a + b + c + d;
}

public int addNumbers(int a, int b, int c, int d, int e) {
    return a + b + c + d + e;
}

public int addNumbers(int... nums) {
    int sum = 0;
    for (int num : nums) {
        sum += num;
    }
    return sum;
}

public static void main(String[] args) {
    System.out.println(addNumbers(1, 2, 3)); // 输出: 6
    System.out.println(addNumbers(1, 2, 3, 4)); // 输出: 10
    System.out.println(addNumbers(1, 2, 3, 4, 5)); // 输出: 15
    System.out.println(addNumbers(1, 2, 3, 4, 5, 6, 7, 8)); // 输出: 36
}

类与对象

Java是一种面向对象的语言，其核心是类和对象。类用于描述对象的属性和行为，对象是类的实例。

类的定义

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

    // 构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 方法
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

创建对象

Person person = new Person("张三", 25);
System.out.println(person.getName());
System.out.println(person.getAge());

面向对象编程基础

面向对象编程的核心概念包括封装、继承和多态。

封装

封装是指将数据和操作数据的方法封装到一个类中，提供公共接口，隐藏内部实现细节。

public class BankAccount {
    private double balance;

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    public void deposit(double amount) {
        this.balance += amount;
    }

    public void withdraw(double amount) {
        if (amount <= this.balance) {
            this.balance -= amount;
        }
    }

    public double getBalance() {
        return this.balance;
    }
}

BankAccount account = new BankAccount(1000);
account.deposit(500);
account.withdraw(200);
System.out.println(account.getBalance());  // 输出: 1300

继承

继承是指一个类可以继承另一个类的属性和方法，实现代码的复用。

public class Animal {
    public void eat() {
        System.out.println("动物在进食");
    }
}

public class Cat extends Animal {
    public void sleep() {
        System.out.println("猫在睡觉");
    }
}

Cat cat = new Cat();
cat.eat();    // 输出: 动物在进食
cat.sleep();  // 输出: 猫在睡觉

多态

多态是指一个对象可以有多种形态，允许使用相同的方法名实现不同的行为。

public class Animal {
    public void eat() {
        System.out.println("动物在进食");
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫在吃鱼");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗在吃骨头");
    }
}

Animal animal = new Cat();
animal.eat();  // 输出: 猫在吃鱼

Animal animal2 = new Dog();
animal2.eat();  // 输出: 狗在吃骨头
Java后端开发框架介绍

Servlet与JSP基础

Servlet是Java Web应用中用于处理客户端请求和服务器响应的Java类。JSP（JavaServer Pages）是一种结合了Java代码和HTML代码的Web技术，可以动态生成HTML内容。

创建Servlet

  1. 创建HelloServlet.java文件：
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        out.println("<html>");
        out.println("<head>");
        out.println("<title>Hello Servlet</title>");
        out.println("</head>");
        out.println("<body>");
        out.println("<h1>Hello, Servlet!</h1>");
        out.println("</body>");
        out.println("</html>");
    }
}
  1. 创建web.xml文件，配置Servlet：
<web-app>
    <servlet>
        <servlet-name>Hello</servlet-name>
        <servlet-class>HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>Hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

创建JSP页面

  1. 创建index.jsp文件：
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>欢迎页面</title>
</head>
<body>
    <h1>欢迎页面</h1>
</body>
</html>

Spring框架入门

Spring是一个开源框架，用于简化Java开发。Spring的核心功能包括IoC（控制反转）和AOP（面向切面编程）。

创建Spring项目

  1. 创建Spring配置文件applicationContext.xml：
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 配置Bean -->
    <bean id="helloBean" class="com.example.HelloBean"/>

</beans>
  1. 创建HelloBean.java类：
public class HelloBean {
    public void sayHello() {
        System.out.println("Hello, Spring!");
    }
}
  1. 在主类中使用Spring容器：
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloBean helloBean = (HelloBean) context.getBean("helloBean");
        helloBean.sayHello();
    }
}

Spring Boot快速开发

Spring Boot是Spring的快速开发框架，简化了Spring应用的配置和开发。

创建Spring Boot项目

  1. 创建SpringApplication.java：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringApplication.class, args);
    }
}
  1. 创建HelloController.java：
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }
}
数据库操作基础

JDBC连接数据库

JDBC（Java Database Connectivity）是Java访问数据库的标准接口。以下是使用JDBC连接数据库的基本步骤：

  1. 加载数据库驱动
  2. 创建数据库连接
  3. 创建Statement对象
  4. 执行SQL语句
  5. 处理结果集
  6. 关闭连接资源

示例代码

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class JdbcExample {
    public static void main(String[] args) {
        try {
            // 1. 加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");

            // 2. 创建数据库连接
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "root", "password");

            // 3. 创建Statement对象
            Statement stmt = conn.createStatement();

            // 4. 执行SQL语句
            ResultSet rs = stmt.executeQuery("SELECT * FROM users");

            // 5. 处理结果集
            while (rs.next()) {
                System.out.println(rs.getString("name") + "\t" + rs.getInt("age"));
            }

            // 6. 关闭连接资源
            rs.close();
            stmt.close();
            conn.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ORM框架Hibernate简介

Hibernate是一个持久层框架，提供透明的数据库访问，简化了数据库操作。

配置Hibernate

  1. 创建hibernate.cfg.xml：
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mydb</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.current_session_context_class">thread</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
    </session-factory>
</hibernate-configuration>
  1. 创建User.java：
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private int age;

    public User() {}

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

    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 int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
  1. 使用Hibernate进行数据库操作：
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import java.util.List;

public class HibernateExample {
    public static void main(String[] args) {
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction tx = session.beginTransaction();

        // 插入数据
        User user = new User("张三", 25);
        session.save(user);
        tx.commit();

        // 查询数据
        List<User> users = session.createQuery("FROM User").list();
        for (User u : users) {
            System.out.println(u.getName() + "\t" + u.getAge());
        }

        tx.commit();
        session.close();
        sessionFactory.close();
    }
}

实战：CRUD操作

插入数据

public void insertUser(User user) {
    Session session = sessionFactory.openSession();
    Transaction tx = session.beginTransaction();
    session.save(user);
    tx.commit();
    session.close();
}

查询数据

public List<User> getAllUsers() {
    Session session = sessionFactory.openSession();
    List<User> users = session.createQuery("FROM User").list();
    session.close();
    return users;
}

更新数据

public void updateUser(User user) {
    Session session = sessionFactory.openSession();
    Transaction tx = session.beginTransaction();
    session.update(user);
    tx.commit();
    session.close();
}

删除数据

public void deleteUser(User user) {
    Session session = sessionFactory.openSession();
    Transaction tx = session.beginTransaction();
    session.delete(user);
    tx.commit();
    session.close();
}
常见后端开发技术点

RESTful API设计与实现

RESTful API是一种基于HTTP协议的API设计风格，用于构建可扩展和易维护的Web应用。

示例代码

使用Spring Boot实现RESTful API

  1. 创建User.java实体类：
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private int age;

    // 构造器、getter和setter省略
}
  1. 创建UserController.java：
import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {
    // 查询所有用户
    @GetMapping
    public List<User> getAllUsers() {
        // 实际返回User列表
        return List.of(new User(1, "张三", 25), new User(2, "李四", 30));
    }

    // 根据ID获取单个用户
    @GetMapping("/{id}")
    public User getUserById(@PathVariable int id) {
        // 实际返回User对象
        return new User(id, "张三", 25);
    }

    // 创建用户
    @PostMapping
    public User createUser(@RequestBody User user) {
        // 实际创建User对象
        return new User(1, "张三", 25);
    }

    // 更新用户
    @PutMapping("/{id}")
    public User updateUser(@PathVariable int id, @RequestBody User user) {
        // 实际更新User对象
        return new User(id, "张三", 25);
    }

    // 删除用户
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable int id) {
        // 实际删除User对象
    }
}

JSON和XML数据交换

JSON（JavaScript Object Notation）和XML（eXtensible Markup Language）是两种常用的数据交换格式。

JSON示例

import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonExample {
    public static void main(String[] args) throws Exception {
        // 创建对象
        User user = new User(1, "张三", 25);

        // 转换为JSON字符串
        ObjectMapper mapper = new ObjectMapper();
        String jsonString = mapper.writeValueAsString(user);
        System.out.println(jsonString);  // 输出: {"id":1,"name":"张三","age":25}
    }
}

XML示例

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;

public class XmlExample {
    public static void main(String[] args) throws JAXBException {
        // 创建对象
        User user = new User(1, "张三", 25);

        // 转换为XML字符串
        JAXBContext context = JAXBContext.newInstance(User.class);
        Marshaller marshaller = context.createMarshaller();
        marshaller.marshal(user, System.out);  // 输出: <?xml version="1.0" encoding="UTF-8" standalone="yes"?><user><id>1</id><name>张三</name><age>25</age></user>
    }
}

身份验证与授权

身份验证（Authentication）是验证用户身份的过程，授权（Authorization）是确定用户权限的过程。

示例代码

使用Spring Security实现身份验证和授权

  1. 在pom.xml中添加Spring Security依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactid>
</dependency>
  1. 创建SecurityConfig.java：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/user/**").hasRole("USER")
                .anyRequest().authenticated()
            .and()
                .formLogin()
                .loginPage("/login")
                .permitAll()
            .and()
                .logout()
                .permitAll();
    }

    @Override
    @Bean
    public UserDetailsService userDetailsService() {
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
        manager.createUser(User.withDefaultPasswordEncoder()
            .username("user")
            .password("password")
            .roles("USER")
            .build());
        manager.createUser(User.withDefaultPasswordEncoder()
            .username("admin")
            .password("password")
            .roles("ADMIN")
            .build());
        return manager;
    }
}
实战项目：构建简单的后端应用

设计数据库模型

假设我们构建一个简单的用户管理系统，需要设计以下数据库模型：

  1. User表

    • id：用户ID
    • name：用户名
    • age：年龄

  2. Role表

    • id：角色ID
    • role_name：角色名称

  3. User_Role表

    • user_id：用户ID
    • role_id：角色ID

示例SQL

CREATE TABLE `User` (
    `id` INT PRIMARY KEY AUTO_INCREMENT,
    `name` VARCHAR(255) NOT NULL,
    `age` INT NOT NULL
);

CREATE TABLE `Role` (
    `id` INT PRIMARY KEY AUTO_INCREMENT,
    `role_name` VARCHAR(255) NOT NULL
);

CREATE TABLE `User_Role` (
    `user_id` INT NOT NULL,
    `role_id` INT NOT NULL,
    PRIMARY KEY (`user_id`, `role_id`),
    FOREIGN KEY (`user_id`) REFERENCES `User`(`id`),
    FOREIGN KEY (`role_id`) REFERENCES `Role`(`id`)
);

开发REST API

基于设计的数据库模型，开发相应的REST API。

  1. 创建User.java实体类：
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import java.util.List;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private int age;

    @ManyToMany
    private List<Role> roles;

    // 构造器、getter和setter省略
}
  1. 创建Role.java实体类：
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import java.util.List;

@Entity
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String roleName;

    @ManyToMany(mappedBy = "roles")
    private List<User> users;

    // 构造器、getter和setter省略
}
  1. 创建UserController.java：
import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {
    // 查询所有用户
    @GetMapping
    public List<User> getAllUsers() {
        // 返回User列表
        return List.of(new User(1, "张三", 25));
    }

    // 根据ID获取单个用户
    @GetMapping("/{id}")
    public User getUserById(@PathVariable int id) {
        // 返回User对象
        return new User(id, "张三", 25);
    }

    // 创建用户
    @PostMapping
    public User createUser(@RequestBody User user) {
        // 创建User对象
        return new User(1, "张三", 25);
    }

    // 更新用户
    @PutMapping("/{id}")
    public User updateUser(@PathVariable int id, @RequestBody User user) {
        // 更新User对象
        return new User(id, "张三", 25);
    }

    // 删除用户
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable int id) {
        // 删除User对象
    }
}

测试与部署

测试API

使用Postman或curl工具进行API测试。

# 查询所有用户
curl -X GET http://localhost:8080/api/users

# 查询单个用户
curl -X GET http://localhost:8080/api/users/1

# 创建用户
curl -X POST http://localhost:8080/api/users -d '{"name": "李四", "age": 30}' -H "Content-Type: application/json"

# 更新用户
curl -X PUT http://localhost:8080/api/users/1 -d '{"name": "张三", "age": 26}' -H "Content-Type: application/json"

# 删除用户
curl -X DELETE http://localhost:8080/api/users/1

部署应用

部署Java后端应用可以通过打包为WAR文件或JAR文件，然后部署到Tomcat或Spring Boot应用服务器。

  1. 打包项目：
mvn clean package
  1. 部署到Tomcat：
cp target/myapp.war /path/to/tomcat/webapps/
  1. 部署到Spring Boot应用服务器：
java -jar target/myapp.jar

以上是构建Java后端应用的基本步骤和示例代码。通过这些步骤，可以快速入门Java后端开发，为后续的项目开发打下坚实的基础。

點擊查看更多內容
為 TA 點贊

若覺得本文不錯，就分享一下吧！

評論

作者其他優質文章

正在加載中
  • 推薦
  • 評論
  • 收藏
  • 共同學習，寫下你的評論
感謝您的支持，我會繼續努力的～
掃碼打賞，你說多少就多少
贊賞金額會直接到老師賬戶
支付方式
打開微信掃一掃，即可進行掃碼打賞哦
今天注冊有機會得

100積分直接送

付費專欄免費學

大額優惠券免費領

立即參與 放棄機會
微信客服

購課補貼
聯系客服咨詢優惠詳情

 幫助反饋 APP下載

慕課網APP
您的移動學習伙伴

 公眾號

掃描二維碼
關注慕課網微信公眾號

舉報

0/150
提交
取消