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

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

Java醫療系統教程：新手入門詳解

標簽：
Java
概述

本文提供了详细的指导，帮助读者学习如何使用Java开发医疗系统。从Java基础回顾到医疗系统的需求分析、数据库设计、前端界面设计和后端业务逻辑实现，每一步都详尽阐述。此外，还介绍了系统的测试与部署流程，确保开发者能够全面掌握Java医疗系统开发的全过程。文中涵盖了关键词java医疗系统教程的所有必要内容。

1. Java基础回顾

Java语言简介

Java是一种广泛使用的面向对象编程语言，由Sun Microsystems（现为Oracle公司）于1995年推出。Java的特性包括跨平台性、面向对象、自动内存管理和安全性等。Java程序在任何安装了Java虚拟机（JVM）的操作系统上都能运行，这使得它成为开发跨平台应用程序的理想选择。Java语言最初被设计用于嵌入到智能家电中的小装置，后来逐渐发展成为企业级应用开发的主流语言之一。

Java开发环境搭建

安装Java开发工具包（JDK）

首先，需要安装Java开发工具包（JDK），它包含了编译、运行Java程序所需的所有工具和库文件。可以从Oracle官方网站下载最新版本的JDK。按照官方指南进行安装过程，确保在安装过程中选择添加环境变量（如Java的bin目录路径到系统PATH变量中）。

安装集成开发环境（IDE）

对于初学者来说，推荐使用Eclipse或IntelliJ IDEA这类集成开发环境（IDE），因为它们提供了代码编辑、调试、版本控制等功能，使得软件开发更加高效。下载并安装你喜欢的IDE，建议选择Eclipse和IntelliJ IDEA，因为它们都有丰富的插件和强大的代码提示功能，非常适合Java开发。

配置IDE

配置IDE以确保其能够正确识别Java环境。在Eclipse中，可以通过菜单中的“Preferences”选项进入设置界面，然后找到“Java”下的“Installed JREs”，点击“Add”按钮添加新的运行时环境，选择之前安装的JDK路径。这样Eclipse就可以识别并使用该Java环境了。

在IntelliJ IDEA中，可以通过“File”菜单选择“Project Structure”，然后在“SDKs”选项卡中添加新的JDK路径。完成后，IDE会自动识别并使用该Java环境。

Java基础语法速览

变量与类型

在Java中，所有变量都有类型，这决定了变量可以存储的数据类型。常见的基本数据类型包括int（整型）、double（浮点型）、boolean（布尔型）和char（字符型）。下面是一个简单的变量声明和赋值的例子：

public class VariableExample {
    public static void main(String[] args) {
        int age = 25;         // 整型变量
        double height = 180.5;  // 浮点型变量
        boolean married = false; // 布尔型变量
        char initial = 'A';      // 字符型变量

        System.out.println("Age: " + age);
        System.out.println("Height: " + height);
        System.out.println("Married: " + married);
        System.out.println("Initial: " + initial);
    }
}

控制结构

Java提供了多种控制结构，包括条件语句（如if-else）、循环语句（如for、while）。这些控制结构帮助程序根据不同的条件执行不同的逻辑。下面的例子展示了if-else和for循环的基本用法：

public class ControlStructureExample {
    public static void main(String[] args) {
        int num = 10;

        if (num > 0) {
            System.out.println("Number is positive.");
        } else {
            System.out.println("Number is non-positive.");
        }

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

函数与方法

在Java中，函数被称为方法，它们是由关键字public、private（访问修饰符）、返回类型、方法名和参数列表组成。方法定义了可以被类或对象调用的代码块。下面是一个简单的示例，展示了如何定义和调用方法：

public class MethodExample {
    public static void main(String[] args) {
        int result = addNumbers(5, 10);
        System.out.println("Result: " + result);
    }

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

在上述代码中，addNumbers方法接收两个整数参数，并返回它们的和。main方法调用了addNumbers方法并将结果输出到控制台。

面向对象编程

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;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public 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("Alice", 28);
        person.introduce();
        person.setName("Alicia");
        person.setAge(29);
        person.introduce();
    }
}

在上面的代码中，Person类具有两个私有属性name和age，以及公共方法getName()、setAge(int)和introduce()。Main类中创建了一个Person对象并调用了其方法。这个例子展示了封装的概念，即数据和操作数据的方法被封装在一个类中，这样可以隐藏内部实现细节并提供对外界安全的接口。

2. 医疗系统需求分析

医疗系统的基本功能

医疗系统通常包括患者信息管理、病历记录、预约挂号、医疗费用结算等功能。具体来说，系统需要提供以下功能：

  • 患者信息管理：包括患者基本信息（如姓名、年龄、性别）、联系方式、地址等的录入、查询和修改。
  • 病历记录：记录患者的病史、诊断信息、治疗方案和用药情况等。
  • 预约挂号：提供在线预约挂号服务，方便患者选择就诊时间。
  • 医疗费用结算：记录患者的医疗费用，支持费用查询和结算操作。

用户需求分析

医疗系统用户主要包括患者、医生和管理员三类角色，每类用户的需求不同：

  • 患者：期望能够方便地查询自己的病历记录、预约挂号、查看医疗费用等。
  • 医生：需要访问患者的病历记录，进行诊断和开药，同时能够查询费用结算情况。
  • 管理员：负责管理整个系统的运行，包括用户管理、数据备份、系统维护等。

系统架构设计基础

系统架构设计应当遵循模块化、层次化的原则，确保系统的可扩展性和可维护性。常见的系统架构模式包括三层架构（即表示层、业务逻辑层和数据访问层）和微服务架构。

  • 三层架构：将系统划分为表示层（与用户交互）、业务逻辑层（处理业务规则）和数据访问层（操作数据库）。这种架构模式有助于清晰地分离职责，使得每层相对独立，易于维护。

  • 微服务架构：将整个系统拆分成多个小的服务单元，每个服务单元负责独立的功能模块，通过API接口进行通信。这种架构模式提高了系统的可伸缩性和灵活性，但也增加了服务间的协作复杂度。

3. 数据库设计与操作

数据库选择与安装

对于医疗系统来说，推荐使用开源的关系型数据库MySQL，因为它具有良好的性能、稳定性和广泛的社区支持。MySQL可通过官方网站下载并按照其安装指南进行安装，确保在安装过程中选择合适的配置选项。

数据库设计原则

数据库设计应遵循一定的原则，如第一范式、第二范式、第三范式等。这些范式旨在消除数据冗余、保证数据的一致性和完整性。通常的做法是：

  1. 规范化：通过分解表来消除数据冗余，使每个表只存储一个主题的信息。
  2. 外键约束：使用外键确保数据的一致性，例如一个表中的某个字段引用另一个表中的主键。
  3. 索引优化：合理使用索引来提高查询效率，避免对大量数据进行全表扫描。
  4. 数据备份：定期备份数据库以防止数据丢失，使用备份策略来确保关键数据的安全性。

JDBC连接数据库

JDBC（Java Database Connectivity）是Java程序访问数据库的标准API。下面是一个简单的JDBC连接MySQL数据库的示例：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DatabaseConnectionExample {
    public static void main(String[] args) {
        Connection connection = null;

        try {
            // 加载驱动程序
            Class.forName("com.mysql.cj.jdbc.Driver");

            // 建立连接
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase", "root", "password");

            // 输出连接信息
            System.out.println("Connected to database!");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭连接
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

此代码段展示了如何加载MySQL驱动程序，使用DriverManager.getConnection方法建立连接，并处理可能出现的异常和资源释放。

CRUD操作实现

CRUD操作是指创建（Create）、读取（Read）、更新（Update）和删除（Delete）操作，下面展示了如何使用JDBC实现这些基本操作：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class CRUDOperations {
    private static final String CREATE_TABLE = "CREATE TABLE patients (id INT PRIMARY KEY, name VARCHAR(255), age INT)";
    private static final String INSERT_PATIENT = "INSERT INTO patients (name, age) VALUES (?, ?)";
    private static final String SELECT_PATIENT = "SELECT * FROM patients WHERE id = ?";
    private static final String UPDATE_PATIENT = "UPDATE patients SET name = ?, age = ? WHERE id = ?";
    private static final String DELETE_PATIENT = "DELETE FROM patients WHERE id = ?";

    public static void main(String[] args) {
        Connection connection = null;

        try {
            // 建立连接
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase", "root", "password");

            // 创建表
            createTable(connection);

            // 插入数据
            insertPatient(connection, "Alice", 28);

            // 查询数据
            ResultSet resultSet = selectPatient(connection, 1);
            while (resultSet.next()) {
                System.out.println("Name: " + resultSet.getString("name"));
                System.out.println("Age: " + resultSet.getInt("age"));
            }

            // 更新数据
            updatePatient(connection, 1, "Alicia", 29);

            // 删除数据
            deletePatient(connection, 1);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭连接
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static void createTable(Connection connection) throws SQLException {
        try (PreparedStatement stmt = connection.prepareStatement(CREATE_TABLE)) {
            stmt.executeUpdate();
        }
    }

    private static void insertPatient(Connection connection, String name, int age) throws SQLException {
        try (PreparedStatement stmt = connection.prepareStatement(INSERT_PATIENT)) {
            stmt.setString(1, name);
            stmt.setInt(2, age);
            stmt.executeUpdate();
        }
    }

    private static ResultSet selectPatient(Connection connection, int id) throws SQLException {
        try (PreparedStatement stmt = connection.prepareStatement(SELECT_PATIENT)) {
            stmt.setInt(1, id);
            return stmt.executeQuery();
        }
    }

    private static void updatePatient(Connection connection, int id, String name, int age) throws SQLException {
        try (PreparedStatement stmt = connection.prepareStatement(UPDATE_PATIENT)) {
            stmt.setString(1, name);
            stmt.setInt(2, age);
            stmt.setInt(3, id);
            stmt.executeUpdate();
        }
    }

    private static void deletePatient(Connection connection, int id) throws SQLException {
        try (PreparedStatement stmt = connection.prepareStatement(DELETE_PATIENT)) {
            stmt.setInt(1, id);
            stmt.executeUpdate();
        }
    }
}

以上代码展示了如何创建一个名为patients的表，插入、查询、更新和删除数据的示例。

4. 前端界面设计

常见的前端开发框架介绍

前端开发框架是用于构建用户界面的工具和技术，常见的有Angular、React和Vue.js。本教程主要以Vue.js、Angular和React为例子，它们简单易学，适合快速开发动态用户界面。Vue.js采用声明式语法，通过简单的HTML标记加上绑定的变量来实现复杂的交互效果；Angular和React则提供了强大的组件化开发能力，能够构建复杂且高效的动态Web应用。

基本界面元素设计

使用Vue.js可以快速构建动态用户界面。下面是一个简单的Vue.js示例，展示了如何创建一个包含标题、输入框和按钮的基本界面：

<!DOCTYPE html>
<html>
<head>
    <title>Vue.js Example</title>
    <script class="lazyload" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAANSURBVBhXYzh8+PB/AAffA0nNPuCLAAAAAElFTkSuQmCC" data-original="https://cdn.jsdelivr.net/npm/vue@2"></script>
</head>
<body>
    <div id="app">
        <h1>{{ title }}</h1>
        <p>Enter your name:</p>
        <input type="text" v-model="name" placeholder="Your name">
        <button v-on:click="sayHello">Say Hello</button>
    </div>

    <script>
        var app = new Vue({
            el: '#app',
            data: {
                title: 'Welcome to Vue.js',
                name: ''
            },
            methods: {
                sayHello: function() {
                    alert('Hello, ' + this.name + '!');
                }
            }
        });
    </script>
</body>
</html>

使用Angular可以快速构建动态用户界面。下面是一个简单的Angular示例，展示了如何创建一个包含标题、输入框和按钮的基本界面：

<!DOCTYPE html>
<html>
<head>
    <title>Angular Example</title>
    <script class="lazyload" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAANSURBVBhXYzh8+PB/AAffA0nNPuCLAAAAAElFTkSuQmCC" data-original="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.8.2/angular.min.js"></script>
</head>
<body ng-app="myApp">
    <div ng-controller="HelloController">
        <h1>{{ title }}</h1>
        <p>Enter your name:</p>
        <input type="text" ng-model="name" placeholder="Your name">
        <button ng-click="sayHello()">Say Hello</button>
    </div>

    <script>
        var app = angular.module('myApp', []);
        app.controller('HelloController', function($scope) {
            $scope.title = 'Welcome to Angular';
            $scope.sayHello = function() {
                alert('Hello, ' + $scope.name + '!');
            }
        });
    </script>
</body>
</html>

使用React可以快速构建动态用户界面。下面是一个简单的React示例，展示了如何创建一个包含标题、输入框和按钮的基本界面：

<!DOCTYPE html>
<html>
<head>
    <title>React Example</title>
    <script class="lazyload" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAANSURBVBhXYzh8+PB/AAffA0nNPuCLAAAAAElFTkSuQmCC" data-original="https://unpkg.com/react@17/umd/react.development.js"></script>
    <script class="lazyload" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAANSURBVBhXYzh8+PB/AAffA0nNPuCLAAAAAElFTkSuQmCC" data-original="https://unpkg.com/react-dom@17/umd/react-dom.development.js"></script>
    <script class="lazyload" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAANSURBVBhXYzh8+PB/AAffA0nNPuCLAAAAAElFTkSuQmCC" data-original="https://unpkg.com/babel-standalone@6/babel.min.js"></script>
</head>
<body>
    <div id="root"></div>

    <script type="text/babel">
        function Hello(props) {
            function sayHello() {
                alert('Hello, ' + props.name + '!');
            }
            return (
                <div>
                    <h1>{props.title}</h1>
                    <p>Enter your name:</p>
                    <input type="text" onChange={(e) => props.setName(e.target.value)} placeholder="Your name" />
                    <button onClick={sayHello}>Say Hello</button>
                </div>
            );
        }

        class App extends React.Component {
            constructor(props) {
                super(props);
                this.state = { name: '' };
                this.setName = this.setName.bind(this);
            }

            setName(name) {
                this.setState({ name });
            }

            render() {
                return <Hello title="Welcome to React" name={this.state.name} setName={this.setName} />;
            }
        }

        ReactDOM.render(<App />, document.getElementById('root'));
    </script>
</body>
</html>

界面交互设计

界面交互设计是确保用户能够以直观的方式操作界面的关键。例如，当用户点击按钮时，可以触发某些操作，如发送请求到服务器或更新界面的某些部分。以下是一个简单的交互示例，展示了如何根据用户的输入动态变化界面内容：

<!DOCTYPE html>
<html>
<head>
    <title>Vue.js Example</title>
    <script class="lazyload" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAANSURBVBhXYzh8+PB/AAffA0nNPuCLAAAAAElFTkSuQmCC" data-original="https://cdn.jsdelivr.net/npm/vue@2"></script>
</head>
<body>
    <div id="app">
        <p>{{ message }}</p>
        <input type="text" v-model="inputText">
        <button v-on:click="changeMessage">Change Message</button>
    </div>

    <script>
        var app = new Vue({
            el: '#app',
            data: {
                message: 'Hello, Vue.js!',
                inputText: ''
            },
            methods: {
                changeMessage: function() {
                    this.message = this.inputText;
                }
            }
        });
    </script>
</body>
</html>

5. 后端业务逻辑实现

业务逻辑设计

后端业务逻辑是指处理应用程序的核心业务规则和流程。对于医疗系统，业务逻辑包括患者信息管理、病历记录、预约挂号等。下面以患者信息管理为例，展示如何设计和实现相关的业务逻辑。

控制器与服务层实现

在三层架构中，控制器负责处理HTTP请求，服务层负责处理具体的业务逻辑。控制器通常会调用服务层的方法来执行业务逻辑，并将结果返回给客户端。下面是一个简单的患者信息管理的控制器和服务层实现示例：

// 控制器
import org.springframework.web.bind.annotation.*;

@RestController
public class PatientController {
    private final PatientService patientService;

    public PatientController(PatientService patientService) {
        this.patientService = patientService;
    }

    @PostMapping("/patients")
    public Patient createPatient(@RequestBody Patient patient) {
        return patientService.createPatient(patient);
    }

    @GetMapping("/patients/{id}")
    public Patient getPatient(@PathVariable Long id) {
        return patientService.getPatientById(id);
    }

    @PutMapping("/patients/{id}")
    public Patient updatePatient(@PathVariable Long id, @RequestBody Patient patient) {
        patient.setId(id);
        return patientService.updatePatient(patient);
    }

    @DeleteMapping("/patients/{id}")
    public void deletePatient(@PathVariable Long id) {
        patientService.deletePatient(id);
    }
}

// 服务层
import org.springframework.stereotype.Service;

@Service
public class PatientService {
    private final PatientRepository patientRepository;

    public PatientService(PatientRepository patientRepository) {
        this.patientRepository = patientRepository;
    }

    public Patient createPatient(Patient patient) {
        return patientRepository.save(patient);
    }

    public Patient getPatientById(Long id) {
        return patientRepository.findById(id)
                .orElseThrow(() -> new PatientNotFoundException(id));
    }

    public Patient updatePatient(Patient patient) {
        return patientRepository.save(patient);
    }

    public void deletePatient(Long id) {
        patientRepository.deleteById(id);
    }
}

异常处理与日志记录

异常处理是确保应用程序健壮性和可靠性的重要环节。在Spring框架中，可以通过@ControllerAdvice和@ExceptionHandler注解来集中处理异常。以下是一个简单的异常处理器示例：

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;

@ControllerAdvice
public class CustomExceptionHandler {
    @ExceptionHandler(PatientNotFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public ResponseEntity<String> handlePatientNotFoundException(PatientNotFoundException ex) {
        return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
    }
}

日志记录是跟踪应用程序执行和调试的重要手段。在Spring Boot应用中，可以通过@Slf4j注解来方便地使用slf4j日志记录框架。以下是一个简单的日志记录示例：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class LoggingExampleController {
    private static final Logger logger = LoggerFactory.getLogger(LoggingExampleController.class);

    @GetMapping("/log")
    public String logMessage() {
        logger.info("Logging an info level message.");
        return "Logged an info level message.";
    }
}

6. 测试与部署

单元测试与集成测试

单元测试是对应用程序中最小可测试组件（如函数或方法）进行测试的过程，它有助于确保代码的正确性和质量。Spring Boot提供了内置的测试支持，可以通过@SpringBootTest注解来编写单元测试。

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
public class PatientServiceTest {
    @Autowired
    private PatientService patientService;

    @Test
    public void testCreatePatient() {
        Patient patient = new Patient(1L, "Alice", 28);
        Patient createdPatient = patientService.createPatient(patient);
        assertEquals("Alice", createdPatient.getName());
        assertEquals(28, createdPatient.getAge());
    }
}

集成测试则验证不同模块之间的协作。Spring Boot提供了@IntegrationTest注解，可以用来编写更复杂的测试案例。

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.ResponseEntity;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class PatientControllerIntegrationTest {
    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    public void testCreatePatient() {
        Patient patient = new Patient(null, "Alice", 28);
        ResponseEntity<String> response = restTemplate.postForEntity("/patients", patient, String.class);
        assertEquals(HttpStatus.CREATED, response.getStatusCode());
    }
}

系统部署流程

部署流程通常包括打包应用、配置服务器环境和启动应用等步骤。Spring Boot应用可以通过Maven或Gradle构建工具打包成可执行的JAR文件，然后部署到服务器上。

mvn clean install

部署到服务器后，可以通过以下命令启动应用：

java -jar target/myapp.jar

常见问题及解决方案

在实际部署过程中，可能会遇到各种问题，如端口冲突、环境配置错误等。以下是一些常见的解决方案：

端口冲突

如果应用启动时出现端口冲突错误，可以通过设置server.port属性来更改应用监听的端口。

java -jar target/myapp.jar --server.port=8081
环境配置错误

确保所有环境变量和配置文件已经正确设置，特别是数据库连接信息、服务器地址等。

spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.username=root
spring.datasource.password=password
點擊查看更多內容
為 TA 點贊

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

評論

作者其他優質文章

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

100積分直接送

付費專欄免費學

大額優惠券免費領

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

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

 幫助反饋 APP下載

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

 公眾號

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

舉報

0/150
提交
取消