首页手记 Java主流技术学习：从入门到实践指南

Java主流技术学习：从入门到实践指南

标签：

Java SpringBoot Spring

概述

本文全面介绍了Java主流技术学习的相关内容，从Java基础入门到核心编程技术，涵盖了面向对象编程、集合框架、异常处理、IO流操作等多个方面。此外，文章还详细讲解了Java Web开发入门、数据库编程以及并发编程等重要技术，并提供了丰富的示例代码和实践指南。最后，文章通过项目开发实践进一步巩固了所学知识，帮助读者掌握Java项目的开发流程和部署技巧。

Java主流技术学习：从入门到实践指南

Java基础入门

Java简介

Java 是一种广泛使用的编程语言，由 Sun Microsystems（现为 Oracle 公司）开发。它具有跨平台、面向对象、可移植性等特性。Java 的主要应用领域包括桌面应用、Web 应用、移动应用和企业级应用。Java 程序代码在 Java 虚拟机（JVM）上运行，这意味着 Java 代码可以在任何安装了 JVM 的平台（如 Windows、Linux、macOS）上运行。

Java开发环境搭建

下载并安装 JDK

访问 Oracle 官方网站下载最新版本的 Java Development Kit (JDK)。安装时选择合适的安装路径，安装过程中建议勾选所有功能。
配置环境变量
- 编辑系统环境变量，将 JDK 的 bin 目录添加到系统 PATH 环境变量中。例如，如果 JDK 被安装在 C:\Program Files\Java\jdk-17.0.1，则需要将 C:\Program Files\Java\jdk-17.0.1\bin 添加到 PATH 中。
- 设置 JAVA_HOME 环境变量指向 JDK 根目录，如 C:\Program Files\Java\jdk-17.0.1。
验证安装

打开命令行工具，输入 java -version 和 javac -version，确保能够正确显示版本信息，说明 Java 已经安装成功。

Java基本语法和数据类型

Java 中的数据类型分为两种：基本数据类型和引用数据类型。

基本数据类型
- byte：1 字节（-128 到 127）
- short：2 字节（-32,768 到 32,767）
- int：4 字节（-2,147,483,648 到 2,147,483,647）
- long：8 字节（-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807）
- float：4 字节（单精度浮点数）
- double：8 字节（双精度浮点数）
- char：2 字节（0 到 65,535 的 Unicode 字符）
- boolean：1 位（true 或 false）
引用数据类型
- 类（Class）
- 接口（Interface）
- 数组（Array）

变量声明

int age;
String name;
boolean isAdult;
double height;

变量赋值

age = 25;
name = "张三";
isAdult = true;
height = 1.75;

常量声明

使用 final 关键字声明常量。
```
final double PI = 3.14159;
```

Java面向对象编程基础

Java 是一种面向对象（Object-Oriented）的编程语言。面向对象编程的基本思想是把对象作为程序的基本单元，强调封装、继承和多态。

封装

封装是将数据和操作数据的方法捆绑在一起，通过提供公共接口来访问这些数据和方法。

public class Person {
   private String name;
   private int age;

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

继承

继承允许一个类继承另一个类的属性和方法。

public class Animal {
   public void eat() {
       System.out.println("Animal is eating");
   }
}

public class Dog extends Animal {
   public void bark() {
       System.out.println("Dog is barking");
   }
}

多态

多态是指同一个行为在不同的对象上有不同的表现形式。

public class Animal {
   public void eat() {
       System.out.println("Animal is eating");
   }
}

public class Dog extends Animal {
   @Override
   public void eat() {
       System.out.println("Dog is eating");
   }
}

public class Cat extends Animal {
   @Override
   public void eat() {
       System.out.println("Cat is eating");
   }
}

public class Test {
   public static void main(String[] args) {
       Animal animal = new Dog();
       animal.eat(); // 输出 "Dog is eating"
       animal = new Cat();
       animal.eat(); // 输出 "Cat is eating"
   }
}

Java核心编程技术

Java集合框架

Java 集合框架是一组核心接口和实现类的集合，提供了对集合对象的访问。常用的集合接口包括 List、Set 和 Map。

List 接口

List 接口表示一个元素有序的集合，允许元素重复。

import java.util.ArrayList;
import java.util.List;

public class ListExample {
   public static void main(String[] args) {
       List<String> list = new ArrayList<>();
       list.add("Apple");
       list.add("Banana");
       list.add("Orange");

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

Set 接口

Set 接口表示一个元素无序且不重复的集合。

import java.util.HashSet;
import java.util.Set;

public class SetExample {
   public static void main(String[] args) {
       Set<String> set = new HashSet<>();
       set.add("Apple");
       set.add("Banana");
       set.add("Orange");
       set.add("Apple"); // 重复添加不会影响结果

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

Map 接口

Map 接口表示一个元素成对出现的集合，键（key）唯一且不可重复。

import java.util.HashMap;
import java.util.Map;

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

       System.out.println("Apple count: " + map.get("Apple"));
       System.out.println("Banana count: " + map.get("Banana"));
       System.out.println("Orange count: " + map.get("Orange"));
   }
}

Java异常处理

Java 中的异常处理机制用于处理程序运行时可能出现的异常情况，确保程序的健壮性。

异常类型

异常分为 Checked Exception 和 Unchecked Exception 两大类。Checked Exception 需要显式捕获或抛出，Unchecked Exception 不需要。

异常处理机制

public class ExceptionExample {
   public static void main(String[] args) {
       try {
           int result = 10 / 0;
       } catch (ArithmeticException e) {
           System.out.println("Cannot divide by zero.");
       } finally {
           System.out.println("Finally block executed.");
       }
   }
}

Java IO流操作

Java 中的 IO 流是输入输出操作的基础，用于处理文件、网络等数据的读写。

文件读写

示例代码：读取文件内容。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

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

网络读写

示例代码：创建一个简单的 TCP 客户端。

import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;

public class SimpleClient {
   public static void main(String[] args) {
       try (Socket socket = new Socket("localhost", 8080);
            OutputStream out = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(out, true)) {
           writer.println("Hello, Server!");
       } catch (Exception e) {
           e.printStackTrace();
       }
   }
}

Socket 通信

示例代码：创建一个简单的 TCP 服务器。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class SimpleServer {
   public static void main(String[] args) {
       try (ServerSocket server = new ServerSocket(8080);
            Socket socket = server.accept();
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
           String clientMessage = in.readLine();
           System.out.println("Received: " + clientMessage);
       } catch (Exception e) {
           e.printStackTrace();
       }
   }
}

Java网络编程基础

Java 网络编程主要涉及 TCP/IP 协议栈中的 Socket 通信。

Socket 通信

示例代码：创建一个简单的 TCP 服务器。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class SimpleServer {
   public static void main(String[] args) {
       try (ServerSocket server = new ServerSocket(8080);
            Socket socket = server.accept();
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
           String clientMessage = in.readLine();
           System.out.println("Received: " + clientMessage);
       } catch (Exception e) {
           e.printStackTrace();
       }
   }
}

Java Web开发入门

Java Web开发概述

Java Web 开发主要涉及 Servlet、JSP（JavaServer Pages）、JSTL（JavaServer Pages Standard Tag Library）、EL（Expression Language）、Filter 和 Listener 等技术。

Servlet

Servlet 是运行在服务器端的 Java 类，用于处理客户端的请求和响应。

示例代码：创建一个简单的 Servlet。

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class HelloWorldServlet extends HttpServlet {
   @Override
   protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       response.setContentType("text/html;charset=UTF-8");
       response.getWriter().println("<h1>Hello, World!</h1>");
   }
}

JSP

JSP 是 Java 技术的一个扩展，用于创建 Web 页面，可以动态生成 HTML、XML 等文本。

示例代码：创建一个简单的 JSP 页面。

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
   <meta charset="UTF-8">
   <title>Hello, World!</title>
</head>
<body>
   <h1>Hello, World!</h1>
</body>
</html>

Servlet和JSP基础

Servlet 生命周期
- 初始化：init() 方法
- 处理请求：service() 方法
- 销毁：destroy() 方法
JSP 指令
- <%@ page ... %>：指定页面属性
- <%@ include ... %>：包含其他文件
- <%@ taglib ... %>：引入标签库

简单的Servlet和JSP代码示例

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class HelloWorldServlet extends HttpServlet {
   @Override
   protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       response.setContentType("text/html;charset=UTF-8");
       response.getWriter().println("<h1>Hello, World!</h1>");
   }
}

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
   <meta charset="UTF-8">
   <title>Hello, World!</title>
</head>
<body>
   <h1>Hello, World!</h1>
</body>
</html>

MVC设计模式和Spring框架简介

MVC（Model-View-Controller）设计模式是处理 Web 应用程序的一种经典模式。

MVC 构成
- Model：负责应用程序的数据和业务逻辑
- View：负责应用程序的用户界面
- Controller：负责处理用户输入和调用 Model 和 View

Spring 框架

Spring 框架是一个强大的 Java 应用程序开发框架，提供了一系列简化开发、测试、部署等工作的框架。

示例代码：使用 Spring 注解创建一个简单的 Controller。

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloWorldController {
   @GetMapping("/hello")
   @ResponseBody
   public String sayHello() {
       return "Hello, World!";
   }
}

Java Web应用开发实践

环境搭建
- 安装 JDK
- 配置 Tomcat 服务器
- 配置 Spring Boot
开发流程
- 创建 Spring Boot 项目
- 编写 Controller 和 Service 层
- 配置数据库连接
- 运行和调试应用

Java数据库编程

JDBC基础

JDBC（Java Database Connectivity）是 Java 中用于连接数据库的标准 API。

JDBC URL 格式

jdbc:mysql://hostname:port/dbname

数据库连接

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

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

       try (Connection conn = DriverManager.getConnection(url, user, password)) {
           System.out.println("Connected to the database!");
       } catch (SQLException e) {
           e.printStackTrace();
       }
   }
}

Java与MySQL数据库连接

示例代码：连接 MySQL 数据库并执行查询。

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

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

        try (Connection conn = DriverManager.getConnection(url, user, password);
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM mytable")) {

            while (rs.next()) {
                System.out.println("Name: " + rs.getString("name"));
                System.out.println("Age: " + rs.getInt("age"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

ORM框架Hibernate简介

ORM（Object-Relational Mapping）框架将对象模型映射到关系型数据库。

配置 Hibernate
- hibernate.cfg.xml 配置文件
- Entity 类的 @Entity 注解
基本操作
- 创建对象并保存到数据库
- 从数据库中读取对象
- 更新对象
- 删除对象

示例代码：使用 Hibernate 操作数据库。

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

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

        // 创建对象并保存
        User user = new User();
        user.setName("John");
        user.setAge(30);
        session.beginTransaction();
        session.save(user);
        session.getTransaction().commit();

        // 从数据库中读取对象
        session = sessionFactory.openSession();
        user = session.get(User.class, 1L);
        System.out.println("Name: " + user.getName());
        System.out.println("Age: " + user.getAge());

        // 更新对象
        user.setAge(31);
        session = sessionFactory.openSession();
        session.beginTransaction();
        session.update(user);
        session.getTransaction().commit();

        // 删除对象
        session = sessionFactory.openSession();
        session.beginTransaction();
        session.delete(user);
        session.getTransaction().commit();

        sessionFactory.close();
    }
}

数据库事务和连接池管理

事务

使用 Transaction 对象管理事务。

import org.hibernate.Session;
import org.hibernate.Transaction;

public class TransactionExample {
   public static void main(String[] args) {
       Session session = HibernateSessionFactory.getSession().openSession();
       Transaction tx = session.beginTransaction();

       // 执行数据库操作
       // ...

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

连接池管理

使用第三方连接池管理工具，如 HikariCP。

# hikaricp.properties
dataSourceClassName=com.mysql.jdbc.jdbc2.optional.MysqlDataSource
dataSource.url=jdbc:mysql://localhost:3306/mydb
dataSource.user=root
dataSource.password=password

Java并发编程基础

多线程编程基础

Java 中的多线程编程使用 Thread 类和 Runnable 接口实现。

创建线程
- 继承 Thread 类
- 实现 Runnable 接口
线程生命周期
- 新建（New）
- 可运行（Runnable）
- 运行（Running）
- 阻塞（Blocked）
- 活跃（Timed Waiting）
- 等待（Waiting）
- 终止（Terminated）

示例代码：实现一个简单的多线程程序。

public class ThreadExample extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread " + Thread.currentThread().getName() + " running " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ThreadExample thread1 = new ThreadExample();
        ThreadExample thread2 = new ThreadExample();

        thread1.start();
        thread2.start();
    }
}

线程安全与锁机制

线程安全是指代码在多个线程并行执行时不会产生错误结果。

同步机制

使用 synchronized 关键字实现同步。

public class SynchronizedExample {
   private int count = 0;

   public synchronized void increment() {
       count++;
   }

   public synchronized int getCount() {
       return count;
   }

   public static void main(String[] args) {
       SynchronizedExample example = new SynchronizedExample();

       Thread thread1 = new Thread(() -> {
           for (int i = 0; i < 1000; i++) {
               example.increment();
           }
       });

       Thread thread2 = new Thread(() -> {
           for (int i = 0; i < 1000; i++) {
               example.increment();
           }
       });

       thread1.start();
       thread2.start();

       try {
           thread1.join();
           thread2.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println("Final count: " + example.getCount());
   }
}

ReentrantLock

使用 ReentrantLock 实现可重入锁。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
   private int count = 0;
   private final Lock lock = new ReentrantLock();

   public void increment() {
       lock.lock();
       try {
           count++;
       } finally {
           lock.unlock();
       }
   }

   public int getCount() {
       return count;
   }

   public static void main(String[] args) {
       ReentrantLockExample example = new ReentrantLockExample();

       Thread thread1 = new Thread(() -> {
           for (int i = 0; i < 1000; i++) {
               example.increment();
           }
       });

       Thread thread2 = new Thread(() -> {
           for (int i = 0; i < 1000; i++) {
               example.increment();
           }
       });

       thread1.start();
       thread2.start();

       try {
           thread1.join();
           thread2.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println("Final count: " + example.getCount());
   }
}

Java并发工具类

Java 提供了多种并发工具类，如 ExecutorService、CountDownLatch、Semaphore 等。

ExecutorService

使用 ExecutorService 管理线程池。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorServiceExample {
   public static void main(String[] args) {
       ExecutorService executor = Executors.newFixedThreadPool(5);

       for (int i = 0; i < 10; i++) {
           executor.submit(() -> {
               System.out.println("Task " + Thread.currentThread().getName() + " running");
           });
       }

       executor.shutdown();
   }
}

CountDownLatch

使用 CountDownLatch 实现线程等待。

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
   public static void main(String[] args) throws InterruptedException {
       CountDownLatch latch = new CountDownLatch(2);

       new Thread(() -> {
           System.out.println("Thread 1 running");
           latch.countDown();
       }).start();

       new Thread(() -> {
           System.out.println("Thread 2 running");
           latch.countDown();
       }).start();

       latch.await();
       System.out.println("Both threads finished");
   }
}

并发编程实战案例

示例代码：实现一个多线程的下载器。

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.nio.file.Files;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class MultiThreadDownloader {
    private static final int THREAD_COUNT = 5;

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);

        String url = "http://example.com/file.zip";
        int fileSize = 100; // 假设文件大小为100MB

        for (int i = 0; i < THREAD_COUNT; i++) {
            int start = i * (fileSize / THREAD_COUNT);
            int end = (i + 1) * (fileSize / THREAD_COUNT) - 1;
            executor.submit(() -> download(url, start, end));
        }

        executor.shutdown();
        try {
            executor.awaitTermination(1, TimeUnit.HOURS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void download(String url, int start, int end) {
        try {
            URL resource = new URL(url);
            long totalLength = 100; // 假设文件大小为100MB
            long downloaded = 0;

            try (FileOutputStream fos = new FileOutputStream(new File("part_" + start + ".zip"))) {
                byte[] buffer = new byte[1024];
                int readBytes;

                long startTime = System.currentTimeMillis();
                while ((readBytes = resource.openConnection().getInputStream().read(buffer)) != -1) {
                    fos.write(buffer, 0, readBytes);
                    downloaded += readBytes;
                    if (downloaded >= totalLength) {
                        break;
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Java项目开发实践

Java项目开发流程

Java 项目开发流程通常包括以下几个阶段：

需求分析
设计
编码
测试
部署
维护

示例代码：简单的开发流程示例。

public class ProjectDevelopmentExample {
    public static void main(String[] args) {
        // 初始化
        System.out.println("Project Development Process");
        System.out.println("--------------------------");

        // 需求分析
        System.out.println("1. 需求分析");
        System.out.println("2. 设计");
        System.out.println("3. 编码");
        System.out.println("4. 测试");
        System.out.println("5. 部署");
        System.out.println("6. 维护");
    }
}

常用开发工具介绍

常用的 Java 开发工具包括 IntelliJ IDEA、Eclipse、Maven、Gradle 等。

IntelliJ IDEA

IntelliJ IDEA 是一款专业的 Java 开发工具，提供了智能代码补全、代码检查、重构等功能。
Eclipse

Eclipse 是一个开源的集成开发环境，支持 Java 以及其他多种语言的开发。
Maven

Maven 是一个项目管理和构建工具，可以管理项目依赖和构建流程。
Gradle

Gradle 是一个基于 Apache Ant 和 Apache Maven 项目体系的构建工具，可以生成、测试、部署等多种任务。

代码版本控制与Git使用

代码版本控制是软件开发中非常重要的一个环节，Git 是目前最流行的版本控制系统之一。

初始化仓库
```
git init
```
添加文件
```
git add .
```
提交更改
```
git commit -m "Initial commit"
```

远程仓库

git remote add origin https://github.com/user/repo.git
git push -u origin main

Java项目部署与运行

Java 项目的部署和运行通常涉及打包、安装部署工具、配置环境变量等步骤。

打包

使用 Maven 或 Gradle 打包项目。
```
mvn package
```
安装部署工具

使用 Tomcat、Jetty 等 Web 服务器部署 Java Web 应用。
配置环境变量

设置 JAVA_HOME、CATALINA_HOME 等环境变量。
启动服务器

启动 Tomcat 或 Jetty 等服务器。
```
./bin/startup.sh
```

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

吃鸡游戏

手记
篇

粉丝

55

获赞与收藏

339

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19244 315

Java 并发原理入门教程

26个小节 38983 568

Java 入门教程

50个小节 341700 3163

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空