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

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

标签：

Java Spring Cloud SSM

概述

本文全面介绍了Java主流技术学习的各个方面，从基础入门到面向对象编程，涵盖了Spring框架、MyBatis等常用框架的使用方法，同时详细讲解了Java Web开发和数据库集成技术。希望通过本文，读者能够系统地掌握Java主流技术并应用于实际项目中。

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

Java基础入门

Java简介

Java是一种广泛应用于企业级应用开发的高级编程语言，其设计目标是具有“一次编写，到处运行”的特性，这意味着Java程序在编写后可以在任何支持Java虚拟机（JVM）的平台上运行，而无需重新编译。Java语言有如下特点：

面向对象：Java支持面向对象的编程，允许开发者通过封装、继承和多态等特性来组织代码。
跨平台性：Java程序可以在不同的操作系统上运行，得益于JVM的存在。
安全性：Java内置了安全机制，能有效防止恶意代码的执行。
垃圾回收：Java自动管理内存，提供了垃圾回收器来自动回收不再使用的对象。
丰富的库支持：Java提供了大量的标准库，涵盖了网络编程、图形界面、数据库访问等领域。

Java环境搭建

为了开始编写Java程序，首先需要在计算机上安装Java开发环境。以下是安装步骤：

下载Java开发工具包（JDK）：
访问Oracle官方网站或使用OpenJDK，下载对应平台的JDK安装包。
安装JDK：
按照安装向导完成安装过程，安装过程中可以选择安装路径和设置环境变量。
设置环境变量：
- Path：将JDK的bin目录路径添加到系统环境变量Path中。例如，如果JDK安装在C:\Program Files\Java\jdk1.8.0_231，则在环境变量Path中添加C:\Program Files\Java\jdk1.8.0_231\bin。
- JAVA_HOME：设置JAVA_HOME环境变量为JDK的安装路径。例如，设置为C:\Program Files\Java\jdk1.8.0_231。
验证安装：
打开命令行，输入java -version和javac -version，如果能够显示版本信息，说明安装成功。

第一个Java程序

编写一个简单的Java程序，输出“Hello, World!”：

创建Java源文件：
使用文本编辑器创建一个新文件，命名为HelloWorld.java。

编写代码：

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

编译文件：
打开命令行，切换到源文件所在的目录，输入javac HelloWorld.java。
运行程序：
输入java HelloWorld，命令行将输出“Hello, World!”。

Java基本语法

Java语言的基础语法包括变量定义、运算符、控制结构等。

1. 变量与类型

变量是程序中的数据容器，用于存储数据信息。Java中的变量属于特定的数据类型，常见的基本数据类型有：

整数类型：byte、short、int、long
浮点类型：float、double
字符类型：char
布尔类型：boolean

变量定义如下：

int age = 25;  // 定义一个整数类型变量
double weight = 70.5;  // 定义一个浮点类型变量
char letter = 'A';  // 定义一个字符类型变量
boolean isTrue = true;  // 定义一个布尔类型变量

2. 控制结构

Java中的控制结构用于控制程序的流程，包括条件语句和循环语句。

条件语句：

if 语句：

int num = 10;
if (num > 5) {
System.out.println("num大于5");
}

if-else 语句：

if (num > 5) {
  System.out.println("num大于5");
} else {
  System.out.println("num小于等于5");
}

switch 语句：

int number = 2;
switch (number) {
  case 1:
      System.out.println("number是1");
      break;
  case 2:
      System.out.println("number是2");
      break;
  default:
      System.out.println("number不是1或2");
}

循环语句：

for 循环：

for (int i = 0; i < 5; i++) {
  System.out.println("当前循环次数：" + i);
}

while 循环：

int counter = 0;
while (counter < 5) {
  System.out.println("当前循环次数：" + counter);
  counter++;
}

do-while 循环：

int counter = 0;
do {
  System.out.println("当前循环次数：" + counter);
  counter++;
} while (counter < 5);

3. 数组

数组是一种用于存储多个相同类型的变量的数据结构。Java中数组的定义和使用如下：

int[] numbers = new int[5];  // 创建一个长度为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("数组元素：" + numbers[i]);
}

4. 方法

方法是执行特定任务的代码块，可以包含参数和返回值。方法的定义和使用如下：

public class Calculator {
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int result = add(5, 3);
        System.out.println("两数之和：" + result);
    }
}

Java面向对象编程

类和对象

面向对象编程是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("我的名字是" + name + "，今年" + age + "岁");
    }
}

对象：
对象是由类实例化创建的实际实体。例如，根据上面定义的Person类创建一个对象：

Person person = new Person("张三", 25);
person.introduce();  // 输出：我的名字是张三，今年25岁

继承与多态

继承：
继承允许子类继承父类的属性和方法。例如，定义一个父类Animal和一个子类Dog：

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

public class Dog extends Animal {
    public void bark() {
        System.out.println("狗在吠叫");
    }
}

通过继承，Dog类可以访问Animal类的eat方法：

Dog dog = new Dog();
dog.eat();  // 输出：动物在进食
dog.bark();  // 输出：狗在吠叫

多态：
多态允许子类重写父类的方法，实现不同的行为。例如，定义一个父类Shape和两个子类Circle和Rectangle：

public abstract class Shape {
    public abstract double getArea();
}

public class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

public class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double getArea() {
        return width * height;
    }
}

通过多态，可以使用父类引用指向子类对象：

Shape circle = new Circle(5);
System.out.println("圆的面积：" + circle.getArea());  // 输出：圆的面积：78.53981633974483

Shape rectangle = new Rectangle(4, 6);
System.out.println("矩形的面积：" + rectangle.getArea());  // 输出：矩形的面积：24.0

封装和抽象

封装：
封装是将数据（属性）和访问这些数据的方法（方法）封装在一起，以隐藏对象的内部实现细节。例如，定义一个BankAccount类：

public class BankAccount {
    private double balance;

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

    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }
}

通过封装，确保了balance属性只能通过deposit和withdraw方法进行修改，外部代码不能直接访问或修改balance。

抽象：
抽象是将类的公共特征提取出来形成一个抽象类，子类继承抽象类并实现具体行为。例如，定义一个抽象类Vehicle：

public abstract class Vehicle {
    public abstract void start();
    public abstract void stop();
}

定义Car和Bike两个子类，分别实现Vehicle的抽象方法：

public class Car extends Vehicle {
    @Override
    public void start() {
        System.out.println("汽车启动");
    }

    @Override
    public void stop() {
        System.out.println("汽车停止");
    }
}

public class Bike extends Vehicle {
    @Override
    public void start() {
        System.out.println("自行车启动");
    }

    @Override
    public void stop() {
        System.out.println("自行车停止");
    }
}

通过抽象类，我们可以统一管理车辆的启动和停止行为：

Vehicle car = new Car();
car.start();  // 输出：汽车启动
car.stop();  // 输出：汽车停止

Vehicle bike = new Bike();
bike.start();  // 输出：自行车启动
bike.stop();  // 输出：自行车停止

Java常用框架入门

Spring框架简介

Spring是一个开源的企业级应用开发框架，最初由Rod Johnson编写，目的是简化企业应用的开发过程。Spring框架提供了一系列核心模块，包括：

Spring Core：提供了IoC容器和服务定位的基本功能。
Spring MVC：提供了一个适用于Web应用程序的模型-视图-控制器（MVC）框架。
Spring Data：简化了数据库访问的开发。
Spring Security：提供了全面的安全性支持。

Spring框架有诸多优点，包括依赖注入、AOP（面向切面编程）、声明式事务管理等。

Spring Boot快速入门

Spring Boot是一个基于Spring框架的简化开发工具，旨在让开发人员快速构建独立的、生产级别的基于Spring的应用程序。Spring Boot通过自动配置和约定优于配置的原则简化了Spring应用程序的开发过程。

1. 创建Spring Boot项目

可以通过Spring Initializr网站或Maven/Gradle创建新的Spring Boot项目。例如，在Maven项目中，添加以下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

2. Spring Boot应用

创建一个简单的Spring Boot应用，实现一个RESTful API：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
class HelloController {
    @GetMapping("/")
    public String helloWorld() {
        return "Hello, World!";
    }
}

3. 启动和测试应用

在命令行中运行mvn spring-boot:run启动应用，访问http://localhost:8080/，可以查看页面输出Hello, World!。

MyBatis框架简介

MyBatis是一个持久层框架，它通过使用简单的XML或注解进行配置，将POJO（Plain Old Java Objects）映射到数据库表列。MyBatis负责处理SQL语句的执行、结果集的处理和映射，在Java应用程序和数据库之间提供了一种松耦合的连接方式。

1. MyBatis配置

在mybatis-config.xml中配置MyBatis的基本设置，例如：

<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

2. Mapper XML

定义映射文件，将Java对象与数据库表进行映射。例如，创建一个UserMapper.xml：

<mapper namespace="com.example.mapper.UserMapper">
    <select id="getUserById" resultType="com.example.model.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
</mapper>

3. Java代码

在Java代码中使用MyBatis进行数据库操作：

import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.InputStream;

public class MyBatisDemo {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        UserMapper mapper = sqlSessionFactory.openSession().getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user.getName());
    }
}

Java Web开发

Servlet和JSP基础

Servlet是Java技术用于扩展Web服务器功能的一种机制，它接收客户端的请求，处理后返回响应。JSP（JavaServer Pages）是一种使用Java语言编写的动态网页技术。

1. 创建Servlet

创建一个简单的Servlet，实现HttpServlet接口：

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 IOException {
        response.getWriter().println("Hello, World!");
    }
}

2. 部署Servlet

在web.xml中配置Servlet：

<web-app>
    <servlet>
        <servlet-name>HelloWorldServlet</servlet-name>
        <servlet-class>com.example.servlet.HelloWorldServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloWorldServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

3. JSP页面

创建一个简单的JSP页面，输出“Hello, World!”：

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

JavaWeb开发流程

JavaWeb开发流程包括以下步骤：

需求分析：明确项目的功能需求和技术需求。
环境搭建：搭建Java开发环境，安装IDE（如Eclipse、IntelliJ IDEA）和服务器（如Tomcat）。
设计：设计系统架构，包括数据模型、业务逻辑和界面设计。
编码实现：根据设计文档编写代码，实现功能模块。
测试：进行单元测试、集成测试和系统测试，确保代码质量。
部署上线：将应用程序部署到服务器上，进行灰度发布或全量发布。
维护升级：根据用户反馈和需求迭代进行维护和升级。

常见Web框架介绍

常见的Java Web框架包括Spring MVC、Spring Boot、Struts等。

Spring MVC：Spring框架的一部分，提供了一个强大的Web开发框架，支持RESTful风格的请求处理。
Spring Boot：基于Spring框架的简化开发工具，简化了Spring应用程序的开发和配置。
Struts：一个成熟的Java Web框架，提供了强大的MVC模型支持，支持表单验证。

数据库与Java集成

JDBC编程入门

JDBC（Java Database Connectivity）是Java SE平台的一部分，提供了一套用于连接和访问数据库的标准API。JDBC API通过JDBC驱动程序与数据库进行交互，实现SQL语句的执行和结果集的处理。

1. 加载JDBC驱动

在Java代码中加载数据库驱动：

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

public class JdbcDemo {
    public static void main(String[] args) {
        try {
            // 加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 获取数据库连接
            Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "root", "password");
            // 关闭连接
            connection.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2. 执行SQL语句

使用Statement或PreparedStatement执行SQL语句：

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

public class JdbcDemo {
    public static void main(String[] args) {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "root", "password");

            // 执行SQL语句
            Statement statement = connection.createStatement();
            ResultSet resultSet = statement.executeQuery("SELECT * FROM users");
            while (resultSet.next()) {
                System.out.println(resultSet.getString("name"));
            }

            // 关闭资源
            resultSet.close();
            statement.close();
            connection.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ORM映射技术

ORM（Object-Relational Mapping）是一种编程技术，将对象模型映射到关系数据库模型。常用ORM框架包括Hibernate、MyBatis等。

1. Hibernate

Hibernate是Java中一个优秀的持久层框架，它通过提供对象关系映射（ORM）来实现Java对象与数据库表之间的映射。

配置文件：
配置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.hbm2ddl.auto">update</property>

        <mapping resource="com/example/model/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

映射文件：
定义对象模型与数据库表的映射关系，例如User.hbm.xml：

<hibernate-mapping>
    <class name="com.example.model.User" table="users">
        <id name="id" column="id" type="long">
            <generator class="native"/>
        </id>
        <property name="name" column="name" type="string"/>
        <property name="age" column="age" type="integer"/>
    </class>
</hibernate-mapping>

Java代码：
使用Hibernate进行数据库操作：

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

import java.util.List;

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

        // 查询所有用户
        List<User> users = session.createQuery("FROM User").list();
        for (User user : users) {
            System.out.println(user.getName());
        }

        // 关闭资源
        session.close();
        sessionFactory.close();
    }
}

数据库连接池

数据库连接池是数据库连接管理的一种机制，它预先创建一定数量的数据库连接对象，并将其保存在连接池中，应用程序需要时向池中“借用”，用完后归还，避免频繁创建和销毁数据库连接。

1. C3P0

C3P0是一个开源的JDBC连接池实现，它可以自动管理数据库连接。

配置文件：
在c3p0-config.xml中配置连接池参数：

<c3p0-config>
    <default-config>
        <driverClass>com.mysql.jdbc.Driver</driverClass>
        <jdbcUrl>jdbc:mysql://localhost:3306/mydb</jdbcUrl>
        <user>root</user>
        <password>password</password>
        <acquireIncrement>5</acquireIncrement>
        <minPoolSize>5</minPoolSize>
        <maxPoolSize>10</maxPoolSize>
    </default-config>
</c3p0-config>

Java代码：
使用C3P0获取数据库连接：

import com.mchange.v2.c3p0.ComboPooledDataSource;

import java.sql.Connection;

public class C3P0Demo {
    public static void main(String[] args) {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        try {
            dataSource.setConfigFile("c3p0-config.xml");

            Connection connection = dataSource.getConnection();
            // 执行数据库操作
            // ...
            // 关闭连接
            connection.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Java项目实战

小项目开发流程

开发一个Java Web项目的基本流程如下：

需求分析：明确项目的目标、功能需求和非功能需求。
设计：进行系统架构设计、数据库设计和页面设计。
编码实现：使用Java、Spring、MyBatis等技术实现功能模块。
单元测试：编写单元测试用例，确保每个模块的正确性。
集成测试：进行端到端的集成测试，验证整个系统是否协同工作。
调试优化：修复发现的问题，优化程序性能。
部署上线：将项目部署到生产环境，进行灰度发布或全量发布。
维护升级：根据用户反馈，持续维护和升级项目。

项目部署与发布

项目部署通常包括打包、配置和启动三个步骤。

1. 打包

使用Maven或Gradle将项目打包成可执行的JAR或WAR文件：

mvn clean package

2. 部署

将打包好的文件部署到服务器上，配置好环境，启动应用程序。

3. 灰度发布

灰度发布是将新版本部署到一小部分用户群体，收集反馈，评估新版本的稳定性和性能。

常见问题解决

在Java开发过程中，可能会遇到各种问题，以下是一些常见的问题及解决方法：

内存溢出：增加JVM的堆内存大小，优化代码，减少内存泄漏。
- 增加堆内存大小可以通过设置JVM参数-Xms和-Xmx，例如：java -Xms128m -Xmx512m
ClassNotFoundException：确保所有依赖库正确导入。
- 检查pom.xml或build.gradle文件，确保所有依赖项都已正确配置。
NullPointerException：检查代码中是否存在空指针引用。
- 使用断言或条件判断，确保引用对象不为空。
SQL注入：使用参数化查询或ORM框架，避免直接拼接SQL语句。
- 使用PreparedStatement或MyBatis提供的#{}占位符。

通过以上步骤，可以系统地学习Java技术，并应用到实际开发中。希望读者能够通过不断实践，提高自己的Java编程技能。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

jeck猫

手记
篇

粉丝

75

获赞与收藏

402

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19264 315

Java 并发原理入门教程

26个小节 38992 568

Java 入门教程

50个小节 341847 3163

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空