首页手记 Java全栈开发入门教程

Java全栈开发入门教程

标签：

Java

概述

本文详细介绍了Java全栈开发的基础知识，从Java基础语法入门到面向对象编程，再到Web开发和数据库操作，涵盖了Java全栈开发的各个方面。此外，还介绍了前端技术的基础知识，包括HTML、CSS、JavaScript以及Vue.js框架。通过实战项目练习，进一步加深了对Java全栈开发的理解和应用。

Java基础语法入门

变量与数据类型

在Java中，变量是一种用于存储数据的标识符。这些数据可以是数字、文本、布尔值等不同类型。Java是一种静态类型语言，这意味着变量在声明时就必须指定其类型。以下是Java中的几种基本数据类型：

byte: 一个8位有符号字节，范围从-128到127。
short: 一个16位有符号短整数，范围从-32768到32767。
int: 一个32位有符号整数，范围从-2147483648到2147483647。
long: 一个64位有符号长整数，范围从-9223372036854775808到9223372036854775807。
float: 一个32位单精度浮点数。
double: 一个64位双精度浮点数。
char: 一个16位Unicode字符。
boolean: 一个表示真或假的布尔值。

示例代码：

public class DataTypesExample {
    public static void main(String[] args) {
        byte b = 100;
        short s = 1000;
        int i = 10000;
        long l = 1000000L;
        float f = 23.5f;
        double d = 123.456;
        char c = 'A';
        boolean bool = true;

        System.out.println("byte: " + b);
        System.out.println("short: " + s);
        System.out.println("int: " + i);
        System.out.println("long: " + l);
        System.out.println("float: " + f);
        System.out.println("double: " + d);
        System.out.println("char: " + c);
        System.out.println("boolean: " + bool);
    }
}

控制结构

在Java中，控制结构用于控制程序的执行流程。这些结构包括条件语句（如if, switch）和循环语句（如for, while）。

条件语句

if语句用于根据条件执行代码块。switch语句则用于根据变量的值执行不同的代码块。

示例代码：

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

        if (num > 0) {
            System.out.println("num is positive");
        } else if (num < 0) {
            System.out.println("num is negative");
        } else {
            System.out.println("num is zero");
        }

        String fruit = "apple";
        switch (fruit) {
            case "apple":
                System.out.println("It's an apple");
                break;
            case "banana":
                System.out.println("It's a banana");
                break;
            default:
                System.out.println("Unknown fruit");
        }
    }
}

循环语句

for循环用于遍历一系列数据，而while循环则根据条件重复执行代码块。

示例代码：

public class LoopStatements {
    public static void main(String[] args) {
        // 使用for循环打印数字1到5
        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
        }

        // 使用while循环打印数字1到5
        int j = 1;
        while (j <= 5) {
            System.out.println(j);
            j++;
        }

        // 使用do-while循环打印数字1到5
        int k = 1;
        do {
            System.out.println(k);
            k++;
        } while (k <= 5);
    }
}

函数与方法

在Java中，方法是用于执行特定任务的代码块。方法可以接受输入（参数），并根据需要返回一个值。

示例代码：

public class FunctionsAndMethods {
    public static void main(String[] args) {
        int result = addNumbers(10, 20);
        System.out.println(result);

        int max = findMax(15, 25, 35);
        System.out.println(max);
    }

    // 定义一个方法，返回两个数的和
    public static int addNumbers(int a, int b) {
        return a + b;
    }

    // 定义一个方法，返回三个数中的最大值
    public static int findMax(int a, int b, int c) {
        return Math.max(a, Math.max(b, c));
    }
}

Java面向对象编程

类与对象

在面向对象编程中，类是一种蓝图，描述了对象的属性和行为。对象是类的实例，具有类定义的属性和方法。

示例代码：

public class Car {
    // 属性
    String brand;
    String model;
    int year;

    // 构造方法
    public Car(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
    }

    // 方法
    public void displayInfo() {
        System.out.println("Brand: " + brand + ", Model: " + model + ", Year: " + year);
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("Toyota", "Corolla", 2020);
        myCar.displayInfo();
    }
}

继承与多态

继承允许一个类继承另一个类的属性和方法。多态允许子类覆盖父类的方法，以提供特定于子类的行为。

示例代码：

public class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound();

        Animal dog = new Dog();
        dog.makeSound();

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

接口与抽象类

接口定义了一组方法签名，但不提供实现。抽象类可以包含方法实现和抽象方法。

示例代码：

public interface Flyable {
    void fly();
}

public class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("Bird flies");
    }
}

public abstract class Vehicle {
    public abstract void move();
}

public class Car extends Vehicle {
    @Override
    public void move() {
        System.out.println("Car moves on the road");
    }
}

public class Main {
    public static void main(String[] args) {
        Bird bird = new Bird();
        bird.fly();

        Car car = new Car();
        car.move();
    }
}

Java Web开发基础

Servlet与JSP

Servlet是运行在服务器上的Java程序，用于生成动态内容。JSP（JavaServer Pages）是一种动态网页技术，它允许将Java代码嵌入到HTML中。

示例代码：

// ServletExample.java
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;

public class ServletExample extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<html>");
        out.println("<body>");
        out.println("<h1>Hello, Servlet!</h1>");
        out.println("</body>");
        out.println("</html>");
    }
}

// index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Simple JSP Page</title>
</head>
<body>
<h1>Hello, JSP!</h1>
<%
    out.print("Current date and time: " + new java.util.Date());
%>
</body>
</html>

Java EE框架简介

Java EE（Java Platform, Enterprise Edition）是Java技术的扩展，用于开发、部署和运行企业级应用程序。Java EE应用通常依赖于EJB（Enterprise JavaBeans）、JPA（Java Persistence API）、JSF（JavaServer Faces）等技术。

Spring框架入门

Spring是一个流行的Java框架，提供了一系列功能，包括依赖注入（DI）、面向切面编程（AOP）、数据访问、Web开发等。

示例代码：

// AppConfig.java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
    @Bean
    public MessageService messageService() {
        return new MessageServiceImpl();
    }
}

// MessageService.java
public interface MessageService {
    String getMessage();
}

// MessageServiceImpl.java
public class MessageServiceImpl implements MessageService {
    @Override
    public String getMessage() {
        return "Hello, Spring!";
    }
}

// MainApp.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MessageService messageService = context.getBean(MessageService.class);
        System.out.println(messageService.getMessage());
    }
}

数据库操作基础

JDBC编程

JDBC（Java Database Connectivity）是Java中访问数据库的标准API。通过JDBC，可以执行SQL语句和处理结果集。

示例代码：

import java.sql.*;

public class JDBCExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydb";
        String user = "root";
        String password = "password";

        try {
            Connection connection = DriverManager.getConnection(url, user, password);
            Statement statement = connection.createStatement();
            ResultSet resultSet = statement.executeQuery("SELECT * FROM users");

            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                System.out.println("ID: " + id + ", Name: " + name);
            }

            resultSet.close();
            statement.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

ORM框架Hibernate入门

Hibernate是一个流行的ORM（对象关系映射）框架，它允许Java对象与数据库表之间的映射。通过使用Hibernate，可以避免编写大量的SQL语句。

示例代码：

// User.java
import javax.persistence.*;

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

    // Getter and Setter
}

// UserDAO.java
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class UserDAO {
    private SessionFactory sessionFactory;

    public UserDAO() {
        sessionFactory = new Configuration().configure().buildSessionFactory();
    }

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

    public void listUsers() {
        Session session = sessionFactory.openSession();
        List<User> users = session.createQuery("FROM User").list();
        for (User user : users) {
            System.out.println("ID: " + user.getId() + ", Name: " + user.getName());
        }
        session.close();
    }
}

// MainApp.java
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class MainApp {
    public static void main(String[] args) {
        UserDAO userDAO = new UserDAO();
        User user = new User();
        user.setName("John Doe");
        userDAO.addUser(user);
        userDAO.listUsers();
    }
}

前端技术简介

HTML与CSS基础

HTML（HyperText Markup Language）用于定义网页结构，CSS（Cascading Style Sheets）用于控制网页样式。

示例代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>HTML & CSS Example</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background-color: #f4f4f9;
            margin: 0;
            padding: 0;
        }
        header {
            background-color: #007BFF;
            color: white;
            padding: 10px;
            text-align: center;
        }
        main {
            padding: 20px;
        }
        footer {
            background-color: #333;
            color: white;
            text-align: center;
            padding: 10px;
        }
    </style>
</head>
<body>
    <header>
        <h1>My Website</h1>
    </header>
    <main>
        <p>Welcome to my website!</p>
        <p>This is a paragraph.</p>
    </main>
    <footer>
        <p>Copyright © 2023</p>
    </footer>
</body>
</html>

JavaScript入门

JavaScript是一种用于Web开发的脚本语言，它可以添加交互性和动态内容到网页中。

示例代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>JavaScript Example</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background-color: #f4f4f9;
            margin: 0;
            padding: 0;
        }
        header {
            background-color: #007BFF;
            color: white;
            padding: 10px;
            text-align: center;
        }
        main {
            padding: 20px;
        }
        footer {
            background-color: #333;
            color: white;
            text-align: center;
            padding: 10px;
        }
    </style>
</head>
<body>
    <header>
        <h1>My Website</h1>
    </header>
    <main>
        <p id="greeting">Hello, World!</p>
        <button onclick="changeGreeting()">Change Greeting</button>
    </main>
    <footer>
        <p>Copyright © 2023</p>
    </footer>

    <script>
        function changeGreeting() {
            document.getElementById("greeting").innerText = "Hello, JavaScript!";
        }
    </script>
</body>
</html>

前端框架Vue.js基础

Vue.js是一个用于构建用户界面的渐进式框架，它允许你使用声明性模板语法构建动态UI。

示例代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <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>
    <style>
        body {
            font-family: Arial, sans-serif;
            background-color: #f4f4f9;
            margin: 0;
            padding: 0;
        }
        header {
            background-color: #007BFF;
            color: white;
            padding: 10px;
            text-align: center;
        }
        main {
            padding: 20px;
        }
        footer {
            background-color: #333;
            color: white;
            text-align: center;
            padding: 10px;
        }
    </style>
</head>
<body>
    <header>
        <h1>My Website</h1>
    </header>
    <main>
        <div id="app">
            <p>{{ message }}</p>
            <button @click="changeMessage">Change Message</button>
        </div>
    </main>
    <footer>
        <p>Copyright © 2023</p>
    </footer>

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

实战项目练习

创建一个简单的在线商城系统

本节将指导你如何创建一个简单的在线商城系统。我们将使用Spring Boot框架来快速搭建后端服务，并使用简单的HTML和JavaScript来构建前端页面。

功能模块设计与实现

我们将实现以下几个功能模块：

用户管理
商品管理
购物车功能
订单管理

示例代码：

// User.java
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    @Column(name = "name")
    private String name;
    // Getter and Setter
}

// UserRepository.java
public interface UserRepository extends JpaRepository<User, Integer> {}

// UserService.java
public class UserService {
    private UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public User createUser(User user) {
        return userRepository.save(user);
    }
}

// UserController.java
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class UserController {
    private UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }
}

// Product.java
@Entity
@Table(name = "products")
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    @Column(name = "name")
    private String name;
    @Column(name = "price")
    private double price;
    // Getter and Setter
}

// ProductRepository.java
public interface ProductRepository extends JpaRepository<Product, Integer> {}

// ProductService.java
public class ProductService {
    private ProductRepository productRepository;

    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }

    public Product createProduct(Product product) {
        return productRepository.save(product);
    }
}

// ProductController.java
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/products")
public class ProductController {
    private ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    @GetMapping
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }

    @PostMapping
    public Product createProduct(@RequestBody Product product) {
        return productService.createProduct(product);
    }
}

// CartItem.java
@Entity
@Table(name = "cart_items")
public class CartItem {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    @Column(name = "product_id")
    private int productId;
    @Column(name = "quantity")
    private int quantity;
    // Getter and Setter
}

// CartItemRepository.java
public interface CartItemRepository extends JpaRepository<CartItem, Integer> {}

// CartService.java
public class CartService {
    private CartItemRepository cartItemRepository;

    public CartService(CartItemRepository cartItemRepository) {
        this.cartItemRepository = cartItemRepository;
    }

    public List<CartItem> getCartItems() {
        return cartItemRepository.findAll();
    }

    public CartItem addCartItem(CartItem cartItem) {
        return cartItemRepository.save(cartItem);
    }
}

// CartController.java
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/carts")
public class CartController {
    private CartService cartService;

    public CartController(CartService cartService) {
        this.cartService = cartService;
    }

    @GetMapping
    public List<CartItem> getCartItems() {
        return cartService.getCartItems();
    }

    @PostMapping
    public CartItem addCartItem(@RequestBody CartItem cartItem) {
        return cartService.addCartItem(cartItem);
    }
}

// Order.java
@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    @Column(name = "user_id")
    private int userId;
    @Column(name = "total_price")
    private double totalPrice;
    // Getter and Setter
}

// OrderRepository.java
public interface OrderRepository extends JpaRepository<Order, Integer> {}

// OrderService.java
public class OrderService {
    private OrderRepository orderRepository;

    public OrderService(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }

    public List<Order> getAllOrders() {
        return orderRepository.findAll();
    }

    public Order createOrder(Order order) {
        return orderRepository.save(order);
    }
}

// OrderController.java
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/orders")
public class OrderController {
    private OrderService orderService;

    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }

    @GetMapping
    public List<Order> getAllOrders() {
        return orderService.getAllOrders();
    }

    @PostMapping
    public Order createOrder(@RequestBody Order order) {
        return orderService.createOrder(order);
    }
}

项目部署与调试

部署步骤：

在pom.xml或build.gradle文件中配置项目的构建和依赖信息。
使用Maven或Gradle构建项目。
使用Spring Boot的spring-boot-maven-plugin或spring-boot-gradle-plugin插件打包成可执行的JAR文件。
启动应用，可以通过命令行执行java -jar your-app.jar来启动应用。
配置数据库连接，确保数据库服务已经启动并可用。
测试各个功能模块，验证是否能够正常运行。

调试步骤：

使用IDE的断点调试功能，设置断点并观察变量的变化。
使用日志框架（如Log4j或SLF4J）输出调试信息，通过日志来追踪程序执行过程。
使用浏览器的开发者工具检查前端代码的运行情况，确保前端与后端交互正确。

示例代码：

<!-- pom.xml -->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>online-shop</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.4.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
            <version>2.4.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.4.3</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.4.3</version>
            </plugin>
        </plugins>
    </build>
</project>

// Application.java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

以上是一个简单的在线商城系统的实现，你可以根据实际需求进行扩展和优化。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

阿波罗的战车

手记
篇

粉丝

19

获赞与收藏

86

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19187 313

Java 并发原理入门教程

26个小节 38860 566

Java 入门教程

50个小节 340939 3155

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Java全栈开发入门教程

Java基础语法入门

变量与数据类型

控制结构

条件语句

循环语句

函数与方法

Java面向对象编程

类与对象

继承与多态

接口与抽象类

Java Web开发基础

Servlet与JSP

Java EE框架简介

Spring框架入门

数据库操作基础

JDBC编程

ORM框架Hibernate入门

前端技术简介

HTML与CSS基础

JavaScript入门

前端框架Vue.js基础

实战项目练习

创建一个简单的在线商城系统

功能模块设计与实现

项目部署与调试

阅读免费教程